Keyless multi-chain EVM JSON-RPC, indexed Data API, docs, CU pricing and status. API key optional.
Scored across 15 tools
Most tools target clearly distinct operations (rpc_call read vs send_raw_transaction write, list_docs vs search_docs vs read_doc, get_status live vs list_chains static). The pricing trio (get_pricing, get_method_info, estimate_usage) overlaps conceptually, but the descriptions explicitly cross-reference each other with 'use X instead' guidance, keeping misselection low.
Strong snake_case verb_noun pattern throughout (get_account, list_chains, read_doc, search_docs, send_raw_transaction). Minor deviations exist: 'data_api_get' puts the verb last, and 'rpc_call' and 'how_to_get_api_key' break the pattern slightly, but overall it is predictable and readable.
15 tools is well within the ideal range and each maps to a distinct capability of a multi-chain RPC + Data API service (RPC read/write, data queries, account, pricing, chains, status, docs, error/onboarding helpers). No obvious filler.
Covers the core lifecycle: discovery (list_chains, get_status), pricing/methodology, RPC read and broadcast, Data API queries, account/deposit, and documentation/error/onboarding. The only visible gap is webhook/push subscription management, which is referenced in docs but has no dedicated tool.
Query the BlockVectra Data API for a specified chain and path using your BlockVectra API key. For endpoint schemas and parameter specifications, see the OpenAPI contract at https://docs.blockvectra.com/openapi/data.yaml. Requires the 'x-api-key' or 'Authorization: Bearer ' HTTP header in your MCP client configuration (keys must not be passed in tool parameters or chat). Returns the HTTP status and JSON response body.
| Name | Required | Description | Default |
|---|---|---|---|
| path | Yes | Path after '/v1/data/{chain}/' (e.g. 'status/freshness', 'address/0x.../balances'). Must not start with '/', and cannot contain '..', '//', '?', '#', or '%'. | |
| chain | Yes | Target blockchain network slug (e.g. 'robinhood_mainnet'). | |
| query | No | Optional URL query parameters as key-value pairs. |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint and openWorldHint, so the safety profile is covered, but the description adds genuinely useful context beyond them: the required auth header ('x-api-key' or Bearer), the warning that keys must not be passed as tool parameters or in chat, and the return shape (HTTP status plus JSON body). It omits rate limits and error behavior, keeping it short of a 5.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Three tight sentences that front-load the purpose, then auth, then return value, with no filler. Slightly dense but every sentence carries operational information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For an open-world API passthrough, the description covers the essentials: what it queries, where the contract lives, how auth is supplied, and what comes back, and an output schema exists so return values need no elaboration. It could be more complete by naming which sibling to use for specific read tasks instead of raw passthrough.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so chain and path are already fully documented and the description adds no syntax beyond them. The OpenAPI pointer routes the agent to endpoint-specific parameters, but that is not meaning for this tool's own 3 parameters, so the baseline 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb and resource ('Query the BlockVectra Data API') plus the scoping surface (a specified chain and path). It is distinguishable from most siblings, though it never contrasts itself with the closest passthrough sibling, rpc_call.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Usage is implied by the OpenAPI contract pointer ('For endpoint schemas and parameter specifications, see...'), which tells the agent where to look but not when to prefer this tool over rpc_call or the get_* siblings. No explicit when-to-use or when-not guidance is given.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Calculate projected daily and billing cycle Compute Units (CU) and USD costs for planned call volumes across one or more methods, factoring in method weights and free credit allowances from /v1/plans. Available without an API key. Estimates the API key count for planned traffic under the free-account key_defaults (free new-key default CU/s); the result also echoes paid_key_minimums (the paid-account floor, not a cap: the first paid top-up raises each key to at least this value and higher custom limits are kept, and a key's actual limits come from the console Keys list). Cost and quota assumptions are for free-tier accounts. Use this tool for volume budget calculations and capacity planning. For looking up raw system pricing tables, use get_pricing instead. For checking whether a single method is supported on a specific chain, use get_method_info instead. Accepts 'lines' array of {method, calls_per_day} or single 'method' and 'calls_per_day'.
| Name | Required | Description | Default |
|---|---|---|---|
| lines | No | List of methods and daily call volumes to estimate. | |
| method | No | Exact method name (e.g. 'eth_call', 'eth_getLogs', 'eth_blockNumber', 'data.address_balances'). Single-method mode. | |
| calls_per_day | No | Expected daily call volume (non-negative integer). Single-method mode. |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations only cover safety (readOnly, not open-world); the description goes well beyond them, disclosing that no API key is needed, that cost/quota assumptions are free-tier only, and clarifying that paid_key_minimums is a floor rather than a cap with limits authoritatively coming from the console.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Purpose is front-loaded and every sentence carries information, though the long parenthetical about paid_key_minimums semantics is dense and slightly interrupts flow. Still no filler or repetition.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given an output schema exists, return formatting need not be described; the description still covers the key semantic caveats (free-tier assumption, paid_key_minimums being a floor) and both input modes, leaving nothing material for correct invocation missing.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so 3 is the baseline, but the description adds the invocation-level distinction that 'lines' and the single method/calls_per_day form are mutually alternative modes and that single calls_per_day feeds the free-account key_defaults estimate, which the schema alone does not make explicit.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb and resource: calculate projected daily/billing-cycle Compute Units and USD costs for planned call volumes. It also names the sibling tools it is not (get_pricing, get_method_info), so an agent can route without opening other schemas.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly frames the use case ('volume budget calculations and capacity planning') and gives two concrete alternatives with their selecting conditions: get_pricing for raw system pricing tables, get_method_info for per-chain method support.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Lookup error code, reason, or HTTP status in the official error reference catalog. Returns meaning, billing implications (whether the call was billed), retryability, retry delay, recommended agent action, and documentation URL.
| Name | Required | Description | Default |
|---|---|---|---|
| code | No | Error code (e.g. -32600, -32005, -32020, or console code string like 'siwe_invalid'). | |
| lang | No | Response language (case-insensitive). Defaults to 'en'. | |
| reason | No | Error reason slug (e.g. 'invalid_request', 'key_rate_limit', 'insufficient_balance', 'not_found'). | |
| http_status | No | HTTP status code (e.g. 200, 400, 402, 404, 429, 500, 503). |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already establish readOnlyHint=true and openWorldHint=false, so the safety profile is covered. The description adds some behavioral value by flagging that the catalog encodes billing implications and retryability, but that is largely return-payload information already covered by the output schema, and it says nothing about auth, rate limits, or what happens when a code is unknown.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two tight sentences: the first names the lookup target and source, the second front-loads the returned fields as a compact list. No filler, no restatement of the tool name or title's tautology.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
An output schema exists, so the description is not obliged to enumerate return fields (though it helpfully does). It is nearly complete for a read-only lookup, with the one gap being guidance on how to combine the four zero-required parameters — an agent is left to guess whether to pass code, reason, or http_status.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the baseline is 3. The description's 'error code, reason, or HTTP status' mirrors the schema's documented parameters without adding anything the schema lacks. Notably, it does not clarify that all four parameters are optional or that at least one identifier must be supplied — a real ambiguity given required parameters = 0.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb (lookup) and a specific resource (error code, reason, or HTTP status in the official error reference catalog), and it enumerates exactly what the lookup returns. None of the sibling tools (search_docs, read_doc, get_status, get_method_info) overlap with this, so an agent can route to it without opening a schema.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Usage is implied by the phrasing — you use it when you have an error code/reason/status to interpret — but there is no explicit when-to-use statement and no mention of alternatives such as search_docs or read_doc, which an agent might plausibly reach for when diagnosing an error. No exclusions or prerequisites are given.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get the API key's own balance, Compute Units (CU), rate limits, and key parameters from GET /v1/account using your BlockVectra API key. Free and unbilled. Requires the 'x-api-key' or 'Authorization: Bearer ' HTTP header in your MCP client configuration (never pass keys in tool parameters or chat). Returns the account's key_id, plan, balance_units, balance_cu, balance_as_of_age_ms, and key limits.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Goes well beyond the readOnly/openWorld annotations by disclosing the auth mechanism ('x-api-key' or 'Authorization: Bearer <key>' in client config, never in tool parameters), the billing behavior (free/unbilled), and the data surface returned. The explicit warning against passing keys in parameters is exactly the kind of non-obvious operational context an agent needs.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Three sentences, front-loaded with purpose and endpoint, followed by billing and auth constraints. Dense but each sentence carries distinct information; the trailing enumeration of return fields is the only slightly padded element.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Auth requirements, cost behavior, and scope are all covered, and an output schema already exists so return values need no elaboration (the field list is a redundant but harmless bonus). An agent has everything needed to invoke this correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool takes zero parameters, so there is nothing for the description to disambiguate beyond what the schema already states. Baseline of 4 applies for a no-parameter tool with 100% schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb and resource ('Get the API key's own balance, CU, rate limits, and key parameters') and pins it to an exact endpoint (GET /v1/account). This clearly separates it from siblings like estimate_usage, get_pricing, and get_status, which cover related but distinct concerns.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides meaningful selection context by noting the call is 'Free and unbilled,' which tells an agent it can call this without cost concern, unlike usage-estimating or RPC tools. It stops short of explicitly naming an alternative or stating when-not-to-use it, so it does not reach the top of the scale.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Requires an API key. Get your account's dedicated on-chain deposit address and open networks to top up balance; only transfer to the listed networks and tokens.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and openWorldHint=true, so safety is covered. The description adds genuinely useful behavioral context beyond that: the API-key auth requirement and the constraint that only listed networks and tokens should receive transfers.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single compact sentence with the auth prerequisite front-loaded and no filler. It is tight and front-loaded, though the semicolon-joined clause packs two ideas into one sentence.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
An output schema exists, so return values need not be explained. The description covers auth, purpose, and the transfer caution. The only minor gap is the absence of any routing guidance among the many sibling tools.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool takes zero parameters, so per the baseline there is nothing for the description to disambiguate. No syntax or format details are needed, and none are missing.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb (Get) and resource (account's dedicated on-chain deposit address and open networks) with the purpose (to top up balance). An agent can distinguish this from sibling inventory tools like list_chains or get_account without opening any schema.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage context ('to top up balance') and adds a warning about transferring only to listed networks and tokens, but it never states when to use this versus alternatives such as list_chains or get_account. Usage is inferable rather than explicit.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Inspect a single method's chain-by-chain availability, Compute Unit (CU) weight, price per million calls, and documentation link. Check JSON-RPC method policy and Data API dataset coverage separately. JSON-RPC follows methods.allow and methods.deny from /v1/chains. Data API coverage follows data_features in GET /v1/status, with data enabled in /v1/chains. Pricing comes from /v1/plans. For the full system-wide pricing schedule and rate card, use get_pricing instead. For calculating projected bills for expected call volumes across methods, use estimate_usage instead.
| Name | Required | Description | Default |
|---|---|---|---|
| chain | No | Optional chain slug (e.g. 'robinhood_mainnet'). If specified, only availability for this chain is returned. | |
| method | Yes | Method name (e.g. 'eth_call', 'eth_getBalance', 'debug_traceBlockByNumber', 'data.address_balances'). |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and openWorldHint=false, so the safety profile is clear. The description adds context about where policy/coverage/pricing data originates, which is useful. However, it does not describe return format or pagination/limits; with an output schema present this is less critical, but the description could disclose more about response shape.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Front-loads the core purpose in the first sentence. The subsequent sentences provide useful routing and sourcing context, though the middle sentence about policy sources is somewhat dense. Overall efficient, but could be slightly tighter.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the output schema exists, the description needn't explain return values. It covers what data is included, where it comes from, and when to choose siblings. One gap: it doesn't mention any authentication or permission requirements, though annotations suggest a safe read. Sufficient for correct invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so both parameters are fully documented in the schema. The description mentions that availability is chain-by-chain and that specifying a chain narrows results, but this largely repeats the schema's description of the optional chain parameter. Baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb (Inspect) and resource (a single method), and enumerates the exact data returned: chain-by-chain availability, CU weight, price per million calls, and documentation link. This clearly distinguishes it from get_pricing (full schedule) and estimate_usage (projected bills).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly names two alternatives and the conditions that select them: get_pricing for system-wide pricing, estimate_usage for projected bills. Also clarifies the separate policy/coverage sources for JSON-RPC and Data API, which helps the agent know when this tool's data applies.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Live prices and plan limits from GET /v1/plans. Use before estimating cost or when asked about free credits, rate limits or per-method prices. Units: 1 billing unit = pricing.cu_per_unit CU; 1 USD buys pricing.units_per_usd units. method_weights includes JSON-RPC and Data API CU per call, push.log / push.native_transfer / push.token_transfer per delivered data event, push.history per successful history request and push.address_day per billable address-day; resolve a method by exact match, then the longest prefix rule ending in *, then the * row (JSON-RPC only; Data API and push operations have no default). free.* values are in billing units; key_defaults are the free-account new-key default CU/s and burst CU; paid_key_minimums (when present, otherwise null or absent) are the paid-account per-key lower bounds in CU/s and burst CU — a floor, not a cap, and not any key's actual value (the first paid top-up raises each key to at least this floor and higher custom limits are kept; actual limits are per key in the console). promo.ends_at is a sign-up coverage cutoff, not the end of the offer. For a single method's chain support and documentation use get_method_info instead; for projecting cycle costs use estimate_usage instead.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations only declare readOnlyHint and openWorldHint=false; the description goes far beyond them, disclosing unit semantics (1 unit = pricing.cu_per_unit CU), the exact method_weights resolution order (exact match, then longest prefix ending in '*', then the '*' row, with JSON-RPC vs Data API/push distinctions), and critical interpretation caveats such as paid_key_minimums being a floor rather than a cap and promo.ends_at being a sign-up coverage cutoff rather than the offer's end.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Purpose and trigger are front-loaded in the first two sentences, and the subsequent technical detail is dense but mostly load-bearing (prefix-match rules, floor-vs-cap caveats). It is nonetheless long for a zero-param call, and some field enumeration overlaps with the existing output schema.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Output schema exists, so return values need not be narrated, yet the description still supplies the interpretive layer an agent needs (unit conversions, floor-not-cap, cutoff-not-offer-end). For a zero-param read-only pricing lookup, nothing material is missing.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Zero parameters, so per the rubric the baseline is 4. The description compensates richly by documenting the semantics of returned fields, but the 'parameter semantics' dimension has no parameters to add meaning to.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Opens with a specific verb+resource+source: 'Live prices and plan limits from GET /v1/plans'. It explicitly denies coverage of a sibling's domain ('For a single method's chain support and documentation use get_method_info instead'), so an agent can route correctly without opening any schema.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
States a concrete trigger ('Use before estimating cost or when asked about free credits, rate limits or per-method prices') and names two alternatives with the conditions that select them: get_method_info for a single method's chain support/docs, estimate_usage for cycle cost projection. Both when-to-use and when-not-to-use are covered.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Live operational status and network health from GET /v1/status. Confirm chain status is 'ok' before calling methods; see list_chains for static chain capabilities and method policies. For Data API, data_status can be 'ok', 'syncing' (queryable and billed normally, but indexing is lagging behind latest block time), or 'unavailable'.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations only declare readOnlyHint and openWorldHint; the description adds real behavioral context beyond them — a gating prerequisite for other calls and the fact that 'syncing' is still queryable and billed normally while indexing lags. That billing/lag nuance is not derivable from the schema or annotations. It stops short of stating auth needs or freshness/refresh cadence, keeping it just under the top mark.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Purpose is front-loaded, followed by the usage rule and then status-value semantics — a sensible order with no filler sentences. The final clause is dense and packs several state definitions plus a billing implication into one sentence, which slightly taxes readability.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a zero-parameter read tool with an output schema and readOnly annotations, the description supplies everything an agent needs: what it returns at a high level, when to call it, and what the returned status values mean. Nothing material is missing.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool takes zero parameters, so per the rubric the baseline is 4; there is no parameter surface for the description to explain. The description correctly adds no parameter noise.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb+resource — 'live operational status and network health' — and anchors it to the concrete endpoint GET /v1/status. It explicitly distinguishes itself from list_chains ('static chain capabilities and method policies'), so an agent can separate the two without opening schemas.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Gives an explicit precondition ('Confirm chain status is ok before calling methods') and routes the agent to the correct alternative ('see list_chains for static chain capabilities and method policies'). Both when-to-use and when-to-use-something-else are covered.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get instructions and endpoints for obtaining a BlockVectra API key via preferred programmatic SIWE sign-up or browser handoff, plus authentication header and URL formats for JSON-RPC and Data API.
| Name | Required | Description | Default |
|---|---|---|---|
| lang | No | Response language (case-insensitive). Defaults to 'en'. |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and openWorldHint=false, so the safety profile is covered. The description still adds value by spelling out what the response contains (auth header format, JSON-RPC and Data API endpoint URLs), which is more than a bare restatement of the name.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single front-loaded sentence that delivers the purpose, the two sign-up routes, and the returned material with no filler. It is dense but every clause corresponds to real content the tool returns.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a low-parameter, read-only documentation lookup with an output schema and full annotation coverage, the description supplies enough to call it correctly. The only gap is the absence of any routing hint versus the doc-search siblings.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
There is one optional parameter (lang) with 100% schema description coverage and an enum of supported languages, so the schema fully documents it. The description adds nothing about language behavior, which is acceptable given the coverage baseline but no better than baseline.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description names a specific retrieval target (instructions and endpoints for obtaining an API key) and enumerates the content returned: SIWE sign-up, browser handoff, auth header and URL formats. That clearly separates it from generic doc tools like read_doc, search_docs and list_docs, though it never explicitly contrasts itself with them.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Saying the programmatic SIWE path is 'preferred' over browser handoff gives useful guidance on choosing an onboarding route, but there is no explicit statement of when an agent should call this tool rather than search_docs or read_doc, and no prerequisites or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Fetch supported blockchain networks and static parameters from GET /v1/chains. methods.allow and methods.deny support wildcard patterns where deny takes precedence over allow. state_window_blocks indicates the historical state window in blocks for state queries (null when full history is available); max_logs_block_range limits eth_getLogs: the range is inclusive, so toBlock - fromBlock + 1 must not exceed it, otherwise the call fails with logs_range_too_large. public describes the keyless endpoint: public.url serves only the methods in public.methods, and public.history_blocks is how far back a block reference may reach on that endpoint (it does not add methods). Pass chain (a slug such as base_mainnet) to return only that chain.
| Name | Required | Description | Default |
|---|---|---|---|
| chain | No | Optional chain slug (exact match, e.g. 'base_mainnet'). When set, only that chain is returned; unknown slugs return an error listing the available ones. Omit to list all chains. |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint and closed-world scope, and the description adds substantive behavior beyond that: wildcard precedence (deny over allow), the exact inclusive range rule for `max_logs_block_range`, the resulting `logs_range_too_large` failure, and null semantics for `state_window_blocks`. It stops short of mentioning pagination, caching, or rate limits, but the constraint disclosure is well above the annotation baseline.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Purpose is front-loaded correctly, but roughly two-thirds of the text is field-by-field documentation of the response (`methods.allow/deny`, `state_window_blocks`, `max_logs_block_range`, `public.*`) despite an output schema existing. That is dense, useful-looking but largely misplaced bulk.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a single-optional-parameter read tool with full schema coverage, annotations, and an output schema, nothing essential to invoking it correctly is missing. The remaining gap is that it never frames the decision of when to reach for this tool rather than a sibling.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100% and the schema already explains the optional `chain` slug, exact-match behavior, and the error on unknown slugs. The description's 'Pass `chain` (a slug such as `base_mainnet`)' restates rather than extends that, so the baseline 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Opens with a specific verb+resource: fetch supported blockchain networks and static parameters from `GET /v1/chains`. An agent immediately knows this is the discovery/metadata tool. It does not explicitly contrast with adjacent siblings like `get_method_info` or `get_status`, but the resource is distinct enough that confusion is unlikely.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The only usage guidance is the `chain` filter: 'Pass `chain` ... to return only that chain,' which is really parameter explanation rather than when-to-use. There is no statement of when an agent should call this versus `get_method_info` or `get_pricing`, and no prerequisites or exclusions are given.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List all available documentation pages, relative paths, and titles from the static documentation index, including webhook push subscriptions, signatures, delivery and billing. Available without an API key.
| Name | Required | Description | Default |
|---|---|---|---|
| lang | No | Published documentation language (case-insensitive, e.g. zh-hant or zh-Hant). Omit for English; unavailable languages return an error. |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and openWorldHint=false, so the safety profile is covered. The description adds genuine context beyond that: the source is a 'static documentation index' (fixed, not live) and access requires no API key — both operationally useful facts.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
One sentence, front-loaded with the core action and result shape. The trailing 'including webhook push subscriptions, signatures, delivery and billing' is a somewhat odd topical enumeration but not enough to count as waste.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
An output schema exists, so return-value explanation is unnecessary. The definition covers what is listed, where it comes from, and the auth posture — sufficient for an agent to call it correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, and the single optional lang param is fully documented in-schema (case-insensitive, omit for English, error on unavailable languages). The description adds no parameter detail, so the baseline 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb (List) and resource (documentation pages), and goes further to name the payload — relative paths and titles — from the static documentation index. It is distinguishable from read_doc and search_docs in spirit, though it never explicitly contrasts itself with those siblings.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Conveys implied usage as a discovery/index tool and notes the useful constraint 'Available without an API key,' but gives no explicit when-to-use or when-not-to-use guidance relative to read_doc or search_docs.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Read the raw Markdown content of a documentation page from /md/{lang}/{path}.md. Path must be an internal relative path (e.g. 'quickstart', 'guides/ai-agents', 'api/json-rpc', 'chains').
| Name | Required | Description | Default |
|---|---|---|---|
| lang | No | Published documentation language (case-insensitive, e.g. zh-hant or zh-Hant). Omit for English; unavailable languages return an error. | |
| path | Yes | Internal relative documentation path (e.g. 'quickstart', 'guides/ai-agents', 'api/json-rpc'). Do not include protocol, hostname, query string, fragment, or '..'. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and openWorldHint=false, so safety is covered. The description adds that the return value is raw Markdown, which is useful beyond the annotations, but says nothing about missing-page errors, size limits, or caching behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, no filler, with the resource and route front-loaded followed by the path constraint. Every clause earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With no output schema, the description correctly states what is returned (raw Markdown), and the parameter contract is fully documented by the schema plus annotations. Minor gaps remain around error handling for unavailable languages or missing paths, which the schema only partially covers.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the baseline is 3, but the description adds value by showing how lang and path compose into the URL template (/md/{lang}/{path}.md) and by providing an extra path example not in the schema. It reinforces rather than merely repeats the constraints.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb ("Read") and resource ("raw Markdown content of a documentation page") and even exposes the underlying route (/md/{lang}/{path}.md). This clearly distinguishes it from siblings like list_docs and search_docs, which enumerate or query rather than fetch a specific page's raw content.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Usage is only implied: the agent can infer it should call this to fetch one known page's raw text, but no explicit when-to-use or when-not-to-use guidance is given, and no alternatives (search_docs, list_docs) are named. The path-format constraint is parameter guidance, not usage routing.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Execute a read-only JSON-RPC 2.0 method on a specified blockchain network using your BlockVectra API key, or via the keyless public endpoint if available on the chain. Chain slugs look like 'base_mainnet'; take them from list_chains. Without a key the call goes to the keyless endpoint /v1/{chain}/public (the chain's public.url in list_chains), which only serves the methods listed in that chain's public.methods. Write methods (such as 'eth_sendRawTransaction') are not supported in rpc_call; use 'send_raw_transaction' instead. Consult the Ethereum JSON-RPC specification (https://ethereum.org/en/developers/docs/apis/json-rpc/) and the BlockVectra method reference (https://docs.blockvectra.com/en/api/json-rpc/methods/). With a key, set the 'x-api-key' or 'Authorization: Bearer ' HTTP header in your MCP client configuration for full access (keys must not be passed in tool parameters or chat). Returns the raw JSON-RPC response from the server.
| Name | Required | Description | Default |
|---|---|---|---|
| chain | Yes | Target blockchain network slug (e.g. 'base_mainnet'). Must exist in GET /v1/chains; list_chains returns the valid slugs. | |
| method | Yes | JSON-RPC 2.0 method name (e.g. 'eth_blockNumber', 'eth_call', 'eth_getLogs'). Write methods are not accepted. | |
| params | No | Optional JSON-RPC parameter array. Defaults to []. |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already cover readOnlyHint and openWorldHint, and the description still adds substantive context: the keyless fallback path `/v1/{chain}/public`, its restriction to the chain's `public.methods` allowlist, the auth header mechanism ('x-api-key' or Bearer), and the warning that keys must never be passed as tool parameters. That is real behavioral disclosure beyond structured data.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The operation and its scope are front-loaded in the first clause, and each following sentence carries a distinct constraint (chain naming, keyless path, write-method exclusion, auth placement, references). Documentation links are the only borderline filler and they serve a real lookup need for method semantics.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
An output schema exists, so return details are not required, yet the description still notes that the raw JSON-RPC server response is returned. Auth requirements, fallback behavior, and the write-method boundary are all covered, leaving nothing an agent needs in order to invoke this correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so the baseline is 3. The description still adds orientation: chain slugs come from list_chains and follow the 'base_mainnet' shape, method must be a non-write JSON-RPC name, and params is the optional positional array defaulting to []. It stops short of adding syntax detail the schema lacks, so it earns 4 rather than 5.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb and resource ('Execute a read-only JSON-RPC 2.0 method on a specified blockchain network') and immediately scopes what it does not do (write methods). This clearly separates it from the sibling send_raw_transaction without opening either schema.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly names the alternative for write operations ('use send_raw_transaction instead') and lays out the conditional branches: keyless endpoint when no API key is configured, full access with a key. It also points to list_chains for valid slugs and external specs for method semantics.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Find documentation by topic or task keywords when the page path is unknown. Searches page titles, navigation titles, relative paths, and page summaries, returning titles, relative paths, and summaries. Read a result with read_doc using its path and the same lang; use read_doc directly for a known path or list_docs to browse the documentation catalog. Omit lang for English; limit is 1-20 (default 5). If no results match, try broader keywords or browse list_docs. Available without an API key.
| Name | Required | Description | Default |
|---|---|---|---|
| lang | No | Published documentation language (case-insensitive, e.g. zh-hant or zh-Hant). Omit for English; unavailable languages return an error. | |
| limit | No | Maximum number of search results to return (1-20, default 5). | |
| query | Yes | Keywords to search for in documentation titles, navigation titles, paths, and summaries. |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint and openWorldHint=false, but the description adds real value beyond them: it states the tool works without an API key, lists what it returns (titles, relative paths, summaries), and prescribes recovery when nothing matches. It doesn't discuss pagination or ranking, which keeps it from a 5.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Front-loaded with purpose and routing before operational details, and every sentence carries information (search scope, handoff, defaults, fallback, auth). It is dense and slightly run-on across topics but wastes little.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a three-parameter search tool with an output schema, the description covers everything an agent needs: purpose, search fields, routing to siblings, language/limit handling, failure recovery, and API-key requirement. Nothing material is left ambiguous.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% and the schema already documents lang's default (omit for English), the enum, and the limit range (1-20, default 5). The description largely restates these, adding no syntax or semantic detail beyond the schema, so the baseline 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb (Find/Searches) and resource (documentation), and explicitly scopes it to the case where the page path is unknown. It names which fields are searched and clearly differentiates itself from read_doc and list_docs.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Gives explicit routing: use read_doc for a known path, list_docs to browse, and this tool when the path is unknown. It even covers the no-results fallback (broaden keywords or use list_docs), so an agent never has to infer the alternative.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Broadcast a signed raw transaction to a specified blockchain network via eth_sendRawTransaction. Requires the 'x-api-key' or 'Authorization: Bearer ' HTTP header in your MCP client configuration for full access, or uses the keyless public endpoint if permitted on the chain (keys must not be passed in tool parameters or chat). Returns the transaction hash or JSON-RPC error.
| Name | Required | Description | Default |
|---|---|---|---|
| chain | Yes | Target blockchain network slug (e.g. 'robinhood_mainnet'). Must exist in GET /v1/chains. | |
| raw_tx | Yes | Signed raw transaction data as a 0x-prefixed hex string (the RLP-encoded raw transaction). |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnly=false and destructive=true, and the description adds genuinely new context: the required x-api-key/Authorization header, the warning that keys must not appear in parameters or chat, and the keyless-endpoint fallback. It stops short of warning that a broadcast is irreversible or explaining failure/reversion semantics, which matters for a destructive open-world call.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Three sentences, front-loaded with the action, then auth requirement, then return value. Each sentence carries information, though the auth clause is dense and could be tightened.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
An output schema exists, so explaining return values is optional, yet the description still names the tx hash or JSON-RPC error. Auth is covered, which is the main gap for a destructive, open-world tool; only the irreversibility of broadcasting is unaddressed.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so both parameters are fully documented in the schema, including the hex pattern for raw_tx and the chain slug cross-reference to GET /v1/chains. The description adds no syntax or format detail beyond this, so the baseline 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb (broadcast) and resource (signed raw transaction) and names the underlying RPC method (eth_sendRawTransaction), so the agent knows exactly what wire call is made. It doesn't explicitly differentiate from the sibling rpc_call tool, which could also send this payload, so it falls short of a 5.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides context on access (API key header vs keyless public endpoint) but gives no guidance on when to pick this tool versus the generic rpc_call sibling, nor when a chain doesn't permit keyless use. Usage is implied rather than stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
get_pricing1 field changedOutput schema / anyOfPrevious value: -[
- {
- "allOf": [
- {
- "properties": {
- "free": {
- "type": "object"
- },
- "key_defaults": {
- "type": "object"
- },
- "method_weights": {
- "type": "array"
- },
- "pricing": {
- "type": "object"
- }
- },
- "required": [
- "pricing",
- "method_weights"
- ],
- "type": "object"
- },
- {
- "not": {
- "properties": {
- "error": {
- "const": "invalid_tool_arguments",
- "type": "string"
- }
- },
- "required": [
- "error"
- ],
- "type": "object"
- }
- }
- ]
- },
- {
- "additionalProperties": false,
- "properties": {
- "error": {
- "const": "invalid_tool_arguments",
- "type": "string"
- },
- "message": {
- "minLength": 1,
- "type": "string"
- },
- "reason": {
- "enum": [
- "invalid_root",
- "schema_type",
- "schema_enum",
- "undeclared_property",
- "credential_field",
- "credential_value"
- ],
- "type": "string"
- }
- },
- "required": [
- "error",
- "reason",
- "message"
- ],
- "type": "object"
- }
-]New value: +[
+ {
+ "allOf": [
+ {
+ "properties": {
+ "free": {
+ "type": "object"
+ },
+ "key_defaults": {
+ "type": "object"
+ },
+ "method_weights": {
+ "type": "array"
+ },
+ "paid_key_minimums": {
+ "type": [
+ "object",
+ "null"
+ ]
+ },
+ "pricing": {
+ "type": "object"
+ }
+ },
+ "required": [
+ "pricing",
+ "method_weights"
+ ],
+ "type": "object"
+ },
+ {
+ "not": {
+ "properties": {
+ "error": {
+ "const": "invalid_tool_arguments",
+ "type": "string"
+ }
+ },
+ "required": [
+ "error"
+ ],
+ "type": "object"
+ }
+ }
+ ]
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "error": {
+ "const": "invalid_tool_arguments",
+ "type": "string"
+ },
+ "message": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "reason": {
+ "enum": [
+ "invalid_root",
+ "schema_type",
+ "schema_enum",
+ "undeclared_property",
+ "credential_field",
+ "credential_value"
+ ],
+ "type": "string"
+ }
+ },
+ "required": [
+ "error",
+ "reason",
+ "message"
+ ],
+ "type": "object"
+ }
+]data_api_get1 field changedOutput schema / anyOfPrevious value: -[
- {
- "allOf": [
- {
- "properties": {
- "_truncated": {
- "type": "boolean"
- },
- "balance_units": {
- "description": "Remaining balance units after this request (only present when balance is known and x-bv-meter: 1 was sent).",
- "type": "integer"
- },
- "bytes": {
- "type": "integer"
- },
- "cu_charged": {
- "description": "Compute Units billed for this request (only present when charged and x-bv-meter: 1 was sent).",
- "type": "integer"
- },
- "data": {},
- "error": {
- "type": "string"
- },
- "status": {
- "type": "number"
- }
- },
- "type": "object"
- },
- {
- "not": {
- "properties": {
- "error": {
- "const": "invalid_tool_arguments",
- "type": "string"
- }
- },
- "required": [
- "error"
- ],
- "type": "object"
- }
- }
- ]
- },
- {
- "additionalProperties": false,
- "properties": {
- "error": {
- "const": "invalid_tool_arguments",
- "type": "string"
- },
- "message": {
- "minLength": 1,
- "type": "string"
- },
- "reason": {
- "enum": [
- "invalid_root",
- "schema_type",
- "schema_enum",
- "undeclared_property",
- "credential_field",
- "credential_value"
- ],
- "type": "string"
- }
- },
- "required": [
- "error",
- "reason",
- "message"
- ],
- "type": "object"
- }
-]New value: +[
+ {
+ "allOf": [
+ {
+ "anyOf": [
+ {
+ "allOf": [
+ {
+ "properties": {
+ "_truncated": {
+ "type": "boolean"
+ },
+ "balance_units": {
+ "description": "Remaining balance units after this request (only present when balance is known and x-bv-meter: 1 was sent).",
+ "type": "integer"
+ },
+ "bytes": {
+ "type": "integer"
+ },
+ "cu_charged": {
+ "description": "Compute Units billed for this request (only present when charged and x-bv-meter: 1 was sent).",
+ "type": "integer"
+ },
+ "data": {},
+ "error": {
+ "type": "string"
+ },
+ "status": {
+ "type": "number"
+ }
+ },
+ "type": "object"
+ },
+ {
+ "not": {
+ "properties": {
+ "error": {
+ "const": "executor_request_rejected",
+ "type": "string"
+ }
+ },
+ "required": [
+ "error"
+ ],
+ "type": "object"
+ }
+ }
+ ]
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "error": {
+ "const": "executor_request_rejected",
+ "type": "string"
+ },
+ "message": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "reason": {
+ "enum": [
+ "chain_invalid",
+ "path_invalid"
+ ],
+ "type": "string"
+ }
+ },
+ "required": [
+ "error",
+ "reason",
+ "message"
+ ],
+ "type": "object"
+ }
+ ],
+ "type": "object"
+ },
+ {
+ "not": {
+ "properties": {
+ "error": {
+ "const": "invalid_tool_arguments",
+ "type": "string"
+ }
+ },
+ "required": [
+ "error"
+ ],
+ "type": "object"
+ }
+ }
+ ]
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "error": {
+ "const": "invalid_tool_arguments",
+ "type": "string"
+ },
+ "message": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "reason": {
+ "enum": [
+ "invalid_root",
+ "schema_type",
+ "schema_enum",
+ "undeclared_property",
+ "credential_field",
+ "credential_value"
+ ],
+ "type": "string"
+ }
+ },
+ "required": [
+ "error",
+ "reason",
+ "message"
+ ],
+ "type": "object"
+ }
+]estimate_usage1 field changedOutput schema / anyOfPrevious value: -[
- {
- "allOf": [
- {
- "anyOf": [
- {
- "required": [
- "method",
- "calls_per_day"
- ]
- },
- {
- "not": {
- "anyOf": [
- {
- "required": [
- "method"
- ]
- },
- {
- "required": [
- "calls_per_day"
- ]
- },
- {
- "required": [
- "cu_weight"
- ]
- }
- ]
- },
- "properties": {
- "lines": {
- "minItems": 2,
- "type": "array"
- }
- },
- "required": [
- "lines",
- "daily_cu",
- "daily_cost_usd",
- "cycle_days",
- "cycle_cu",
- "cycle_cost_usd"
- ]
- }
- ],
- "properties": {
- "average_calls_per_sec": {
- "type": "number"
- },
- "calls_per_day": {
- "type": "number"
- },
- "cu_weight": {
- "type": [
- "number",
- "null"
- ]
- },
- "cycle_cost_usd": {
- "type": [
- "number",
- "null"
- ]
- },
- "cycle_cu": {
- "type": "number"
- },
- "cycle_days": {
- "type": "number"
- },
- "daily_cost_usd": {
- "type": [
- "number",
- "null"
- ]
- },
- "daily_cu": {
- "type": "number"
- },
- "exceeds_free_quota": {
- "type": "boolean"
- },
- "exceeds_rate_limit": {
- "type": "boolean"
- },
- "free_quota_cu": {
- "type": [
- "number",
- "null"
- ]
- },
- "lines": {
- "items": {
- "properties": {
- "calls_per_day": {
- "type": "number"
- },
- "cu_weight": {
- "type": "number"
- },
- "daily_cost_usd": {
- "type": [
- "number",
- "null"
- ]
- },
- "daily_cu": {
- "type": "number"
- },
- "method": {
- "type": "string"
- }
- },
- "required": [
- "method",
- "calls_per_day",
- "cu_weight",
- "daily_cu",
- "daily_cost_usd"
- ],
- "type": "object"
- },
- "type": "array"
- },
- "max_calls_per_sec": {
- "type": [
- "number",
- "null"
- ]
- },
- "method": {
- "type": "string"
- },
- "quota_percent": {
- "type": [
- "number",
- "null"
- ]
- }
- },
- "type": "object"
- },
- {
- "not": {
- "properties": {
- "error": {
- "const": "invalid_tool_arguments",
- "type": "string"
- }
- },
- "required": [
- "error"
- ],
- "type": "object"
- }
- }
- ]
- },
- {
- "additionalProperties": false,
- "properties": {
- "error": {
- "const": "invalid_tool_arguments",
- "type": "string"
- },
- "message": {
- "minLength": 1,
- "type": "string"
- },
- "reason": {
- "enum": [
- "invalid_root",
- "schema_type",
- "schema_enum",
- "undeclared_property",
- "credential_field",
- "credential_value"
- ],
- "type": "string"
- }
- },
- "required": [
- "error",
- "reason",
- "message"
- ],
- "type": "object"
- }
-]New value: +[
+ {
+ "allOf": [
+ {
+ "anyOf": [
+ {
+ "allOf": [
+ {
+ "anyOf": [
+ {
+ "required": [
+ "method",
+ "calls_per_day"
+ ]
+ },
+ {
+ "not": {
+ "anyOf": [
+ {
+ "required": [
+ "method"
+ ]
+ },
+ {
+ "required": [
+ "calls_per_day"
+ ]
+ },
+ {
+ "required": [
+ "cu_weight"
+ ]
+ }
+ ]
+ },
+ "properties": {
+ "lines": {
+ "minItems": 2,
+ "type": "array"
+ }
+ },
+ "required": [
+ "lines",
+ "daily_cu",
+ "daily_cost_usd",
+ "cycle_days",
+ "cycle_cu",
+ "cycle_cost_usd"
+ ]
+ }
+ ],
+ "properties": {
+ "average_calls_per_sec": {
+ "type": "number"
+ },
+ "calls_per_day": {
+ "type": "number"
+ },
+ "cu_weight": {
+ "type": [
+ "number",
+ "null"
+ ]
+ },
+ "cycle_cost_usd": {
+ "type": [
+ "number",
+ "null"
+ ]
+ },
+ "cycle_cu": {
+ "type": "number"
+ },
+ "cycle_days": {
+ "type": "number"
+ },
+ "daily_cost_usd": {
+ "type": [
+ "number",
+ "null"
+ ]
+ },
+ "daily_cu": {
+ "type": "number"
+ },
+ "exceeds_free_quota": {
+ "type": "boolean"
+ },
+ "exceeds_rate_limit": {
+ "type": "boolean"
+ },
+ "free_quota_cu": {
+ "type": [
+ "number",
+ "null"
+ ]
+ },
+ "lines": {
+ "items": {
+ "properties": {
+ "calls_per_day": {
+ "type": "number"
+ },
+ "cu_weight": {
+ "type": "number"
+ },
+ "daily_cost_usd": {
+ "type": [
+ "number",
+ "null"
+ ]
+ },
+ "daily_cu": {
+ "type": "number"
+ },
+ "method": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "method",
+ "calls_per_day",
+ "cu_weight",
+ "daily_cu",
+ "daily_cost_usd"
+ ],
+ "type": "object"
+ },
+ "type": "array"
+ },
+ "max_calls_per_sec": {
+ "type": [
+ "number",
+ "null"
+ ]
+ },
+ "method": {
+ "type": "string"
+ },
+ "quota_percent": {
+ "type": [
+ "number",
+ "null"
+ ]
+ }
+ },
+ "type": "object"
+ },
+ {
+ "not": {
+ "properties": {
+ "error": {
+ "const": "executor_request_rejected",
+ "type": "string"
+ }
+ },
+ "required": [
+ "error"
+ ],
+ "type": "object"
+ }
+ }
+ ]
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "error": {
+ "const": "executor_request_rejected",
+ "type": "string"
+ },
+ "message": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "reason": {
+ "enum": [
+ "method_required",
+ "calls_per_day_invalid"
+ ],
+ "type": "string"
+ }
+ },
+ "required": [
+ "error",
+ "reason",
+ "message"
+ ],
+ "type": "object"
+ }
+ ],
+ "type": "object"
+ },
+ {
+ "not": {
+ "properties": {
+ "error": {
+ "const": "invalid_tool_arguments",
+ "type": "string"
+ }
+ },
+ "required": [
+ "error"
+ ],
+ "type": "object"
+ }
+ }
+ ]
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "error": {
+ "const": "invalid_tool_arguments",
+ "type": "string"
+ },
+ "message": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "reason": {
+ "enum": [
+ "invalid_root",
+ "schema_type",
+ "schema_enum",
+ "undeclared_property",
+ "credential_field",
+ "credential_value"
+ ],
+ "type": "string"
+ }
+ },
+ "required": [
+ "error",
+ "reason",
+ "message"
+ ],
+ "type": "object"
+ }
+]get_method_info1 field changedOutput schema / anyOfPrevious value: -[
- {
- "allOf": [
- {
- "properties": {
- "available_chains": {
- "items": {
- "type": "string"
- },
- "type": "array"
- },
- "chain": {
- "type": [
- "string",
- "null"
- ]
- },
- "cost_per_million_usd": {
- "type": [
- "number",
- "null"
- ]
- },
- "cu_weight": {
- "type": [
- "number",
- "null"
- ]
- },
- "docs_url": {
- "type": [
- "string",
- "null"
- ]
- },
- "method": {
- "type": "string"
- },
- "notes": {
- "type": [
- "string",
- "null"
- ]
- },
- "supported": {
- "type": "boolean"
- }
- },
- "required": [
- "method",
- "supported",
- "available_chains"
- ],
- "type": "object"
- },
- {
- "not": {
- "properties": {
- "error": {
- "const": "invalid_tool_arguments",
- "type": "string"
- }
- },
- "required": [
- "error"
- ],
- "type": "object"
- }
- }
- ]
- },
- {
- "additionalProperties": false,
- "properties": {
- "error": {
- "const": "invalid_tool_arguments",
- "type": "string"
- },
- "message": {
- "minLength": 1,
- "type": "string"
- },
- "reason": {
- "enum": [
- "invalid_root",
- "schema_type",
- "schema_enum",
- "undeclared_property",
- "credential_field",
- "credential_value"
- ],
- "type": "string"
- }
- },
- "required": [
- "error",
- "reason",
- "message"
- ],
- "type": "object"
- }
-]New value: +[
+ {
+ "allOf": [
+ {
+ "anyOf": [
+ {
+ "allOf": [
+ {
+ "properties": {
+ "available_chains": {
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+ },
+ "chain": {
+ "type": [
+ "string",
+ "null"
+ ]
+ },
+ "cost_per_million_usd": {
+ "type": [
+ "number",
+ "null"
+ ]
+ },
+ "cu_weight": {
+ "type": [
+ "number",
+ "null"
+ ]
+ },
+ "docs_url": {
+ "type": [
+ "string",
+ "null"
+ ]
+ },
+ "method": {
+ "type": "string"
+ },
+ "notes": {
+ "type": [
+ "string",
+ "null"
+ ]
+ },
+ "supported": {
+ "type": "boolean"
+ }
+ },
+ "required": [
+ "method",
+ "supported",
+ "available_chains"
+ ],
+ "type": "object"
+ },
+ {
+ "not": {
+ "properties": {
+ "error": {
+ "const": "executor_request_rejected",
+ "type": "string"
+ }
+ },
+ "required": [
+ "error"
+ ],
+ "type": "object"
+ }
+ }
+ ]
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "error": {
+ "const": "executor_request_rejected",
+ "type": "string"
+ },
+ "message": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "reason": {
+ "enum": [
+ "method_required"
+ ],
+ "type": "string"
+ }
+ },
+ "required": [
+ "error",
+ "reason",
+ "message"
+ ],
+ "type": "object"
+ }
+ ],
+ "type": "object"
+ },
+ {
+ "not": {
+ "properties": {
+ "error": {
+ "const": "invalid_tool_arguments",
+ "type": "string"
+ }
+ },
+ "required": [
+ "error"
+ ],
+ "type": "object"
+ }
+ }
+ ]
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "error": {
+ "const": "invalid_tool_arguments",
+ "type": "string"
+ },
+ "message": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "reason": {
+ "enum": [
+ "invalid_root",
+ "schema_type",
+ "schema_enum",
+ "undeclared_property",
+ "credential_field",
+ "credential_value"
+ ],
+ "type": "string"
+ }
+ },
+ "required": [
+ "error",
+ "reason",
+ "message"
+ ],
+ "type": "object"
+ }
+]rpc_call1 field changedOutput schema / anyOfPrevious value: -[
- {
- "allOf": [
- {
- "properties": {
- "balance_units": {
- "description": "Remaining balance units after this request (only present when balance is known and x-bv-meter: 1 was sent).",
- "type": "integer"
- },
- "cu_charged": {
- "description": "Compute Units billed for this request (only present when charged and x-bv-meter: 1 was sent).",
- "type": "integer"
- },
- "error": {
- "properties": {
- "code": {
- "type": "number"
- },
- "docs_url": {
- "type": [
- "string",
- "null"
- ]
- },
- "message": {
- "type": "string"
- },
- "reason": {
- "type": [
- "string",
- "null"
- ]
- }
- },
- "type": [
- "object",
- "string"
- ]
- },
- "help": {
- "properties": {
- "guide_url": {
- "type": "string"
- },
- "tool": {
- "type": "string"
- }
- },
- "type": "object"
- },
- "id": {
- "type": [
- "number",
- "string",
- "null"
- ]
- },
- "jsonrpc": {
- "type": "string"
- },
- "message": {
- "type": "string"
- },
- "result": {},
- "signup_url": {
- "description": "Registration and sign-up URL (returned when rate-limited on the public endpoint).",
- "type": "string"
- }
- },
- "type": "object"
- },
- {
- "not": {
- "properties": {
- "error": {
- "const": "invalid_tool_arguments",
- "type": "string"
- }
- },
- "required": [
- "error"
- ],
- "type": "object"
- }
- }
- ]
- },
- {
- "additionalProperties": false,
- "properties": {
- "error": {
- "const": "invalid_tool_arguments",
- "type": "string"
- },
- "message": {
- "minLength": 1,
- "type": "string"
- },
- "reason": {
- "enum": [
- "invalid_root",
- "schema_type",
- "schema_enum",
- "undeclared_property",
- "credential_field",
- "credential_value"
- ],
- "type": "string"
- }
- },
- "required": [
- "error",
- "reason",
- "message"
- ],
- "type": "object"
- }
-]New value: +[
+ {
+ "allOf": [
+ {
+ "anyOf": [
+ {
+ "allOf": [
+ {
+ "properties": {
+ "balance_units": {
+ "description": "Remaining balance units after this request (only present when balance is known and x-bv-meter: 1 was sent).",
+ "type": "integer"
+ },
+ "cu_charged": {
+ "description": "Compute Units billed for this request (only present when charged and x-bv-meter: 1 was sent).",
+ "type": "integer"
+ },
+ "error": {
+ "properties": {
+ "code": {
+ "type": "number"
+ },
+ "docs_url": {
+ "type": [
+ "string",
+ "null"
+ ]
+ },
+ "message": {
+ "type": "string"
+ },
+ "reason": {
+ "type": [
+ "string",
+ "null"
+ ]
+ }
+ },
+ "type": [
+ "object",
+ "string"
+ ]
+ },
+ "help": {
+ "properties": {
+ "guide_url": {
+ "type": "string"
+ },
+ "tool": {
+ "type": "string"
+ }
+ },
+ "type": "object"
+ },
+ "id": {
+ "type": [
+ "number",
+ "string",
+ "null"
+ ]
+ },
+ "jsonrpc": {
+ "type": "string"
+ },
+ "message": {
+ "type": "string"
+ },
+ "result": {},
+ "signup_url": {
+ "description": "Registration and sign-up URL (returned when rate-limited on the public endpoint).",
+ "type": "string"
+ }
+ },
+ "type": "object"
+ },
+ {
+ "not": {
+ "properties": {
+ "error": {
+ "const": "executor_request_rejected",
+ "type": "string"
+ }
+ },
+ "required": [
+ "error"
+ ],
+ "type": "object"
+ }
+ }
+ ]
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "error": {
+ "const": "executor_request_rejected",
+ "type": "string"
+ },
+ "message": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "reason": {
+ "enum": [
+ "chain_required",
+ "method_required",
+ "unknown_chain"
+ ],
+ "type": "string"
+ }
+ },
+ "required": [
+ "error",
+ "reason",
+ "message"
+ ],
+ "type": "object"
+ }
+ ],
+ "type": "object"
+ },
+ {
+ "not": {
+ "properties": {
+ "error": {
+ "const": "invalid_tool_arguments",
+ "type": "string"
+ }
+ },
+ "required": [
+ "error"
+ ],
+ "type": "object"
+ }
+ }
+ ]
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "error": {
+ "const": "invalid_tool_arguments",
+ "type": "string"
+ },
+ "message": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "reason": {
+ "enum": [
+ "invalid_root",
+ "schema_type",
+ "schema_enum",
+ "undeclared_property",
+ "credential_field",
+ "credential_value"
+ ],
+ "type": "string"
+ }
+ },
+ "required": [
+ "error",
+ "reason",
+ "message"
+ ],
+ "type": "object"
+ }
+]search_docs1 field changedOutput schema / anyOfPrevious value: -[
- {
- "allOf": [
- {
- "properties": {
- "message": {
- "type": "string"
- },
- "results": {
- "items": {
- "properties": {
- "path": {
- "type": "string"
- },
- "summary": {
- "type": "string"
- },
- "title": {
- "type": "string"
- }
- },
- "required": [
- "title",
- "path",
- "summary"
- ],
- "type": "object"
- },
- "type": "array"
- }
- },
- "required": [
- "results"
- ],
- "type": "object"
- },
- {
- "not": {
- "properties": {
- "error": {
- "const": "invalid_tool_arguments",
- "type": "string"
- }
- },
- "required": [
- "error"
- ],
- "type": "object"
- }
- }
- ]
- },
- {
- "additionalProperties": false,
- "properties": {
- "error": {
- "const": "invalid_tool_arguments",
- "type": "string"
- },
- "message": {
- "minLength": 1,
- "type": "string"
- },
- "reason": {
- "enum": [
- "invalid_root",
- "schema_type",
- "schema_enum",
- "undeclared_property",
- "credential_field",
- "credential_value"
- ],
- "type": "string"
- }
- },
- "required": [
- "error",
- "reason",
- "message"
- ],
- "type": "object"
- }
-]New value: +[
+ {
+ "allOf": [
+ {
+ "anyOf": [
+ {
+ "allOf": [
+ {
+ "properties": {
+ "message": {
+ "type": "string"
+ },
+ "results": {
+ "items": {
+ "properties": {
+ "path": {
+ "type": "string"
+ },
+ "summary": {
+ "type": "string"
+ },
+ "title": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "title",
+ "path",
+ "summary"
+ ],
+ "type": "object"
+ },
+ "type": "array"
+ }
+ },
+ "required": [
+ "results"
+ ],
+ "type": "object"
+ },
+ {
+ "not": {
+ "properties": {
+ "error": {
+ "const": "executor_request_rejected",
+ "type": "string"
+ }
+ },
+ "required": [
+ "error"
+ ],
+ "type": "object"
+ }
+ }
+ ]
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "error": {
+ "const": "executor_request_rejected",
+ "type": "string"
+ },
+ "message": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "reason": {
+ "enum": [
+ "query_required"
+ ],
+ "type": "string"
+ }
+ },
+ "required": [
+ "error",
+ "reason",
+ "message"
+ ],
+ "type": "object"
+ }
+ ],
+ "type": "object"
+ },
+ {
+ "not": {
+ "properties": {
+ "error": {
+ "const": "invalid_tool_arguments",
+ "type": "string"
+ }
+ },
+ "required": [
+ "error"
+ ],
+ "type": "object"
+ }
+ }
+ ]
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "error": {
+ "const": "invalid_tool_arguments",
+ "type": "string"
+ },
+ "message": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "reason": {
+ "enum": [
+ "invalid_root",
+ "schema_type",
+ "schema_enum",
+ "undeclared_property",
+ "credential_field",
+ "credential_value"
+ ],
+ "type": "string"
+ }
+ },
+ "required": [
+ "error",
+ "reason",
+ "message"
+ ],
+ "type": "object"
+ }
+]send_raw_transaction1 field changedOutput schema / anyOfPrevious value: -[
- {
- "allOf": [
- {
- "properties": {
- "balance_units": {
- "description": "Remaining balance units after this request (only present when balance is known and x-bv-meter: 1 was sent).",
- "type": "integer"
- },
- "cu_charged": {
- "description": "Compute Units billed for this request (only present when charged and x-bv-meter: 1 was sent).",
- "type": "integer"
- },
- "error": {
- "properties": {
- "code": {
- "type": "number"
- },
- "docs_url": {
- "type": [
- "string",
- "null"
- ]
- },
- "message": {
- "type": "string"
- },
- "reason": {
- "type": [
- "string",
- "null"
- ]
- }
- },
- "type": [
- "object",
- "string"
- ]
- },
- "help": {
- "properties": {
- "guide_url": {
- "type": "string"
- },
- "tool": {
- "type": "string"
- }
- },
- "type": "object"
- },
- "id": {
- "type": [
- "number",
- "string",
- "null"
- ]
- },
- "jsonrpc": {
- "type": "string"
- },
- "message": {
- "type": "string"
- },
- "result": {},
- "signup_url": {
- "description": "Registration and sign-up URL (returned when rate-limited on the public endpoint).",
- "type": "string"
- }
- },
- "type": "object"
- },
- {
- "not": {
- "properties": {
- "error": {
- "const": "invalid_tool_arguments",
- "type": "string"
- }
- },
- "required": [
- "error"
- ],
- "type": "object"
- }
- }
- ]
- },
- {
- "additionalProperties": false,
- "properties": {
- "error": {
- "const": "invalid_tool_arguments",
- "type": "string"
- },
- "message": {
- "minLength": 1,
- "type": "string"
- },
- "reason": {
- "enum": [
- "invalid_root",
- "schema_type",
- "schema_enum",
- "undeclared_property",
- "credential_field",
- "credential_value"
- ],
- "type": "string"
- }
- },
- "required": [
- "error",
- "reason",
- "message"
- ],
- "type": "object"
- }
-]New value: +[
+ {
+ "allOf": [
+ {
+ "anyOf": [
+ {
+ "allOf": [
+ {
+ "properties": {
+ "balance_units": {
+ "description": "Remaining balance units after this request (only present when balance is known and x-bv-meter: 1 was sent).",
+ "type": "integer"
+ },
+ "cu_charged": {
+ "description": "Compute Units billed for this request (only present when charged and x-bv-meter: 1 was sent).",
+ "type": "integer"
+ },
+ "error": {
+ "properties": {
+ "code": {
+ "type": "number"
+ },
+ "docs_url": {
+ "type": [
+ "string",
+ "null"
+ ]
+ },
+ "message": {
+ "type": "string"
+ },
+ "reason": {
+ "type": [
+ "string",
+ "null"
+ ]
+ }
+ },
+ "type": [
+ "object",
+ "string"
+ ]
+ },
+ "help": {
+ "properties": {
+ "guide_url": {
+ "type": "string"
+ },
+ "tool": {
+ "type": "string"
+ }
+ },
+ "type": "object"
+ },
+ "id": {
+ "type": [
+ "number",
+ "string",
+ "null"
+ ]
+ },
+ "jsonrpc": {
+ "type": "string"
+ },
+ "message": {
+ "type": "string"
+ },
+ "result": {},
+ "signup_url": {
+ "description": "Registration and sign-up URL (returned when rate-limited on the public endpoint).",
+ "type": "string"
+ }
+ },
+ "type": "object"
+ },
+ {
+ "not": {
+ "properties": {
+ "error": {
+ "const": "executor_request_rejected",
+ "type": "string"
+ }
+ },
+ "required": [
+ "error"
+ ],
+ "type": "object"
+ }
+ }
+ ]
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "error": {
+ "const": "executor_request_rejected",
+ "type": "string"
+ },
+ "message": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "reason": {
+ "enum": [
+ "chain_required",
+ "raw_tx_required",
+ "unknown_chain"
+ ],
+ "type": "string"
+ }
+ },
+ "required": [
+ "error",
+ "reason",
+ "message"
+ ],
+ "type": "object"
+ }
+ ],
+ "type": "object"
+ },
+ {
+ "not": {
+ "properties": {
+ "error": {
+ "const": "invalid_tool_arguments",
+ "type": "string"
+ }
+ },
+ "required": [
+ "error"
+ ],
+ "type": "object"
+ }
+ }
+ ]
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "error": {
+ "const": "invalid_tool_arguments",
+ "type": "string"
+ },
+ "message": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "reason": {
+ "enum": [
+ "invalid_root",
+ "schema_type",
+ "schema_enum",
+ "undeclared_property",
+ "credential_field",
+ "credential_value"
+ ],
+ "type": "string"
+ }
+ },
+ "required": [
+ "error",
+ "reason",
+ "message"
+ ],
+ "type": "object"
+ }
+]estimate_usage1 field changedOutput schema / anyOfPrevious value: -[
- {
- "allOf": [
- {
- "properties": {
- "average_calls_per_sec": {
- "type": "number"
- },
- "calls_per_day": {
- "type": "number"
- },
- "cu_weight": {
- "type": [
- "number",
- "null"
- ]
- },
- "cycle_cost_usd": {
- "type": [
- "number",
- "null"
- ]
- },
- "cycle_cu": {
- "type": "number"
- },
- "cycle_days": {
- "type": "number"
- },
- "daily_cost_usd": {
- "type": [
- "number",
- "null"
- ]
- },
- "daily_cu": {
- "type": "number"
- },
- "exceeds_free_quota": {
- "type": "boolean"
- },
- "exceeds_rate_limit": {
- "type": "boolean"
- },
- "free_quota_cu": {
- "type": [
- "number",
- "null"
- ]
- },
- "max_calls_per_sec": {
- "type": [
- "number",
- "null"
- ]
- },
- "method": {
- "type": "string"
- },
- "quota_percent": {
- "type": [
- "number",
- "null"
- ]
- }
- },
- "required": [
- "method",
- "calls_per_day"
- ],
- "type": "object"
- },
- {
- "not": {
- "properties": {
- "error": {
- "const": "invalid_tool_arguments",
- "type": "string"
- }
- },
- "required": [
- "error"
- ],
- "type": "object"
- }
- }
- ]
- },
- {
- "additionalProperties": false,
- "properties": {
- "error": {
- "const": "invalid_tool_arguments",
- "type": "string"
- },
- "message": {
- "minLength": 1,
- "type": "string"
- },
- "reason": {
- "enum": [
- "invalid_root",
- "schema_type",
- "schema_enum",
- "undeclared_property",
- "credential_field",
- "credential_value"
- ],
- "type": "string"
- }
- },
- "required": [
- "error",
- "reason",
- "message"
- ],
- "type": "object"
- }
-]New value: +[
+ {
+ "allOf": [
+ {
+ "anyOf": [
+ {
+ "required": [
+ "method",
+ "calls_per_day"
+ ]
+ },
+ {
+ "not": {
+ "anyOf": [
+ {
+ "required": [
+ "method"
+ ]
+ },
+ {
+ "required": [
+ "calls_per_day"
+ ]
+ },
+ {
+ "required": [
+ "cu_weight"
+ ]
+ }
+ ]
+ },
+ "properties": {
+ "lines": {
+ "minItems": 2,
+ "type": "array"
+ }
+ },
+ "required": [
+ "lines",
+ "daily_cu",
+ "daily_cost_usd",
+ "cycle_days",
+ "cycle_cu",
+ "cycle_cost_usd"
+ ]
+ }
+ ],
+ "properties": {
+ "average_calls_per_sec": {
+ "type": "number"
+ },
+ "calls_per_day": {
+ "type": "number"
+ },
+ "cu_weight": {
+ "type": [
+ "number",
+ "null"
+ ]
+ },
+ "cycle_cost_usd": {
+ "type": [
+ "number",
+ "null"
+ ]
+ },
+ "cycle_cu": {
+ "type": "number"
+ },
+ "cycle_days": {
+ "type": "number"
+ },
+ "daily_cost_usd": {
+ "type": [
+ "number",
+ "null"
+ ]
+ },
+ "daily_cu": {
+ "type": "number"
+ },
+ "exceeds_free_quota": {
+ "type": "boolean"
+ },
+ "exceeds_rate_limit": {
+ "type": "boolean"
+ },
+ "free_quota_cu": {
+ "type": [
+ "number",
+ "null"
+ ]
+ },
+ "lines": {
+ "items": {
+ "properties": {
+ "calls_per_day": {
+ "type": "number"
+ },
+ "cu_weight": {
+ "type": "number"
+ },
+ "daily_cost_usd": {
+ "type": [
+ "number",
+ "null"
+ ]
+ },
+ "daily_cu": {
+ "type": "number"
+ },
+ "method": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "method",
+ "calls_per_day",
+ "cu_weight",
+ "daily_cu",
+ "daily_cost_usd"
+ ],
+ "type": "object"
+ },
+ "type": "array"
+ },
+ "max_calls_per_sec": {
+ "type": [
+ "number",
+ "null"
+ ]
+ },
+ "method": {
+ "type": "string"
+ },
+ "quota_percent": {
+ "type": [
+ "number",
+ "null"
+ ]
+ }
+ },
+ "type": "object"
+ },
+ {
+ "not": {
+ "properties": {
+ "error": {
+ "const": "invalid_tool_arguments",
+ "type": "string"
+ }
+ },
+ "required": [
+ "error"
+ ],
+ "type": "object"
+ }
+ }
+ ]
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "error": {
+ "const": "invalid_tool_arguments",
+ "type": "string"
+ },
+ "message": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "reason": {
+ "enum": [
+ "invalid_root",
+ "schema_type",
+ "schema_enum",
+ "undeclared_property",
+ "credential_field",
+ "credential_value"
+ ],
+ "type": "string"
+ }
+ },
+ "required": [
+ "error",
+ "reason",
+ "message"
+ ],
+ "type": "object"
+ }
+]data_api_get2 fields changedOutput schema / anyOfAdded value: +[
+ {
+ "allOf": [
+ {
+ "properties": {
+ "_truncated": {
+ "type": "boolean"
+ },
+ "balance_units": {
+ "description": "Remaining balance units after this request (only present when balance is known and x-bv-meter: 1 was sent).",
+ "type": "integer"
+ },
+ "bytes": {
+ "type": "integer"
+ },
+ "cu_charged": {
+ "description": "Compute Units billed for this request (only present when charged and x-bv-meter: 1 was sent).",
+ "type": "integer"
+ },
+ "data": {},
+ "error": {
+ "type": "string"
+ },
+ "status": {
+ "type": "number"
+ }
+ },
+ "type": "object"
+ },
+ {
+ "not": {
+ "properties": {
+ "error": {
+ "const": "invalid_tool_arguments",
+ "type": "string"
+ }
+ },
+ "required": [
+ "error"
+ ],
+ "type": "object"
+ }
+ }
+ ]
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "error": {
+ "const": "invalid_tool_arguments",
+ "type": "string"
+ },
+ "message": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "reason": {
+ "enum": [
+ "invalid_root",
+ "schema_type",
+ "schema_enum",
+ "undeclared_property",
+ "credential_field",
+ "credential_value"
+ ],
+ "type": "string"
+ }
+ },
+ "required": [
+ "error",
+ "reason",
+ "message"
+ ],
+ "type": "object"
+ }
+]Output schema / propertiesRemoved value: -{
- "_truncated": {
- "type": "boolean"
- },
- "balance_units": {
- "description": "Remaining balance units after this request (only present when balance is known and x-bv-meter: 1 was sent).",
- "type": "integer"
- },
- "bytes": {
- "type": "integer"
- },
- "cu_charged": {
- "description": "Compute Units billed for this request (only present when charged and x-bv-meter: 1 was sent).",
- "type": "integer"
- },
- "data": {},
- "error": {
- "type": "string"
- },
- "status": {
- "type": "number"
- }
-}estimate_usage3 fields changedOutput schema / anyOfAdded value: +[
+ {
+ "allOf": [
+ {
+ "properties": {
+ "average_calls_per_sec": {
+ "type": "number"
+ },
+ "calls_per_day": {
+ "type": "number"
+ },
+ "cu_weight": {
+ "type": [
+ "number",
+ "null"
+ ]
+ },
+ "cycle_cost_usd": {
+ "type": [
+ "number",
+ "null"
+ ]
+ },
+ "cycle_cu": {
+ "type": "number"
+ },
+ "cycle_days": {
+ "type": "number"
+ },
+ "daily_cost_usd": {
+ "type": [
+ "number",
+ "null"
+ ]
+ },
+ "daily_cu": {
+ "type": "number"
+ },
+ "exceeds_free_quota": {
+ "type": "boolean"
+ },
+ "exceeds_rate_limit": {
+ "type": "boolean"
+ },
+ "free_quota_cu": {
+ "type": [
+ "number",
+ "null"
+ ]
+ },
+ "max_calls_per_sec": {
+ "type": [
+ "number",
+ "null"
+ ]
+ },
+ "method": {
+ "type": "string"
+ },
+ "quota_percent": {
+ "type": [
+ "number",
+ "null"
+ ]
+ }
+ },
+ "required": [
+ "method",
+ "calls_per_day"
+ ],
+ "type": "object"
+ },
+ {
+ "not": {
+ "properties": {
+ "error": {
+ "const": "invalid_tool_arguments",
+ "type": "string"
+ }
+ },
+ "required": [
+ "error"
+ ],
+ "type": "object"
+ }
+ }
+ ]
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "error": {
+ "const": "invalid_tool_arguments",
+ "type": "string"
+ },
+ "message": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "reason": {
+ "enum": [
+ "invalid_root",
+ "schema_type",
+ "schema_enum",
+ "undeclared_property",
+ "credential_field",
+ "credential_value"
+ ],
+ "type": "string"
+ }
+ },
+ "required": [
+ "error",
+ "reason",
+ "message"
+ ],
+ "type": "object"
+ }
+]Output schema / propertiesRemoved value: -{
- "average_calls_per_sec": {
- "type": "number"
- },
- "calls_per_day": {
- "type": "number"
- },
- "cu_weight": {
- "type": [
- "number",
- "null"
- ]
- },
- "cycle_cost_usd": {
- "type": [
- "number",
- "null"
- ]
- },
- "cycle_cu": {
- "type": "number"
- },
- "cycle_days": {
- "type": "number"
- },
- "daily_cost_usd": {
- "type": [
- "number",
- "null"
- ]
- },
- "daily_cu": {
- "type": "number"
- },
- "exceeds_free_quota": {
- "type": "boolean"
- },
- "exceeds_rate_limit": {
- "type": "boolean"
- },
- "free_quota_cu": {
- "type": [
- "number",
- "null"
- ]
- },
- "max_calls_per_sec": {
- "type": [
- "number",
- "null"
- ]
- },
- "method": {
- "type": "string"
- },
- "quota_percent": {
- "type": [
- "number",
- "null"
- ]
- }
-}Output schema / requiredRemoved value: -[
- "method",
- "calls_per_day"
-]explain_error3 fields changedOutput schema / anyOfAdded value: +[
+ {
+ "allOf": [
+ {
+ "properties": {
+ "count": {
+ "type": "number"
+ },
+ "errors": {
+ "items": {
+ "properties": {
+ "action": {
+ "type": "string"
+ },
+ "billed": {
+ "type": [
+ "boolean",
+ "string"
+ ]
+ },
+ "category": {
+ "type": "string"
+ },
+ "code": {
+ "type": [
+ "number",
+ "string"
+ ]
+ },
+ "docs_url": {
+ "type": "string"
+ },
+ "http": {
+ "type": "number"
+ },
+ "message": {
+ "type": "string"
+ },
+ "reason": {
+ "type": [
+ "string",
+ "null"
+ ]
+ },
+ "retry_after": {
+ "type": [
+ "string",
+ "null"
+ ]
+ },
+ "retryable": {
+ "type": "boolean"
+ }
+ },
+ "required": [
+ "code",
+ "http",
+ "message",
+ "billed",
+ "retryable",
+ "action",
+ "docs_url"
+ ],
+ "type": "object"
+ },
+ "type": "array"
+ },
+ "matched": {
+ "type": "boolean"
+ }
+ },
+ "required": [
+ "matched",
+ "errors"
+ ],
+ "type": "object"
+ },
+ {
+ "not": {
+ "properties": {
+ "error": {
+ "const": "invalid_tool_arguments",
+ "type": "string"
+ }
+ },
+ "required": [
+ "error"
+ ],
+ "type": "object"
+ }
+ }
+ ]
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "error": {
+ "const": "invalid_tool_arguments",
+ "type": "string"
+ },
+ "message": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "reason": {
+ "enum": [
+ "invalid_root",
+ "schema_type",
+ "schema_enum",
+ "undeclared_property",
+ "credential_field",
+ "credential_value"
+ ],
+ "type": "string"
+ }
+ },
+ "required": [
+ "error",
+ "reason",
+ "message"
+ ],
+ "type": "object"
+ }
+]Output schema / propertiesRemoved value: -{
- "count": {
- "type": "number"
- },
- "errors": {
- "items": {
- "properties": {
- "action": {
- "type": "string"
- },
- "billed": {
- "type": [
- "boolean",
- "string"
- ]
- },
- "category": {
- "type": "string"
- },
- "code": {
- "type": [
- "number",
- "string"
- ]
- },
- "docs_url": {
- "type": "string"
- },
- "http": {
- "type": "number"
- },
- "message": {
- "type": "string"
- },
- "reason": {
- "type": [
- "string",
- "null"
- ]
- },
- "retry_after": {
- "type": [
- "string",
- "null"
- ]
- },
- "retryable": {
- "type": "boolean"
- }
- },
- "required": [
- "code",
- "http",
- "message",
- "billed",
- "retryable",
- "action",
- "docs_url"
- ],
- "type": "object"
- },
- "type": "array"
- },
- "matched": {
- "type": "boolean"
- }
-}Output schema / requiredRemoved value: -[
- "matched",
- "errors"
-]get_account2 fields changedOutput schema / anyOfAdded value: +[
+ {
+ "allOf": [
+ {
+ "properties": {
+ "_truncated": {
+ "type": "boolean"
+ },
+ "balance_as_of_age_ms": {
+ "type": "integer"
+ },
+ "balance_cu": {
+ "type": "integer"
+ },
+ "balance_units": {
+ "type": "integer"
+ },
+ "bytes": {
+ "type": "integer"
+ },
+ "data": {},
+ "error": {
+ "properties": {
+ "code": {
+ "type": "string"
+ },
+ "data": {
+ "properties": {
+ "docs_url": {
+ "type": "string"
+ },
+ "reason": {
+ "type": "string"
+ },
+ "request_id": {
+ "type": "string"
+ },
+ "retryable": {
+ "type": "boolean"
+ }
+ },
+ "type": "object"
+ },
+ "message": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "code",
+ "message"
+ ],
+ "type": [
+ "string",
+ "object"
+ ]
+ },
+ "key": {
+ "properties": {
+ "burst_cu": {
+ "type": "integer"
+ },
+ "cu_cap": {
+ "type": [
+ "integer",
+ "null"
+ ]
+ },
+ "cu_cap_remaining": {
+ "type": [
+ "integer",
+ "null"
+ ]
+ },
+ "cu_per_sec": {
+ "type": "integer"
+ },
+ "expires_at": {
+ "type": [
+ "string",
+ "null"
+ ]
+ }
+ },
+ "type": "object"
+ },
+ "key_id": {
+ "type": "string"
+ },
+ "plan": {
+ "type": "string"
+ },
+ "status": {
+ "type": "number"
+ }
+ },
+ "type": "object"
+ },
+ {
+ "not": {
+ "properties": {
+ "error": {
+ "const": "invalid_tool_arguments",
+ "type": "string"
+ }
+ },
+ "required": [
+ "error"
+ ],
+ "type": "object"
+ }
+ }
+ ]
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "error": {
+ "const": "invalid_tool_arguments",
+ "type": "string"
+ },
+ "message": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "reason": {
+ "enum": [
+ "invalid_root",
+ "schema_type",
+ "schema_enum",
+ "undeclared_property",
+ "credential_field",
+ "credential_value"
+ ],
+ "type": "string"
+ }
+ },
+ "required": [
+ "error",
+ "reason",
+ "message"
+ ],
+ "type": "object"
+ }
+]Output schema / propertiesRemoved value: -{
- "_truncated": {
- "type": "boolean"
- },
- "balance_as_of_age_ms": {
- "type": "integer"
- },
- "balance_cu": {
- "type": "integer"
- },
- "balance_units": {
- "type": "integer"
- },
- "bytes": {
- "type": "integer"
- },
- "data": {},
- "error": {
- "properties": {
- "code": {
- "type": "string"
- },
- "data": {
- "properties": {
- "docs_url": {
- "type": "string"
- },
- "reason": {
- "type": "string"
- },
- "request_id": {
- "type": "string"
- },
- "retryable": {
- "type": "boolean"
- }
- },
- "type": "object"
- },
- "message": {
- "type": "string"
- }
- },
- "required": [
- "code",
- "message"
- ],
- "type": [
- "string",
- "object"
- ]
- },
- "key": {
- "properties": {
- "burst_cu": {
- "type": "integer"
- },
- "cu_cap": {
- "type": [
- "integer",
- "null"
- ]
- },
- "cu_cap_remaining": {
- "type": [
- "integer",
- "null"
- ]
- },
- "cu_per_sec": {
- "type": "integer"
- },
- "expires_at": {
- "type": [
- "string",
- "null"
- ]
- }
- },
- "type": "object"
- },
- "key_id": {
- "type": "string"
- },
- "plan": {
- "type": "string"
- },
- "status": {
- "type": "number"
- }
-}get_deposit_address2 fields changedOutput schema / anyOfAdded value: +[
+ {
+ "allOf": [
+ {
+ "properties": {
+ "_truncated": {
+ "type": "boolean"
+ },
+ "address": {
+ "type": "string"
+ },
+ "bytes": {
+ "type": "integer"
+ },
+ "data": {},
+ "deposits_url": {
+ "type": "string"
+ },
+ "error": {
+ "type": "string"
+ },
+ "min_deposit_usd": {
+ "type": "string"
+ },
+ "networks": {
+ "items": {
+ "properties": {
+ "chain": {
+ "type": "string"
+ },
+ "chain_id": {
+ "type": "integer"
+ },
+ "explorer_tx_url": {
+ "type": "string"
+ },
+ "name": {
+ "type": "string"
+ },
+ "tokens": {
+ "items": {
+ "properties": {
+ "contract": {
+ "type": "string"
+ },
+ "decimals": {
+ "type": "integer"
+ },
+ "min_amount_raw": {
+ "type": "string"
+ },
+ "symbol": {
+ "type": "string"
+ }
+ },
+ "type": "object"
+ },
+ "type": "array"
+ },
+ "typical_credit_seconds": {
+ "type": "integer"
+ }
+ },
+ "type": "object"
+ },
+ "type": "array"
+ },
+ "status": {
+ "type": "number"
+ }
+ },
+ "type": "object"
+ },
+ {
+ "not": {
+ "properties": {
+ "error": {
+ "const": "invalid_tool_arguments",
+ "type": "string"
+ }
+ },
+ "required": [
+ "error"
+ ],
+ "type": "object"
+ }
+ }
+ ]
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "error": {
+ "const": "invalid_tool_arguments",
+ "type": "string"
+ },
+ "message": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "reason": {
+ "enum": [
+ "invalid_root",
+ "schema_type",
+ "schema_enum",
+ "undeclared_property",
+ "credential_field",
+ "credential_value"
+ ],
+ "type": "string"
+ }
+ },
+ "required": [
+ "error",
+ "reason",
+ "message"
+ ],
+ "type": "object"
+ }
+]Output schema / propertiesRemoved value: -{
- "_truncated": {
- "type": "boolean"
- },
- "address": {
- "type": "string"
- },
- "bytes": {
- "type": "integer"
- },
- "data": {},
- "deposits_url": {
- "type": "string"
- },
- "error": {
- "type": "string"
- },
- "min_deposit_usd": {
- "type": "string"
- },
- "networks": {
- "items": {
- "properties": {
- "chain": {
- "type": "string"
- },
- "chain_id": {
- "type": "integer"
- },
- "explorer_tx_url": {
- "type": "string"
- },
- "name": {
- "type": "string"
- },
- "tokens": {
- "items": {
- "properties": {
- "contract": {
- "type": "string"
- },
- "decimals": {
- "type": "integer"
- },
- "min_amount_raw": {
- "type": "string"
- },
- "symbol": {
- "type": "string"
- }
- },
- "type": "object"
- },
- "type": "array"
- },
- "typical_credit_seconds": {
- "type": "integer"
- }
- },
- "type": "object"
- },
- "type": "array"
- },
- "status": {
- "type": "number"
- }
-}get_method_info3 fields changedOutput schema / anyOfAdded value: +[
+ {
+ "allOf": [
+ {
+ "properties": {
+ "available_chains": {
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+ },
+ "chain": {
+ "type": [
+ "string",
+ "null"
+ ]
+ },
+ "cost_per_million_usd": {
+ "type": [
+ "number",
+ "null"
+ ]
+ },
+ "cu_weight": {
+ "type": [
+ "number",
+ "null"
+ ]
+ },
+ "docs_url": {
+ "type": [
+ "string",
+ "null"
+ ]
+ },
+ "method": {
+ "type": "string"
+ },
+ "notes": {
+ "type": [
+ "string",
+ "null"
+ ]
+ },
+ "supported": {
+ "type": "boolean"
+ }
+ },
+ "required": [
+ "method",
+ "supported",
+ "available_chains"
+ ],
+ "type": "object"
+ },
+ {
+ "not": {
+ "properties": {
+ "error": {
+ "const": "invalid_tool_arguments",
+ "type": "string"
+ }
+ },
+ "required": [
+ "error"
+ ],
+ "type": "object"
+ }
+ }
+ ]
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "error": {
+ "const": "invalid_tool_arguments",
+ "type": "string"
+ },
+ "message": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "reason": {
+ "enum": [
+ "invalid_root",
+ "schema_type",
+ "schema_enum",
+ "undeclared_property",
+ "credential_field",
+ "credential_value"
+ ],
+ "type": "string"
+ }
+ },
+ "required": [
+ "error",
+ "reason",
+ "message"
+ ],
+ "type": "object"
+ }
+]Output schema / propertiesRemoved value: -{
- "available_chains": {
- "items": {
- "type": "string"
- },
- "type": "array"
- },
- "chain": {
- "type": [
- "string",
- "null"
- ]
- },
- "cost_per_million_usd": {
- "type": [
- "number",
- "null"
- ]
- },
- "cu_weight": {
- "type": [
- "number",
- "null"
- ]
- },
- "docs_url": {
- "type": [
- "string",
- "null"
- ]
- },
- "method": {
- "type": "string"
- },
- "notes": {
- "type": [
- "string",
- "null"
- ]
- },
- "supported": {
- "type": "boolean"
- }
-}Output schema / requiredRemoved value: -[
- "method",
- "supported",
- "available_chains"
-]get_pricing3 fields changedOutput schema / anyOfAdded value: +[
+ {
+ "allOf": [
+ {
+ "properties": {
+ "free": {
+ "type": "object"
+ },
+ "key_defaults": {
+ "type": "object"
+ },
+ "method_weights": {
+ "type": "array"
+ },
+ "pricing": {
+ "type": "object"
+ }
+ },
+ "required": [
+ "pricing",
+ "method_weights"
+ ],
+ "type": "object"
+ },
+ {
+ "not": {
+ "properties": {
+ "error": {
+ "const": "invalid_tool_arguments",
+ "type": "string"
+ }
+ },
+ "required": [
+ "error"
+ ],
+ "type": "object"
+ }
+ }
+ ]
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "error": {
+ "const": "invalid_tool_arguments",
+ "type": "string"
+ },
+ "message": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "reason": {
+ "enum": [
+ "invalid_root",
+ "schema_type",
+ "schema_enum",
+ "undeclared_property",
+ "credential_field",
+ "credential_value"
+ ],
+ "type": "string"
+ }
+ },
+ "required": [
+ "error",
+ "reason",
+ "message"
+ ],
+ "type": "object"
+ }
+]Output schema / propertiesRemoved value: -{
- "free": {
- "type": "object"
- },
- "key_defaults": {
- "type": "object"
- },
- "method_weights": {
- "type": "array"
- },
- "pricing": {
- "type": "object"
- }
-}Output schema / requiredRemoved value: -[
- "pricing",
- "method_weights"
-]get_status3 fields changedOutput schema / anyOfAdded value: +[
+ {
+ "allOf": [
+ {
+ "properties": {
+ "chains": {
+ "type": "array"
+ },
+ "checked_at": {
+ "type": "string"
+ },
+ "gateway": {
+ "type": "object"
+ }
+ },
+ "required": [
+ "checked_at",
+ "gateway",
+ "chains"
+ ],
+ "type": "object"
+ },
+ {
+ "not": {
+ "properties": {
+ "error": {
+ "const": "invalid_tool_arguments",
+ "type": "string"
+ }
+ },
+ "required": [
+ "error"
+ ],
+ "type": "object"
+ }
+ }
+ ]
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "error": {
+ "const": "invalid_tool_arguments",
+ "type": "string"
+ },
+ "message": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "reason": {
+ "enum": [
+ "invalid_root",
+ "schema_type",
+ "schema_enum",
+ "undeclared_property",
+ "credential_field",
+ "credential_value"
+ ],
+ "type": "string"
+ }
+ },
+ "required": [
+ "error",
+ "reason",
+ "message"
+ ],
+ "type": "object"
+ }
+]Output schema / propertiesRemoved value: -{
- "chains": {
- "type": "array"
- },
- "checked_at": {
- "type": "string"
- },
- "gateway": {
- "type": "object"
- }
-}Output schema / requiredRemoved value: -[
- "checked_at",
- "gateway",
- "chains"
-]how_to_get_api_key3 fields changedOutput schema / anyOfAdded value: +[
+ {
+ "allOf": [
+ {
+ "properties": {
+ "auth_methods": {
+ "properties": {
+ "data_api": {
+ "properties": {
+ "example": {
+ "type": "string"
+ },
+ "header": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "header"
+ ],
+ "type": "object"
+ },
+ "json_rpc": {
+ "properties": {
+ "bearer": {
+ "type": "string"
+ },
+ "example": {
+ "type": "string"
+ },
+ "header": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "header"
+ ],
+ "type": "object"
+ }
+ },
+ "required": [
+ "data_api",
+ "json_rpc"
+ ],
+ "type": "object"
+ },
+ "env_var": {
+ "type": "string"
+ },
+ "handoff_instructions": {
+ "type": "string"
+ },
+ "paths": {
+ "properties": {
+ "browser": {
+ "properties": {
+ "console_url": {
+ "type": "string"
+ },
+ "instructions": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "console_url",
+ "instructions"
+ ],
+ "type": "object"
+ },
+ "programmatic": {
+ "properties": {
+ "base_url": {
+ "type": "string"
+ },
+ "guide_url": {
+ "type": "string"
+ },
+ "notes": {
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+ },
+ "rate_limit_policy": {
+ "properties": {
+ "error_code": {
+ "type": "string"
+ },
+ "instruction": {
+ "type": "string"
+ },
+ "retry_after_header": {
+ "type": "string"
+ },
+ "status": {
+ "type": "number"
+ }
+ },
+ "required": [
+ "error_code",
+ "status",
+ "retry_after_header",
+ "instruction"
+ ],
+ "type": "object"
+ },
+ "security": {
+ "type": "string"
+ },
+ "steps": {
+ "items": {
+ "properties": {
+ "description": {
+ "type": "string"
+ },
+ "endpoint": {
+ "type": [
+ "string",
+ "null"
+ ]
+ },
+ "name": {
+ "type": "string"
+ },
+ "step": {
+ "type": "number"
+ }
+ },
+ "required": [
+ "step",
+ "name",
+ "description"
+ ],
+ "type": "object"
+ },
+ "type": "array"
+ },
+ "token_lifetime": {
+ "properties": {
+ "absolute_ttl_days": {
+ "type": "number"
+ },
+ "description": {
+ "type": "string"
+ },
+ "idle_ttl_hours": {
+ "type": "number"
+ },
+ "refresh_token": {
+ "type": "boolean"
+ }
+ },
+ "required": [
+ "absolute_ttl_days",
+ "idle_ttl_hours",
+ "refresh_token",
+ "description"
+ ],
+ "type": "object"
+ }
+ },
+ "required": [
+ "base_url",
+ "guide_url",
+ "steps",
+ "rate_limit_policy",
+ "token_lifetime",
+ "notes",
+ "security"
+ ],
+ "type": "object"
+ }
+ },
+ "required": [
+ "programmatic",
+ "browser"
+ ],
+ "type": "object"
+ },
+ "preferred_path": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "preferred_path",
+ "paths",
+ "handoff_instructions",
+ "env_var",
+ "auth_methods"
+ ],
+ "type": "object"
+ },
+ {
+ "not": {
+ "properties": {
+ "error": {
+ "const": "invalid_tool_arguments",
+ "type": "string"
+ }
+ },
+ "required": [
+ "error"
+ ],
+ "type": "object"
+ }
+ }
+ ]
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "error": {
+ "const": "invalid_tool_arguments",
+ "type": "string"
+ },
+ "message": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "reason": {
+ "enum": [
+ "invalid_root",
+ "schema_type",
+ "schema_enum",
+ "undeclared_property",
+ "credential_field",
+ "credential_value"
+ ],
+ "type": "string"
+ }
+ },
+ "required": [
+ "error",
+ "reason",
+ "message"
+ ],
+ "type": "object"
+ }
+]Output schema / propertiesRemoved value: -{
- "auth_methods": {
- "properties": {
- "data_api": {
- "properties": {
- "example": {
- "type": "string"
- },
- "header": {
- "type": "string"
- }
- },
- "required": [
- "header"
- ],
- "type": "object"
- },
- "json_rpc": {
- "properties": {
- "bearer": {
- "type": "string"
- },
- "example": {
- "type": "string"
- },
- "header": {
- "type": "string"
- }
- },
- "required": [
- "header"
- ],
- "type": "object"
- }
- },
- "required": [
- "data_api",
- "json_rpc"
- ],
- "type": "object"
- },
- "env_var": {
- "type": "string"
- },
- "handoff_instructions": {
- "type": "string"
- },
- "paths": {
- "properties": {
- "browser": {
- "properties": {
- "console_url": {
- "type": "string"
- },
- "instructions": {
- "type": "string"
- }
- },
- "required": [
- "console_url",
- "instructions"
- ],
- "type": "object"
- },
- "programmatic": {
- "properties": {
- "base_url": {
- "type": "string"
- },
- "guide_url": {
- "type": "string"
- },
- "notes": {
- "items": {
- "type": "string"
- },
- "type": "array"
- },
- "rate_limit_policy": {
- "properties": {
- "error_code": {
- "type": "string"
- },
- "instruction": {
- "type": "string"
- },
- "retry_after_header": {
- "type": "string"
- },
- "status": {
- "type": "number"
- }
- },
- "required": [
- "error_code",
- "status",
- "retry_after_header",
- "instruction"
- ],
- "type": "object"
- },
- "security": {
- "type": "string"
- },
- "steps": {
- "items": {
- "properties": {
- "description": {
- "type": "string"
- },
- "endpoint": {
- "type": [
- "string",
- "null"
- ]
- },
- "name": {
- "type": "string"
- },
- "step": {
- "type": "number"
- }
- },
- "required": [
- "step",
- "name",
- "description"
- ],
- "type": "object"
- },
- "type": "array"
- },
- "token_lifetime": {
- "properties": {
- "absolute_ttl_days": {
- "type": "number"
- },
- "description": {
- "type": "string"
- },
- "idle_ttl_hours": {
- "type": "number"
- },
- "refresh_token": {
- "type": "boolean"
- }
- },
- "required": [
- "absolute_ttl_days",
- "idle_ttl_hours",
- "refresh_token",
- "description"
- ],
- "type": "object"
- }
- },
- "required": [
- "base_url",
- "guide_url",
- "steps",
- "rate_limit_policy",
- "token_lifetime",
- "notes",
- "security"
- ],
- "type": "object"
- }
- },
- "required": [
- "programmatic",
- "browser"
- ],
- "type": "object"
- },
- "preferred_path": {
- "type": "string"
- }
-}Output schema / requiredRemoved value: -[
- "preferred_path",
- "paths",
- "handoff_instructions",
- "env_var",
- "auth_methods"
-]list_chains3 fields changedOutput schema / anyOfAdded value: +[
+ {
+ "allOf": [
+ {
+ "properties": {
+ "chains": {
+ "items": {
+ "properties": {
+ "chain": {
+ "type": "string"
+ },
+ "chain_id": {
+ "type": "number"
+ },
+ "data": {
+ "type": "boolean"
+ },
+ "jsonrpc": {
+ "type": "boolean"
+ },
+ "max_logs_block_range": {
+ "description": "Max block span of one eth_getLogs request. Both ends are inclusive: toBlock - fromBlock + 1 must not exceed this value, otherwise the call returns logs_range_too_large.",
+ "type": [
+ "number",
+ "null"
+ ]
+ },
+ "methods": {
+ "type": [
+ "object",
+ "null"
+ ]
+ },
+ "name": {
+ "type": "string"
+ },
+ "public": {
+ "properties": {
+ "history_blocks": {
+ "description": "How many blocks back a block reference may reach on the keyless public.url. It applies only to methods in public.methods and does not add methods.",
+ "type": "number"
+ },
+ "methods": {
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+ },
+ "rate_limit": {
+ "properties": {
+ "batch_max": {
+ "type": "number"
+ },
+ "burst": {
+ "type": "number"
+ },
+ "per_ip_rps": {
+ "type": "number"
+ }
+ },
+ "required": [
+ "per_ip_rps",
+ "burst",
+ "batch_max"
+ ],
+ "type": "object"
+ },
+ "send_raw_rate_limit": {
+ "properties": {
+ "burst": {
+ "type": "number"
+ },
+ "per_ip_rps": {
+ "type": "number"
+ }
+ },
+ "required": [
+ "per_ip_rps",
+ "burst"
+ ],
+ "type": "object"
+ },
+ "url": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "url",
+ "methods",
+ "rate_limit"
+ ],
+ "type": "object"
+ },
+ "state_window_blocks": {
+ "type": [
+ "number",
+ "null"
+ ]
+ },
+ "subscriptions": {
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+ },
+ "ws": {
+ "type": "boolean"
+ }
+ },
+ "required": [
+ "chain"
+ ],
+ "type": "object"
+ },
+ "type": "array"
+ }
+ },
+ "required": [
+ "chains"
+ ],
+ "type": "object"
+ },
+ {
+ "not": {
+ "properties": {
+ "error": {
+ "const": "invalid_tool_arguments",
+ "type": "string"
+ }
+ },
+ "required": [
+ "error"
+ ],
+ "type": "object"
+ }
+ }
+ ]
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "error": {
+ "const": "invalid_tool_arguments",
+ "type": "string"
+ },
+ "message": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "reason": {
+ "enum": [
+ "invalid_root",
+ "schema_type",
+ "schema_enum",
+ "undeclared_property",
+ "credential_field",
+ "credential_value"
+ ],
+ "type": "string"
+ }
+ },
+ "required": [
+ "error",
+ "reason",
+ "message"
+ ],
+ "type": "object"
+ }
+]Output schema / propertiesRemoved value: -{
- "chains": {
- "items": {
- "properties": {
- "chain": {
- "type": "string"
- },
- "chain_id": {
- "type": "number"
- },
- "data": {
- "type": "boolean"
- },
- "jsonrpc": {
- "type": "boolean"
- },
- "max_logs_block_range": {
- "description": "Max block span of one eth_getLogs request. Both ends are inclusive: toBlock - fromBlock + 1 must not exceed this value, otherwise the call returns logs_range_too_large.",
- "type": [
- "number",
- "null"
- ]
- },
- "methods": {
- "type": [
- "object",
- "null"
- ]
- },
- "name": {
- "type": "string"
- },
- "public": {
- "properties": {
- "history_blocks": {
- "description": "How many blocks back a block reference may reach on the keyless public.url. It applies only to methods in public.methods and does not add methods.",
- "type": "number"
- },
- "methods": {
- "items": {
- "type": "string"
- },
- "type": "array"
- },
- "rate_limit": {
- "properties": {
- "batch_max": {
- "type": "number"
- },
- "burst": {
- "type": "number"
- },
- "per_ip_rps": {
- "type": "number"
- }
- },
- "required": [
- "per_ip_rps",
- "burst",
- "batch_max"
- ],
- "type": "object"
- },
- "send_raw_rate_limit": {
- "properties": {
- "burst": {
- "type": "number"
- },
- "per_ip_rps": {
- "type": "number"
- }
- },
- "required": [
- "per_ip_rps",
- "burst"
- ],
- "type": "object"
- },
- "url": {
- "type": "string"
- }
- },
- "required": [
- "url",
- "methods",
- "rate_limit"
- ],
- "type": "object"
- },
- "state_window_blocks": {
- "type": [
- "number",
- "null"
- ]
- },
- "subscriptions": {
- "items": {
- "type": "string"
- },
- "type": "array"
- },
- "ws": {
- "type": "boolean"
- }
- },
- "required": [
- "chain"
- ],
- "type": "object"
- },
- "type": "array"
- }
-}Output schema / requiredRemoved value: -[
- "chains"
-]list_docs3 fields changedOutput schema / anyOfAdded value: +[
+ {
+ "allOf": [
+ {
+ "properties": {
+ "count": {
+ "type": "number"
+ },
+ "docs": {
+ "items": {
+ "properties": {
+ "path": {
+ "type": "string"
+ },
+ "summary": {
+ "type": "string"
+ },
+ "title": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "title",
+ "path",
+ "summary"
+ ],
+ "type": "object"
+ },
+ "type": "array"
+ },
+ "lang": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "lang",
+ "count",
+ "docs"
+ ],
+ "type": "object"
+ },
+ {
+ "not": {
+ "properties": {
+ "error": {
+ "const": "invalid_tool_arguments",
+ "type": "string"
+ }
+ },
+ "required": [
+ "error"
+ ],
+ "type": "object"
+ }
+ }
+ ]
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "error": {
+ "const": "invalid_tool_arguments",
+ "type": "string"
+ },
+ "message": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "reason": {
+ "enum": [
+ "invalid_root",
+ "schema_type",
+ "schema_enum",
+ "undeclared_property",
+ "credential_field",
+ "credential_value"
+ ],
+ "type": "string"
+ }
+ },
+ "required": [
+ "error",
+ "reason",
+ "message"
+ ],
+ "type": "object"
+ }
+]Output schema / propertiesRemoved value: -{
- "count": {
- "type": "number"
- },
- "docs": {
- "items": {
- "properties": {
- "path": {
- "type": "string"
- },
- "summary": {
- "type": "string"
- },
- "title": {
- "type": "string"
- }
- },
- "required": [
- "title",
- "path",
- "summary"
- ],
- "type": "object"
- },
- "type": "array"
- },
- "lang": {
- "type": "string"
- }
-}Output schema / requiredRemoved value: -[
- "lang",
- "count",
- "docs"
-]rpc_call2 fields changedOutput schema / anyOfAdded value: +[
+ {
+ "allOf": [
+ {
+ "properties": {
+ "balance_units": {
+ "description": "Remaining balance units after this request (only present when balance is known and x-bv-meter: 1 was sent).",
+ "type": "integer"
+ },
+ "cu_charged": {
+ "description": "Compute Units billed for this request (only present when charged and x-bv-meter: 1 was sent).",
+ "type": "integer"
+ },
+ "error": {
+ "properties": {
+ "code": {
+ "type": "number"
+ },
+ "docs_url": {
+ "type": [
+ "string",
+ "null"
+ ]
+ },
+ "message": {
+ "type": "string"
+ },
+ "reason": {
+ "type": [
+ "string",
+ "null"
+ ]
+ }
+ },
+ "type": [
+ "object",
+ "string"
+ ]
+ },
+ "help": {
+ "properties": {
+ "guide_url": {
+ "type": "string"
+ },
+ "tool": {
+ "type": "string"
+ }
+ },
+ "type": "object"
+ },
+ "id": {
+ "type": [
+ "number",
+ "string",
+ "null"
+ ]
+ },
+ "jsonrpc": {
+ "type": "string"
+ },
+ "message": {
+ "type": "string"
+ },
+ "result": {},
+ "signup_url": {
+ "description": "Registration and sign-up URL (returned when rate-limited on the public endpoint).",
+ "type": "string"
+ }
+ },
+ "type": "object"
+ },
+ {
+ "not": {
+ "properties": {
+ "error": {
+ "const": "invalid_tool_arguments",
+ "type": "string"
+ }
+ },
+ "required": [
+ "error"
+ ],
+ "type": "object"
+ }
+ }
+ ]
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "error": {
+ "const": "invalid_tool_arguments",
+ "type": "string"
+ },
+ "message": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "reason": {
+ "enum": [
+ "invalid_root",
+ "schema_type",
+ "schema_enum",
+ "undeclared_property",
+ "credential_field",
+ "credential_value"
+ ],
+ "type": "string"
+ }
+ },
+ "required": [
+ "error",
+ "reason",
+ "message"
+ ],
+ "type": "object"
+ }
+]Output schema / propertiesRemoved value: -{
- "balance_units": {
- "description": "Remaining balance units after this request (only present when balance is known and x-bv-meter: 1 was sent).",
- "type": "integer"
- },
- "cu_charged": {
- "description": "Compute Units billed for this request (only present when charged and x-bv-meter: 1 was sent).",
- "type": "integer"
- },
- "error": {
- "properties": {
- "code": {
- "type": "number"
- },
- "docs_url": {
- "type": [
- "string",
- "null"
- ]
- },
- "message": {
- "type": "string"
- },
- "reason": {
- "type": [
- "string",
- "null"
- ]
- }
- },
- "type": [
- "object",
- "string"
- ]
- },
- "help": {
- "properties": {
- "guide_url": {
- "type": "string"
- },
- "tool": {
- "type": "string"
- }
- },
- "type": "object"
- },
- "id": {
- "type": [
- "number",
- "string",
- "null"
- ]
- },
- "jsonrpc": {
- "type": "string"
- },
- "message": {
- "type": "string"
- },
- "result": {},
- "signup_url": {
- "description": "Registration and sign-up URL (returned when rate-limited on the public endpoint).",
- "type": "string"
- }
-}search_docs3 fields changedOutput schema / anyOfAdded value: +[
+ {
+ "allOf": [
+ {
+ "properties": {
+ "message": {
+ "type": "string"
+ },
+ "results": {
+ "items": {
+ "properties": {
+ "path": {
+ "type": "string"
+ },
+ "summary": {
+ "type": "string"
+ },
+ "title": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "title",
+ "path",
+ "summary"
+ ],
+ "type": "object"
+ },
+ "type": "array"
+ }
+ },
+ "required": [
+ "results"
+ ],
+ "type": "object"
+ },
+ {
+ "not": {
+ "properties": {
+ "error": {
+ "const": "invalid_tool_arguments",
+ "type": "string"
+ }
+ },
+ "required": [
+ "error"
+ ],
+ "type": "object"
+ }
+ }
+ ]
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "error": {
+ "const": "invalid_tool_arguments",
+ "type": "string"
+ },
+ "message": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "reason": {
+ "enum": [
+ "invalid_root",
+ "schema_type",
+ "schema_enum",
+ "undeclared_property",
+ "credential_field",
+ "credential_value"
+ ],
+ "type": "string"
+ }
+ },
+ "required": [
+ "error",
+ "reason",
+ "message"
+ ],
+ "type": "object"
+ }
+]Output schema / propertiesRemoved value: -{
- "message": {
- "type": "string"
- },
- "results": {
- "items": {
- "properties": {
- "path": {
- "type": "string"
- },
- "summary": {
- "type": "string"
- },
- "title": {
- "type": "string"
- }
- },
- "required": [
- "title",
- "path",
- "summary"
- ],
- "type": "object"
- },
- "type": "array"
- }
-}Output schema / requiredRemoved value: -[
- "results"
-]send_raw_transaction2 fields changedOutput schema / anyOfAdded value: +[
+ {
+ "allOf": [
+ {
+ "properties": {
+ "balance_units": {
+ "description": "Remaining balance units after this request (only present when balance is known and x-bv-meter: 1 was sent).",
+ "type": "integer"
+ },
+ "cu_charged": {
+ "description": "Compute Units billed for this request (only present when charged and x-bv-meter: 1 was sent).",
+ "type": "integer"
+ },
+ "error": {
+ "properties": {
+ "code": {
+ "type": "number"
+ },
+ "docs_url": {
+ "type": [
+ "string",
+ "null"
+ ]
+ },
+ "message": {
+ "type": "string"
+ },
+ "reason": {
+ "type": [
+ "string",
+ "null"
+ ]
+ }
+ },
+ "type": [
+ "object",
+ "string"
+ ]
+ },
+ "help": {
+ "properties": {
+ "guide_url": {
+ "type": "string"
+ },
+ "tool": {
+ "type": "string"
+ }
+ },
+ "type": "object"
+ },
+ "id": {
+ "type": [
+ "number",
+ "string",
+ "null"
+ ]
+ },
+ "jsonrpc": {
+ "type": "string"
+ },
+ "message": {
+ "type": "string"
+ },
+ "result": {},
+ "signup_url": {
+ "description": "Registration and sign-up URL (returned when rate-limited on the public endpoint).",
+ "type": "string"
+ }
+ },
+ "type": "object"
+ },
+ {
+ "not": {
+ "properties": {
+ "error": {
+ "const": "invalid_tool_arguments",
+ "type": "string"
+ }
+ },
+ "required": [
+ "error"
+ ],
+ "type": "object"
+ }
+ }
+ ]
+ },
+ {
+ "additionalProperties": false,
+ "properties": {
+ "error": {
+ "const": "invalid_tool_arguments",
+ "type": "string"
+ },
+ "message": {
+ "minLength": 1,
+ "type": "string"
+ },
+ "reason": {
+ "enum": [
+ "invalid_root",
+ "schema_type",
+ "schema_enum",
+ "undeclared_property",
+ "credential_field",
+ "credential_value"
+ ],
+ "type": "string"
+ }
+ },
+ "required": [
+ "error",
+ "reason",
+ "message"
+ ],
+ "type": "object"
+ }
+]Output schema / propertiesRemoved value: -{
- "balance_units": {
- "description": "Remaining balance units after this request (only present when balance is known and x-bv-meter: 1 was sent).",
- "type": "integer"
- },
- "cu_charged": {
- "description": "Compute Units billed for this request (only present when charged and x-bv-meter: 1 was sent).",
- "type": "integer"
- },
- "error": {
- "properties": {
- "code": {
- "type": "number"
- },
- "docs_url": {
- "type": [
- "string",
- "null"
- ]
- },
- "message": {
- "type": "string"
- },
- "reason": {
- "type": [
- "string",
- "null"
- ]
- }
- },
- "type": [
- "object",
- "string"
- ]
- },
- "help": {
- "properties": {
- "guide_url": {
- "type": "string"
- },
- "tool": {
- "type": "string"
- }
- },
- "type": "object"
- },
- "id": {
- "type": [
- "number",
- "string",
- "null"
- ]
- },
- "jsonrpc": {
- "type": "string"
- },
- "message": {
- "type": "string"
- },
- "result": {},
- "signup_url": {
- "description": "Registration and sign-up URL (returned when rate-limited on the public endpoint).",
- "type": "string"
- }
-}get_account3 fields changedOutput schema / properties / error / propertiesAdded value: +{
+ "code": {
+ "type": "string"
+ },
+ "data": {
+ "properties": {
+ "docs_url": {
+ "type": "string"
+ },
+ "reason": {
+ "type": "string"
+ },
+ "request_id": {
+ "type": "string"
+ },
+ "retryable": {
+ "type": "boolean"
+ }
+ },
+ "type": "object"
+ },
+ "message": {
+ "type": "string"
+ }
+}Output schema / properties / error / requiredAdded value: +[
+ "code",
+ "message"
+]Output schema / properties / error / typePrevious value: -"string"New value: +[
+ "string",
+ "object"
+]search_docs1 field changedInput schema / properties / query / descriptionPrevious value: -"Keywords to search for in documentation titles, paths, and summaries."New value: +"Keywords to search for in documentation titles, navigation titles, paths, and summaries."explain_error1 field changedInput schema / properties / lang / descriptionPrevious value: -"Response language. Defaults to 'en'."New value: +"Response language (case-insensitive). Defaults to 'en'."how_to_get_api_key1 field changedInput schema / properties / lang / descriptionPrevious value: -"Response language. Defaults to 'en'."New value: +"Response language (case-insensitive). Defaults to 'en'."list_docs1 field changedInput schema / properties / lang / descriptionPrevious value: -"Published documentation language. Omit for English; unavailable languages return an error."New value: +"Published documentation language (case-insensitive, e.g. zh-hant or zh-Hant). Omit for English; unavailable languages return an error."read_doc1 field changedInput schema / properties / lang / descriptionPrevious value: -"Published documentation language. Omit for English; unavailable languages return an error."New value: +"Published documentation language (case-insensitive, e.g. zh-hant or zh-Hant). Omit for English; unavailable languages return an error."search_docs1 field changedInput schema / properties / lang / descriptionPrevious value: -"Published documentation language. Omit for English; unavailable languages return an error."New value: +"Published documentation language (case-insensitive, e.g. zh-hant or zh-Hant). Omit for English; unavailable languages return an error."explain_error1 field changedInput schema / properties / lang / enumPrevious value: -[
- "zh",
- "en",
- "ja",
- "es",
- "pt-br",
- "ko",
- "vi",
- "zh-hant",
- "id",
- "tr",
- "de",
- "fr",
- "ru"
-]New value: +[
+ "zh",
+ "en",
+ "ja",
+ "es",
+ "pt-br",
+ "ko",
+ "vi",
+ "zh-hant",
+ "id",
+ "tr",
+ "de",
+ "fr",
+ "ru",
+ "th",
+ "uk"
+]how_to_get_api_key1 field changedInput schema / properties / lang / enumPrevious value: -[
- "zh",
- "en",
- "ja",
- "es",
- "pt-br",
- "ko",
- "vi",
- "zh-hant",
- "id",
- "tr",
- "de",
- "fr",
- "ru"
-]New value: +[
+ "zh",
+ "en",
+ "ja",
+ "es",
+ "pt-br",
+ "ko",
+ "vi",
+ "zh-hant",
+ "id",
+ "tr",
+ "de",
+ "fr",
+ "ru",
+ "th",
+ "uk"
+]list_docs1 field changedInput schema / properties / lang / enumPrevious value: -[
- "en",
- "zh",
- "de",
- "es",
- "fr",
- "id",
- "ja",
- "ko",
- "pt-br",
- "ru",
- "tr",
- "vi",
- "zh-hant"
-]New value: +[
+ "en",
+ "zh",
+ "de",
+ "es",
+ "fr",
+ "id",
+ "ja",
+ "ko",
+ "pt-br",
+ "ru",
+ "th",
+ "tr",
+ "uk",
+ "vi",
+ "zh-hant"
+]read_doc1 field changedInput schema / properties / lang / enumPrevious value: -[
- "en",
- "zh",
- "de",
- "es",
- "fr",
- "id",
- "ja",
- "ko",
- "pt-br",
- "ru",
- "tr",
- "vi",
- "zh-hant"
-]New value: +[
+ "en",
+ "zh",
+ "de",
+ "es",
+ "fr",
+ "id",
+ "ja",
+ "ko",
+ "pt-br",
+ "ru",
+ "th",
+ "tr",
+ "uk",
+ "vi",
+ "zh-hant"
+]search_docs1 field changedInput schema / properties / lang / enumPrevious value: -[
- "en",
- "zh",
- "de",
- "es",
- "fr",
- "id",
- "ja",
- "ko",
- "pt-br",
- "ru",
- "tr",
- "vi",
- "zh-hant"
-]New value: +[
+ "en",
+ "zh",
+ "de",
+ "es",
+ "fr",
+ "id",
+ "ja",
+ "ko",
+ "pt-br",
+ "ru",
+ "th",
+ "tr",
+ "uk",
+ "vi",
+ "zh-hant"
+]list_chains3 fields changedInput schema / propertiesAdded value: +{
+ "chain": {
+ "description": "Optional chain slug (exact match, e.g. 'base_mainnet'). When set, only that chain is returned; unknown slugs return an error listing the available ones. Omit to list all chains.",
+ "type": "string"
+ }
+}Output schema / properties / chains / items / properties / max_logs_block_range / descriptionAdded value: +"Max block span of one eth_getLogs request. Both ends are inclusive: toBlock - fromBlock + 1 must not exceed this value, otherwise the call returns logs_range_too_large."Output schema / properties / chains / items / properties / public / properties / history_blocks / descriptionAdded value: +"How many blocks back a block reference may reach on the keyless public.url. It applies only to methods in public.methods and does not add methods."rpc_call1 field changedInput schema / properties / chain / descriptionPrevious value: -"Target blockchain network slug (e.g. 'robinhood_mainnet'). Must exist in GET /v1/chains."New value: +"Target blockchain network slug (e.g. 'base_mainnet'). Must exist in GET /v1/chains; list_chains returns the valid slugs."explain_error2 fields changedInput schema / properties / lang / descriptionPrevious value: -"Language for explanations: 'en' for English or 'zh' for Chinese. Defaults to 'en'."New value: +"Response language. Defaults to 'en'."Input schema / properties / lang / enumPrevious value: -[
- "en",
- "zh"
-]New value: +[
+ "zh",
+ "en",
+ "ja",
+ "es",
+ "pt-br",
+ "ko",
+ "vi",
+ "zh-hant",
+ "id",
+ "tr",
+ "de",
+ "fr",
+ "ru"
+]how_to_get_api_key2 fields changedInput schema / properties / lang / descriptionPrevious value: -"Documentation language: 'en' for English or 'zh' for Chinese. Defaults to 'en'."New value: +"Response language. Defaults to 'en'."Input schema / properties / lang / enumPrevious value: -[
- "en",
- "zh"
-]New value: +[
+ "zh",
+ "en",
+ "ja",
+ "es",
+ "pt-br",
+ "ko",
+ "vi",
+ "zh-hant",
+ "id",
+ "tr",
+ "de",
+ "fr",
+ "ru"
+]list_docs1 field changedInput schema / properties / lang / enumPrevious value: -[
- "en",
- "zh",
- "es",
- "id",
- "ja",
- "ko",
- "pt-br",
- "ru",
- "vi",
- "zh-hant"
-]New value: +[
+ "en",
+ "zh",
+ "de",
+ "es",
+ "fr",
+ "id",
+ "ja",
+ "ko",
+ "pt-br",
+ "ru",
+ "tr",
+ "vi",
+ "zh-hant"
+]read_doc1 field changedInput schema / properties / lang / enumPrevious value: -[
- "en",
- "zh",
- "es",
- "id",
- "ja",
- "ko",
- "pt-br",
- "ru",
- "vi",
- "zh-hant"
-]New value: +[
+ "en",
+ "zh",
+ "de",
+ "es",
+ "fr",
+ "id",
+ "ja",
+ "ko",
+ "pt-br",
+ "ru",
+ "tr",
+ "vi",
+ "zh-hant"
+]search_docs1 field changedInput schema / properties / lang / enumPrevious value: -[
- "en",
- "zh",
- "es",
- "id",
- "ja",
- "ko",
- "pt-br",
- "ru",
- "vi",
- "zh-hant"
-]New value: +[
+ "en",
+ "zh",
+ "de",
+ "es",
+ "fr",
+ "id",
+ "ja",
+ "ko",
+ "pt-br",
+ "ru",
+ "tr",
+ "vi",
+ "zh-hant"
+]list_docs1 field changedInput schema / properties / lang / enumPrevious value: -[
- "en",
- "zh",
- "es",
- "id",
- "ja",
- "ko",
- "pt-br",
- "vi",
- "zh-hant"
-]New value: +[
+ "en",
+ "zh",
+ "es",
+ "id",
+ "ja",
+ "ko",
+ "pt-br",
+ "ru",
+ "vi",
+ "zh-hant"
+]read_doc1 field changedInput schema / properties / lang / enumPrevious value: -[
- "en",
- "zh",
- "es",
- "id",
- "ja",
- "ko",
- "pt-br",
- "vi",
- "zh-hant"
-]New value: +[
+ "en",
+ "zh",
+ "es",
+ "id",
+ "ja",
+ "ko",
+ "pt-br",
+ "ru",
+ "vi",
+ "zh-hant"
+]search_docs1 field changedInput schema / properties / lang / enumPrevious value: -[
- "en",
- "zh",
- "es",
- "id",
- "ja",
- "ko",
- "pt-br",
- "vi",
- "zh-hant"
-]New value: +[
+ "en",
+ "zh",
+ "es",
+ "id",
+ "ja",
+ "ko",
+ "pt-br",
+ "ru",
+ "vi",
+ "zh-hant"
+]list_docs1 field changedInput schema / properties / lang / enumPrevious value: -[
- "en",
- "zh",
- "ja",
- "ko",
- "pt-br"
-]New value: +[
+ "en",
+ "zh",
+ "es",
+ "id",
+ "ja",
+ "ko",
+ "pt-br",
+ "vi",
+ "zh-hant"
+]read_doc1 field changedInput schema / properties / lang / enumPrevious value: -[
- "en",
- "zh",
- "ja",
- "ko",
- "pt-br"
-]New value: +[
+ "en",
+ "zh",
+ "es",
+ "id",
+ "ja",
+ "ko",
+ "pt-br",
+ "vi",
+ "zh-hant"
+]search_docs1 field changedInput schema / properties / lang / enumPrevious value: -[
- "en",
- "zh",
- "ja",
- "ko",
- "pt-br"
-]New value: +[
+ "en",
+ "zh",
+ "es",
+ "id",
+ "ja",
+ "ko",
+ "pt-br",
+ "vi",
+ "zh-hant"
+]list_docs1 field changedInput schema / properties / lang / enumPrevious value: -[
- "en",
- "zh",
- "ko"
-]New value: +[
+ "en",
+ "zh",
+ "ja",
+ "ko",
+ "pt-br"
+]read_doc1 field changedInput schema / properties / lang / enumPrevious value: -[
- "en",
- "zh",
- "ko"
-]New value: +[
+ "en",
+ "zh",
+ "ja",
+ "ko",
+ "pt-br"
+]search_docs1 field changedInput schema / properties / lang / enumPrevious value: -[
- "en",
- "zh",
- "ko"
-]New value: +[
+ "en",
+ "zh",
+ "ja",
+ "ko",
+ "pt-br"
+]list_docs1 field changedInput schema / properties / lang / enumPrevious value: -[
- "en",
- "zh"
-]New value: +[
+ "en",
+ "zh",
+ "ko"
+]read_doc1 field changedInput schema / properties / lang / enumPrevious value: -[
- "en",
- "zh"
-]New value: +[
+ "en",
+ "zh",
+ "ko"
+]search_docs1 field changedInput schema / properties / lang / enumPrevious value: -[
- "en",
- "zh"
-]New value: +[
+ "en",
+ "zh",
+ "ko"
+]list_docs1 field changedInput schema / properties / lang / descriptionPrevious value: -"Documentation language: 'en' for English or 'zh' for Chinese. Defaults to 'en'."New value: +"Published documentation language. Omit for English; unavailable languages return an error."read_doc1 field changedInput schema / properties / lang / descriptionPrevious value: -"Documentation language: 'en' for English or 'zh' for Chinese. Defaults to 'en'."New value: +"Published documentation language. Omit for English; unavailable languages return an error."search_docs1 field changedInput schema / properties / lang / descriptionPrevious value: -"Language to search: 'en' for English or 'zh' for Chinese. Defaults to 'en'."New value: +"Published documentation language. Omit for English; unavailable languages return an error."get_status1 field changedOutput schema / requiredPrevious value: -[
- "gateway",
- "chains"
-]New value: +[
+ "checked_at",
+ "gateway",
+ "chains"
+]Blockchain RPC for 125+ chains: endpoints, method support, probing and RPC calls with your key.
64 tools: balances, blocks, gas, txs and logs on 5 EVM chains, plus Bitcoin. 25 free calls.
Read chain data on 200+ networks and Sui: transactions, logs, balances, objects, ABI-decoded.
EVM and Solana reads: balances, tokens, eth_call, logs, receipts, gas, blocks, transactions, ENS.
Add one secure layer between your agents and this server.