Blackwood State

Server Details

Pay-per-call tools for agents: onchain data, ECB FX rates, text tools. USDC on Base, x402

If you are the author of this connector, you can claim ownership by verifying the domain or GitHub account it belongs to. Claimed connector authors can inspect health checks, view analytics, and manage their listing.

Status: Healthy
Uptime: 100.0% over 21 days
Last Tested: 2026-11-06 22:32
Transport: Streamable HTTP · MCP 2025-11-25
URL
ChatGPT: –
Claude: –

TDQS

A4.1/5.0

Scored 2026-10-19 00:02 across 38 tools

Disambiguation3/5

Several clusters of tools have overlapping purposes: wallet_balances, wallet_portfolio, and wallet_value all deal with wallet balances; news_search, crypto_news, and news_briefing overlap on news; company_dossier bundles domain_intel and headers_audit; and llm_chat overlaps with text_summarize, text_translate, and text_sentiment. The detailed descriptions with 'do not use for' clauses mitigate confusion, but an agent could still misselect without careful reading.

Naming Consistency5/5

All 38 tools use the same blackwood_ prefix and lower snake_case, with a predictable structure of domain/object and action. The convention is applied consistently throughout, with no mixing of camelCase or other styles.

Tool Count2/5

38 tools is well above the typical 3-15 range and exceeds the 25+ threshold that indicates too many tools for a coherent set. While the server is a multi-service platform, the sheer number increases cognitive load and the risk of misselection.

Completeness4/5

Each tool is well-scoped and covers its specific function thoroughly, with status tools for long-running jobs and clear boundaries. Minor gaps exist (e.g., no geocoding tool despite weather_forecast requiring coordinates, no credit top-up tool), but agents can work around these.

Available Tools

38 tools

blackwood_airport_delaysAirport delaysA

Read-onlyIdempotent

Inspect

Use when you need airport delays, FAA ground stops or the airport status of a US airport right now, such as departure delays or closures. Do not use for the status of a flight number, airports outside the US or historical delays. Returns JSON with current US airport delays from the FAA: ground stops, ground delay programs with average and maximum delay, arrival and departure delays and closures, for all airports or one for 0.007 USDC per call. Typical response time 1500 ms (p95). Category: Data.

Name	Required	Description	Default
`airport`	No	US airport code to filter, e.g. SFO or KSFO (all airports with delays when omitted)
`response_format`	No	concise (the default when omitted) keeps the JSON short: long fields such as base64 images or audio come back as separate image/audio content blocks and other long strings are cut with a marker; detailed returns the full JSON

Output Schema

Name	Required	Description
No output parameters

TDQS

A4.6/5.0

Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare read-only, idempotent, open-world and non-destructive, so the safety profile is covered. The description adds value beyond that: per-call cost (0.007 USDC), p95 latency (1500 ms), data source (FAA) and freshness ('right now') – all decision-relevant facts an agent cannot get from structured fields.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Front-loaded with the usage trigger and efficiently packed with scope, output, pricing and latency. It is slightly repetitive – ground stops and delays are enumerated twice ('ground stops' then 'ground stops, ground delay programs with average and maximum delay') – which costs a little tightness.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a two-parameter read tool with a full output schema, the description covers everything an agent needs: scope, exclusions, cost, latency and the shape of the payload. Return-value detail is a bonus given the output schema exists.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100% and the airport pattern, response_format enum and defaults are all documented in the schema itself. The description only restates that results cover 'all airports or one', which adds nothing new. Baseline 3 is appropriate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb+resource (fetch current US airport delays / FAA ground stops) and pins the scope with 'right now' and 'US airport'. The explicit exclusions (flight number status, non-US airports, historical delays) carve out the domain clearly, so an agent can tell this apart from weather_forecast or news tools without opening the schema.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Opens with 'Use when you need...' and follows with 'Do not use for...' covering three distinct out-of-scope cases. This is an explicit when/when-not pair, not inferred usage.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

blackwood_altcoin_discoveryAltcoin discovery on BaseA

Read-onlyIdempotent

Inspect

Use when you need altcoin discovery, new token listings or fresh Base tokens with real liquidity to research. Do not use for established coins, other chains or DEXs, price history, trading signals or token safety audits. Returns JSON with new tokens on Base that just got liquidity: Uniswap v3 pools created in the last hours against WETH or USDC, read on-chain from pool creation events, with price, depth and age for 0.003 USDC per call. Typical response time 3000 ms (p95). Category: Trading.

Name	Required	Description
`hours`	No	Look back this many hours for new pools, 1 to 72 (24 when omitted), e.g. 24
`limit`	No	Tokens to return, 1 to 25 (10 when omitted), e.g. 5
`quote`	No	Quote side of the pool (any when omitted), e.g. "WETH"
`minDepthUsd`	No	Minimum USD on the WETH or USDC side of the pool (5000 when omitted), e.g. 10000
`response_format`	No	concise (the default when omitted) keeps the JSON short: long fields such as base64 images or audio come back as separate image/audio content blocks and other long strings are cut with a marker; detailed returns the full JSON

Output Schema

Name	Required	Description
No output parameters

TDQS

A4.4/5.0

Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already cover read-only, idempotent, non-destructive, open-world behavior, so the bar is lower. The description nonetheless adds decision-relevant facts the annotations cannot convey: on-chain pool-creation-event sourcing, 0.003 USDC per call, and ~3000 ms p95 latency.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Front-loads usage and exclusions before mechanism and cost, and every sentence carries signal. The single long middle sentence and trailing 'Category: Trading' metadata are slightly less economical, but the description stays tight overall.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

With an output schema present, return values need no elaboration. Given the zero-required-parameter, five-parameter schema, the description supplies everything else an agent needs: scope, freshness window, quote constraint, data source, cost and latency.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100% and every parameter already documents its default, range and enum values, so the baseline is 3. The description only gestures at output fields (price, depth, age) and adds no per-parameter meaning beyond what the schema supplies.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description states a specific verb and resource: discovering new altcoin/Base tokens that just received Uniswap v3 liquidity. It pinpoints the exact scope (fresh pools quoted in WETH or USDC within the last hours), which cleanly separates it from broad crypto siblings like token_price or crypto_news.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

It gives explicit positive triggers (altcoin discovery, new listings, fresh Base tokens with real liquidity) and an explicit exclusion list (established coins, other chains/DEXs, price history, trading signals, token safety audits). An agent can route correctly without opening any schema.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

blackwood_audio_transcribeSpeech to textA

Read-onlyIdempotent

Inspect

Use when you need speech to text transcription or translation of an audio file at a public URL. Do not use for audio over 10 MB or speaker labels. Returns JSON with a Whisper transcription of an audio file: text, timed segments and language, or an English translation for 0.005 USDC per megabyte, up to 0.05 USDC per call (clients without upto pay the cap). Result in the same call (about 20000 ms); a status tool polls for free if it takes longer. Category: Media.

Name	Required	Description
`url`	Yes	Public http(s) URL of the audio file, e.g. https://example.com/talk.mp3 (mp3, wav, ogg, m4a, webm; up to 10 MB)
`task`	No	transcribe keeps the spoken language; translate returns English (transcribe when omitted)
`language`	No	ISO 639-1 code of the spoken language, e.g. en or pt (detected when omitted)
`response_format`	No	concise (the default when omitted) keeps the JSON short: long fields such as base64 images or audio come back as separate image/audio content blocks and other long strings are cut with a marker; detailed returns the full JSON

Output Schema

Name	Required	Description
No output parameters

TDQS

A4.6/5.0

Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already cover the safety profile (readOnly, idempotent, non-destructive), and the description goes well beyond them: per-megabyte pricing with a per-call cap, the 'clients without upto pay the cap' caveat, and an expected ~20000 ms synchronous latency with a free polling alternative. Cost and latency characteristics are exactly the behavior an agent needs before invoking a metered API.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Front-loads the usage condition, then layers return shape, pricing, and timing in dense but non-redundant sentences. The trailing 'Category: Media.' is minor filler, but nothing else is wasted.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

With an output schema present, the description need not detail return values, yet it still summarizes them (text, timed segments, language) alongside pricing and latency fallback. Nothing an agent needs to invoke this tool correctly is missing.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the schema already fully documents url, task, language and response_format. The description's mentions of 'translation' and language detection restate rather than extend the schema, so the baseline 3 is appropriate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb and resource ('speech to text transcription or translation of an audio file at a public URL') and scopes the input source precisely. An agent can immediately distinguish it from siblings like blackwood_speech_synthesize and blackwood_text_translate 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.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Explicit when-to-use ('when you need speech to text transcription or translation') plus explicit when-not ('Do not use for audio over 10 MB or speaker labels'). It also routes the agent to the async fallback, naming blackwood_audio_transcribe_status for jobs that exceed the inline wait.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

blackwood_audio_transcribe_statusSpeech to text (status)A

Read-onlyIdempotent

Inspect

Free. Status and result of a job created by blackwood_audio_transcribe. Poll until done is true.

Name	Required	Description	Default
`jobId`	Yes

Output Schema

Name	Required	Description
`done`	Yes
`error`	No
`jobId`	Yes
`output`	No
`status`	Yes

TDQS

A4.2/5.0

Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnly/idempotent/non-destructive, so the safety bar is low. The description adds two useful traits beyond them: the tool is free (cost signal) and it is meant to be polled repeatedly until completion, which explains why idempotency matters here. It stops short of describing terminal failure states or retention of results.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Three terse sentences with zero redundancy; the cost signal is front-loaded and the polling action follows immediately. Nothing could be cut without losing information.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

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 detail is not required, and the 'done is true' reference aligns with the expected completion field. Combined with the annotations and the named sibling, an agent has enough to call this correctly; minor gaps remain around job expiry or error states.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 0% for the single required jobId, but the description identifies its origin ('a job created by blackwood_audio_transcribe'), which tells the agent where the value comes from. It adds no format, length, or expiry detail, so it only partially compensates for the undocumented parameter.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific resource (status and result of a job) plus its origin tool by name, and distinguishes itself from blackwood_audio_transcribe, the tool that creates the job. An agent can identify the polling counterpart 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.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

'Poll until done is true' gives explicit invocation guidance and implies the workflow order (create via blackwood_audio_transcribe, then poll here). It does not explicitly state the negative case (e.g. not to call without a jobId), but the routing context is clear.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

blackwood_company_dossierCompany research dossierA

Read-only

Inspect

Use when you need company research, due diligence or a quick analysis of a business from its website domain and optional ticker. Do not use for private financials, credit scores, people search or businesses without a website. Returns JSON with a company research dossier in one call: domain registration and DNS, email and website security, latest news and, with a ticker, SEC financials, priced below the separate calls for 0.03 USDC per call. Typical response time 8000 ms (p95). Category: Data.

Name	Required	Description
`name`	No	Company name for the news search (taken from the domain when omitted), e.g. Stripe
`domain`	Yes	Company website domain, e.g. stripe.com
`ticker`	No	Stock ticker for SEC financials, US filers only (no financials when omitted), e.g. AAPL
`response_format`	No	concise (the default when omitted) keeps the JSON short: long fields such as base64 images or audio come back as separate image/audio content blocks and other long strings are cut with a marker; detailed returns the full JSON

Output Schema

Name	Required	Description
No output parameters

TDQS

A4.5/5.0

Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already cover the safety profile (readOnly, non-destructive, openWorld), so the description rightly spends its words on non-obvious traits: 0.03 USDC per call, p95 latency of 8000 ms, and that bundling is cheaper than the separate calls. It does not explain error/partial-failure behavior or why idempotentHint is false, which would have pushed this to 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.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Three tight sentences, front-loaded with the usage condition and exclusions, followed by payload contents, pricing and latency. Every sentence carries information an agent needs to decide or budget; the trailing 'Category: Data' tag is the only filler.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For an aggregator tool with an output schema present, the description supplies everything the schema cannot: when it beats the constituent tools, what it excludes, cost, and latency. Return shape is already handled by the output schema, so no gap remains.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the schema already documents domain, name, ticker and the concise/detailed response_format enum in detail. The description only restates the ticker gating ('with a ticker, SEC financials') and never mentions response_format, so it adds little beyond structured data; baseline 3 is appropriate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description names a concrete verb+resource (company research dossier built from a domain and optional ticker) and enumerates the bundled payloads (domain registration/DNS, email and website security, news, SEC financials). This enumeration implicitly differentiates it from the sibling single-purpose tools (blackwood_domain_intel, blackwood_headers_audit, blackwood_news_search, blackwood_sec_facts) by making clear it is an aggregator.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Explicit when-to-use ('company research, due diligence or a quick analysis of a business from its website domain') and explicit when-not-to-use ('private financials, credit scores, people search or businesses without a website'). The condition selecting the ticker-driven financial branch is also stated. Nothing is left to inference.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

blackwood_credits_balancePrepaid credits balanceA

Read-onlyIdempotent

Inspect

Use this when you call Blackwood State tools many times and want to pay once: returns the prepaid credit balance of the API key sent as Authorization: Bearer on this MCP connection, recent debits and the top-up packs (pay once via x402, then every tool call debits the balance with no payment signature). Free. Category: Infrastructure.

Name	Required	Description	Default
No parameters

TDQS

A4.5/5.0

Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare read-only, idempotent, non-destructive behavior. The description adds valuable context beyond that: it explains the x402 pay-once-then-debit billing model, that the API key is sent as Authorization: Bearer on this connection, and that the tool is free. It doesn't mention rate limits or response format, but it substantially enriches the billing model understanding.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Front-loads the usage condition and then lists what is returned. Slightly dense with multiple clauses (payment model, auth, top-up packs) but every clause carries useful information. One sentence, no waste.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a zero-param, read-only tool with annotations covering safety and no output schema, the description covers the essential behavioral context: what it returns, how auth works, and the billing model. The only minor gap is not describing the shape of the returned balance/debits/packs, but that's acceptable without an output schema.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Zero parameters, so baseline is 4. The description correctly indicates no parameters are needed and explains that the API key comes from the connection context rather than a parameter, which is a helpful clarification.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb (returns) and resource (prepaid credit balance of the API key), plus what else is returned (recent debits, top-up packs). Clearly distinguishes itself from all 28 siblings, none of which deal with billing/credits.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Explicitly tells the agent when to use it: 'when you call Blackwood State tools many times and want to pay once.' This is a concrete condition that routes the agent correctly, and it implicitly contrasts with the per-call x402 payment model used by siblings.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

blackwood_crypto_newsCrypto newsA

Read-onlyIdempotent

Inspect

Use when you need crypto news or crypto market news headlines about a token or the market from recent articles. Do not use for prices, full article text, social media posts or news older than 72 hours. Returns JSON with the latest crypto news headlines from the last 72 hours (title, link, source, time, tone, people and organizations) about bitcoin, ethereum and blockchain news, from the GDELT news graph for 0.005 USDC per call. Typical response time 1500 ms (p95). Category: Search.

Name	Required	Description
`hours`	No	How far back to search, in hours (1-72, default 24)
`limit`	No	Most articles to return (1-50, default 20), newest first
`token`	No	Narrow to one coin, chain or company, e.g. solana, xrp or coinbase (any crypto news when omitted)
`response_format`	No	concise (the default when omitted) keeps the JSON short: long fields such as base64 images or audio come back as separate image/audio content blocks and other long strings are cut with a marker; detailed returns the full JSON

Output Schema

Name	Required	Description
No output parameters

TDQS

A4.4/5.0

Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Goes well beyond the annotations (readOnly/openWorld/idempotent/non-destructive) by disclosing the data source (GDELT), the pricing model (0.005 USDC per call), a hard freshness ceiling (72 hours), expected latency (1500 ms p95), and the returned fields (title, link, source, time, tone, people, organizations). That is exactly the operational context annotations cannot convey for a metered, open-world search.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Front-loads the use case, then constraints, then return/pricing details — a sensible order with no wasted padding. The trailing "Category: Search." label is metadata that does not help an agent decide or call the tool.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

An output schema exists, yet the description still names the key return fields, and it supplies cost, latency, freshness limit, and data provenance. For an open-world, per-call-billed search tool, nothing material is missing.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so all four parameters are already documented, which sets the baseline at 3. The description only reinforces the token parameter (coin, chain or company) and the 72-hour cap; it adds no syntax, defaults, or interaction guidance beyond the schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb (retrieve news headlines) and resource (crypto news about a token or the market) with scope (last 72 hours, GDELT news graph). It actively distinguishes itself from siblings by excluding prices (token_price), full article text (webpage_markdown/pdf_extract), and social posts, 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.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Explicit when-to-use ("crypto news or crypto market news headlines about a token or the market") and clear when-not-use exclusions (prices, full article text, social media, news older than 72 hours). It stops short of naming the alternative tools that cover those excluded cases, so routing requires inference.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

blackwood_domain_intelDomain intelligenceA

Read-onlyIdempotent

Inspect

Use when you need a domain lookup, whois, dns records or certificate transparency data for osint, security or due diligence. Do not use for historical whois, registrant personal data (redacted by registries) or port and vulnerability scans. Returns JSON with domain intelligence: WHOIS/RDAP registration, DNS records (A, AAAA, MX, NS, TXT, CAA), SPF and DMARC, and TLS certificates from certificate transparency logs for 0.02 USDC per call. Typical response time 4000 ms (p95). Category: Data.

Name	Required	Description
`domain`	Yes	Domain name in ASCII (punycode for internationalized names), e.g. example.com
`certificates`	No	Include issued TLS certificates from Certificate Transparency (crt.sh); true when omitted
`response_format`	No	concise (the default when omitted) keeps the JSON short: long fields such as base64 images or audio come back as separate image/audio content blocks and other long strings are cut with a marker; detailed returns the full JSON

Output Schema

Name	Required	Description
No output parameters

TDQS

A4.6/5.0

Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already cover safety (readOnly, idempotent, non-destructive, openWorld), and the description goes further with cost (0.02 USDC per call), p95 latency (4000 ms), and the registry-level redaction limitation. These are operational facts the agent cannot get from the structured fields.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Front-loaded with the 'Use when' clause and kept to three tight sentences; the trailing 'Category: Data' is filler. Dense but every substantive sentence earns its place.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a read-only lookup with a full output schema, the description supplies the remaining decision-relevant context: scope, exclusions, cost, latency, and output shape. Nothing needed to call it correctly is missing.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the schema already documents 'domain', 'certificates' (default true) and 'response_format' (concise vs detailed, with truncation behavior). The description's mention of certificate transparency data loosely maps to the 'certificates' parameter but adds no syntax or default nuance 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.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb and resource set ('domain lookup, whois, dns records or certificate transparency data') and enumerates exactly what is returned (WHOIS/RDAP, A/AAAA/MX/NS/TXT/CAA, SPF/DMARC, TLS certs). This is clearly distinguishable from the nearest siblings (blackwood_ens_lookup, blackwood_headers_audit) 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.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Explicitly names the use contexts (osint, security, due diligence) and the exclusions (historical whois, registrant personal data redacted by registries, port/vulnerability scans). The 'when-not' list removes the most likely mis-invocations, which is rare and valuable.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

blackwood_email_batchEmail list checkA

Read-onlyIdempotent

Inspect

Use when you need bulk email validation, email list verification or to verify email lists before a send or import. Do not use for one address (email-check is cheaper), proving a mailbox exists (no SMTP probe) or sending email. Returns JSON checking up to 20 email addresses in one call: syntax, MX records, disposable, free and role flags, SPF, DMARC and a verdict each, plus counts by verdict for 0.02 USDC per call. Typical response time 2500 ms (p95). Category: Data.

Name	Required	Description	Default
`emails`	Yes	Email addresses to check, 1 to 20, e.g. ["jane@example.com", "info@ietf.org"]
`response_format`	No	concise (the default when omitted) keeps the JSON short: long fields such as base64 images or audio come back as separate image/audio content blocks and other long strings are cut with a marker; detailed returns the full JSON

Output Schema

Name	Required	Description
No output parameters

TDQS

A4.7/5.0

Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare read-only, idempotent, non-destructive, open-world behavior, so the bar is lower. The description adds substantive behavioral context beyond that: no SMTP probe limitation, per-call cost (0.02 USDC), p95 latency (2500 ms), and the 20-address batch cap.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Front-loads the usage condition and exclusion before the return-value details; every sentence (use case, exclusions, return contents, cost/latency) carries distinct information with no filler.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

With an output schema present the description need not enumerate return fields, yet it still summarizes the verdict structure and counts. Combined with rich annotations and full parameter coverage, an agent has everything needed to invoke correctly.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100%, so both parameters (emails and response_format) are already documented in the schema, establishing a baseline of 3. The description reiterates the 20-address cap but adds no syntax, format, or breaking-down detail beyond what the schema states.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb and resource (bulk email validation / email list verification) and explicitly distinguishes itself from the sibling blackwood_email_check by rejecting single-address use. An agent can identify the tool's domain without opening the schema.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Explicitly names when to use it ('before a send or import'), when not to use it ('one address', 'proving a mailbox exists', 'sending email'), and points to the cheaper alternative email-check. Nothing is left to inference.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

blackwood_email_checkEmail validationA

Read-onlyIdempotent

Inspect

Use when you need email validation, to verify email addresses or validate email syntax and MX records before sending or signup. Do not use for confirming that the mailbox itself exists (no SMTP probe is done) or sending email. Returns JSON with email verification of one address: syntax, domain MX records, disposable, free and role-account flags, SPF and DMARC, and a verdict on whether the domain can receive mail for 0.005 USDC per call. Typical response time 800 ms (p95). Category: Data.

Name	Required	Description	Default
`email`	Yes	Email address to check, e.g. jane@example.com
`response_format`	No	concise (the default when omitted) keeps the JSON short: long fields such as base64 images or audio come back as separate image/audio content blocks and other long strings are cut with a marker; detailed returns the full JSON

Output Schema

Name	Required	Description
No output parameters

TDQS

A4.5/5.0

Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnly/idempotent/non-destructive, but the description adds genuinely non-structured behavior: 0.005 USDC per call pricing, 800 ms p95 latency, and the no-SMTP-probe limitation. The enumeration of return fields overlaps what the output schema already provides, so this is strong but not maximally additive.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Single dense paragraph, front-loaded with the usage cue, then scope exclusions, then returns and cost. No sentence is filler; cost and latency earn their place.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a paid, network-bound validation tool with full annotations, complete schema, and an output schema, the description covers trigger, exclusions, return shape, and cost/latency. Nothing required for correct invocation is missing.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

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 says nothing about the 'email' or 'response_format' parameters that isn't already in the schema, so it neither compensates nor adds value here.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb and resource ('email validation', 'verify email addresses or validate email syntax and MX records') and sharply bounds scope by contrasting with sibling-adjacent functions (no mailbox existence check, no sending). An agent can tell this single-address validator apart from batch or send-email tools 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.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Gives explicit trigger context ('before sending or signup') and two explicit exclusions ('Do not use for confirming that the mailbox itself exists... or sending email'). This is the when/when-not pattern done properly.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

blackwood_ens_lookupENS name lookupA

Read-onlyIdempotent

Inspect

Use when you need to resolve an ENS name to an address, reverse-resolve an address to its ENS name, or read an ENS avatar and profile records. Do not use for registering or renewing names, or non-ENS naming such as Solana SNS. Returns JSON with an ENS lookup on Ethereum in one call: the address of a name, the verified primary name of an address (reverse), the avatar and text records such as url, twitter and github for 0.003 USDC per call. Typical response time 2000 ms (p95). Category: Data.

Name	Required	Description
`name`	No	ENS name to resolve, e.g. vitalik.eth (send name or address, not both)
`texts`	No	Text record keys to read (avatar, url, description, com.twitter, com.github and email when omitted), e.g. ["url", "com.github"]
`address`	No	Ethereum address to reverse-resolve, e.g. 0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045 (send name or address, not both)
`response_format`	No	concise (the default when omitted) keeps the JSON short: long fields such as base64 images or audio come back as separate image/audio content blocks and other long strings are cut with a marker; detailed returns the full JSON

Output Schema

Name	Required	Description
No output parameters

TDQS

A4.3/5.0

Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint, so the safety profile is covered structurally. The description adds genuinely new operational context: cost (0.003 USDC per call), p95 latency of 2000 ms, single-call JSON return, and Ethereum as the chain. Rate limits and failure modes are not described, keeping it below 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.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Three sentences, appropriately front-loaded with the use-when/enum-style trigger before exclusions. Minor redundancy: the second sentence re-enumerates resolve/reverse/records already stated in sentence 1 while folding in pricing and latency, so a little trimming is possible.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

With an output schema present, return values need not be explained, yet the description still restates them; the important extras - cost, latency, chain, category, exclusions - are all supplied. Complete enough that an agent can select and call the tool correctly with no further inference.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so all four parameters (name, address, texts, response_format) are already documented in the schema, including the name-or-address exclusivity and the concise default. The description reinforces that invariants but adds no syntax, format, or default detail beyond the structured fields, so the baseline 3 applies.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

Names a specific verb+resource triple: resolve an ENS name to an address, reverse-resolve an address to its ENS name, and read avatar/text records. It also draws the boundary against adjacent tools (registering/renewing, non-ENS naming like Solana SNS), so an agent can distinguish it from domain_intel and wallet_* siblings 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.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Opens with an explicit 'Use when...' trigger list and follows with an explicit 'Do not use for...' exclusion covering registration/renewal and non-ENS naming systems. The only mild gap is that it doesn't name a specific sibling to use instead for non-ENS lookups, but the exclusion condition is fully stated.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

blackwood_fx_historyHistorical exchange ratesA

Read-onlyIdempotent

Inspect

Use when you need historical exchange rates, a historical FX rate series, forex history or a currency trend. Do not use for rates older than 90 days, live quotes or crypto (one ECB rate per business day). Returns JSON with historical exchange rates: 90 days of daily ECB euro reference rates (free at ecb.europa.eu) for up to 10 currencies, rebased to any base as cross rates, with min, max and percent change for 0.005 USDC per call. Typical response time 1500 ms (p95). Category: Data.

Name	Required	Description
`base`	No	Base currency, ISO 4217 (EUR when omitted), e.g. USD
`days`	No	Calendar days back from endDate, 1 to 90 (90 when omitted; ignored with startDate), e.g. 30
`endDate`	No	Last day, YYYY-MM-DD (latest ECB day when omitted), e.g. 2026-09-30
`symbols`	Yes	Currencies to return, ISO 4217, up to 10, e.g. ["USD", "BRL"]
`startDate`	No	First day, YYYY-MM-DD, within the last 90 days, e.g. 2026-09-01
`response_format`	No	concise (the default when omitted) keeps the JSON short: long fields such as base64 images or audio come back as separate image/audio content blocks and other long strings are cut with a marker; detailed returns the full JSON

Output Schema

Name	Required	Description
No output parameters

TDQS

A4.3/5.0

Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations cover the safety profile (readOnly, idempotent, openWorld, non-destructive), and the description goes well beyond them: ECB as the source, one rate per business day, 90-day ceiling, up to 10 currencies, cross-rate rebasing, cost of 0.005 USDC per call, and p95 latency of 1500 ms. Cost and latency disclosures in particular are exactly the kind of operational context annotations cannot carry.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Front-loaded with the use condition, then exclusions, then behavior and limits — a good ordering with no filler sentences. The opening list of near-synonyms ('historical exchange rates, a historical FX rate series, forex history or a currency trend') is somewhat redundant keyword padding that a 5 would have trimmed.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a 6-parameter, read-only data tool with a full schema and an output schema, the description supplies everything else an agent needs: data source, coverage window, currency cap, pricing, latency, and explicit exclusions. Return-value shape is correctly left to the output schema.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

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 adds real meaning on top by explaining that results are 'rebased to any base as cross rates', which clarifies how the base parameter actually behaves, plus the derived min/max/percent-change outputs. It does not clarify startDate/days interaction or response_format beyond the schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb+resource ('historical exchange rates', 'historical FX rate series') and clearly delimits scope to historical ECB data. It does not name or differentiate from the near-identical sibling blackwood_fx_rates, which is the one sibling an agent is most likely to confuse it with, 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.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Gives explicit when-to-use ('need historical exchange rates... currency trend') and when-not ('rates older than 90 days, live quotes or crypto'), which is strong routing guidance. It stops short of naming the alternative tool (blackwood_fx_rates) for the live-quote case, so the agent must infer the substitute.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

blackwood_fx_ratesCurrency exchange ratesA

Read-onlyIdempotent

Inspect

Use when you need currency exchange rates, fx rates or forex conversion of an amount between two currencies like EUR and GBP. Do not use for live trading quotes, intraday or crypto rates (ECB rates update once per business day). Returns JSON with currency exchange rates: official ECB euro reference FX rates (free at ecb.europa.eu) for about 30 currencies, rebased to any base as cross rates, with optional conversion for 0.005 USDC per call. Typical response time 1500 ms (p95). Category: Data.

Name	Required	Description
`base`	No	Base currency, ISO 4217 (EUR when omitted), e.g. USD
`amount`	No	Amount in the base currency to convert, e.g. 100
`symbols`	No	Currencies to return, e.g. ["BRL", "JPY"] (all ECB currencies when omitted)
`response_format`	No	concise (the default when omitted) keeps the JSON short: long fields such as base64 images or audio come back as separate image/audio content blocks and other long strings are cut with a marker; detailed returns the full JSON

Output Schema

Name	Required	Description
No output parameters

TDQS

A4.1/5.0

Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnly/idempotent/non-destructive/openWorld, and the description goes well beyond them: cost (0.005 USDC per call), latency (1500 ms p95), data freshness (once per business day), source and licensing (ECB, free), and currency coverage (~30). This is exactly the operational context an agent needs before invoking.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Front-loaded with the 'Use when' trigger, then exclusions, then return/cost/latency facts in a compact run. Minor waste in the near-synonym list 'currency exchange rates, fx rates or forex conversion' and the trailing 'Category: Data' label, but the structure is otherwise tight.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

An output schema exists, so return formatting need not be explained, yet the description still covers data source, coverage, cost, latency and refresh cadence. Combined with the full schema coverage and rich annotations, nothing essential is missing for correct invocation.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so all four parameters are already documented with types, patterns and defaults. The description adds only marginal semantics ('rebased to any base as cross rates', 'optional conversion'), which is the expected baseline when the schema does the heavy lifting.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb and resource ('currency exchange rates', 'fx rates', 'forex conversion of an amount') and pins down the data source (official ECB euro reference rates, ~30 currencies, rebased as cross rates). It clearly distinguishes itself from live/intraday and crypto rate tools, but never differentiates from the sibling blackwood_fx_history, which an agent could plausibly confuse with this tool.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Gives an explicit 'Use when' trigger and an explicit 'Do not use for' exclusion (live trading quotes, intraday, crypto), with the reason (ECB updates once per business day). It stops short of naming the correct alternative tool for historical or crypto rates, so the routing guidance is strong but not complete.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

blackwood_gas_feesGas price and feesA

Read-only

Inspect

Use when you need the current gas price, an ethereum gas fee estimate before a transaction, or to compare gas fees across chains. Do not use for gas units of a given transaction, gas history or chains beyond Ethereum, Base and Solana. Returns JSON with the gas price and gas fees on Ethereum and Base (base fee, slow, standard and fast EIP-1559 fees in gwei, transfer cost) plus Solana priority fees for 0.002 USDC per call. Typical response time 1500 ms (p95). Category: Data.

Name	Required	Description	Default
`chains`	No	Chains to read (ethereum, base and solana when omitted), e.g. ["base", "ethereum"]
`response_format`	No	concise (the default when omitted) keeps the JSON short: long fields such as base64 images or audio come back as separate image/audio content blocks and other long strings are cut with a marker; detailed returns the full JSON

Output Schema

Name	Required	Description
No output parameters

TDQS

A4.4/5.0

Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already cover the safety profile (readOnlyHint, destructiveHint=false, openWorldHint), and the description adds genuinely non-redundant behavior: cost of 0.002 USDC per call and a p95 latency of 1500 ms. It stops short of describing failure modes or what happens on unsupported chain input, so it is strong rather than exhaustive.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

It is front-loaded with the 'Use when' clause and every sentence carries content (use cases, exclusions, return shape, cost, latency). It is a dense single paragraph, but nothing is filler and the key routing information comes first.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

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 documented, yet the description still summarizes the payload (base fee, slow/standard/fast EIP-1559 fees, transfer cost, Solana priority fees). Combined with annotations and full schema coverage, 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.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100% and both parameters are fully documented in the schema, including the default for omitted chains and the concise/detailed response behavior. The description adds no parameter-level syntax or semantics beyond restating which chains are supported, so the baseline 3 applies.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description names a specific resource (gas price / gas fee estimate) with a clear verb framing ('need the current gas price', 'compare gas fees across chains'), and explicitly distinguishes itself from the gas-units and gas-history use cases. An agent can tell this apart from siblings like blackwood_token_price or blackwood_wallet_value 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.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

It gives an explicit when-to-use list (pre-transaction fee estimate, cross-chain fee comparison) and an explicit when-not-to-use list (gas units of a given transaction, gas history, chains outside Ethereum/Base/Solana). This is exactly the routing guidance an agent needs.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

blackwood_headers_auditSecurity headersA

Read-onlyIdempotent

Inspect

Use when you need an http security headers audit of a website or URL, with a grade and what to fix. Do not use for vulnerability scans, TLS cipher analysis or pages behind a login. Returns JSON auditing the HTTP security headers of a public URL (HSTS, CSP, X-Frame-Options, X-Content-Type-Options, Referrer-Policy, Permissions-Policy, cookies) with a grade and fixes for 0.007 USDC per call. Typical response time 2500 ms (p95). Category: Infrastructure.

Name	Required	Description	Default
`url`	Yes	Public http(s) URL to audit, e.g. https://example.com
`response_format`	No	concise (the default when omitted) keeps the JSON short: long fields such as base64 images or audio come back as separate image/audio content blocks and other long strings are cut with a marker; detailed returns the full JSON

Output Schema

Name	Required	Description
No output parameters

TDQS

A4.6/5.0

Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnly/idempotent/openWorld/non-destructive, and the description adds context beyond them: the exact response shape (JSON with grade and fixes), the audited header set, the 0.007 USDC per-call cost, and a 2500 ms p95 latency expectation. Cost and latency disclosure is the kind of operational detail annotations cannot carry.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

It is front-loaded with the usage trigger and exclusions, then pivots to return shape and operational metadata. Slightly dense with trailing pricing/latency/category facts, but every sentence carries information an agent can act on.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

With an output schema present, return values need not be spelled out, and the description still covers scope, exclusions, audited headers, cost and latency. Nothing an agent needs to decide or invoke correctly is missing.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, and the url and response_format parameters are fully documented in the schema, including the concise/detailed trade-off. The description adds nothing about parameter semantics beyond that, so the baseline of 3 applies.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description states a precise verb and resource: an HTTP security headers audit of a website or URL, returning a grade and fixes. It names the exact headers examined (HSTS, CSP, X-Frame-Options, etc.), which no sibling tool overlaps with, so an agent can separate it from domain_intel or webpage_markdown at a glance.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

It gives explicit when-to-use (need a headers audit with grade and fixes) and explicit when-not-to-use (vulnerability scans, TLS cipher analysis, pages behind a login). The login exclusion is a genuinely useful boundary an agent would otherwise get wrong.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

blackwood_image_generateImage generationA

Read-onlyIdempotent

Inspect

Use when you need image generation, an AI image generator or text to image from a prompt for illustrations, mockups or social posts. Do not use for image edits, specific sizes, photos of real people or more than one image per call. Returns JSON with an AI-generated image from a text prompt: a 1024x1024 JPEG made by FLUX.1 schnell on Workers AI, as base64 for 0.03 USDC per call. Result in the same call (about 10000 ms); a status tool polls for free if it takes longer. Category: Media.

Name	Required	Description
`steps`	No	Diffusion steps (1-8, 4 when omitted); more steps, more detail
`prompt`	Yes	What the image should show, in English, e.g. a lighthouse on a cliff at sunset, watercolor
`response_format`	No	concise (the default when omitted) keeps the JSON short: long fields such as base64 images or audio come back as separate image/audio content blocks and other long strings are cut with a marker; detailed returns the full JSON

Output Schema

Name	Required	Description
No output parameters

TDQS

A4.6/5.0

Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnly/idempotent/openWorld/non-destructive, but the description adds substantial behavior the annotations cannot convey: cost (0.03 USDC per call), expected latency (~10000 ms), the exact model and output (FLUX.1 schnell on Workers AI, 1024x1024 JPEG base64), and the fallback polling path. This is exactly the kind of paid-call, latency, and fallback context an agent needs before invoking.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Front-loaded with the usage condition and exclusion list before the output/cost details, so the reader can decide fast. The synonym chain ("image generation, an AI image generator or text to image") is arguably keyword padding, and the paragraph packs four distinct concerns into one block, which slightly hurts scannability.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given an existing output schema, the description need not explain return values, yet it still covers model, resolution, format, cost, latency, and the async escape hatch. For a paid, slow, single-image generation tool, an agent has everything required to call it correctly or route elsewhere.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100% and each parameter (prompt, steps, response_format) already carries its own description, so the baseline of 3 applies. The description adds only marginal parameter-adjacent meaning: that output size is fixed ("Do not use for specific sizes") and that generation is one image per call. It says nothing about steps or the concise/detailed response_format trade-off beyond what the schema states.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

Names a specific verb and resource (image generation from a text prompt) and immediately scopes what it produces: illustrations, mockups, social posts. It also differentiates itself from siblings by naming the excluded cases (image edits, real people's photos) and by pointing at blackwood_image_generate_status for long runs, which only a handful of its 37 siblings do.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Explicit when-to-use ("Use when you need image generation... from a prompt") and when-not ("Do not use for image edits, specific sizes, photos of real people or more than one image per call"). It also supplies the alternative for the long-running case: the status tool that polls for free. Nothing about tool selection is left to inference.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

blackwood_image_generate_statusImage generation (status)A

Read-onlyIdempotent

Inspect

Free. Status and result of a job created by blackwood_image_generate. Poll until done is true.

Name	Required	Description	Default
`jobId`	Yes

Output Schema

Name	Required	Description
`done`	Yes
`error`	No
`jobId`	Yes
`output`	No
`status`	Yes

TDQS

A4.1/5.0

Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already cover read-only/idempotent/non-destructive, so the bar is lower, and the description still adds two things annotations cannot: that the call is free and that it must be polled repeatedly until a 'done' flag is true. It omits any statement about jobId lifetime, error states, or rate limits.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Three short sentences, front-loaded with cost and purpose, with the polling instruction last. Minimal waste, though the one-word 'Free.' fragment is terse enough to read as clipped rather than polished.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

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, and the description correctly focuses on the async workflow (create, then poll). It stops just short of covering failure handling or how long results remain retrievable.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0% for the single jobId parameter, so the description carries some burden; it does usefully imply the value comes from blackwood_image_generate's response. However, it never explicitly identifies jobId as the job handle, nor its format or validity window.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb+resource ('status and result of a job') and explicitly ties it to the sibling tool that creates that job, blackwood_image_generate. An agent can immediately tell this apart from blackwood_image_generate and the other *_status siblings.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Names the prerequisite call (blackwood_image_generate) and gives explicit usage behavior: 'Poll until done is true.' Clear context for when to call it, though it offers no guidance on polling intervals or what to do on failure.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

blackwood_llm_chatLLM chat completionA

Read-onlyIdempotent

Inspect

Use when you need an llm chat completion for summaries, extraction or classification from a cheap open model. Do not use for frontier models, tool calling or streaming. Returns JSON with a chat completion from IBM Granite 4.0 Micro on Workers AI, with token usage for 0.002 USDC per thousand tokens, up to 0.03 USDC per call (clients without upto pay the cap). Result in the same call (about 8000 ms); a status tool polls for free if it takes longer. Category: Inference.

Name	Required	Description
`messages`	Yes	Conversation so far, oldest first, e.g. [{"role": "user", "content": "Summarize: ..."}]
`maxTokens`	No	Maximum tokens to generate (1-4096, 512 when omitted); billed as requested
`temperature`	No	Sampling temperature (0-2), e.g. 0.2 for near-deterministic output
`response_format`	No	concise (the default when omitted) keeps the JSON short: long fields such as base64 images or audio come back as separate image/audio content blocks and other long strings are cut with a marker; detailed returns the full JSON

Output Schema

Name	Required	Description
No output parameters

TDQS

A4.4/5.0

Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations only cover the safety profile (readOnly, idempotent, openWorld, non-destructive); the description adds the operationally decisive facts an agent needs: pricing per thousand tokens with a per-call cap, the ~8000 ms synchronous latency, the fallback to the status tool, and confirmation that token usage is included in the response.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Front-loaded with the use case, then when-not, then cost/latency/return. Dense but each clause carries a distinct operational fact; the pricing parenthetical ('clients without upto pay the cap') is the one piece of jargon that costs a little momentum.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

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, and the description still supplies the latency, cost and polling-escape-hatch context. For a paid, synchronous inference call with a capped budget, that is the complete picture.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so roles, token limits, temperature and response_format semantics are already fully documented in the schema; the description adds no format or constraint detail beyond noting that token usage comes back. Baseline 3 applies when the schema does the heavy lifting.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb+resource (LLM chat completion) and the intended jobs (summaries, extraction, classification) plus the model behind it (IBM Granite 4.0 Micro on Workers AI). It carves out boundaries against frontier models, tool calling and streaming, though it never contrasts itself with the related siblings blackwood_text_summarize or blackwood_text_sentiment, which overlap on the stated use cases.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Explicit when-to-use ('summaries, extraction or classification'), explicit when-not ('frontier models, tool calling or streaming'), and it names the alternative path for long-running calls ('a status tool polls for free if it takes longer'). Nothing is left to inference.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

blackwood_llm_chat_statusLLM chat completion (status)A

Read-onlyIdempotent

Inspect

Free. Status and result of a job created by blackwood_llm_chat. Poll until done is true.

Name	Required	Description	Default
`jobId`	Yes

Output Schema

Name	Required	Description
`done`	Yes
`error`	No
`jobId`	Yes
`output`	No
`status`	Yes

TDQS

A4.1/5.0

Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnly, idempotent, closed-world, non-destructive. The description adds genuinely new context: the call is free (no credit consumption, relevant given blackwood_credits_balance exists) and the job is asynchronous, requiring polling until done is true. It omits failure/expiry behavior, but the added polling semantics are substantive.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Three tight sentences with no filler. Leading with 'Free.' is a slightly odd prioritization versus the polling instruction, but nothing is wasted and the core information is front-loaded.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

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 no explanation, and the description covers the async lifecycle, the source of the id, and cost. The only gap is error/terminal-failure handling, which is minor for a single-parameter status endpoint.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 0% for the single jobId parameter, so the description carries the burden and it partially does: it identifies the jobId as coming from a blackwood_llm_chat job. It still says nothing about format, length, or what happens with an unknown/expired id, leaving a gap for a low-coverage schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb+resource pair: retrieving the status and result of a job created by blackwood_llm_chat. It explicitly names the sibling that creates the job, so an agent can tell it apart from blackwood_llm_chat and from unrelated *_status tools 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.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

'Poll until done is true' gives the operating pattern and implicitly tells the agent this must be called after blackwood_llm_chat. It stops short of explicit when-not guidance (e.g. what to do on a failed job, or whether to poll with backoff), but the usage context is clear.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

blackwood_news_briefingNews research briefingA

Read-only

Inspect

Use when you need a news briefing, a research summary of recent coverage or an analysis of what the press says about a topic or company. Do not use for breaking news, paywalled pages or one known article (use blackwood_webpage_markdown). Returns JSON with a research briefing on a topic in one call: up to 3 recent GDELT news articles, each read and summarized, with source and link, below the price of separate calls for 0.04 USDC per call. Typical response time 15000 ms (p95). Category: Search.

Name	Required	Description
`hours`	No	How far back to look for news, in hours, 1 to 72 (24 when omitted), e.g. 48
`topic`	Yes	Topic, company or person to research, e.g. stablecoin regulation
`language`	No	Language of the summaries (English when omitted), e.g. Portuguese
`response_format`	No	concise (the default when omitted) keeps the JSON short: long fields such as base64 images or audio come back as separate image/audio content blocks and other long strings are cut with a marker; detailed returns the full JSON

Output Schema

Name	Required	Description
No output parameters

TDQS

A4.6/5.0

Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already carry the safety profile (readOnly, openWorld, non-idempotent, non-destructive), and the description adds genuinely useful behavior beyond them: the 0.04 USDC per-call cost, the ~15000 ms p95 latency, and the shape of the result (up to 3 articles, each read and summarized, with source and link). Cost and latency are exactly the signals annotations cannot convey.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Front-loaded with the 'Use when...' trigger and tightly packed with no filler sentences. It is a dense single paragraph that mixes usage, exclusions, output, cost and latency, which slightly hurts scannability, but every clause carries information.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

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 optional, yet the description still summarizes the response. Combined with clear usage, exclusions, cost and latency, nothing material is missing for an agent deciding to call it; the only mild gap is that the very close sibling blackwood_news_search is not explicitly differentiated.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so all four parameters (topic, hours, language, response_format) are already documented in the schema. The description adds nothing parameter-specific beyond mentioning articles, so the baseline 3 for fully covered schemas applies.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific resource and scope: a news briefing / research summary built from up to 3 recent GDELT articles that are read and summarized. It also explicitly distinguishes itself from a sibling by routing single-article lookups to blackwood_webpage_markdown, so an agent can separate it from that alternative 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.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Gives explicit when-to-use ('news briefing, research summary of recent coverage, analysis of what the press says') and when-not ('breaking news, paywalled pages, one known article'), and names the alternative tool for the excluded case. This is close to textbook routing guidance.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

blackwood_news_searchNews headlines searchA

Read-onlyIdempotent

Inspect

Use when you need news articles or headlines from the last 72 hours about a topic, company or person. Do not use for full article text, paywalled sources, non-English coverage or news older than 72 hours. Returns JSON with recent news articles matching keywords: headline, URL, source, publish time, authors, tone, image and the people and organizations named, from GDELT for 0.008 USDC per call. Typical response time 600 ms (p95). Category: Search.

Name	Required	Description
`sort`	No	recent (default) or relevance
`hours`	No	How far back to look, in hours (1-72, 24 when omitted)
`limit`	No	Maximum articles to return (1-50, 20 when omitted)
`query`	Yes	Keywords to find in headlines, people and organizations, e.g. nvidia earnings (all words must match)
`domain`	No	Only articles from this source domain, e.g. reuters.com
`response_format`	No	concise (the default when omitted) keeps the JSON short: long fields such as base64 images or audio come back as separate image/audio content blocks and other long strings are cut with a marker; detailed returns the full JSON

Output Schema

Name	Required	Description
No output parameters

TDQS

A4.6/5.0

Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already cover the safety profile (readOnly, idempotent, openWorld, non-destructive), yet the description still adds materially: upstream data source (GDELT), per-call cost (0.008 USDC), and p95 latency (600 ms). Cost and latency are operationally decisive for an agent deciding whether to spend, and they are not derivable from the schema or annotations.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Well front-loaded: intended use, then exclusions, then return shape, then source/cost/latency. Three dense sentences with almost no waste. The trailing 'Category: Search.' is pure filler and the return-field enumeration slightly duplicates the output schema, keeping it out of the top band.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a read-only search tool with 6 parameters, full schema coverage, and an existing output schema, the description supplies everything else an agent needs: scope limits, exclusions, cost, and latency. Restating the returned fields is redundant given the output schema but harmless, and no decision-relevant information is missing.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so every parameter, enum, and default is already documented in the schema. The description only reinforces the 72-hour window and the multi-word-AND semantics implied by 'query'; it adds no new syntax, format, or interaction detail between parameters. Baseline 3 is appropriate when the schema does the heavy lifting.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb and resource (news articles/headlines) plus a hard scope (last 72 hours) and the intended query subject (topic, company or person). The explicit 'do not use for full article text' clause separates it from siblings like blackwood_webpage_markdown and blackwood_crypto_news without needing to open any schema.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Gives both the when ('need news articles or headlines from the last 72 hours about a topic, company or person') and four concrete exclusions: full article text, paywalled sources, non-English coverage, and news older than 72 hours. The exclusions map directly to alternative tools, so routing is unambiguous.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

blackwood_pdf_extractPDF to textA

Read-onlyIdempotent

Inspect

Use when you need to extract text from a pdf, pdf to text or document parsing for an LLM. Do not use for scanned PDFs (no OCR), password-protected files or files over 15 MB. Returns JSON with PDF text extraction: the text of each page (first 20 pages) plus title, author and producer metadata for 0.0025 USDC per page, up to 0.05 USDC per call (clients without upto pay the cap). Result in the same call (about 10000 ms); a status tool polls for free if it takes longer. Category: Data.

Name	Required	Description	Default
`url`	Yes	Public http(s) URL of the PDF file, e.g. https://example.com/report.pdf (up to 15 MB)
`response_format`	No	concise (the default when omitted) keeps the JSON short: long fields such as base64 images or audio come back as separate image/audio content blocks and other long strings are cut with a marker; detailed returns the full JSON

Output Schema

Name	Required	Description
No output parameters

TDQS

A4.6/5.0

Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare the read-only, idempotent, non-destructive profile, and the description layers on substantial operational detail the annotations cannot carry: no OCR, no password-protected files, 15 MB ceiling, 20-page cap, per-page pricing with a per-call cap, and ~10 s synchronous latency with a polling fallback. That is exactly the extra context this dimension rewards.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Front-loaded with the 'Use when' condition and the exclusions, with cost and latency trailing — the right ordering. It loses a point because the pricing clause ('for 0.0025 USDC per page, up to 0.05 USDC per call (clients without upto pay the cap)') is a run-on that takes a second read to parse.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a paid, latency-bound extraction tool with a sibling status endpoint, the description covers the inputs it rejects, the cost envelope, the synchronous time budget, and the polling escape hatch. An output schema exists, yet the description still sketches the return shape, so nothing an agent needs before invoking is missing.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100% — both 'url' and the 'response_format' enum are fully documented in the schema, including the concise/detailed trade-off — so the baseline is 3. The description corroborates the 15 MB limit but adds no syntax, format, or default nuance beyond what the schema already states.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb and resource — extract text from a PDF — and extends it to the practical framing ('document parsing for an LLM'), which is enough for an agent to distinguish it from unrelated siblings such as webpage_markdown or audio_transcribe. The scope limit ('first 20 pages') is stated up front.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Explicitly gives both directions: 'Use when you need to extract text from a pdf...' and 'Do not use for scanned PDFs (no OCR), password-protected files or files over 15 MB.' It also names the escalation path (the status tool polls for free) rather than leaving the agent to guess what to do on timeout.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

blackwood_pdf_extract_statusPDF to text (status)A

Read-onlyIdempotent

Inspect

Free. Status and result of a job created by blackwood_pdf_extract. Poll until done is true.

Name	Required	Description	Default
`jobId`	Yes

Output Schema

Name	Required	Description
`done`	Yes
`error`	No
`jobId`	Yes
`output`	No
`status`	Yes

TDQS

A4.2/5.0

Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already establish read-only, idempotent, non-destructive, closed-world behavior, and the description adds useful non-annotation context: that the call is free and that polling continues until a 'done' flag flips true. It stops short of describing failure states, terminal-error conditions, or backoff guidance.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Three terse sentences, no filler: cost, identity/provenance, and the polling condition are each front-loaded and independently actionable.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

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 needn't be spelled out, and the tool is a simple single-parameter poller whose core loop is described. It is nearly complete, with only failure/terminal-error handling left implicit.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Only one parameter (jobId) with 0% schema description coverage, so the description must carry the load. It does imply provenance ('a job created by blackwood_pdf_extract'), which tells the agent where jobId comes from, but adds no format or validity details beyond length constraints already in the schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb and resource (status/result of a PDF extraction job) and names the sibling tool that creates the job, so an agent can distinguish it from blackwood_pdf_extract and the other *_status tools at a glance.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Gives clear operational guidance — 'Poll until done is true' — which tells the agent both when to call it (after blackwood_pdf_extract) and how to terminate polling. It doesn't explicitly contrast with the other *_status siblings, but the workflow context is unambiguous.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

blackwood_qrcode_generateQR codeA

Read-onlyIdempotent

Inspect

Use when you need a qr code generator for a URL, text, Wi-Fi or payment link as an SVG image. Do not use for reading or decoding an existing QR code, logos, colored codes or PNG output. Returns JSON with a QR code for your text or URL as SVG markup and an SVG data URL, with error correction level and border options, generated by the uqr library for 0.004 USDC per call. Typical response time 500 ms (p95). Category: Media.

Name	Required	Description
`ecc`	No	Error correction level: L 7%, M 15% (default), Q 25%, H 30%
`text`	Yes	Text or URL to encode, e.g. https://example.com (up to 2000 characters)
`border`	No	Quiet zone around the code, in modules (default 2)
`pixelSize`	No	SVG units per module (default 10)
`response_format`	No	concise (the default when omitted) keeps the JSON short: long fields such as base64 images or audio come back as separate image/audio content blocks and other long strings are cut with a marker; detailed returns the full JSON

Output Schema

Name	Required	Description
No output parameters

TDQS

A4.6/5.0

Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already cover the safety profile (readOnly, idempotent, non-destructive, openWorld), and the description goes well beyond that by disclosing cost (0.004 USDC per call), latency (500 ms p95), the rendering library (uqr), and the exact return shape (SVG markup plus an SVG data URL). These are operationally relevant traits an agent cannot get from the annotations.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Front-loaded with the usage trigger and exclusions, then the return/behavioral facts, so an agent can stop reading early. Slightly dense and the trailing 'Category: Media' is redundant metadata, but almost every clause carries useful information.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a paid, annotated, output-schema-backed generation tool, the description supplies the trigger, the exclusions, the cost, the latency, and the output format. Nothing needed to call it correctly is missing, and return values are additionally covered by the output schema.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100%, so ecc, border, pixelSize, and response_format are already documented in the schema, and the description only alludes to 'error correction level and border options'. Baseline 3 applies since the schema carries the parameter burden and the description adds no syntax or format detail beyond it.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb (generate) and resource (QR code), plus the supported payloads (URL, text, Wi-Fi, payment link) and the output form (SVG). It also carves out what it is NOT for (reading/decoding existing codes, logos, colored codes, PNG), which lets an agent separate it from adjacent media/image tools 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.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Opens with an explicit 'Use when you need...' trigger and immediately follows with a 'Do not use for...' exclusion list. Both the positive condition and the negative boundary are spelled out, leaving nothing to inference.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

blackwood_random_generateRandom numbersA

Read-onlyIdempotent

Inspect

Use when you need a random number generator, dice rolls, a coin flip, a uuid or random bytes that no one can predict. Do not use for verifiable on-chain randomness (VRF) or reproducible seeded sequences. Returns JSON with cryptographically secure random values: integers in a range, dice rolls, coin flips, UUIDs or hex bytes, from the Workers Web Crypto CSPRNG for 0.005 USDC per call. Typical response time 500 ms (p95). Category: Infrastructure.

Name	Required	Description
`max`	No	integer: highest value, inclusive (default 100)
`min`	No	integer: lowest value, inclusive (default 1)
`kind`	Yes	integer (count values between min and max), dice (count rolls of a die with sides faces), coin (count flips), uuid (count UUID v4) or bytes (length random bytes as hex)
`count`	No	How many values (1-100, default 1); ignored for bytes
`sides`	No	dice: faces of the die (default 6)
`length`	No	bytes: how many random bytes (1-256, default 32)
`response_format`	No	concise (the default when omitted) keeps the JSON short: long fields such as base64 images or audio come back as separate image/audio content blocks and other long strings are cut with a marker; detailed returns the full JSON

Output Schema

Name	Required	Description
No output parameters

TDQS

A4.4/5.0

Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already cover the safety profile (readOnly, idempotent, non-destructive), but the description adds material context they do not: the CSPRNG source (Workers Web Crypto), the price (0.005 USDC per call), and p95 latency (500 ms). It does not mention rate limits or error behavior, so it stops 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.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Front-loaded with the trigger condition and the exclusion, and the cost/latency facts earn their place. The trailing 'Category: Infrastructure' is filler that adds no invocation value, keeping it from a 5.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

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 re-explained, yet the description still summarizes the shape (JSON with secure random values). Combined with source, pricing, latency, and the explicit exclusions, an agent has everything needed to call it correctly.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100% and every parameter (min/max/count/sides/length/kind/response_format) is already documented in the schema, so the baseline is 3. The description restates the kind vocabulary in prose but adds no syntax, defaults, or constraints beyond what the schema already carries.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb+resource (random number generator) and enumerates the exact output kinds: integers in a range, dice rolls, coin flips, UUIDs, hex bytes. It explicitly distinguishes itself from the on-chain VRF and seeded-sequence cases, so an agent can tell it apart from siblings without reading the schema.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Gives an explicit 'use when' trigger list and an explicit 'do not use' clause naming two alternatives (verifiable on-chain randomness / VRF, reproducible seeded sequences). Both the positive and negative conditions are stated, leaving nothing to inference.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

blackwood_sec_factsSEC company financialsA

Read-onlyIdempotent

Inspect

Use when you need company financials from SEC filings, earnings or fundamentals of a US company by ticker for the last two years. Do not use for quarterly numbers, real-time prices, non-US companies or filings older than two years. Returns JSON with SEC company financials for a US stock ticker from 10-K filings on SEC EDGAR: annual revenue, net and operating income, diluted EPS, cash flow and the balance sheet for 0.02 USDC per call. Typical response time 300 ms (p95). Category: Data.

Name	Required	Description	Default
`ticker`	Yes	Stock ticker of a company that files with the SEC, e.g. AAPL
`response_format`	No	concise (the default when omitted) keeps the JSON short: long fields such as base64 images or audio come back as separate image/audio content blocks and other long strings are cut with a marker; detailed returns the full JSON

Output Schema

Name	Required	Description
No output parameters

TDQS

A4.6/5.0

Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already cover safety (readOnly, idempotent, non-destructive, closed-world), and the description adds genuinely non-redundant behavior: data provenance (10-K on EDGAR), per-call cost of 0.02 USDC, and p95 latency of 300 ms. Cost and latency are decision-relevant facts not present in any structured field.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Three front-loaded sentences with scope, exclusions, and return profile in that order — efficient. Minor waste: the trailing 'Category: Data.' tag adds nothing, and the 'Returns JSON with SEC company financials...' clause partially restates the opening sentence.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

With an output schema present, the description needn't enumerate return fields in detail, and it still names the main ones. Annotations, full schema coverage, cost, latency, source, and temporal scope together leave no material gap for correct invocation.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100% and both parameters are described there, including the concise/detailed enum behavior, so the schema carries the load. The description adds only the implicit constraint that the ticker must be an SEC-filing US company, and says nothing about response_format beyond the JSON return claim. Baseline 3 is appropriate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

States a concrete verb+resource: annual financials for a US-listed company from SEC 10-K filings, scoped to the last two years. The enumerated fields (revenue, net/operating income, diluted EPS, cash flow, balance sheet) make the output concrete and distinguish it from siblings like blackwood_company_dossier or blackwood_news_search.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Gives explicit when-to-use ('company financials from SEC filings... by ticker for the last two years') and an explicit exclusion list: no quarterly numbers, no real-time prices, no non-US companies, nothing older than two years. That negative routing is exactly what an agent needs to avoid mis-selecting this tool.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

blackwood_speech_synthesizeText to speechA

Read-onlyIdempotent

Inspect

Use when you need text to speech, tts, a voice audio file or spoken narration of a short text. Do not use for voice cloning, a chosen voice, SSML or audio longer than about two minutes. Returns JSON with text to speech (TTS): your text read aloud as WAV voice audio (base64, 44.1 kHz mono) by MeloTTS on Workers AI, in English, Spanish, French, Chinese, Japanese or Korean for 0.023 USDC per call. Typical response time 8000 ms (p95). Category: Media.

Name	Required	Description
`lang`	No	Speech language: en (default), es, fr, zh, ja or ko
`text`	Yes	Text to read aloud, e.g. Welcome to our store (up to 1000 characters)
`response_format`	No	concise (the default when omitted) keeps the JSON short: long fields such as base64 images or audio come back as separate image/audio content blocks and other long strings are cut with a marker; detailed returns the full JSON

Output Schema

Name	Required	Description
No output parameters

TDQS

A4.6/5.0

Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnly/idempotent/non-destructive, and the description adds substantive behavior beyond them: the backing model (MeloTTS on Workers AI), output format and sample rate (base64 WAV, 44.1 kHz mono), the per-call cost (0.023 USDC) and the p95 latency (8000 ms). That is exactly the operational context an agent needs to decide whether to spend a call.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The structure is well front-loaded: purpose, then exclusions, then return/pricing facts. It is a single dense block with some keyword-list padding ('text to speech, tts, a voice audio file or spoken narration'), but nearly every clause carries decision-relevant information.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given an output schema exists, return values need not be re-explained, yet the description still states format, languages, cost and latency. Combined with the exclusion list and the 1000-character schema bound, an agent has everything needed to call this correctly.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, with enums documented for lang and response_format, so the schema already carries parameter meaning and the baseline is 3. The description reinforces the language list and the short-text constraint but adds no syntax or default behavior beyond the schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The opening sentence states a specific capability (text to speech / spoken narration of short text) with concrete synonyms an agent might match against, and the sibling blackwood_audio_transcribe is implicitly separated by the 'audio file out' vs transcription direction. An agent can identify the tool's output (WAV voice audio) without opening the schema.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

It gives explicit use triggers ('text to speech, tts, a voice audio file or spoken narration') and explicit exclusions ('not for voice cloning, a chosen voice, SSML, or audio longer than about two minutes'), which routes the agent away from unsupported requests. The length ceiling and language set give practical boundary conditions for choosing this tool.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

blackwood_text_sentimentSentiment analysisA

Read-onlyIdempotent

Inspect

Use when you need sentiment analysis, text sentiment or opinion mining of reviews, comments or headlines in English. Do not use for neutral or emotion labels, non-English text or aspect-level sentiment. Returns JSON with sentiment analysis of English text: a positive or negative label with a confidence score, from DistilBERT SST-2 on Workers AI, for one text or a batch of up to 20 for 0.004 USDC per call. Typical response time 1500 ms (p95). Category: Inference.

Name	Required	Description
`text`	No	One English text to classify, e.g. The checkout was fast (up to 2000 characters)
`texts`	No	Or a batch of up to 20 English texts, e.g. ["Great support", "Broken on arrival"]
`response_format`	No	concise (the default when omitted) keeps the JSON short: long fields such as base64 images or audio come back as separate image/audio content blocks and other long strings are cut with a marker; detailed returns the full JSON

Output Schema

Name	Required	Description
No output parameters

TDQS

A4.6/5.0

Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already cover read-only/idempotent/non-destructive safety, and the description layers on valuable operational context beyond them: the underlying model (DistilBERT SST-2 on Workers AI), per-call cost (0.004 USDC), p95 latency (~1500 ms), and batch cap (20). These are the traits an agent needs to budget a call.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Front-loaded with the usage trigger and exclusions, followed by return/cost/latency facts; every clause earns its place. It is dense and slightly run-on but not padded.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

With an output schema present, return-value detail isn't strictly required, yet the description still summarizes the output (label + confidence score) and adds cost, latency, model, and limits. Nothing material for correct invocation is missing.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the schema documents text/texts/response_format fully; the description only echoes the batch size and single-vs-batch choice. The response_format tradeoff is explained in the schema, not the description, so the baseline 3 is appropriate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description states a specific verb+resource (sentiment analysis of English text) and enumerates the exact task variants it covers ('text sentiment or opinion mining of reviews, comments or headlines'). It is clearly distinguishable from siblings like blackwood_text_summarize and blackwood_text_translate, which operate on different tasks.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

It gives explicit 'use when' conditions and equally explicit exclusions ('Do not use for neutral or emotion labels, non-English text or aspect-level sentiment'). The agent knows precisely when this tool is and isn't the right pick.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

blackwood_text_summarizeSummarize textA

Read-onlyIdempotent

Inspect

Use when you need to summarize text such as an article, notes or a transcript into a short summary. Do not use for uRLs or PDFs (extract the text first), exact quotes or citations. Returns JSON with a concise summary of the plain text you send (up to 20,000 characters): one short paragraph and key bullet points, written by IBM Granite 4.0 Micro on Workers AI for 0.008 USDC per call. Typical response time 8000 ms (p95). Category: Inference.

Name	Required	Description
`text`	Yes	Plain text to summarize, e.g. an article or a transcript (80 to 20,000 characters)
`language`	No	Language for the summary, e.g. English or Portuguese (default: the language of the text)
`maxBullets`	No	Most bullet points to return (1-10, default 5)
`response_format`	No	concise (the default when omitted) keeps the JSON short: long fields such as base64 images or audio come back as separate image/audio content blocks and other long strings are cut with a marker; detailed returns the full JSON

Output Schema

Name	Required	Description
No output parameters

TDQS

A4.4/5.0

Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already cover the safety profile (readOnly, idempotent, non-destructive), and the description adds real operational context the annotations cannot: the underlying model (IBM Granite 4.0 Micro on Workers AI), a per-call price of 0.008 USDC and p95 latency of 8000 ms. It does not discuss failure modes (e.g. what happens with input below 80 characters or rate limiting), so it stops 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.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Front-loaded with the trigger condition and dense with useful facts (exclusions, output shape, model, cost, latency, category) with no filler. It is nonetheless one sprawling sentence chain with slightly awkward casing ('uRLs'), and the cost/latency details could be split out for readability.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

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, annotations cover safety, schema covers parameters, and the description supplies cost, latency and model provenance. An agent has everything needed to decide and call correctly.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100%, so text, language, maxBullets and response_format are all documented in the schema, including defaults and ranges. The description restates the 20,000-character ceiling and the paragraph-plus-bullets output but adds no syntax or format detail beyond the schema, which is the expected baseline-3 case.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb and resource ('summarize text such as an article, notes or a transcript into a short summary') and immediately delimits scope by excluding URLs/PDFs, quotes and citations, which routes the agent to blackwood_webpage_markdown / blackwood_pdf_extract without opening their schemas.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Gives an explicit when-to-use clause plus concrete exclusions with a remedy ('extract the text first'), and rules out quote/citation tasks that a sibling such as a search tool would serve. Nothing about applicability is left to inference.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

blackwood_text_translateTranslate textA

Read-onlyIdempotent

Inspect

Use when you need to translate text, a language translation or a text translation of a sentence or paragraph between two languages. Do not use for formatting that must be preserved, certified or legal translation, or speech (transcribe first). Returns JSON with text translation between about 100 languages by Meta M2M100 1.2B on Workers AI: the translated text with the source and target languages used for 0.012 USDC per call. Typical response time 5000 ms (p95). Category: Inference.

Name	Required	Description
`to`	Yes	Target language as an ISO 639-1 code, e.g. es, fr, pt, de, ja, zh
`from`	No	Source language as an ISO 639-1 code (default en)
`text`	Yes	Text to translate, e.g. Pay only for the requests you make (up to 2000 characters)
`response_format`	No	concise (the default when omitted) keeps the JSON short: long fields such as base64 images or audio come back as separate image/audio content blocks and other long strings are cut with a marker; detailed returns the full JSON

Output Schema

Name	Required	Description
No output parameters

TDQS

A4.4/5.0

Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already cover the safety profile (readOnly, idempotent, non-destructive, open-world), so the bar is lower, yet the description adds genuinely actionable context: 0.012 USDC per call, p95 latency of 5000 ms, the underlying model/family and language coverage (~100 languages), and the shape of the JSON result. It does not mention failure modes (unsupported language pair, >2000 char input), which is the only real gap.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Front-loaded with the use-when clause and every trailing clause (cost, latency, model, return shape) earns its place for a paid inference tool. The opening 'text, a language translation or a text translation of a sentence or paragraph' is redundant restatement that could be cut without loss.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

With an output schema present, return-value description is optional, and the description still summarizes it. Combined with cost, latency, model identity, language coverage, and explicit exclusions, an agent has everything needed to select and call this tool correctly.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100% and each property (to, from, text, response_format) is documented in-schema with patterns, defaults, and limits, so the baseline is 3. The description adds no parameter-level detail beyond echoing source/target language output, so it neither helps nor hurts.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb+resource ('translate text ... between two languages') and immediately scopes it against non-goals: preserving formatting, certified/legal translation, and speech. A reader can differentiate it from blackwood_audio_transcribe (deferred to for speech) and from the summarize/sentiment siblings 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.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Explicit 'Use when...' plus 'Do not use for...' exclusions, including a concrete re-routing instruction ('speech (transcribe first)') that names the workflow alternative. This is the when/when-not/alternative pattern done in full.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

blackwood_timezone_convertTime zonesA

Read-onlyIdempotent

Inspect

Use when you need timezone conversion between time zones, the current time in a zone or a utc offset with daylight saving. Do not use for places given only by city or address without an IANA zone name, or dates before 1970. Returns JSON converting a date and time between IANA time zones with daylight saving rules, with UTC offsets, abbreviations and the current time in each zone, from the IANA tz database for 0.003 USDC per call. Typical response time 500 ms (p95). Category: Data.

Name	Required	Description
`to`	Yes	IANA time zones to convert to, e.g. ["Europe/London", "Asia/Tokyo"]
`from`	No	IANA time zone of a local time, e.g. America/Sao_Paulo (UTC when omitted)
`time`	No	Date and time to convert, ISO 8601: local wall time like 2026-10-17T15:30 (read in the from zone) or an instant with Z or an offset; now when omitted
`response_format`	No	concise (the default when omitted) keeps the JSON short: long fields such as base64 images or audio come back as separate image/audio content blocks and other long strings are cut with a marker; detailed returns the full JSON

Output Schema

Name	Required	Description
No output parameters

TDQS

A4.8/5.0

Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnly/idempotent/non-destructive, and the description layers on genuinely new operational context: per-call cost (0.003 USDC), p95 latency (500 ms), the backing data source (IANA tz database), and the exact shape of the returned JSON. None of this is derivable from the structured fields.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Front-loaded with the use/when-not framing before any details, which is the right ordering. Nearly every clause earns its place, though the trailing 'Category: Data' is filler and the pricing/latency could be read as marginally optional.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

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 spelled out, yet the description still previews them (offsets, abbreviations, current time per zone). Combined with cost, latency, data source, and explicit exclusions, an agent has everything needed to select and call it correctly.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100%, so the baseline is 3, but the description still adds value by constraining valid inputs (IANA zone names only, no city/address resolution, 1970 lower bound) and by clarifying that `to` is plural while `from` is singular. It does not restate ISO 8601 mechanics, which the schema already covers.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb+resource (timezone conversion), and enumerates the exact sub-capabilities it covers: conversion between zones, current time in a zone, and UTC offsets with daylight saving. An agent can immediately tell this apart from data-oriented siblings like fx_rates or weather_forecast.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Explicit 'Use when...' clause followed by explicit exclusions ('Do not use for places given only by city or address without an IANA zone name, or dates before 1970'). The boundary conditions that would cause a wrong invocation are named directly.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

blackwood_token_priceToken price on BaseA

Read-onlyIdempotent

Inspect

Use when you need a crypto token price or market data for a Base token, quoted from on-chain liquidity. Do not use for tokens that only trade off Base or on other DEXs (Aerodrome is not read), price history or OHLC. Returns JSON with the USD price of a token on Base computed on-chain from its deepest Uniswap v3 pool against USDC or WETH, with pool, fee tier and depth for 0.002 USDC per call. Typical response time 1200 ms (p95). Category: Trading.

Name	Required	Description	Default
`token`	Yes	Token on Base: contract address (0x...) or a symbol like WETH, cbBTC, AERO, DEGEN, VIRTUAL
`response_format`	No	concise (the default when omitted) keeps the JSON short: long fields such as base64 images or audio come back as separate image/audio content blocks and other long strings are cut with a marker; detailed returns the full JSON

Output Schema

Name	Required	Description
No output parameters

TDQS

A4.7/5.0

Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnly/idempotent/openWorld, but the description adds substantial context beyond them: the 0.002 USDC per-call cost, the p95 latency of 1200 ms, and the exact on-chain derivation (deepest Uniswap v3 pool vs USDC or WETH) including pool, fee tier and depth. This is exactly the kind of cost/latency/derivation detail annotations cannot carry.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Front-loaded with the usage trigger, followed by exclusions, return shape, cost, and latency in order of decision-relevance. Every sentence earns its place with no filler.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Covers scope, exclusions, return contents, cost, and latency; an output schema exists so return values need not be enumerated. Nothing an agent needs to call it correctly or decide against it is missing.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100% and both parameters (token, response_format) are already well documented in the schema, including the enum semantics, so the description adds no parameter-level detail. Baseline 3 is appropriate when the schema does the heavy lifting.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific resource (USD price of a Base token), the exact mechanism (computed on-chain from its deepest Uniswap v3 pool against USDC or WETH), and the return shape. An agent can distinguish it from wallet_value, wallet_portfolio, and altcoin_discovery 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.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Explicitly says when to use it ('need a crypto token price or market data for a Base token') and when not to ('tokens that only trade off Base or on other DEXs (Aerodrome is not read), price history or OHLC'). The exclusions route the agent away from inapplicable cases.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

blackwood_wallet_balancesWallet balances on BaseA

Read-onlyIdempotent

Inspect

Use when you need a wallet balance, token balances or the ERC20 balance of an address on Base, read live from the chain. Do not use for ethereum mainnet or other chains, NFTs, transaction history or USD values. Returns JSON with the wallet balance of an address on Base: ETH and ERC20 token balances read on-chain in one block, 21 major tokens plus any you list for 0.003 USDC per call. Typical response time 1200 ms (p95). Category: Data.

Name	Required	Description
`tokens`	No	Extra ERC20 token addresses on Base to check, e.g. ["0x4200000000000000000000000000000000000006"] (up to 20, beyond the 21 major ones)
`address`	Yes	Wallet address on Base, e.g. 0x5A6c77758820182484EA8DE614FC65423E80749a
`includeZero`	No	Also list tokens with zero balance (false when omitted)
`response_format`	No	concise (the default when omitted) keeps the JSON short: long fields such as base64 images or audio come back as separate image/audio content blocks and other long strings are cut with a marker; detailed returns the full JSON

Output Schema

Name	Required	Description
No output parameters

TDQS

A4.6/5.0

Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnly/idempotent/non-destructive, and the description goes well beyond them: cost (0.003 USDC per call), latency (1200 ms p95), snapshot semantics ('read on-chain in one block'), token coverage (21 major tokens plus listed extras) and a note on truncation behavior in concise mode. This is exactly the extra context annotations cannot carry.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Front-loaded with the use case and exclusions before the return/cost/latency details, and most sentences earn their place. Slight duplication of title phrasing ('wallet balances on Base') and a trailing 'Category: Data.' add noise but the total length stays reasonable.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

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 no explanation, and the description still covers chain scoping, token coverage, cost, latency and truncation. Nothing an agent needs to select or invoke this tool correctly is missing.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so all four parameters (address, tokens, includeZero, response_format) are already documented with patterns, defaults and enum meaning. The description restates the '21 major tokens plus any you list' limit that the schema itself states, so it adds little beyond pricing context; baseline 3 is appropriate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb and resource ('read a wallet balance / ERC20 token balances on Base'), names the chain, and pins the scope to on-chain live reads. An agent can distinguish it from blackwood_wallet_value, blackwood_wallet_portfolio and blackwood_token_price 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.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Explicit when-to-use ('wallet balance, token balances or the ERC20 balance of an address on Base') and explicit when-not ('ethereum mainnet or other chains, NFTs, transaction history or USD values'). The exclusion list routes the agent away from the value/portfolio/price siblings even though those names are not spelled out.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

blackwood_wallet_portfolioWallet portfolio and historyA

Read-only

Inspect

Use when you need a multi-chain wallet balance, a wallet portfolio or wallet transaction history on Ethereum, Base or Solana. Do not use for uSD values, NFTs, DeFi positions, long-tail tokens or chains beyond Ethereum, Base and Solana. Returns JSON with a multi-chain wallet balance and transaction history: native and major-token balances on Ethereum, Base or Solana plus the latest transfers, without airdrop spam for 0.003 USDC per call. Typical response time 3000 ms (p95). Category: Data.

Name	Required	Description
`chains`	No	Chains to read (ethereum and base for a 0x address, solana for a Solana address, when omitted), e.g. ["base"]
`address`	Yes	Wallet address: 0x... for Ethereum and Base, or a Solana address, e.g. 0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045
`historyLimit`	No	Latest transfers to return per chain, 0 to 25 (10 when omitted), e.g. 5
`response_format`	No	concise (the default when omitted) keeps the JSON short: long fields such as base64 images or audio come back as separate image/audio content blocks and other long strings are cut with a marker; detailed returns the full JSON

Output Schema

Name	Required	Description
No output parameters

TDQS

A4.6/5.0

Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations cover the safety profile (readOnlyHint, destructiveHint=false), and the description goes well beyond them with cost (0.003 USDC per call), p95 latency, response content (native plus major-token balances, latest transfers), and anti-spam behavior (airdrop spam filtered). These are exactly the operational traits an agent needs before committing to a paid call.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Front-loaded with the use case, then exclusions, then return/pricing details — a sensible ordering. Slightly repetitive in restating 'multi-chain wallet balance' in both the opening and the returns sentence, which costs it the top mark.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

With an output schema present the description need not enumerate return fields, yet it still summarizes them; combined with pricing, latency, category and scope limits, an agent has everything needed to select and invoke this correctly.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so chains, address, historyLimit and response_format are already fully documented in the schema, including enum values and defaults. The description adds only the chain-scope constraint and the 'no airdrop spam' nuance, so the baseline 3 applies.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb+resource (multi-chain wallet balance, portfolio, transaction history) and constrains it to three named chains. It is immediately distinguishable from siblings like blackwood_wallet_value, whose domain (USD values) it explicitly disclaims.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Gives both positive triggers ('Use when you need a multi-chain wallet balance...') and an explicit exclusion list (USD values, NFTs, DeFi positions, long-tail tokens, unsupported chains). This is about as unambiguous a routing rule as a description can carry.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

blackwood_wallet_valueWallet value in USDA

Read-onlyIdempotent

Inspect

Use when you need a wallet portfolio value in USD, a wallet net worth or token balances with USD value for a 0x address. Do not use for solana wallets, transaction history, NFTs, DeFi positions or long-tail tokens. Returns JSON with a wallet's USD value on Ethereum and Base in one call: native and major-token balances priced on-chain from Uniswap v3 pools on Base, per-chain totals and the tokens left unpriced for 0.003 USDC per call. Typical response time 5000 ms (p95). Category: Trading.

Name	Required	Description
`chains`	No	Chains to value (ethereum and base when omitted), e.g. ["base"]
`address`	Yes	Wallet address (0x...) on Ethereum and Base, e.g. 0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045
`response_format`	No	concise (the default when omitted) keeps the JSON short: long fields such as base64 images or audio come back as separate image/audio content blocks and other long strings are cut with a marker; detailed returns the full JSON

Output Schema

Name	Required	Description
No output parameters

TDQS

A4.1/5.0

Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already cover read-only/idempotent safety, and the description adds substantial context beyond them: pricing is sourced on-chain from Uniswap v3 pools on Base, both chains are valued in one call, tokens that cannot be priced are returned separately, cost is 0.003 USDC per call, and p95 latency is 5000 ms. Cost and latency disclosure is exactly the kind of operational detail annotations cannot carry.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Front-loaded with the use-when clause and the exclusions before the return/cost details, which is the right ordering. The middle sentence is long and crams return shape, pricing source, per-chain totals, unpriced tokens, cost and latency into one breath, costing some readability.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

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 no explanation, yet the description still orients the agent on what comes back. Combined with cost, latency, chain scope, and pricing methodology, an agent has everything needed to decide and invoke correctly for a 3-parameter tool.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so address, chains (enum, default both chains) and response_format are fully documented in the schema; the baseline is 3. The description only loosely gestures at chains ('on Ethereum and Base in one call') and says nothing about response_format, so it adds no meaning beyond the schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific resource and outcome: a wallet's portfolio value in USD, net worth, or token balances with USD value for a 0x address, plus scope constraints (Ethereum and Base). It differentiates by exclusion (no Solana, tx history, NFTs, DeFi positions, long-tail tokens) but never names the overlapping siblings blackwood_wallet_balances or blackwood_wallet_portfolio, so the agent must infer the boundary.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Explicit 'Use when you need...' plus a concrete 'Do not use for...' exclusion list gives clear when/when-not guidance. What is missing is a positive pointer to the correct alternative tool (e.g. wallet_balances for non-priced balances, token_price for long-tail tokens), so routing between siblings is still partly inferred.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

blackwood_weather_forecastWeather forecastA

Read-onlyIdempotent

Inspect

Use when you need a weather forecast, the current weather, temperature, rain or wind for the next hours or days at given coordinates. Do not use for historical weather, severe weather alerts or places given only by name (geocode first). Returns JSON with the weather forecast for a latitude and longitude: hourly temperature, rain and precipitation, wind, humidity and cloud cover for the next days, from MET Norway for 0.003 USDC per call. Typical response time 1500 ms (p95). Category: Data.

Name	Required	Description
`hours`	No	How many hours ahead to return (1-240, 48 when omitted); hourly at first, then every 6 hours
`latitude`	Yes	Latitude in decimal degrees (WGS84), e.g. 59.9139 for Oslo, rounded to 4 decimals
`longitude`	Yes	Longitude in decimal degrees (WGS84), e.g. 10.7522 for Oslo, rounded to 4 decimals
`response_format`	No	concise (the default when omitted) keeps the JSON short: long fields such as base64 images or audio come back as separate image/audio content blocks and other long strings are cut with a marker; detailed returns the full JSON

Output Schema

Name	Required	Description
No output parameters

TDQS

A4.6/5.0

Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare read-only, idempotent, open-world, non-destructive, but the description adds genuinely new behavioral facts: the upstream provider (MET Norway), cost (0.003 USDC per call), and latency (1500 ms p95). These are exactly the operational details annotations cannot express and that an agent weighing cost/latency tradeoffs needs.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Front-loads usage, then exclusions, then return shape, cost and latency — a sensible priority order with no filler sentences. Minor redundancy ('rain or wind' in the usage clause vs 'rain and precipitation' in the return clause) and a trailing 'Category: Data' metadata tag slightly dilute density but do not obscure the content.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

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 detailed, yet the description still conveys cost, latency, provider and exclusion boundaries — enough for an agent to invoke correctly and to judge whether the call is worth it. Nothing material is missing for a 4-parameter, fully-documented read tool.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so latitude, longitude, hours and response_format are already fully documented in the schema, including the 1-240 range and the concise/detailed semantics. The description adds only the return granularity context ('hourly temperature, rain and precipitation, wind...'), which does not meaningfully extend the parameters beyond the schema. Baseline 3 applies.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb and resource — retrieve a weather forecast at given coordinates — and enumerates the data returned (temperature, rain, wind, humidity, cloud cover). It also carves out adjacent-but-different tasks (historical weather, severe alerts, place-name lookups) so an agent can tell it apart from a geocoding or alerts tool.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Explicit when-to-use ('need a weather forecast, current weather, ... for the next hours or days at given coordinates') and explicit when-not-to-use ('not for historical weather, severe weather alerts or places given only by name (geocode first)'). The prerequisite (geocode first) is stated outright, leaving nothing to inference.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

blackwood_webpage_markdownWeb page to MarkdownA

Read-onlyIdempotent

Inspect

Use when you need web page to markdown, url to markdown, to scrape a web page or extract content from a url for an LLM. Do not use for pages that need JavaScript to render, sit behind a login or paywall, or are not HTML (PDFs go to blackwood_pdf_extract). Returns JSON with the clean Markdown of a public web page (URL to Markdown, boilerplate stripped) plus its title, description, language, canonical URL and links for 0.01 USDC per call. Typical response time 2500 ms (p95). Category: Data.

Name	Required	Description
`url`	Yes	Public http(s) URL of the web page to read, e.g. https://example.com/article
`maxChars`	No	Maximum length of the returned markdown (500-100000 characters, 50000 when omitted)
`response_format`	No	concise (the default when omitted) keeps the JSON short: long fields such as base64 images or audio come back as separate image/audio content blocks and other long strings are cut with a marker; detailed returns the full JSON

Output Schema

Name	Required	Description
No output parameters

TDQS

A4.6/5.0

Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnly/idempotent/openWorld/non-destructive, yet the description still adds cost (0.01 USDC per call), p95 latency (2500 ms), the content of the response (Markdown plus title, description, language, canonical URL, links), and the rendering/login constraints that annotations cannot express.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Front-loaded with the use condition and exclusions, and every later sentence (exclusions, return shape, price, latency) carries information. The opening "web page to markdown, url to markdown" phrase is somewhat keyword-stuffed, which costs it a point.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a paid, open-world scraping tool the description covers selection rules, hard limits (no JS, no login/paywall, HTML only), cost, latency, and output shape. With an output schema present it does not need to enumerate return fields and doesn't need to.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100% and all three parameters are documented in-schema, including the enum behavior of response_format and the 500-100000 range of maxChars. The description only re-echoes "public web page"/URL framing without adding syntax or format detail beyond the schema, so baseline 3 applies.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb+resource (convert a public web page to clean Markdown) and explicitly names the sibling to use for the excluded case (PDFs go to blackwood_pdf_extract). An agent can distinguish it from blackwood_pdf_extract and the text/image tools 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.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Gives both sides: "Use when you need web page to markdown ... for an LLM" and three explicit exclusions (JS-rendered pages, login/paywall, non-HTML) with a concrete alternative named for the last one. Nothing is left to inference.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

blackwood_x402_checkx402 endpoint checkA

Read-onlyIdempotent

Inspect

Use when you need an x402 endpoint check or x402 endpoint test, or to validate x402 endpoint listings before paying or integrating. Do not use for actually paying the endpoint, or endpoints behind authentication. Returns JSON with an x402 check of an endpoint without paying: whether it answers 402, its payment options (scheme, network, asset, amount, payTo), Bazaar metadata and problems found for 0.007 USDC per call. Typical response time 2500 ms (p95). Category: Infrastructure.

Name	Required	Description
`url`	Yes	Public http(s) URL of the x402 endpoint, e.g. https://x402.org/protected
`body`	No	JSON body to send with POST, e.g. {"url": "https://example.com"} (no payment is ever attached)
`method`	No	HTTP method of the endpoint (GET when omitted)
`response_format`	No	concise (the default when omitted) keeps the JSON short: long fields such as base64 images or audio come back as separate image/audio content blocks and other long strings are cut with a marker; detailed returns the full JSON

Output Schema

Name	Required	Description
No output parameters

TDQS

A4.6/5.0

Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnly/idempotent/non-destructive, but the description adds materially more: no payment is ever attached, a per-call cost of 0.007 USDC, a p95 latency of 2500 ms, and the shape of what is returned (402 status, payment options, Bazaar metadata, problems). Cost and timing disclosures are not derivable from the annotations and are exactly the 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.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The usage condition, exclusions, return shape, cost, and latency are all front-loaded and each carries useful information. The opening 'x402 endpoint check or x402 endpoint test' phrase is mildly redundant filler, keeping it just short of a 5.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given a rich output schema the return value needn't be re-explained, yet the description still captures the key returned fields, cost, latency, and scope limits for a paid, open-world read tool. Nothing needed to call it correctly is missing.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so url, body, method, and response_format are already documented in the schema with examples and enum meanings. The description reinforces the no-payment behavior of the body but adds no parameter syntax or defaults beyond what the schema provides, so the baseline 3 applies.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description states a specific verb+resource ('x402 endpoint check/test', 'validate x402 endpoint listings') and immediately frames the scope as inspection without payment, which no sibling tool overlaps with. An agent can identify the tool's function without opening the schema.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

It gives explicit when-to-use ('validate x402 endpoint listings before paying or integrating') and when-not ('do not use for actually paying the endpoint, or endpoints behind authentication'). Both positive and negative conditions are stated, so routing is unambiguous.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

1 tool updateOct 18, 2026
- Addedblackwood_altcoin_discovery
1 tool updateOct 18, 2026
- Addedblackwood_wallet_value
3 tool updatesOct 18, 2026
- Addedblackwood_company_dossier
- Addedblackwood_news_briefing
- Addedblackwood_wallet_portfolio
2 tool updatesOct 18, 2026
- Addedblackwood_ens_lookup
- Addedblackwood_gas_fees

26 tool updatesOct 17, 2026

Changedblackwood_airport_delays1 field changed

changedOutput schema / anyOf

Previous value: -[
-  {
-    "additionalProperties": false,
-    "properties": {
-      "airport": {
-        "type": [
-          "string",
-          "null"
-        ]
-      },
-      "arrivalDepartureDelays": {
-        "items": {
-          "additionalProperties": false,
-          "properties": {
-            "airport": {
-              "type": "string"
-            },
-            "maximum": {
-              "type": [
-                "string",
-                "null"
-              ]
-            },
-            "minimum": {
-              "type": [
-                "string",
-                "null"
-              ]
-            },
-            "reason": {
-              "type": "string"
-            },
-            "trend": {
-              "type": [
-                "string",
-                "null"
-              ]
-            },
-            "type": {
-              "type": [
-                "string",
-                "null"
-              ]
-            }
-          },
-          "required": [
-            "airport",
-            "reason",
-            "type",
-            "minimum",
-            "maximum",
-            "trend"
-          ],
-          "type": "object"
-        },
-        "type": "array"
-      },
-      "attribution": {
-        "type": "string"
-      },
-      "closures": {
-        "items": {
-          "additionalProperties": false,
-          "properties": {
-            "airport": {
-              "type": "string"
-            },
-            "reason": {
-              "type": "string"
-            },
-            "reopen": {
-              "type": [
-                "string",
-                "null"
-              ]
-            },
-            "start": {
-              "type": [
-                "string",
-                "null"
-              ]
-            }
-          },
-          "required": [
-            "airport",
-            "reason",
-            "start",
-            "reopen"
-          ],
-          "type": "object"
-        },
-        "type": "array"
-      },
-      "groundDelays": {
-        "items": {
-          "additionalProperties": false,
-          "properties": {
-            "airport": {
-              "type": "string"
-            },
-            "average": {
-              "type": [
-                "string",
-                "null"
-              ]
-            },
-            "maximum": {
-              "type": [
-                "string",
-                "null"
-              ]
-            },
-            "reason": {
-              "type": "string"
-            }
-          },
-          "required": [
-            "airport",
-            "reason",
-            "average",
-            "maximum"
-          ],
-          "type": "object"
-        },
-        "type": "array"
-      },
-      "groundStops": {
-        "items": {
-          "additionalProperties": false,
-          "properties": {
-            "airport": {
-              "type": "string"
-            },
-            "endTime": {
-              "type": [
-                "string",
-                "null"
-              ]
-            },
-            "reason": {
-              "type": "string"
-            }
-          },
-          "required": [
-            "airport",
-            "reason",
-            "endTime"
-          ],
-          "type": "object"
-        },
-        "type": "array"
-      },
-      "total": {
-        "type": "number"
-      },
-      "updatedAt": {
-        "type": [
-          "string",
-          "null"
-        ]
-      }
-    },
-    "required": [
-      "updatedAt",
-      "airport",
-      "total",
-      "groundStops",
-      "groundDelays",
-      "arrivalDepartureDelays",
-      "closures",
-      "attribution"
-    ],
-    "type": "object"
-  },
-  {
-    "description": "x402 PaymentRequired (returned with isError when payment is needed)",
-    "properties": {
-      "accepts": {
-        "items": {
-          "type": "object"
-        },
-        "type": "array"
-      },
-      "error": {
-        "type": "string"
-      },
-      "extensions": {
-        "type": "object"
-      },
-      "resource": {
-        "type": "object"
-      },
-      "x402Version": {
-        "type": "integer"
-      }
-    },
-    "required": [
-      "x402Version",
-      "accepts"
-    ],
-    "type": "object"
-  }
-]New value: +[
+  {
+    "additionalProperties": false,
+    "properties": {
+      "airport": {
+        "type": [
+          "string",
+          "null"
+        ]
+      },
+      "arrivalDepartureDelays": {
+        "items": {
+          "additionalProperties": false,
+          "properties": {
+            "airport": {
+              "type": "string"
+            },
+            "maximum": {
+              "type": [
+                "string",
+                "null"
+              ]
+            },
+            "minimum": {
+              "type": [
+                "string",
+                "null"
+              ]
+            },
+            "reason": {
+              "type": "string"
+            },
+            "trend": {
+              "type": [
+                "string",
+                "null"
+              ]
+            },
+            "type": {
+              "type": [
+                "string",
+                "null"
+              ]
+            }
+          },
+          "required": [
+            "airport",
+            "reason",
+            "type",
+            "minimum",
+            "maximum",
+            "trend"
+          ],
+          "type": "object"
+        },
+        "type": "array"
+      },
+      "attribution": {
+        "type": "string"
+      },
+      "closures": {
+        "items": {
+          "additionalProperties": false,
+          "properties": {
+            "airport": {
+              "type": "string"
+            },
+            "reason": {
+              "type": "string"
+            },
+            "reopen": {
+              "type": [
+                "string",
+                "null"
+              ]
+            },
+            "start": {
+              "type": [
+                "string",
+                "null"
+              ]
+            }
+          },
+          "required": [
+            "airport",
+            "reason",
+            "start",
+            "reopen"
+          ],
+          "type": "object"
+        },
+        "type": "array"
+      },
+      "groundDelays": {
+        "items": {
+          "additionalProperties": false,
+          "properties": {
+            "airport": {
+              "type": "string"
+            },
+            "average": {
+              "type": [
+                "string",
+                "null"
+              ]
+            },
+            "maximum": {
+              "type": [
+                "string",
+                "null"
+              ]
+            },
+            "reason": {
+              "type": "string"
+            }
+          },
+          "required": [
+            "airport",
+            "reason",
+            "average",
+            "maximum"
+          ],
+          "type": "object"
+        },
+        "type": "array"
+      },
+      "groundStops": {
+        "items": {
+          "additionalProperties": false,
+          "properties": {
+            "airport": {
+              "type": "string"
+            },
+            "endTime": {
+              "type": [
+                "string",
+                "null"
+              ]
+            },
+            "reason": {
+              "type": "string"
+            }
+          },
+          "required": [
+            "airport",
+            "reason",
+            "endTime"
+          ],
+          "type": "object"
+        },
+        "type": "array"
+      },
+      "next": {
+        "additionalProperties": false,
+        "description": "Suggested next paid call in the same family (call it in a loop when the task continues)",
+        "properties": {
+          "method": {
+            "enum": [
+              "GET",
+              "POST"
+            ],
+            "type": "string"
+          },
+          "sample": {
+            "description": "Free fixed sample of the whole family",
+            "type": "string"
+          },
+          "service": {
+            "description": "Service id of the suggested next paid call",
+            "type": "string"
+          },
+          "tool": {
+            "description": "MCP tool name of the same call",
+            "type": "string"
+          },
+          "url": {
+            "description": "Paid route of the next call",
+            "type": "string"
+          },
+          "useWhen": {
+            "description": "When the next call is the right one",
+            "type": "string"
+          }
+        },
+        "required": [
+          "service",
+          "tool",
+          "method",
+          "url",
+          "useWhen",
+          "sample"
+        ],
+        "type": "object"
+      },
+      "total": {
+        "type": "number"
+      },
+      "updatedAt": {
+        "type": [
+          "string",
+          "null"
+        ]
+      }
+    },
+    "required": [
+      "updatedAt",
+      "airport",
+      "total",
+      "groundStops",
+      "groundDelays",
+      "arrivalDepartureDelays",
+      "closures",
+      "attribution"
+    ],
+    "type": "object"
+  },
+  {
+    "description": "x402 PaymentRequired (returned with isError when payment is needed)",
+    "properties": {
+      "accepts": {
+        "items": {
+          "type": "object"
+        },
+        "type": "array"
+      },
+      "error": {
+        "type": "string"
+      },
+      "extensions": {
+        "type": "object"
+      },
+      "resource": {
+        "type": "object"
+      },
+      "x402Version": {
+        "type": "integer"
+      }
+    },
+    "required": [
+      "x402Version",
+      "accepts"
+    ],
+    "type": "object"
+  }
+]

Changedblackwood_audio_transcribe1 field changed

changedOutput schema / anyOf

Previous value: -[
-  {
-    "additionalProperties": false,
-    "properties": {
-      "done": {
-        "type": "boolean"
-      },
-      "error": {
-        "additionalProperties": false,
-        "properties": {
-          "message": {
-            "type": "string"
-          },
-          "name": {
-            "type": "string"
-          }
-        },
-        "required": [
-          "name",
-          "message"
-        ],
-        "type": "object"
-      },
-      "jobId": {
-        "type": "string"
-      },
-      "output": {
-        "additionalProperties": false,
-        "properties": {
-          "bytes": {
-            "maximum": 9007199254740991,
-            "minimum": -9007199254740991,
-            "type": "integer"
-          },
-          "durationSeconds": {
-            "type": [
-              "number",
-              "null"
-            ]
-          },
-          "language": {
-            "type": [
-              "string",
-              "null"
-            ]
-          },
-          "segments": {
-            "items": {
-              "additionalProperties": false,
-              "properties": {
-                "end": {
-                  "type": "number"
-                },
-                "start": {
-                  "type": "number"
-                },
-                "text": {
-                  "type": "string"
-                }
-              },
-              "required": [
-                "start",
-                "end",
-                "text"
-              ],
-              "type": "object"
-            },
-            "type": "array"
-          },
-          "task": {
-            "enum": [
-              "transcribe",
-              "translate"
-            ],
-            "type": "string"
-          },
-          "text": {
-            "type": "string"
-          },
-          "url": {
-            "type": "string"
-          }
-        },
-        "required": [
-          "url",
-          "task",
-          "language",
-          "durationSeconds",
-          "bytes",
-          "text",
-          "segments"
-        ],
-        "type": "object"
-      },
-      "pollUrl": {
-        "type": "string"
-      },
-      "status": {
-        "enum": [
-          "queued",
-          "running",
-          "paused",
-          "errored",
-          "terminated",
-          "complete",
-          "waiting",
-          "waitingForPause",
-          "rollingBack",
-          "unknown"
-        ],
-        "type": "string"
-      }
-    },
-    "required": [
-      "jobId",
-      "status",
-      "done",
-      "pollUrl"
-    ],
-    "type": "object"
-  },
-  {
-    "description": "x402 PaymentRequired (returned with isError when payment is needed)",
-    "properties": {
-      "accepts": {
-        "items": {
-          "type": "object"
-        },
-        "type": "array"
-      },
-      "error": {
-        "type": "string"
-      },
-      "extensions": {
-        "type": "object"
-      },
-      "resource": {
-        "type": "object"
-      },
-      "x402Version": {
-        "type": "integer"
-      }
-    },
-    "required": [
-      "x402Version",
-      "accepts"
-    ],
-    "type": "object"
-  }
-]New value: +[
+  {
+    "additionalProperties": false,
+    "properties": {
+      "done": {
+        "type": "boolean"
+      },
+      "error": {
+        "additionalProperties": false,
+        "properties": {
+          "message": {
+            "type": "string"
+          },
+          "name": {
+            "type": "string"
+          }
+        },
+        "required": [
+          "name",
+          "message"
+        ],
+        "type": "object"
+      },
+      "jobId": {
+        "type": "string"
+      },
+      "next": {
+        "additionalProperties": false,
+        "description": "Suggested next paid call in the same family (call it in a loop when the task continues)",
+        "properties": {
+          "method": {
+            "enum": [
+              "GET",
+              "POST"
+            ],
+            "type": "string"
+          },
+          "sample": {
+            "description": "Free fixed sample of the whole family",
+            "type": "string"
+          },
+          "service": {
+            "description": "Service id of the suggested next paid call",
+            "type": "string"
+          },
+          "tool": {
+            "description": "MCP tool name of the same call",
+            "type": "string"
+          },
+          "url": {
+            "description": "Paid route of the next call",
+            "type": "string"
+          },
+          "useWhen": {
+            "description": "When the next call is the right one",
+            "type": "string"
+          }
+        },
+        "required": [
+          "service",
+          "tool",
+          "method",
+          "url",
+          "useWhen",
+          "sample"
+        ],
+        "type": "object"
+      },
+      "output": {
+        "additionalProperties": false,
+        "properties": {
+          "bytes": {
+            "maximum": 9007199254740991,
+            "minimum": -9007199254740991,
+            "type": "integer"
+          },
+          "durationSeconds": {
+            "type": [
+              "number",
+              "null"
+            ]
+          },
+          "language": {
+            "type": [
+              "string",
+              "null"
+            ]
+          },
+          "segments": {
+            "items": {
+              "additionalProperties": false,
+              "properties": {
+                "end": {
+                  "type": "number"
+                },
+                "start": {
+                  "type": "number"
+                },
+                "text": {
+                  "type": "string"
+                }
+              },
+              "required": [
+                "start",
+                "end",
+                "text"
+              ],
+              "type": "object"
+            },
+            "type": "array"
+          },
+          "task": {
+            "enum": [
+              "transcribe",
+              "translate"
+            ],
+            "type": "string"
+          },
+          "text": {
+            "type": "string"
+          },
+          "url": {
+            "type": "string"
+          }
+        },
+        "required": [
+          "url",
+          "task",
+          "language",
+          "durationSeconds",
+          "bytes",
+          "text",
+          "segments"
+        ],
+        "type": "object"
+      },
+      "pollUrl": {
+        "type": "string"
+      },
+      "status": {
+        "enum": [
+          "queued",
+          "running",
+          "paused",
+          "errored",
+          "terminated",
+          "complete",
+          "waiting",
+          "waitingForPause",
+          "rollingBack",
+          "unknown"
+        ],
+        "type": "string"
+      }
+    },
+    "required": [
+      "jobId",
+      "status",
+      "done",
+      "pollUrl"
+    ],
+    "type": "object"
+  },
+  {
+    "description": "x402 PaymentRequired (returned with isError when payment is needed)",
+    "properties": {
+      "accepts": {
+        "items": {
+          "type": "object"
+        },
+        "type": "array"
+      },
+      "error": {
+        "type": "string"
+      },
+      "extensions": {
+        "type": "object"
+      },
+      "resource": {
+        "type": "object"
+      },
+      "x402Version": {
+        "type": "integer"
+      }
+    },
+    "required": [
+      "x402Version",
+      "accepts"
+    ],
+    "type": "object"
+  }
+]

Changedblackwood_crypto_news1 field changed

changedOutput schema / anyOf

Previous value: -[
-  {
-    "additionalProperties": false,
-    "properties": {
-      "articles": {
-        "items": {
-          "additionalProperties": false,
-          "properties": {
-            "domain": {
-              "type": "string"
-            },
-            "image": {
-              "type": [
-                "string",
-                "null"
-              ]
-            },
-            "organizations": {
-              "items": {
-                "type": "string"
-              },
-              "type": "array"
-            },
-            "persons": {
-              "items": {
-                "type": "string"
-              },
-              "type": "array"
-            },
-            "publishedAt": {
-              "type": "string"
-            },
-            "title": {
-              "type": "string"
-            },
-            "tone": {
-              "type": [
-                "number",
-                "null"
-              ]
-            },
-            "url": {
-              "type": "string"
-            }
-          },
-          "required": [
-            "title",
-            "url",
-            "domain",
-            "publishedAt",
-            "tone",
-            "image",
-            "persons",
-            "organizations"
-          ],
-          "type": "object"
-        },
-        "type": "array"
-      },
-      "attribution": {
-        "type": "string"
-      },
-      "count": {
-        "type": "number"
-      },
-      "hours": {
-        "type": "number"
-      },
-      "lastIngestAt": {
-        "type": [
-          "string",
-          "null"
-        ]
-      },
-      "token": {
-        "type": [
-          "string",
-          "null"
-        ]
-      }
-    },
-    "required": [
-      "token",
-      "hours",
-      "count",
-      "articles",
-      "lastIngestAt",
-      "attribution"
-    ],
-    "type": "object"
-  },
-  {
-    "description": "x402 PaymentRequired (returned with isError when payment is needed)",
-    "properties": {
-      "accepts": {
-        "items": {
-          "type": "object"
-        },
-        "type": "array"
-      },
-      "error": {
-        "type": "string"
-      },
-      "extensions": {
-        "type": "object"
-      },
-      "resource": {
-        "type": "object"
-      },
-      "x402Version": {
-        "type": "integer"
-      }
-    },
-    "required": [
-      "x402Version",
-      "accepts"
-    ],
-    "type": "object"
-  }
-]New value: +[
+  {
+    "additionalProperties": false,
+    "properties": {
+      "articles": {
+        "items": {
+          "additionalProperties": false,
+          "properties": {
+            "domain": {
+              "type": "string"
+            },
+            "image": {
+              "type": [
+                "string",
+                "null"
+              ]
+            },
+            "organizations": {
+              "items": {
+                "type": "string"
+              },
+              "type": "array"
+            },
+            "persons": {
+              "items": {
+                "type": "string"
+              },
+              "type": "array"
+            },
+            "publishedAt": {
+              "type": "string"
+            },
+            "title": {
+              "type": "string"
+            },
+            "tone": {
+              "type": [
+                "number",
+                "null"
+              ]
+            },
+            "url": {
+              "type": "string"
+            }
+          },
+          "required": [
+            "title",
+            "url",
+            "domain",
+            "publishedAt",
+            "tone",
+            "image",
+            "persons",
+            "organizations"
+          ],
+          "type": "object"
+        },
+        "type": "array"
+      },
+      "attribution": {
+        "type": "string"
+      },
+      "count": {
+        "type": "number"
+      },
+      "hours": {
+        "type": "number"
+      },
+      "lastIngestAt": {
+        "type": [
+          "string",
+          "null"
+        ]
+      },
+      "next": {
+        "additionalProperties": false,
+        "description": "Suggested next paid call in the same family (call it in a loop when the task continues)",
+        "properties": {
+          "method": {
+            "enum": [
+              "GET",
+              "POST"
+            ],
+            "type": "string"
+          },
+          "sample": {
+            "description": "Free fixed sample of the whole family",
+            "type": "string"
+          },
+          "service": {
+            "description": "Service id of the suggested next paid call",
+            "type": "string"
+          },
+          "tool": {
+            "description": "MCP tool name of the same call",
+            "type": "string"
+          },
+          "url": {
+            "description": "Paid route of the next call",
+            "type": "string"
+          },
+          "useWhen": {
+            "description": "When the next call is the right one",
+            "type": "string"
+          }
+        },
+        "required": [
+          "service",
+          "tool",
+          "method",
+          "url",
+          "useWhen",
+          "sample"
+        ],
+        "type": "object"
+      },
+      "token": {
+        "type": [
+          "string",
+          "null"
+        ]
+      }
+    },
+    "required": [
+      "token",
+      "hours",
+      "count",
+      "articles",
+      "lastIngestAt",
+      "attribution"
+    ],
+    "type": "object"
+  },
+  {
+    "description": "x402 PaymentRequired (returned with isError when payment is needed)",
+    "properties": {
+      "accepts": {
+        "items": {
+          "type": "object"
+        },
+        "type": "array"
+      },
+      "error": {
+        "type": "string"
+      },
+      "extensions": {
+        "type": "object"
+      },
+      "resource": {
+        "type": "object"
+      },
+      "x402Version": {
+        "type": "integer"
+      }
+    },
+    "required": [
+      "x402Version",
+      "accepts"
+    ],
+    "type": "object"
+  }
+]

Changedblackwood_domain_intel1 field changed

changedOutput schema / anyOf

Previous value: -[
-  {
-    "additionalProperties": false,
-    "properties": {
-      "certificates": {
-        "anyOf": [
-          {
-            "additionalProperties": false,
-            "properties": {
-              "recent": {
-                "items": {
-                  "additionalProperties": false,
-                  "properties": {
-                    "commonName": {
-                      "type": "string"
-                    },
-                    "issuer": {
-                      "type": "string"
-                    },
-                    "notAfter": {
-                      "type": "string"
-                    },
-                    "notBefore": {
-                      "type": "string"
-                    }
-                  },
-                  "required": [
-                    "issuer",
-                    "commonName",
-                    "notBefore",
-                    "notAfter"
-                  ],
-                  "type": "object"
-                },
-                "type": "array"
-              },
-              "total": {
-                "maximum": 9007199254740991,
-                "minimum": -9007199254740991,
-                "type": "integer"
-              }
-            },
-            "required": [
-              "total",
-              "recent"
-            ],
-            "type": "object"
-          },
-          {
-            "type": "null"
-          }
-        ]
-      },
-      "dns": {
-        "additionalProperties": false,
-        "properties": {
-          "a": {
-            "items": {
-              "type": "string"
-            },
-            "type": "array"
-          },
-          "aaaa": {
-            "items": {
-              "type": "string"
-            },
-            "type": "array"
-          },
-          "caa": {
-            "items": {
-              "type": "string"
-            },
-            "type": "array"
-          },
-          "mx": {
-            "items": {
-              "additionalProperties": false,
-              "properties": {
-                "host": {
-                  "type": "string"
-                },
-                "priority": {
-                  "maximum": 9007199254740991,
-                  "minimum": -9007199254740991,
-                  "type": "integer"
-                }
-              },
-              "required": [
-                "priority",
-                "host"
-              ],
-              "type": "object"
-            },
-            "type": "array"
-          },
-          "ns": {
-            "items": {
-              "type": "string"
-            },
-            "type": "array"
-          },
-          "txt": {
-            "items": {
-              "type": "string"
-            },
-            "type": "array"
-          }
-        },
-        "required": [
-          "a",
-          "aaaa",
-          "mx",
-          "ns",
-          "txt",
-          "caa"
-        ],
-        "type": "object"
-      },
-      "domain": {
-        "type": "string"
-      },
-      "email": {
-        "additionalProperties": false,
-        "properties": {
-          "dmarc": {
-            "type": [
-              "string",
-              "null"
-            ]
-          },
-          "dmarcPolicy": {
-            "type": [
-              "string",
-              "null"
-            ]
-          },
-          "spf": {
-            "type": [
-              "string",
-              "null"
-            ]
-          }
-        },
-        "required": [
-          "spf",
-          "dmarc",
-          "dmarcPolicy"
-        ],
-        "type": "object"
-      },
-      "partial": {
-        "items": {
-          "type": "string"
-        },
-        "type": "array"
-      },
-      "registered": {
-        "type": [
-          "boolean",
-          "null"
-        ]
-      },
-      "registration": {
-        "anyOf": [
-          {
-            "additionalProperties": false,
-            "properties": {
-              "created": {
-                "type": [
-                  "string",
-                  "null"
-                ]
-              },
-              "dnssec": {
-                "type": [
-                  "boolean",
-                  "null"
-                ]
-              },
-              "expires": {
-                "type": [
-                  "string",
-                  "null"
-                ]
-              },
-              "nameservers": {
-                "items": {
-                  "type": "string"
-                },
-                "type": "array"
-              },
-              "rdapServer": {
-                "type": [
-                  "string",
-                  "null"
-                ]
-              },
-              "registrar": {
-                "type": [
-                  "string",
-                  "null"
-                ]
-              },
-              "status": {
-                "items": {
-                  "type": "string"
-                },
-                "type": "array"
-              },
-              "updated": {
-                "type": [
-                  "string",
-                  "null"
-                ]
-              }
-            },
-            "required": [
-              "registrar",
-              "created",
-              "updated",
-              "expires",
-              "status",
-              "nameservers",
-              "dnssec",
-              "rdapServer"
-            ],
-            "type": "object"
-          },
-          {
-            "type": "null"
-          }
-        ]
-      }
-    },
-    "required": [
-      "domain",
-      "registered",
-      "registration",
-      "dns",
-      "email",
-      "certificates",
-      "partial"
-    ],
-    "type": "object"
-  },
-  {
-    "description": "x402 PaymentRequired (returned with isError when payment is needed)",
-    "properties": {
-      "accepts": {
-        "items": {
-          "type": "object"
-        },
-        "type": "array"
-      },
-      "error": {
-        "type": "string"
-      },
-      "extensions": {
-        "type": "object"
-      },
-      "resource": {
-        "type": "object"
-      },
-      "x402Version": {
-        "type": "integer"
-      }
-    },
-    "required": [
-      "x402Version",
-      "accepts"
-    ],
-    "type": "object"
-  }
-]New value: +[
+  {
+    "additionalProperties": false,
+    "properties": {
+      "certificates": {
+        "anyOf": [
+          {
+            "additionalProperties": false,
+            "properties": {
+              "recent": {
+                "items": {
+                  "additionalProperties": false,
+                  "properties": {
+                    "commonName": {
+                      "type": "string"
+                    },
+                    "issuer": {
+                      "type": "string"
+                    },
+                    "notAfter": {
+                      "type": "string"
+                    },
+                    "notBefore": {
+                      "type": "string"
+                    }
+                  },
+                  "required": [
+                    "issuer",
+                    "commonName",
+                    "notBefore",
+                    "notAfter"
+                  ],
+                  "type": "object"
+                },
+                "type": "array"
+              },
+              "total": {
+                "maximum": 9007199254740991,
+                "minimum": -9007199254740991,
+                "type": "integer"
+              }
+            },
+            "required": [
+              "total",
+              "recent"
+            ],
+            "type": "object"
+          },
+          {
+            "type": "null"
+          }
+        ]
+      },
+      "dns": {
+        "additionalProperties": false,
+        "properties": {
+          "a": {
+            "items": {
+              "type": "string"
+            },
+            "type": "array"
+          },
+          "aaaa": {
+            "items": {
+              "type": "string"
+            },
+            "type": "array"
+          },
+          "caa": {
+            "items": {
+              "type": "string"
+            },
+            "type": "array"
+          },
+          "mx": {
+            "items": {
+              "additionalProperties": false,
+              "properties": {
+                "host": {
+                  "type": "string"
+                },
+                "priority": {
+                  "maximum": 9007199254740991,
+                  "minimum": -9007199254740991,
+                  "type": "integer"
+                }
+              },
+              "required": [
+                "priority",
+                "host"
+              ],
+              "type": "object"
+            },
+            "type": "array"
+          },
+          "ns": {
+            "items": {
+              "type": "string"
+            },
+            "type": "array"
+          },
+          "txt": {
+            "items": {
+              "type": "string"
+            },
+            "type": "array"
+          }
+        },
+        "required": [
+          "a",
+          "aaaa",
+          "mx",
+          "ns",
+          "txt",
+          "caa"
+        ],
+        "type": "object"
+      },
+      "domain": {
+        "type": "string"
+      },
+      "email": {
+        "additionalProperties": false,
+        "properties": {
+          "dmarc": {
+            "type": [
+              "string",
+              "null"
+            ]
+          },
+          "dmarcPolicy": {
+            "type": [
+              "string",
+              "null"
+            ]
+          },
+          "spf": {
+            "type": [
+              "string",
+              "null"
+            ]
+          }
+        },
+        "required": [
+          "spf",
+          "dmarc",
+          "dmarcPolicy"
+        ],
+        "type": "object"
+      },
+      "next": {
+        "additionalProperties": false,
+        "description": "Suggested next paid call in the same family (call it in a loop when the task continues)",
+        "properties": {
+          "method": {
+            "enum": [
+              "GET",
+              "POST"
+            ],
+            "type": "string"
+          },
+          "sample": {
+            "description": "Free fixed sample of the whole family",
+            "type": "string"
+          },
+          "service": {
+            "description": "Service id of the suggested next paid call",
+            "type": "string"
+          },
+          "tool": {
+            "description": "MCP tool name of the same call",
+            "type": "string"
+          },
+          "url": {
+            "description": "Paid route of the next call",
+            "type": "string"
+          },
+          "useWhen": {
+            "description": "When the next call is the right one",
+            "type": "string"
+          }
+        },
+        "required": [
+          "service",
+          "tool",
+          "method",
+          "url",
+          "useWhen",
+          "sample"
+        ],
+        "type": "object"
+      },
+      "partial": {
+        "items": {
+          "type": "string"
+        },
+        "type": "array"
+      },
+      "registered": {
+        "type": [
+          "boolean",
+          "null"
+        ]
+      },
+      "registration": {
+        "anyOf": [
+          {
+            "additionalProperties": false,
+            "properties": {
+              "created": {
+                "type": [
+                  "string",
+                  "null"
+                ]
+              },
+              "dnssec": {
+                "type": [
+                  "boolean",
+                  "null"
+                ]
+              },
+              "expires": {
+                "type": [
+                  "string",
+                  "null"
+                ]
+              },
+              "nameservers": {
+                "items": {
+                  "type": "string"
+                },
+                "type": "array"
+              },
+              "rdapServer": {
+                "type": [
+                  "string",
+                  "null"
+                ]
+              },
+              "registrar": {
+                "type": [
+                  "string",
+                  "null"
+                ]
+              },
+              "status": {
+                "items": {
+                  "type": "string"
+                },
+                "type": "array"
+              },
+              "updated": {
+                "type": [
+                  "string",
+                  "null"
+                ]
+              }
+            },
+            "required": [
+              "registrar",
+              "created",
+              "updated",
+              "expires",
+              "status",
+              "nameservers",
+              "dnssec",
+              "rdapServer"
+            ],
+            "type": "object"
+          },
+          {
+            "type": "null"
+          }
+        ]
+      }
+    },
+    "required": [
+      "domain",
+      "registered",
+      "registration",
+      "dns",
+      "email",
+      "certificates",
+      "partial"
+    ],
+    "type": "object"
+  },
+  {
+    "description": "x402 PaymentRequired (returned with isError when payment is needed)",
+    "properties": {
+      "accepts": {
+        "items": {
+          "type": "object"
+        },
+        "type": "array"
+      },
+      "error": {
+        "type": "string"
+      },
+      "extensions": {
+        "type": "object"
+      },
+      "resource": {
+        "type": "object"
+      },
+      "x402Version": {
+        "type": "integer"
+      }
+    },
+    "required": [
+      "x402Version",
+      "accepts"
+    ],
+    "type": "object"
+  }
+]

Addedblackwood_email_batch

Changedblackwood_email_check1 field changed

changedOutput schema / anyOf

Previous value: -[
-  {
-    "additionalProperties": false,
-    "properties": {
-      "acceptsMail": {
-        "type": "boolean"
-      },
-      "disposable": {
-        "type": "boolean"
-      },
-      "dmarc": {
-        "type": [
-          "string",
-          "null"
-        ]
-      },
-      "dmarcPolicy": {
-        "type": [
-          "string",
-          "null"
-        ]
-      },
-      "domain": {
-        "type": [
-          "string",
-          "null"
-        ]
-      },
-      "domainExists": {
-        "type": [
-          "boolean",
-          "null"
-        ]
-      },
-      "email": {
-        "type": "string"
-      },
-      "freeProvider": {
-        "type": "boolean"
-      },
-      "mx": {
-        "items": {
-          "additionalProperties": false,
-          "properties": {
-            "host": {
-              "type": "string"
-            },
-            "priority": {
-              "type": "number"
-            }
-          },
-          "required": [
-            "priority",
-            "host"
-          ],
-          "type": "object"
-        },
-        "type": "array"
-      },
-      "normalized": {
-        "type": [
-          "string",
-          "null"
-        ]
-      },
-      "reasons": {
-        "items": {
-          "type": "string"
-        },
-        "type": "array"
-      },
-      "roleAccount": {
-        "type": "boolean"
-      },
-      "smtpChecked": {
-        "type": "boolean"
-      },
-      "spf": {
-        "type": [
-          "string",
-          "null"
-        ]
-      },
-      "syntaxValid": {
-        "type": "boolean"
-      },
-      "verdict": {
-        "enum": [
-          "deliverable_domain",
-          "risky",
-          "undeliverable",
-          "invalid"
-        ],
-        "type": "string"
-      }
-    },
-    "required": [
-      "email",
-      "normalized",
-      "syntaxValid",
-      "domain",
-      "disposable",
-      "freeProvider",
-      "roleAccount",
-      "domainExists",
-      "mx",
-      "acceptsMail",
-      "spf",
-      "dmarc",
-      "dmarcPolicy",
-      "verdict",
-      "reasons",
-      "smtpChecked"
-    ],
-    "type": "object"
-  },
-  {
-    "description": "x402 PaymentRequired (returned with isError when payment is needed)",
-    "properties": {
-      "accepts": {
-        "items": {
-          "type": "object"
-        },
-        "type": "array"
-      },
-      "error": {
-        "type": "string"
-      },
-      "extensions": {
-        "type": "object"
-      },
-      "resource": {
-        "type": "object"
-      },
-      "x402Version": {
-        "type": "integer"
-      }
-    },
-    "required": [
-      "x402Version",
-      "accepts"
-    ],
-    "type": "object"
-  }
-]New value: +[
+  {
+    "additionalProperties": false,
+    "properties": {
+      "acceptsMail": {
+        "type": "boolean"
+      },
+      "disposable": {
+        "type": "boolean"
+      },
+      "dmarc": {
+        "type": [
+          "string",
+          "null"
+        ]
+      },
+      "dmarcPolicy": {
+        "type": [
+          "string",
+          "null"
+        ]
+      },
+      "domain": {
+        "type": [
+          "string",
+          "null"
+        ]
+      },
+      "domainExists": {
+        "type": [
+          "boolean",
+          "null"
+        ]
+      },
+      "email": {
+        "type": "string"
+      },
+      "freeProvider": {
+        "type": "boolean"
+      },
+      "mx": {
+        "items": {
+          "additionalProperties": false,
+          "properties": {
+            "host": {
+              "type": "string"
+            },
+            "priority": {
+              "type": "number"
+            }
+          },
+          "required": [
+            "priority",
+            "host"
+          ],
+          "type": "object"
+        },
+        "type": "array"
+      },
+      "next": {
+        "additionalProperties": false,
+        "description": "Suggested next paid call in the same family (call it in a loop when the task continues)",
+        "properties": {
+          "method": {
+            "enum": [
+              "GET",
+              "POST"
+            ],
+            "type": "string"
+          },
+          "sample": {
+            "description": "Free fixed sample of the whole family",
+            "type": "string"
+          },
+          "service": {
+            "description": "Service id of the suggested next paid call",
+            "type": "string"
+          },
+          "tool": {
+            "description": "MCP tool name of the same call",
+            "type": "string"
+          },
+          "url": {
+            "description": "Paid route of the next call",
+            "type": "string"
+          },
+          "useWhen": {
+            "description": "When the next call is the right one",
+            "type": "string"
+          }
+        },
+        "required": [
+          "service",
+          "tool",
+          "method",
+          "url",
+          "useWhen",
+          "sample"
+        ],
+        "type": "object"
+      },
+      "normalized": {
+        "type": [
+          "string",
+          "null"
+        ]
+      },
+      "reasons": {
+        "items": {
+          "type": "string"
+        },
+        "type": "array"
+      },
+      "roleAccount": {
+        "type": "boolean"
+      },
+      "smtpChecked": {
+        "type": "boolean"
+      },
+      "spf": {
+        "type": [
+          "string",
+          "null"
+        ]
+      },
+      "syntaxValid": {
+        "type": "boolean"
+      },
+      "verdict": {
+        "enum": [
+          "deliverable_domain",
+          "risky",
+          "undeliverable",
+          "invalid"
+        ],
+        "type": "string"
+      }
+    },
+    "required": [
+      "email",
+      "normalized",
+      "syntaxValid",
+      "domain",
+      "disposable",
+      "freeProvider",
+      "roleAccount",
+      "domainExists",
+      "mx",
+      "acceptsMail",
+      "spf",
+      "dmarc",
+      "dmarcPolicy",
+      "verdict",
+      "reasons",
+      "smtpChecked"
+    ],
+    "type": "object"
+  },
+  {
+    "description": "x402 PaymentRequired (returned with isError when payment is needed)",
+    "properties": {
+      "accepts": {
+        "items": {
+          "type": "object"
+        },
+        "type": "array"
+      },
+      "error": {
+        "type": "string"
+      },
+      "extensions": {
+        "type": "object"
+      },
+      "resource": {
+        "type": "object"
+      },
+      "x402Version": {
+        "type": "integer"
+      }
+    },
+    "required": [
+      "x402Version",
+      "accepts"
+    ],
+    "type": "object"
+  }
+]

Addedblackwood_fx_history

Changedblackwood_fx_rates1 field changed

changedOutput schema / anyOf

Previous value: -[
-  {
-    "additionalProperties": false,
-    "properties": {
-      "amount": {
-        "type": [
-          "number",
-          "null"
-        ]
-      },
-      "attribution": {
-        "type": "string"
-      },
-      "base": {
-        "type": "string"
-      },
-      "converted": {
-        "anyOf": [
-          {
-            "additionalProperties": {
-              "type": "number"
-            },
-            "propertyNames": {
-              "type": "string"
-            },
-            "type": "object"
-          },
-          {
-            "type": "null"
-          }
-        ]
-      },
-      "date": {
-        "type": "string"
-      },
-      "note": {
-        "type": "string"
-      },
-      "rates": {
-        "additionalProperties": {
-          "type": "number"
-        },
-        "propertyNames": {
-          "type": "string"
-        },
-        "type": "object"
-      }
-    },
-    "required": [
-      "date",
-      "base",
-      "rates",
-      "amount",
-      "converted",
-      "attribution",
-      "note"
-    ],
-    "type": "object"
-  },
-  {
-    "description": "x402 PaymentRequired (returned with isError when payment is needed)",
-    "properties": {
-      "accepts": {
-        "items": {
-          "type": "object"
-        },
-        "type": "array"
-      },
-      "error": {
-        "type": "string"
-      },
-      "extensions": {
-        "type": "object"
-      },
-      "resource": {
-        "type": "object"
-      },
-      "x402Version": {
-        "type": "integer"
-      }
-    },
-    "required": [
-      "x402Version",
-      "accepts"
-    ],
-    "type": "object"
-  }
-]New value: +[
+  {
+    "additionalProperties": false,
+    "properties": {
+      "amount": {
+        "type": [
+          "number",
+          "null"
+        ]
+      },
+      "attribution": {
+        "type": "string"
+      },
+      "base": {
+        "type": "string"
+      },
+      "converted": {
+        "anyOf": [
+          {
+            "additionalProperties": {
+              "type": "number"
+            },
+            "propertyNames": {
+              "type": "string"
+            },
+            "type": "object"
+          },
+          {
+            "type": "null"
+          }
+        ]
+      },
+      "date": {
+        "type": "string"
+      },
+      "next": {
+        "additionalProperties": false,
+        "description": "Suggested next paid call in the same family (call it in a loop when the task continues)",
+        "properties": {
+          "method": {
+            "enum": [
+              "GET",
+              "POST"
+            ],
+            "type": "string"
+          },
+          "sample": {
+            "description": "Free fixed sample of the whole family",
+            "type": "string"
+          },
+          "service": {
+            "description": "Service id of the suggested next paid call",
+            "type": "string"
+          },
+          "tool": {
+            "description": "MCP tool name of the same call",
+            "type": "string"
+          },
+          "url": {
+            "description": "Paid route of the next call",
+            "type": "string"
+          },
+          "useWhen": {
+            "description": "When the next call is the right one",
+            "type": "string"
+          }
+        },
+        "required": [
+          "service",
+          "tool",
+          "method",
+          "url",
+          "useWhen",
+          "sample"
+        ],
+        "type": "object"
+      },
+      "note": {
+        "type": "string"
+      },
+      "rates": {
+        "additionalProperties": {
+          "type": "number"
+        },
+        "propertyNames": {
+          "type": "string"
+        },
+        "type": "object"
+      }
+    },
+    "required": [
+      "date",
+      "base",
+      "rates",
+      "amount",
+      "converted",
+      "attribution",
+      "note"
+    ],
+    "type": "object"
+  },
+  {
+    "description": "x402 PaymentRequired (returned with isError when payment is needed)",
+    "properties": {
+      "accepts": {
+        "items": {
+          "type": "object"
+        },
+        "type": "array"
+      },
+      "error": {
+        "type": "string"
+      },
+      "extensions": {
+        "type": "object"
+      },
+      "resource": {
+        "type": "object"
+      },
+      "x402Version": {
+        "type": "integer"
+      }
+    },
+    "required": [
+      "x402Version",
+      "accepts"
+    ],
+    "type": "object"
+  }
+]

Changedblackwood_headers_audit1 field changed

changedOutput schema / anyOf

Previous value: -[
-  {
-    "additionalProperties": false,
-    "properties": {
-      "checkedAt": {
-        "type": "string"
-      },
-      "checks": {
-        "items": {
-          "additionalProperties": false,
-          "properties": {
-            "advice": {
-              "type": "string"
-            },
-            "header": {
-              "type": "string"
-            },
-            "result": {
-              "enum": [
-                "pass",
-                "warn",
-                "fail",
-                "info"
-              ],
-              "type": "string"
-            },
-            "value": {
-              "type": [
-                "string",
-                "null"
-              ]
-            }
-          },
-          "required": [
-            "header",
-            "result",
-            "value",
-            "advice"
-          ],
-          "type": "object"
-        },
-        "type": "array"
-      },
-      "cookies": {
-        "items": {
-          "additionalProperties": false,
-          "properties": {
-            "httpOnly": {
-              "type": "boolean"
-            },
-            "name": {
-              "type": "string"
-            },
-            "sameSite": {
-              "type": [
-                "string",
-                "null"
-              ]
-            },
-            "secure": {
-              "type": "boolean"
-            }
-          },
-          "required": [
-            "name",
-            "secure",
-            "httpOnly",
-            "sameSite"
-          ],
-          "type": "object"
-        },
-        "type": "array"
-      },
-      "finalUrl": {
-        "type": "string"
-      },
-      "grade": {
-        "type": "string"
-      },
-      "redirects": {
-        "type": "number"
-      },
-      "score": {
-        "type": "number"
-      },
-      "status": {
-        "type": "number"
-      },
-      "url": {
-        "type": "string"
-      }
-    },
-    "required": [
-      "url",
-      "finalUrl",
-      "status",
-      "redirects",
-      "grade",
-      "score",
-      "checks",
-      "cookies",
-      "checkedAt"
-    ],
-    "type": "object"
-  },
-  {
-    "description": "x402 PaymentRequired (returned with isError when payment is needed)",
-    "properties": {
-      "accepts": {
-        "items": {
-          "type": "object"
-        },
-        "type": "array"
-      },
-      "error": {
-        "type": "string"
-      },
-      "extensions": {
-        "type": "object"
-      },
-      "resource": {
-        "type": "object"
-      },
-      "x402Version": {
-        "type": "integer"
-      }
-    },
-    "required": [
-      "x402Version",
-      "accepts"
-    ],
-    "type": "object"
-  }
-]New value: +[
+  {
+    "additionalProperties": false,
+    "properties": {
+      "checkedAt": {
+        "type": "string"
+      },
+      "checks": {
+        "items": {
+          "additionalProperties": false,
+          "properties": {
+            "advice": {
+              "type": "string"
+            },
+            "header": {
+              "type": "string"
+            },
+            "result": {
+              "enum": [
+                "pass",
+                "warn",
+                "fail",
+                "info"
+              ],
+              "type": "string"
+            },
+            "value": {
+              "type": [
+                "string",
+                "null"
+              ]
+            }
+          },
+          "required": [
+            "header",
+            "result",
+            "value",
+            "advice"
+          ],
+          "type": "object"
+        },
+        "type": "array"
+      },
+      "cookies": {
+        "items": {
+          "additionalProperties": false,
+          "properties": {
+            "httpOnly": {
+              "type": "boolean"
+            },
+            "name": {
+              "type": "string"
+            },
+            "sameSite": {
+              "type": [
+                "string",
+                "null"
+              ]
+            },
+            "secure": {
+              "type": "boolean"
+            }
+          },
+          "required": [
+            "name",
+            "secure",
+            "httpOnly",
+            "sameSite"
+          ],
+          "type": "object"
+        },
+        "type": "array"
+      },
+      "finalUrl": {
+        "type": "string"
+      },
+      "grade": {
+        "type": "string"
+      },
+      "next": {
+        "additionalProperties": false,
+        "description": "Suggested next paid call in the same family (call it in a loop when the task continues)",
+        "properties": {
+          "method": {
+            "enum": [
+              "GET",
+              "POST"
+            ],
+            "type": "string"
+          },
+          "sample": {
+            "description": "Free fixed sample of the whole family",
+            "type": "string"
+          },
+          "service": {
+            "description": "Service id of the suggested next paid call",
+            "type": "string"
+          },
+          "tool": {
+            "description": "MCP tool name of the same call",
+            "type": "string"
+          },
+          "url": {
+            "description": "Paid route of the next call",
+            "type": "string"
+          },
+          "useWhen": {
+            "description": "When the next call is the right one",
+            "type": "string"
+          }
+        },
+        "required": [
+          "service",
+          "tool",
+          "method",
+          "url",
+          "useWhen",
+          "sample"
+        ],
+        "type": "object"
+      },
+      "redirects": {
+        "type": "number"
+      },
+      "score": {
+        "type": "number"
+      },
+      "status": {
+        "type": "number"
+      },
+      "url": {
+        "type": "string"
+      }
+    },
+    "required": [
+      "url",
+      "finalUrl",
+      "status",
+      "redirects",
+      "grade",
+      "score",
+      "checks",
+      "cookies",
+      "checkedAt"
+    ],
+    "type": "object"
+  },
+  {
+    "description": "x402 PaymentRequired (returned with isError when payment is needed)",
+    "properties": {
+      "accepts": {
+        "items": {
+          "type": "object"
+        },
+        "type": "array"
+      },
+      "error": {
+        "type": "string"
+      },
+      "extensions": {
+        "type": "object"
+      },
+      "resource": {
+        "type": "object"
+      },
+      "x402Version": {
+        "type": "integer"
+      }
+    },
+    "required": [
+      "x402Version",
+      "accepts"
+    ],
+    "type": "object"
+  }
+]

Changedblackwood_image_generate1 field changed

changedOutput schema / anyOf

Previous value: -[
-  {
-    "additionalProperties": false,
-    "properties": {
-      "done": {
-        "type": "boolean"
-      },
-      "error": {
-        "additionalProperties": false,
-        "properties": {
-          "message": {
-            "type": "string"
-          },
-          "name": {
-            "type": "string"
-          }
-        },
-        "required": [
-          "name",
-          "message"
-        ],
-        "type": "object"
-      },
-      "jobId": {
-        "type": "string"
-      },
-      "output": {
-        "additionalProperties": false,
-        "properties": {
-          "imageBase64": {
-            "type": "string"
-          },
-          "mimeType": {
-            "const": "image/jpeg",
-            "type": "string"
-          },
-          "model": {
-            "type": "string"
-          },
-          "prompt": {
-            "type": "string"
-          },
-          "steps": {
-            "maximum": 9007199254740991,
-            "minimum": -9007199254740991,
-            "type": "integer"
-          }
-        },
-        "required": [
-          "model",
-          "prompt",
-          "steps",
-          "mimeType",
-          "imageBase64"
-        ],
-        "type": "object"
-      },
-      "pollUrl": {
-        "type": "string"
-      },
-      "status": {
-        "enum": [
-          "queued",
-          "running",
-          "paused",
-          "errored",
-          "terminated",
-          "complete",
-          "waiting",
-          "waitingForPause",
-          "rollingBack",
-          "unknown"
-        ],
-        "type": "string"
-      }
-    },
-    "required": [
-      "jobId",
-      "status",
-      "done",
-      "pollUrl"
-    ],
-    "type": "object"
-  },
-  {
-    "description": "x402 PaymentRequired (returned with isError when payment is needed)",
-    "properties": {
-      "accepts": {
-        "items": {
-          "type": "object"
-        },
-        "type": "array"
-      },
-      "error": {
-        "type": "string"
-      },
-      "extensions": {
-        "type": "object"
-      },
-      "resource": {
-        "type": "object"
-      },
-      "x402Version": {
-        "type": "integer"
-      }
-    },
-    "required": [
-      "x402Version",
-      "accepts"
-    ],
-    "type": "object"
-  }
-]New value: +[
+  {
+    "additionalProperties": false,
+    "properties": {
+      "done": {
+        "type": "boolean"
+      },
+      "error": {
+        "additionalProperties": false,
+        "properties": {
+          "message": {
+            "type": "string"
+          },
+          "name": {
+            "type": "string"
+          }
+        },
+        "required": [
+          "name",
+          "message"
+        ],
+        "type": "object"
+      },
+      "jobId": {
+        "type": "string"
+      },
+      "next": {
+        "additionalProperties": false,
+        "description": "Suggested next paid call in the same family (call it in a loop when the task continues)",
+        "properties": {
+          "method": {
+            "enum": [
+              "GET",
+              "POST"
+            ],
+            "type": "string"
+          },
+          "sample": {
+            "description": "Free fixed sample of the whole family",
+            "type": "string"
+          },
+          "service": {
+            "description": "Service id of the suggested next paid call",
+            "type": "string"
+          },
+          "tool": {
+            "description": "MCP tool name of the same call",
+            "type": "string"
+          },
+          "url": {
+            "description": "Paid route of the next call",
+            "type": "string"
+          },
+          "useWhen": {
+            "description": "When the next call is the right one",
+            "type": "string"
+          }
+        },
+        "required": [
+          "service",
+          "tool",
+          "method",
+          "url",
+          "useWhen",
+          "sample"
+        ],
+        "type": "object"
+      },
+      "output": {
+        "additionalProperties": false,
+        "properties": {
+          "imageBase64": {
+            "type": "string"
+          },
+          "mimeType": {
+            "const": "image/jpeg",
+            "type": "string"
+          },
+          "model": {
+            "type": "string"
+          },
+          "prompt": {
+            "type": "string"
+          },
+          "steps": {
+            "maximum": 9007199254740991,
+            "minimum": -9007199254740991,
+            "type": "integer"
+          }
+        },
+        "required": [
+          "model",
+          "prompt",
+          "steps",
+          "mimeType",
+          "imageBase64"
+        ],
+        "type": "object"
+      },
+      "pollUrl": {
+        "type": "string"
+      },
+      "status": {
+        "enum": [
+          "queued",
+          "running",
+          "paused",
+          "errored",
+          "terminated",
+          "complete",
+          "waiting",
+          "waitingForPause",
+          "rollingBack",
+          "unknown"
+        ],
+        "type": "string"
+      }
+    },
+    "required": [
+      "jobId",
+      "status",
+      "done",
+      "pollUrl"
+    ],
+    "type": "object"
+  },
+  {
+    "description": "x402 PaymentRequired (returned with isError when payment is needed)",
+    "properties": {
+      "accepts": {
+        "items": {
+          "type": "object"
+        },
+        "type": "array"
+      },
+      "error": {
+        "type": "string"
+      },
+      "extensions": {
+        "type": "object"
+      },
+      "resource": {
+        "type": "object"
+      },
+      "x402Version": {
+        "type": "integer"
+      }
+    },
+    "required": [
+      "x402Version",
+      "accepts"
+    ],
+    "type": "object"
+  }
+]

Changedblackwood_llm_chat1 field changed

changedOutput schema / anyOf

Previous value: -[
-  {
-    "additionalProperties": false,
-    "properties": {
-      "done": {
-        "type": "boolean"
-      },
-      "error": {
-        "additionalProperties": false,
-        "properties": {
-          "message": {
-            "type": "string"
-          },
-          "name": {
-            "type": "string"
-          }
-        },
-        "required": [
-          "name",
-          "message"
-        ],
-        "type": "object"
-      },
-      "jobId": {
-        "type": "string"
-      },
-      "output": {
-        "additionalProperties": false,
-        "properties": {
-          "content": {
-            "type": "string"
-          },
-          "finishReason": {
-            "type": [
-              "string",
-              "null"
-            ]
-          },
-          "model": {
-            "type": "string"
-          },
-          "usage": {
-            "additionalProperties": false,
-            "properties": {
-              "completionTokens": {
-                "maximum": 9007199254740991,
-                "minimum": -9007199254740991,
-                "type": "integer"
-              },
-              "promptTokens": {
-                "maximum": 9007199254740991,
-                "minimum": -9007199254740991,
-                "type": "integer"
-              }
-            },
-            "required": [
-              "promptTokens",
-              "completionTokens"
-            ],
-            "type": "object"
-          }
-        },
-        "required": [
-          "model",
-          "content",
-          "finishReason",
-          "usage"
-        ],
-        "type": "object"
-      },
-      "pollUrl": {
-        "type": "string"
-      },
-      "status": {
-        "enum": [
-          "queued",
-          "running",
-          "paused",
-          "errored",
-          "terminated",
-          "complete",
-          "waiting",
-          "waitingForPause",
-          "rollingBack",
-          "unknown"
-        ],
-        "type": "string"
-      }
-    },
-    "required": [
-      "jobId",
-      "status",
-      "done",
-      "pollUrl"
-    ],
-    "type": "object"
-  },
-  {
-    "description": "x402 PaymentRequired (returned with isError when payment is needed)",
-    "properties": {
-      "accepts": {
-        "items": {
-          "type": "object"
-        },
-        "type": "array"
-      },
-      "error": {
-        "type": "string"
-      },
-      "extensions": {
-        "type": "object"
-      },
-      "resource": {
-        "type": "object"
-      },
-      "x402Version": {
-        "type": "integer"
-      }
-    },
-    "required": [
-      "x402Version",
-      "accepts"
-    ],
-    "type": "object"
-  }
-]New value: +[
+  {
+    "additionalProperties": false,
+    "properties": {
+      "done": {
+        "type": "boolean"
+      },
+      "error": {
+        "additionalProperties": false,
+        "properties": {
+          "message": {
+            "type": "string"
+          },
+          "name": {
+            "type": "string"
+          }
+        },
+        "required": [
+          "name",
+          "message"
+        ],
+        "type": "object"
+      },
+      "jobId": {
+        "type": "string"
+      },
+      "next": {
+        "additionalProperties": false,
+        "description": "Suggested next paid call in the same family (call it in a loop when the task continues)",
+        "properties": {
+          "method": {
+            "enum": [
+              "GET",
+              "POST"
+            ],
+            "type": "string"
+          },
+          "sample": {
+            "description": "Free fixed sample of the whole family",
+            "type": "string"
+          },
+          "service": {
+            "description": "Service id of the suggested next paid call",
+            "type": "string"
+          },
+          "tool": {
+            "description": "MCP tool name of the same call",
+            "type": "string"
+          },
+          "url": {
+            "description": "Paid route of the next call",
+            "type": "string"
+          },
+          "useWhen": {
+            "description": "When the next call is the right one",
+            "type": "string"
+          }
+        },
+        "required": [
+          "service",
+          "tool",
+          "method",
+          "url",
+          "useWhen",
+          "sample"
+        ],
+        "type": "object"
+      },
+      "output": {
+        "additionalProperties": false,
+        "properties": {
+          "content": {
+            "type": "string"
+          },
+          "finishReason": {
+            "type": [
+              "string",
+              "null"
+            ]
+          },
+          "model": {
+            "type": "string"
+          },
+          "usage": {
+            "additionalProperties": false,
+            "properties": {
+              "completionTokens": {
+                "maximum": 9007199254740991,
+                "minimum": -9007199254740991,
+                "type": "integer"
+              },
+              "promptTokens": {
+                "maximum": 9007199254740991,
+                "minimum": -9007199254740991,
+                "type": "integer"
+              }
+            },
+            "required": [
+              "promptTokens",
+              "completionTokens"
+            ],
+            "type": "object"
+          }
+        },
+        "required": [
+          "model",
+          "content",
+          "finishReason",
+          "usage"
+        ],
+        "type": "object"
+      },
+      "pollUrl": {
+        "type": "string"
+      },
+      "status": {
+        "enum": [
+          "queued",
+          "running",
+          "paused",
+          "errored",
+          "terminated",
+          "complete",
+          "waiting",
+          "waitingForPause",
+          "rollingBack",
+          "unknown"
+        ],
+        "type": "string"
+      }
+    },
+    "required": [
+      "jobId",
+      "status",
+      "done",
+      "pollUrl"
+    ],
+    "type": "object"
+  },
+  {
+    "description": "x402 PaymentRequired (returned with isError when payment is needed)",
+    "properties": {
+      "accepts": {
+        "items": {
+          "type": "object"
+        },
+        "type": "array"
+      },
+      "error": {
+        "type": "string"
+      },
+      "extensions": {
+        "type": "object"
+      },
+      "resource": {
+        "type": "object"
+      },
+      "x402Version": {
+        "type": "integer"
+      }
+    },
+    "required": [
+      "x402Version",
+      "accepts"
+    ],
+    "type": "object"
+  }
+]

Changedblackwood_news_search1 field changed

changedOutput schema / anyOf

Previous value: -[
-  {
-    "additionalProperties": false,
-    "properties": {
-      "articles": {
-        "items": {
-          "additionalProperties": false,
-          "properties": {
-            "authors": {
-              "type": [
-                "string",
-                "null"
-              ]
-            },
-            "domain": {
-              "type": "string"
-            },
-            "image": {
-              "type": [
-                "string",
-                "null"
-              ]
-            },
-            "organizations": {
-              "items": {
-                "type": "string"
-              },
-              "type": "array"
-            },
-            "persons": {
-              "items": {
-                "type": "string"
-              },
-              "type": "array"
-            },
-            "publishedAt": {
-              "type": "string"
-            },
-            "themes": {
-              "items": {
-                "type": "string"
-              },
-              "type": "array"
-            },
-            "title": {
-              "type": "string"
-            },
-            "tone": {
-              "type": [
-                "number",
-                "null"
-              ]
-            },
-            "url": {
-              "type": "string"
-            }
-          },
-          "required": [
-            "title",
-            "url",
-            "domain",
-            "publishedAt",
-            "authors",
-            "tone",
-            "image",
-            "persons",
-            "organizations",
-            "themes"
-          ],
-          "type": "object"
-        },
-        "type": "array"
-      },
-      "attribution": {
-        "type": "string"
-      },
-      "count": {
-        "maximum": 9007199254740991,
-        "minimum": -9007199254740991,
-        "type": "integer"
-      },
-      "hours": {
-        "maximum": 9007199254740991,
-        "minimum": -9007199254740991,
-        "type": "integer"
-      },
-      "lastIngestAt": {
-        "type": [
-          "string",
-          "null"
-        ]
-      },
-      "query": {
-        "type": "string"
-      }
-    },
-    "required": [
-      "query",
-      "hours",
-      "count",
-      "articles",
-      "lastIngestAt",
-      "attribution"
-    ],
-    "type": "object"
-  },
-  {
-    "description": "x402 PaymentRequired (returned with isError when payment is needed)",
-    "properties": {
-      "accepts": {
-        "items": {
-          "type": "object"
-        },
-        "type": "array"
-      },
-      "error": {
-        "type": "string"
-      },
-      "extensions": {
-        "type": "object"
-      },
-      "resource": {
-        "type": "object"
-      },
-      "x402Version": {
-        "type": "integer"
-      }
-    },
-    "required": [
-      "x402Version",
-      "accepts"
-    ],
-    "type": "object"
-  }
-]New value: +[
+  {
+    "additionalProperties": false,
+    "properties": {
+      "articles": {
+        "items": {
+          "additionalProperties": false,
+          "properties": {
+            "authors": {
+              "type": [
+                "string",
+                "null"
+              ]
+            },
+            "domain": {
+              "type": "string"
+            },
+            "image": {
+              "type": [
+                "string",
+                "null"
+              ]
+            },
+            "organizations": {
+              "items": {
+                "type": "string"
+              },
+              "type": "array"
+            },
+            "persons": {
+              "items": {
+                "type": "string"
+              },
+              "type": "array"
+            },
+            "publishedAt": {
+              "type": "string"
+            },
+            "themes": {
+              "items": {
+                "type": "string"
+              },
+              "type": "array"
+            },
+            "title": {
+              "type": "string"
+            },
+            "tone": {
+              "type": [
+                "number",
+                "null"
+              ]
+            },
+            "url": {
+              "type": "string"
+            }
+          },
+          "required": [
+            "title",
+            "url",
+            "domain",
+            "publishedAt",
+            "authors",
+            "tone",
+            "image",
+            "persons",
+            "organizations",
+            "themes"
+          ],
+          "type": "object"
+        },
+        "type": "array"
+      },
+      "attribution": {
+        "type": "string"
+      },
+      "count": {
+        "maximum": 9007199254740991,
+        "minimum": -9007199254740991,
+        "type": "integer"
+      },
+      "hours": {
+        "maximum": 9007199254740991,
+        "minimum": -9007199254740991,
+        "type": "integer"
+      },
+      "lastIngestAt": {
+        "type": [
+          "string",
+          "null"
+        ]
+      },
+      "next": {
+        "additionalProperties": false,
+        "description": "Suggested next paid call in the same family (call it in a loop when the task continues)",
+        "properties": {
+          "method": {
+            "enum": [
+              "GET",
+              "POST"
+            ],
+            "type": "string"
+          },
+          "sample": {
+            "description": "Free fixed sample of the whole family",
+            "type": "string"
+          },
+          "service": {
+            "description": "Service id of the suggested next paid call",
+            "type": "string"
+          },
+          "tool": {
+            "description": "MCP tool name of the same call",
+            "type": "string"
+          },
+          "url": {
+            "description": "Paid route of the next call",
+            "type": "string"
+          },
+          "useWhen": {
+            "description": "When the next call is the right one",
+            "type": "string"
+          }
+        },
+        "required": [
+          "service",
+          "tool",
+          "method",
+          "url",
+          "useWhen",
+          "sample"
+        ],
+        "type": "object"
+      },
+      "query": {
+        "type": "string"
+      }
+    },
+    "required": [
+      "query",
+      "hours",
+      "count",
+      "articles",
+      "lastIngestAt",
+      "attribution"
+    ],
+    "type": "object"
+  },
+  {
+    "description": "x402 PaymentRequired (returned with isError when payment is needed)",
+    "properties": {
+      "accepts": {
+        "items": {
+          "type": "object"
+        },
+        "type": "array"
+      },
+      "error": {
+        "type": "string"
+      },
+      "extensions": {
+        "type": "object"
+      },
+      "resource": {
+        "type": "object"
+      },
+      "x402Version": {
+        "type": "integer"
+      }
+    },
+    "required": [
+      "x402Version",
+      "accepts"
+    ],
+    "type": "object"
+  }
+]

Changedblackwood_pdf_extract1 field changed

changedOutput schema / anyOf

Previous value: -[
-  {
-    "additionalProperties": false,
-    "properties": {
-      "done": {
-        "type": "boolean"
-      },
-      "error": {
-        "additionalProperties": false,
-        "properties": {
-          "message": {
-            "type": "string"
-          },
-          "name": {
-            "type": "string"
-          }
-        },
-        "required": [
-          "name",
-          "message"
-        ],
-        "type": "object"
-      },
-      "jobId": {
-        "type": "string"
-      },
-      "output": {
-        "additionalProperties": false,
-        "properties": {
-          "metadata": {
-            "additionalProperties": false,
-            "properties": {
-              "author": {
-                "type": [
-                  "string",
-                  "null"
-                ]
-              },
-              "creationDate": {
-                "type": [
-                  "string",
-                  "null"
-                ]
-              },
-              "producer": {
-                "type": [
-                  "string",
-                  "null"
-                ]
-              },
-              "subject": {
-                "type": [
-                  "string",
-                  "null"
-                ]
-              },
-              "title": {
-                "type": [
-                  "string",
-                  "null"
-                ]
-              }
-            },
-            "required": [
-              "title",
-              "author",
-              "subject",
-              "producer",
-              "creationDate"
-            ],
-            "type": "object"
-          },
-          "pageCount": {
-            "maximum": 9007199254740991,
-            "minimum": -9007199254740991,
-            "type": "integer"
-          },
-          "pages": {
-            "items": {
-              "additionalProperties": false,
-              "properties": {
-                "chars": {
-                  "maximum": 9007199254740991,
-                  "minimum": -9007199254740991,
-                  "type": "integer"
-                },
-                "page": {
-                  "maximum": 9007199254740991,
-                  "minimum": -9007199254740991,
-                  "type": "integer"
-                },
-                "text": {
-                  "type": "string"
-                }
-              },
-              "required": [
-                "page",
-                "text",
-                "chars"
-              ],
-              "type": "object"
-            },
-            "type": "array"
-          },
-          "pagesWithoutText": {
-            "maximum": 9007199254740991,
-            "minimum": -9007199254740991,
-            "type": "integer"
-          },
-          "processedPages": {
-            "maximum": 9007199254740991,
-            "minimum": -9007199254740991,
-            "type": "integer"
-          },
-          "truncated": {
-            "type": "boolean"
-          },
-          "url": {
-            "type": "string"
-          }
-        },
-        "required": [
-          "url",
-          "pageCount",
-          "processedPages",
-          "pages",
-          "pagesWithoutText",
-          "metadata",
-          "truncated"
-        ],
-        "type": "object"
-      },
-      "pollUrl": {
-        "type": "string"
-      },
-      "status": {
-        "enum": [
-          "queued",
-          "running",
-          "paused",
-          "errored",
-          "terminated",
-          "complete",
-          "waiting",
-          "waitingForPause",
-          "rollingBack",
-          "unknown"
-        ],
-        "type": "string"
-      }
-    },
-    "required": [
-      "jobId",
-      "status",
-      "done",
-      "pollUrl"
-    ],
-    "type": "object"
-  },
-  {
-    "description": "x402 PaymentRequired (returned with isError when payment is needed)",
-    "properties": {
-      "accepts": {
-        "items": {
-          "type": "object"
-        },
-        "type": "array"
-      },
-      "error": {
-        "type": "string"
-      },
-      "extensions": {
-        "type": "object"
-      },
-      "resource": {
-        "type": "object"
-      },
-      "x402Version": {
-        "type": "integer"
-      }
-    },
-    "required": [
-      "x402Version",
-      "accepts"
-    ],
-    "type": "object"
-  }
-]New value: +[
+  {
+    "additionalProperties": false,
+    "properties": {
+      "done": {
+        "type": "boolean"
+      },
+      "error": {
+        "additionalProperties": false,
+        "properties": {
+          "message": {
+            "type": "string"
+          },
+          "name": {
+            "type": "string"
+          }
+        },
+        "required": [
+          "name",
+          "message"
+        ],
+        "type": "object"
+      },
+      "jobId": {
+        "type": "string"
+      },
+      "next": {
+        "additionalProperties": false,
+        "description": "Suggested next paid call in the same family (call it in a loop when the task continues)",
+        "properties": {
+          "method": {
+            "enum": [
+              "GET",
+              "POST"
+            ],
+            "type": "string"
+          },
+          "sample": {
+            "description": "Free fixed sample of the whole family",
+            "type": "string"
+          },
+          "service": {
+            "description": "Service id of the suggested next paid call",
+            "type": "string"
+          },
+          "tool": {
+            "description": "MCP tool name of the same call",
+            "type": "string"
+          },
+          "url": {
+            "description": "Paid route of the next call",
+            "type": "string"
+          },
+          "useWhen": {
+            "description": "When the next call is the right one",
+            "type": "string"
+          }
+        },
+        "required": [
+          "service",
+          "tool",
+          "method",
+          "url",
+          "useWhen",
+          "sample"
+        ],
+        "type": "object"
+      },
+      "output": {
+        "additionalProperties": false,
+        "properties": {
+          "metadata": {
+            "additionalProperties": false,
+            "properties": {
+              "author": {
+                "type": [
+                  "string",
+                  "null"
+                ]
+              },
+              "creationDate": {
+                "type": [
+                  "string",
+                  "null"
+                ]
+              },
+              "producer": {
+                "type": [
+                  "string",
+                  "null"
+                ]
+              },
+              "subject": {
+                "type": [
+                  "string",
+                  "null"
+                ]
+              },
+              "title": {
+                "type": [
+                  "string",
+                  "null"
+                ]
+              }
+            },
+            "required": [
+              "title",
+              "author",
+              "subject",
+              "producer",
+              "creationDate"
+            ],
+            "type": "object"
+          },
+          "pageCount": {
+            "maximum": 9007199254740991,
+            "minimum": -9007199254740991,
+            "type": "integer"
+          },
+          "pages": {
+            "items": {
+              "additionalProperties": false,
+              "properties": {
+                "chars": {
+                  "maximum": 9007199254740991,
+                  "minimum": -9007199254740991,
+                  "type": "integer"
+                },
+                "page": {
+                  "maximum": 9007199254740991,
+                  "minimum": -9007199254740991,
+                  "type": "integer"
+                },
+                "text": {
+                  "type": "string"
+                }
+              },
+              "required": [
+                "page",
+                "text",
+                "chars"
+              ],
+              "type": "object"
+            },
+            "type": "array"
+          },
+          "pagesWithoutText": {
+            "maximum": 9007199254740991,
+            "minimum": -9007199254740991,
+            "type": "integer"
+          },
+          "processedPages": {
+            "maximum": 9007199254740991,
+            "minimum": -9007199254740991,
+            "type": "integer"
+          },
+          "truncated": {
+            "type": "boolean"
+          },
+          "url": {
+            "type": "string"
+          }
+        },
+        "required": [
+          "url",
+          "pageCount",
+          "processedPages",
+          "pages",
+          "pagesWithoutText",
+          "metadata",
+          "truncated"
+        ],
+        "type": "object"
+      },
+      "pollUrl": {
+        "type": "string"
+      },
+      "status": {
+        "enum": [
+          "queued",
+          "running",
+          "paused",
+          "errored",
+          "terminated",
+          "complete",
+          "waiting",
+          "waitingForPause",
+          "rollingBack",
+          "unknown"
+        ],
+        "type": "string"
+      }
+    },
+    "required": [
+      "jobId",
+      "status",
+      "done",
+      "pollUrl"
+    ],
+    "type": "object"
+  },
+  {
+    "description": "x402 PaymentRequired (returned with isError when payment is needed)",
+    "properties": {
+      "accepts": {
+        "items": {
+          "type": "object"
+        },
+        "type": "array"
+      },
+      "error": {
+        "type": "string"
+      },
+      "extensions": {
+        "type": "object"
+      },
+      "resource": {
+        "type": "object"
+      },
+      "x402Version": {
+        "type": "integer"
+      }
+    },
+    "required": [
+      "x402Version",
+      "accepts"
+    ],
+    "type": "object"
+  }
+]

Changedblackwood_qrcode_generate1 field changed

changedOutput schema / anyOf

Previous value: -[
-  {
-    "additionalProperties": false,
-    "properties": {
-      "bytes": {
-        "type": "number"
-      },
-      "dataUrl": {
-        "type": "string"
-      },
-      "ecc": {
-        "type": "string"
-      },
-      "modules": {
-        "type": "number"
-      },
-      "svg": {
-        "type": "string"
-      },
-      "version": {
-        "type": "number"
-      }
-    },
-    "required": [
-      "svg",
-      "dataUrl",
-      "version",
-      "modules",
-      "ecc",
-      "bytes"
-    ],
-    "type": "object"
-  },
-  {
-    "description": "x402 PaymentRequired (returned with isError when payment is needed)",
-    "properties": {
-      "accepts": {
-        "items": {
-          "type": "object"
-        },
-        "type": "array"
-      },
-      "error": {
-        "type": "string"
-      },
-      "extensions": {
-        "type": "object"
-      },
-      "resource": {
-        "type": "object"
-      },
-      "x402Version": {
-        "type": "integer"
-      }
-    },
-    "required": [
-      "x402Version",
-      "accepts"
-    ],
-    "type": "object"
-  }
-]New value: +[
+  {
+    "additionalProperties": false,
+    "properties": {
+      "bytes": {
+        "type": "number"
+      },
+      "dataUrl": {
+        "type": "string"
+      },
+      "ecc": {
+        "type": "string"
+      },
+      "modules": {
+        "type": "number"
+      },
+      "next": {
+        "additionalProperties": false,
+        "description": "Suggested next paid call in the same family (call it in a loop when the task continues)",
+        "properties": {
+          "method": {
+            "enum": [
+              "GET",
+              "POST"
+            ],
+            "type": "string"
+          },
+          "sample": {
+            "description": "Free fixed sample of the whole family",
+            "type": "string"
+          },
+          "service": {
+            "description": "Service id of the suggested next paid call",
+            "type": "string"
+          },
+          "tool": {
+            "description": "MCP tool name of the same call",
+            "type": "string"
+          },
+          "url": {
+            "description": "Paid route of the next call",
+            "type": "string"
+          },
+          "useWhen": {
+            "description": "When the next call is the right one",
+            "type": "string"
+          }
+        },
+        "required": [
+          "service",
+          "tool",
+          "method",
+          "url",
+          "useWhen",
+          "sample"
+        ],
+        "type": "object"
+      },
+      "svg": {
+        "type": "string"
+      },
+      "version": {
+        "type": "number"
+      }
+    },
+    "required": [
+      "svg",
+      "dataUrl",
+      "version",
+      "modules",
+      "ecc",
+      "bytes"
+    ],
+    "type": "object"
+  },
+  {
+    "description": "x402 PaymentRequired (returned with isError when payment is needed)",
+    "properties": {
+      "accepts": {
+        "items": {
+          "type": "object"
+        },
+        "type": "array"
+      },
+      "error": {
+        "type": "string"
+      },
+      "extensions": {
+        "type": "object"
+      },
+      "resource": {
+        "type": "object"
+      },
+      "x402Version": {
+        "type": "integer"
+      }
+    },
+    "required": [
+      "x402Version",
+      "accepts"
+    ],
+    "type": "object"
+  }
+]

Changedblackwood_random_generate1 field changed

changedOutput schema / anyOf

Previous value: -[
-  {
-    "additionalProperties": false,
-    "properties": {
-      "generatedAt": {
-        "type": "string"
-      },
-      "kind": {
-        "type": "string"
-      },
-      "source": {
-        "type": "string"
-      },
-      "sum": {
-        "type": [
-          "number",
-          "null"
-        ]
-      },
-      "values": {
-        "items": {
-          "type": [
-            "number",
-            "string"
-          ]
-        },
-        "type": "array"
-      }
-    },
-    "required": [
-      "kind",
-      "values",
-      "sum",
-      "generatedAt",
-      "source"
-    ],
-    "type": "object"
-  },
-  {
-    "description": "x402 PaymentRequired (returned with isError when payment is needed)",
-    "properties": {
-      "accepts": {
-        "items": {
-          "type": "object"
-        },
-        "type": "array"
-      },
-      "error": {
-        "type": "string"
-      },
-      "extensions": {
-        "type": "object"
-      },
-      "resource": {
-        "type": "object"
-      },
-      "x402Version": {
-        "type": "integer"
-      }
-    },
-    "required": [
-      "x402Version",
-      "accepts"
-    ],
-    "type": "object"
-  }
-]New value: +[
+  {
+    "additionalProperties": false,
+    "properties": {
+      "generatedAt": {
+        "type": "string"
+      },
+      "kind": {
+        "type": "string"
+      },
+      "next": {
+        "additionalProperties": false,
+        "description": "Suggested next paid call in the same family (call it in a loop when the task continues)",
+        "properties": {
+          "method": {
+            "enum": [
+              "GET",
+              "POST"
+            ],
+            "type": "string"
+          },
+          "sample": {
+            "description": "Free fixed sample of the whole family",
+            "type": "string"
+          },
+          "service": {
+            "description": "Service id of the suggested next paid call",
+            "type": "string"
+          },
+          "tool": {
+            "description": "MCP tool name of the same call",
+            "type": "string"
+          },
+          "url": {
+            "description": "Paid route of the next call",
+            "type": "string"
+          },
+          "useWhen": {
+            "description": "When the next call is the right one",
+            "type": "string"
+          }
+        },
+        "required": [
+          "service",
+          "tool",
+          "method",
+          "url",
+          "useWhen",
+          "sample"
+        ],
+        "type": "object"
+      },
+      "source": {
+        "type": "string"
+      },
+      "sum": {
+        "type": [
+          "number",
+          "null"
+        ]
+      },
+      "values": {
+        "items": {
+          "type": [
+            "number",
+            "string"
+          ]
+        },
+        "type": "array"
+      }
+    },
+    "required": [
+      "kind",
+      "values",
+      "sum",
+      "generatedAt",
+      "source"
+    ],
+    "type": "object"
+  },
+  {
+    "description": "x402 PaymentRequired (returned with isError when payment is needed)",
+    "properties": {
+      "accepts": {
+        "items": {
+          "type": "object"
+        },
+        "type": "array"
+      },
+      "error": {
+        "type": "string"
+      },
+      "extensions": {
+        "type": "object"
+      },
+      "resource": {
+        "type": "object"
+      },
+      "x402Version": {
+        "type": "integer"
+      }
+    },
+    "required": [
+      "x402Version",
+      "accepts"
+    ],
+    "type": "object"
+  }
+]

Changedblackwood_sec_facts1 field changed

changedOutput schema / anyOf

Previous value: -[
-  {
-    "additionalProperties": false,
-    "properties": {
-      "balanceSheets": {
-        "items": {
-          "additionalProperties": false,
-          "properties": {
-            "asOf": {
-              "type": "string"
-            },
-            "assets": {
-              "type": [
-                "number",
-                "null"
-              ]
-            },
-            "calendarYear": {
-              "maximum": 9007199254740991,
-              "minimum": -9007199254740991,
-              "type": "integer"
-            },
-            "cash": {
-              "type": [
-                "number",
-                "null"
-              ]
-            },
-            "equity": {
-              "type": [
-                "number",
-                "null"
-              ]
-            },
-            "liabilities": {
-              "type": [
-                "number",
-                "null"
-              ]
-            }
-          },
-          "required": [
-            "calendarYear",
-            "asOf",
-            "assets",
-            "liabilities",
-            "equity",
-            "cash"
-          ],
-          "type": "object"
-        },
-        "type": "array"
-      },
-      "cik": {
-        "maximum": 9007199254740991,
-        "minimum": -9007199254740991,
-        "type": "integer"
-      },
-      "currency": {
-        "const": "USD",
-        "type": "string"
-      },
-      "dataUpdatedAt": {
-        "type": [
-          "string",
-          "null"
-        ]
-      },
-      "exchange": {
-        "type": [
-          "string",
-          "null"
-        ]
-      },
-      "fiscalYears": {
-        "items": {
-          "additionalProperties": false,
-          "properties": {
-            "accn": {
-              "type": [
-                "string",
-                "null"
-              ]
-            },
-            "calendarYear": {
-              "maximum": 9007199254740991,
-              "minimum": -9007199254740991,
-              "type": "integer"
-            },
-            "end": {
-              "type": "string"
-            },
-            "epsDiluted": {
-              "type": [
-                "number",
-                "null"
-              ]
-            },
-            "netIncome": {
-              "type": [
-                "number",
-                "null"
-              ]
-            },
-            "operatingCashFlow": {
-              "type": [
-                "number",
-                "null"
-              ]
-            },
-            "operatingIncome": {
-              "type": [
-                "number",
-                "null"
-              ]
-            },
-            "revenue": {
-              "type": [
-                "number",
-                "null"
-              ]
-            },
-            "start": {
-              "type": [
-                "string",
-                "null"
-              ]
-            }
-          },
-          "required": [
-            "calendarYear",
-            "start",
-            "end",
-            "revenue",
-            "netIncome",
-            "operatingIncome",
-            "epsDiluted",
-            "operatingCashFlow",
-            "accn"
-          ],
-          "type": "object"
-        },
-        "type": "array"
-      },
-      "name": {
-        "type": "string"
-      },
-      "source": {
-        "type": "string"
-      },
-      "ticker": {
-        "type": "string"
-      }
-    },
-    "required": [
-      "ticker",
-      "cik",
-      "name",
-      "exchange",
-      "currency",
-      "fiscalYears",
-      "balanceSheets",
-      "source",
-      "dataUpdatedAt"
-    ],
-    "type": "object"
-  },
-  {
-    "description": "x402 PaymentRequired (returned with isError when payment is needed)",
-    "properties": {
-      "accepts": {
-        "items": {
-          "type": "object"
-        },
-        "type": "array"
-      },
-      "error": {
-        "type": "string"
-      },
-      "extensions": {
-        "type": "object"
-      },
-      "resource": {
-        "type": "object"
-      },
-      "x402Version": {
-        "type": "integer"
-      }
-    },
-    "required": [
-      "x402Version",
-      "accepts"
-    ],
-    "type": "object"
-  }
-]New value: +[
+  {
+    "additionalProperties": false,
+    "properties": {
+      "balanceSheets": {
+        "items": {
+          "additionalProperties": false,
+          "properties": {
+            "asOf": {
+              "type": "string"
+            },
+            "assets": {
+              "type": [
+                "number",
+                "null"
+              ]
+            },
+            "calendarYear": {
+              "maximum": 9007199254740991,
+              "minimum": -9007199254740991,
+              "type": "integer"
+            },
+            "cash": {
+              "type": [
+                "number",
+                "null"
+              ]
+            },
+            "equity": {
+              "type": [
+                "number",
+                "null"
+              ]
+            },
+            "liabilities": {
+              "type": [
+                "number",
+                "null"
+              ]
+            }
+          },
+          "required": [
+            "calendarYear",
+            "asOf",
+            "assets",
+            "liabilities",
+            "equity",
+            "cash"
+          ],
+          "type": "object"
+        },
+        "type": "array"
+      },
+      "cik": {
+        "maximum": 9007199254740991,
+        "minimum": -9007199254740991,
+        "type": "integer"
+      },
+      "currency": {
+        "const": "USD",
+        "type": "string"
+      },
+      "dataUpdatedAt": {
+        "type": [
+          "string",
+          "null"
+        ]
+      },
+      "exchange": {
+        "type": [
+          "string",
+          "null"
+        ]
+      },
+      "fiscalYears": {
+        "items": {
+          "additionalProperties": false,
+          "properties": {
+            "accn": {
+              "type": [
+                "string",
+                "null"
+              ]
+            },
+            "calendarYear": {
+              "maximum": 9007199254740991,
+              "minimum": -9007199254740991,
+              "type": "integer"
+            },
+            "end": {
+              "type": "string"
+            },
+            "epsDiluted": {
+              "type": [
+                "number",
+                "null"
+              ]
+            },
+            "netIncome": {
+              "type": [
+                "number",
+                "null"
+              ]
+            },
+            "operatingCashFlow": {
+              "type": [
+                "number",
+                "null"
+              ]
+            },
+            "operatingIncome": {
+              "type": [
+                "number",
+                "null"
+              ]
+            },
+            "revenue": {
+              "type": [
+                "number",
+                "null"
+              ]
+            },
+            "start": {
+              "type": [
+                "string",
+                "null"
+              ]
+            }
+          },
+          "required": [
+            "calendarYear",
+            "start",
+            "end",
+            "revenue",
+            "netIncome",
+            "operatingIncome",
+            "epsDiluted",
+            "operatingCashFlow",
+            "accn"
+          ],
+          "type": "object"
+        },
+        "type": "array"
+      },
+      "name": {
+        "type": "string"
+      },
+      "next": {
+        "additionalProperties": false,
+        "description": "Suggested next paid call in the same family (call it in a loop when the task continues)",
+        "properties": {
+          "method": {
+            "enum": [
+              "GET",
+              "POST"
+            ],
+            "type": "string"
+          },
+          "sample": {
+            "description": "Free fixed sample of the whole family",
+            "type": "string"
+          },
+          "service": {
+            "description": "Service id of the suggested next paid call",
+            "type": "string"
+          },
+          "tool": {
+            "description": "MCP tool name of the same call",
+            "type": "string"
+          },
+          "url": {
+            "description": "Paid route of the next call",
+            "type": "string"
+          },
+          "useWhen": {
+            "description": "When the next call is the right one",
+            "type": "string"
+          }
+        },
+        "required": [
+          "service",
+          "tool",
+          "method",
+          "url",
+          "useWhen",
+          "sample"
+        ],
+        "type": "object"
+      },
+      "source": {
+        "type": "string"
+      },
+      "ticker": {
+        "type": "string"
+      }
+    },
+    "required": [
+      "ticker",
+      "cik",
+      "name",
+      "exchange",
+      "currency",
+      "fiscalYears",
+      "balanceSheets",
+      "source",
+      "dataUpdatedAt"
+    ],
+    "type": "object"
+  },
+  {
+    "description": "x402 PaymentRequired (returned with isError when payment is needed)",
+    "properties": {
+      "accepts": {
+        "items": {
+          "type": "object"
+        },
+        "type": "array"
+      },
+      "error": {
+        "type": "string"
+      },
+      "extensions": {
+        "type": "object"
+      },
+      "resource": {
+        "type": "object"
+      },
+      "x402Version": {
+        "type": "integer"
+      }
+    },
+    "required": [
+      "x402Version",
+      "accepts"
+    ],
+    "type": "object"
+  }
+]

Changedblackwood_speech_synthesize1 field changed

changedOutput schema / anyOf

Previous value: -[
-  {
-    "additionalProperties": false,
-    "properties": {
-      "audioBase64": {
-        "type": "string"
-      },
-      "bytes": {
-        "type": "number"
-      },
-      "chars": {
-        "type": "number"
-      },
-      "lang": {
-        "type": "string"
-      },
-      "mimeType": {
-        "enum": [
-          "audio/wav",
-          "audio/mpeg"
-        ],
-        "type": "string"
-      },
-      "model": {
-        "type": "string"
-      }
-    },
-    "required": [
-      "mimeType",
-      "audioBase64",
-      "bytes",
-      "lang",
-      "chars",
-      "model"
-    ],
-    "type": "object"
-  },
-  {
-    "description": "x402 PaymentRequired (returned with isError when payment is needed)",
-    "properties": {
-      "accepts": {
-        "items": {
-          "type": "object"
-        },
-        "type": "array"
-      },
-      "error": {
-        "type": "string"
-      },
-      "extensions": {
-        "type": "object"
-      },
-      "resource": {
-        "type": "object"
-      },
-      "x402Version": {
-        "type": "integer"
-      }
-    },
-    "required": [
-      "x402Version",
-      "accepts"
-    ],
-    "type": "object"
-  }
-]New value: +[
+  {
+    "additionalProperties": false,
+    "properties": {
+      "audioBase64": {
+        "type": "string"
+      },
+      "bytes": {
+        "type": "number"
+      },
+      "chars": {
+        "type": "number"
+      },
+      "lang": {
+        "type": "string"
+      },
+      "mimeType": {
+        "enum": [
+          "audio/wav",
+          "audio/mpeg"
+        ],
+        "type": "string"
+      },
+      "model": {
+        "type": "string"
+      },
+      "next": {
+        "additionalProperties": false,
+        "description": "Suggested next paid call in the same family (call it in a loop when the task continues)",
+        "properties": {
+          "method": {
+            "enum": [
+              "GET",
+              "POST"
+            ],
+            "type": "string"
+          },
+          "sample": {
+            "description": "Free fixed sample of the whole family",
+            "type": "string"
+          },
+          "service": {
+            "description": "Service id of the suggested next paid call",
+            "type": "string"
+          },
+          "tool": {
+            "description": "MCP tool name of the same call",
+            "type": "string"
+          },
+          "url": {
+            "description": "Paid route of the next call",
+            "type": "string"
+          },
+          "useWhen": {
+            "description": "When the next call is the right one",
+            "type": "string"
+          }
+        },
+        "required": [
+          "service",
+          "tool",
+          "method",
+          "url",
+          "useWhen",
+          "sample"
+        ],
+        "type": "object"
+      }
+    },
+    "required": [
+      "mimeType",
+      "audioBase64",
+      "bytes",
+      "lang",
+      "chars",
+      "model"
+    ],
+    "type": "object"
+  },
+  {
+    "description": "x402 PaymentRequired (returned with isError when payment is needed)",
+    "properties": {
+      "accepts": {
+        "items": {
+          "type": "object"
+        },
+        "type": "array"
+      },
+      "error": {
+        "type": "string"
+      },
+      "extensions": {
+        "type": "object"
+      },
+      "resource": {
+        "type": "object"
+      },
+      "x402Version": {
+        "type": "integer"
+      }
+    },
+    "required": [
+      "x402Version",
+      "accepts"
+    ],
+    "type": "object"
+  }
+]

Changedblackwood_text_sentiment1 field changed

changedOutput schema / anyOf

Previous value: -[
-  {
-    "additionalProperties": false,
-    "properties": {
-      "model": {
-        "type": "string"
-      },
-      "results": {
-        "items": {
-          "additionalProperties": false,
-          "properties": {
-            "label": {
-              "enum": [
-                "positive",
-                "negative"
-              ],
-              "type": "string"
-            },
-            "negative": {
-              "type": "number"
-            },
-            "positive": {
-              "type": "number"
-            },
-            "score": {
-              "type": "number"
-            },
-            "text": {
-              "type": "string"
-            }
-          },
-          "required": [
-            "text",
-            "label",
-            "score",
-            "positive",
-            "negative"
-          ],
-          "type": "object"
-        },
-        "type": "array"
-      }
-    },
-    "required": [
-      "results",
-      "model"
-    ],
-    "type": "object"
-  },
-  {
-    "description": "x402 PaymentRequired (returned with isError when payment is needed)",
-    "properties": {
-      "accepts": {
-        "items": {
-          "type": "object"
-        },
-        "type": "array"
-      },
-      "error": {
-        "type": "string"
-      },
-      "extensions": {
-        "type": "object"
-      },
-      "resource": {
-        "type": "object"
-      },
-      "x402Version": {
-        "type": "integer"
-      }
-    },
-    "required": [
-      "x402Version",
-      "accepts"
-    ],
-    "type": "object"
-  }
-]New value: +[
+  {
+    "additionalProperties": false,
+    "properties": {
+      "model": {
+        "type": "string"
+      },
+      "next": {
+        "additionalProperties": false,
+        "description": "Suggested next paid call in the same family (call it in a loop when the task continues)",
+        "properties": {
+          "method": {
+            "enum": [
+              "GET",
+              "POST"
+            ],
+            "type": "string"
+          },
+          "sample": {
+            "description": "Free fixed sample of the whole family",
+            "type": "string"
+          },
+          "service": {
+            "description": "Service id of the suggested next paid call",
+            "type": "string"
+          },
+          "tool": {
+            "description": "MCP tool name of the same call",
+            "type": "string"
+          },
+          "url": {
+            "description": "Paid route of the next call",
+            "type": "string"
+          },
+          "useWhen": {
+            "description": "When the next call is the right one",
+            "type": "string"
+          }
+        },
+        "required": [
+          "service",
+          "tool",
+          "method",
+          "url",
+          "useWhen",
+          "sample"
+        ],
+        "type": "object"
+      },
+      "results": {
+        "items": {
+          "additionalProperties": false,
+          "properties": {
+            "label": {
+              "enum": [
+                "positive",
+                "negative"
+              ],
+              "type": "string"
+            },
+            "negative": {
+              "type": "number"
+            },
+            "positive": {
+              "type": "number"
+            },
+            "score": {
+              "type": "number"
+            },
+            "text": {
+              "type": "string"
+            }
+          },
+          "required": [
+            "text",
+            "label",
+            "score",
+            "positive",
+            "negative"
+          ],
+          "type": "object"
+        },
+        "type": "array"
+      }
+    },
+    "required": [
+      "results",
+      "model"
+    ],
+    "type": "object"
+  },
+  {
+    "description": "x402 PaymentRequired (returned with isError when payment is needed)",
+    "properties": {
+      "accepts": {
+        "items": {
+          "type": "object"
+        },
+        "type": "array"
+      },
+      "error": {
+        "type": "string"
+      },
+      "extensions": {
+        "type": "object"
+      },
+      "resource": {
+        "type": "object"
+      },
+      "x402Version": {
+        "type": "integer"
+      }
+    },
+    "required": [
+      "x402Version",
+      "accepts"
+    ],
+    "type": "object"
+  }
+]

Changedblackwood_text_summarize1 field changed

changedOutput schema / anyOf

Previous value: -[
-  {
-    "additionalProperties": false,
-    "properties": {
-      "bullets": {
-        "items": {
-          "type": "string"
-        },
-        "type": "array"
-      },
-      "inputChars": {
-        "type": "number"
-      },
-      "model": {
-        "type": "string"
-      },
-      "summary": {
-        "type": "string"
-      },
-      "usage": {
-        "additionalProperties": false,
-        "properties": {
-          "completionTokens": {
-            "type": [
-              "number",
-              "null"
-            ]
-          },
-          "promptTokens": {
-            "type": [
-              "number",
-              "null"
-            ]
-          }
-        },
-        "required": [
-          "promptTokens",
-          "completionTokens"
-        ],
-        "type": "object"
-      }
-    },
-    "required": [
-      "summary",
-      "bullets",
-      "model",
-      "inputChars",
-      "usage"
-    ],
-    "type": "object"
-  },
-  {
-    "description": "x402 PaymentRequired (returned with isError when payment is needed)",
-    "properties": {
-      "accepts": {
-        "items": {
-          "type": "object"
-        },
-        "type": "array"
-      },
-      "error": {
-        "type": "string"
-      },
-      "extensions": {
-        "type": "object"
-      },
-      "resource": {
-        "type": "object"
-      },
-      "x402Version": {
-        "type": "integer"
-      }
-    },
-    "required": [
-      "x402Version",
-      "accepts"
-    ],
-    "type": "object"
-  }
-]New value: +[
+  {
+    "additionalProperties": false,
+    "properties": {
+      "bullets": {
+        "items": {
+          "type": "string"
+        },
+        "type": "array"
+      },
+      "inputChars": {
+        "type": "number"
+      },
+      "model": {
+        "type": "string"
+      },
+      "next": {
+        "additionalProperties": false,
+        "description": "Suggested next paid call in the same family (call it in a loop when the task continues)",
+        "properties": {
+          "method": {
+            "enum": [
+              "GET",
+              "POST"
+            ],
+            "type": "string"
+          },
+          "sample": {
+            "description": "Free fixed sample of the whole family",
+            "type": "string"
+          },
+          "service": {
+            "description": "Service id of the suggested next paid call",
+            "type": "string"
+          },
+          "tool": {
+            "description": "MCP tool name of the same call",
+            "type": "string"
+          },
+          "url": {
+            "description": "Paid route of the next call",
+            "type": "string"
+          },
+          "useWhen": {
+            "description": "When the next call is the right one",
+            "type": "string"
+          }
+        },
+        "required": [
+          "service",
+          "tool",
+          "method",
+          "url",
+          "useWhen",
+          "sample"
+        ],
+        "type": "object"
+      },
+      "summary": {
+        "type": "string"
+      },
+      "usage": {
+        "additionalProperties": false,
+        "properties": {
+          "completionTokens": {
+            "type": [
+              "number",
+              "null"
+            ]
+          },
+          "promptTokens": {
+            "type": [
+              "number",
+              "null"
+            ]
+          }
+        },
+        "required": [
+          "promptTokens",
+          "completionTokens"
+        ],
+        "type": "object"
+      }
+    },
+    "required": [
+      "summary",
+      "bullets",
+      "model",
+      "inputChars",
+      "usage"
+    ],
+    "type": "object"
+  },
+  {
+    "description": "x402 PaymentRequired (returned with isError when payment is needed)",
+    "properties": {
+      "accepts": {
+        "items": {
+          "type": "object"
+        },
+        "type": "array"
+      },
+      "error": {
+        "type": "string"
+      },
+      "extensions": {
+        "type": "object"
+      },
+      "resource": {
+        "type": "object"
+      },
+      "x402Version": {
+        "type": "integer"
+      }
+    },
+    "required": [
+      "x402Version",
+      "accepts"
+    ],
+    "type": "object"
+  }
+]

Changedblackwood_text_translate1 field changed

changedOutput schema / anyOf

Previous value: -[
-  {
-    "additionalProperties": false,
-    "properties": {
-      "from": {
-        "type": "string"
-      },
-      "model": {
-        "type": "string"
-      },
-      "to": {
-        "type": "string"
-      },
-      "translatedText": {
-        "type": "string"
-      }
-    },
-    "required": [
-      "translatedText",
-      "from",
-      "to",
-      "model"
-    ],
-    "type": "object"
-  },
-  {
-    "description": "x402 PaymentRequired (returned with isError when payment is needed)",
-    "properties": {
-      "accepts": {
-        "items": {
-          "type": "object"
-        },
-        "type": "array"
-      },
-      "error": {
-        "type": "string"
-      },
-      "extensions": {
-        "type": "object"
-      },
-      "resource": {
-        "type": "object"
-      },
-      "x402Version": {
-        "type": "integer"
-      }
-    },
-    "required": [
-      "x402Version",
-      "accepts"
-    ],
-    "type": "object"
-  }
-]New value: +[
+  {
+    "additionalProperties": false,
+    "properties": {
+      "from": {
+        "type": "string"
+      },
+      "model": {
+        "type": "string"
+      },
+      "next": {
+        "additionalProperties": false,
+        "description": "Suggested next paid call in the same family (call it in a loop when the task continues)",
+        "properties": {
+          "method": {
+            "enum": [
+              "GET",
+              "POST"
+            ],
+            "type": "string"
+          },
+          "sample": {
+            "description": "Free fixed sample of the whole family",
+            "type": "string"
+          },
+          "service": {
+            "description": "Service id of the suggested next paid call",
+            "type": "string"
+          },
+          "tool": {
+            "description": "MCP tool name of the same call",
+            "type": "string"
+          },
+          "url": {
+            "description": "Paid route of the next call",
+            "type": "string"
+          },
+          "useWhen": {
+            "description": "When the next call is the right one",
+            "type": "string"
+          }
+        },
+        "required": [
+          "service",
+          "tool",
+          "method",
+          "url",
+          "useWhen",
+          "sample"
+        ],
+        "type": "object"
+      },
+      "to": {
+        "type": "string"
+      },
+      "translatedText": {
+        "type": "string"
+      }
+    },
+    "required": [
+      "translatedText",
+      "from",
+      "to",
+      "model"
+    ],
+    "type": "object"
+  },
+  {
+    "description": "x402 PaymentRequired (returned with isError when payment is needed)",
+    "properties": {
+      "accepts": {
+        "items": {
+          "type": "object"
+        },
+        "type": "array"
+      },
+      "error": {
+        "type": "string"
+      },
+      "extensions": {
+        "type": "object"
+      },
+      "resource": {
+        "type": "object"
+      },
+      "x402Version": {
+        "type": "integer"
+      }
+    },
+    "required": [
+      "x402Version",
+      "accepts"
+    ],
+    "type": "object"
+  }
+]

Changedblackwood_timezone_convert1 field changed

changedOutput schema / anyOf

Previous value: -[
-  {
-    "additionalProperties": false,
-    "properties": {
-      "epochMs": {
-        "type": "number"
-      },
-      "from": {
-        "additionalProperties": false,
-        "properties": {
-          "abbreviation": {
-            "type": "string"
-          },
-          "dst": {
-            "type": "boolean"
-          },
-          "localTime": {
-            "type": "string"
-          },
-          "offset": {
-            "type": "string"
-          },
-          "offsetMinutes": {
-            "type": "number"
-          },
-          "zone": {
-            "type": "string"
-          }
-        },
-        "required": [
-          "zone",
-          "localTime",
-          "offset",
-          "offsetMinutes",
-          "abbreviation",
-          "dst"
-        ],
-        "type": "object"
-      },
-      "instant": {
-        "type": "string"
-      },
-      "source": {
-        "type": "string"
-      },
-      "to": {
-        "items": {
-          "additionalProperties": false,
-          "properties": {
-            "abbreviation": {
-              "type": "string"
-            },
-            "dst": {
-              "type": "boolean"
-            },
-            "localTime": {
-              "type": "string"
-            },
-            "offset": {
-              "type": "string"
-            },
-            "offsetMinutes": {
-              "type": "number"
-            },
-            "zone": {
-              "type": "string"
-            }
-          },
-          "required": [
-            "zone",
-            "localTime",
-            "offset",
-            "offsetMinutes",
-            "abbreviation",
-            "dst"
-          ],
-          "type": "object"
-        },
-        "type": "array"
-      }
-    },
-    "required": [
-      "instant",
-      "epochMs",
-      "from",
-      "to",
-      "source"
-    ],
-    "type": "object"
-  },
-  {
-    "description": "x402 PaymentRequired (returned with isError when payment is needed)",
-    "properties": {
-      "accepts": {
-        "items": {
-          "type": "object"
-        },
-        "type": "array"
-      },
-      "error": {
-        "type": "string"
-      },
-      "extensions": {
-        "type": "object"
-      },
-      "resource": {
-        "type": "object"
-      },
-      "x402Version": {
-        "type": "integer"
-      }
-    },
-    "required": [
-      "x402Version",
-      "accepts"
-    ],
-    "type": "object"
-  }
-]New value: +[
+  {
+    "additionalProperties": false,
+    "properties": {
+      "epochMs": {
+        "type": "number"
+      },
+      "from": {
+        "additionalProperties": false,
+        "properties": {
+          "abbreviation": {
+            "type": "string"
+          },
+          "dst": {
+            "type": "boolean"
+          },
+          "localTime": {
+            "type": "string"
+          },
+          "offset": {
+            "type": "string"
+          },
+          "offsetMinutes": {
+            "type": "number"
+          },
+          "zone": {
+            "type": "string"
+          }
+        },
+        "required": [
+          "zone",
+          "localTime",
+          "offset",
+          "offsetMinutes",
+          "abbreviation",
+          "dst"
+        ],
+        "type": "object"
+      },
+      "instant": {
+        "type": "string"
+      },
+      "next": {
+        "additionalProperties": false,
+        "description": "Suggested next paid call in the same family (call it in a loop when the task continues)",
+        "properties": {
+          "method": {
+            "enum": [
+              "GET",
+              "POST"
+            ],
+            "type": "string"
+          },
+          "sample": {
+            "description": "Free fixed sample of the whole family",
+            "type": "string"
+          },
+          "service": {
+            "description": "Service id of the suggested next paid call",
+            "type": "string"
+          },
+          "tool": {
+            "description": "MCP tool name of the same call",
+            "type": "string"
+          },
+          "url": {
+            "description": "Paid route of the next call",
+            "type": "string"
+          },
+          "useWhen": {
+            "description": "When the next call is the right one",
+            "type": "string"
+          }
+        },
+        "required": [
+          "service",
+          "tool",
+          "method",
+          "url",
+          "useWhen",
+          "sample"
+        ],
+        "type": "object"
+      },
+      "source": {
+        "type": "string"
+      },
+      "to": {
+        "items": {
+          "additionalProperties": false,
+          "properties": {
+            "abbreviation": {
+              "type": "string"
+            },
+            "dst": {
+              "type": "boolean"
+            },
+            "localTime": {
+              "type": "string"
+            },
+            "offset": {
+              "type": "string"
+            },
+            "offsetMinutes": {
+              "type": "number"
+            },
+            "zone": {
+              "type": "string"
+            }
+          },
+          "required": [
+            "zone",
+            "localTime",
+            "offset",
+            "offsetMinutes",
+            "abbreviation",
+            "dst"
+          ],
+          "type": "object"
+        },
+        "type": "array"
+      }
+    },
+    "required": [
+      "instant",
+      "epochMs",
+      "from",
+      "to",
+      "source"
+    ],
+    "type": "object"
+  },
+  {
+    "description": "x402 PaymentRequired (returned with isError when payment is needed)",
+    "properties": {
+      "accepts": {
+        "items": {
+          "type": "object"
+        },
+        "type": "array"
+      },
+      "error": {
+        "type": "string"
+      },
+      "extensions": {
+        "type": "object"
+      },
+      "resource": {
+        "type": "object"
+      },
+      "x402Version": {
+        "type": "integer"
+      }
+    },
+    "required": [
+      "x402Version",
+      "accepts"
+    ],
+    "type": "object"
+  }
+]

Changedblackwood_token_price1 field changed

changedOutput schema / anyOf

Previous value: -[
-  {
-    "additionalProperties": false,
-    "properties": {
-      "blockNumber": {
-        "maximum": 9007199254740991,
-        "minimum": -9007199254740991,
-        "type": "integer"
-      },
-      "decimals": {
-        "maximum": 9007199254740991,
-        "minimum": -9007199254740991,
-        "type": "integer"
-      },
-      "depthUsd": {
-        "type": [
-          "number",
-          "null"
-        ]
-      },
-      "feeTier": {
-        "anyOf": [
-          {
-            "maximum": 9007199254740991,
-            "minimum": -9007199254740991,
-            "type": "integer"
-          },
-          {
-            "type": "null"
-          }
-        ]
-      },
-      "pool": {
-        "type": [
-          "string",
-          "null"
-        ]
-      },
-      "priceUsd": {
-        "type": "number"
-      },
-      "quote": {
-        "enum": [
-          "USDC",
-          "WETH"
-        ],
-        "type": "string"
-      },
-      "source": {
-        "type": "string"
-      },
-      "symbol": {
-        "type": [
-          "string",
-          "null"
-        ]
-      },
-      "token": {
-        "type": "string"
-      }
-    },
-    "required": [
-      "token",
-      "symbol",
-      "decimals",
-      "priceUsd",
-      "quote",
-      "pool",
-      "feeTier",
-      "depthUsd",
-      "blockNumber",
-      "source"
-    ],
-    "type": "object"
-  },
-  {
-    "description": "x402 PaymentRequired (returned with isError when payment is needed)",
-    "properties": {
-      "accepts": {
-        "items": {
-          "type": "object"
-        },
-        "type": "array"
-      },
-      "error": {
-        "type": "string"
-      },
-      "extensions": {
-        "type": "object"
-      },
-      "resource": {
-        "type": "object"
-      },
-      "x402Version": {
-        "type": "integer"
-      }
-    },
-    "required": [
-      "x402Version",
-      "accepts"
-    ],
-    "type": "object"
-  }
-]New value: +[
+  {
+    "additionalProperties": false,
+    "properties": {
+      "blockNumber": {
+        "maximum": 9007199254740991,
+        "minimum": -9007199254740991,
+        "type": "integer"
+      },
+      "decimals": {
+        "maximum": 9007199254740991,
+        "minimum": -9007199254740991,
+        "type": "integer"
+      },
+      "depthUsd": {
+        "type": [
+          "number",
+          "null"
+        ]
+      },
+      "feeTier": {
+        "anyOf": [
+          {
+            "maximum": 9007199254740991,
+            "minimum": -9007199254740991,
+            "type": "integer"
+          },
+          {
+            "type": "null"
+          }
+        ]
+      },
+      "next": {
+        "additionalProperties": false,
+        "description": "Suggested next paid call in the same family (call it in a loop when the task continues)",
+        "properties": {
+          "method": {
+            "enum": [
+              "GET",
+              "POST"
+            ],
+            "type": "string"
+          },
+          "sample": {
+            "description": "Free fixed sample of the whole family",
+            "type": "string"
+          },
+          "service": {
+            "description": "Service id of the suggested next paid call",
+            "type": "string"
+          },
+          "tool": {
+            "description": "MCP tool name of the same call",
+            "type": "string"
+          },
+          "url": {
+            "description": "Paid route of the next call",
+            "type": "string"
+          },
+          "useWhen": {
+            "description": "When the next call is the right one",
+            "type": "string"
+          }
+        },
+        "required": [
+          "service",
+          "tool",
+          "method",
+          "url",
+          "useWhen",
+          "sample"
+        ],
+        "type": "object"
+      },
+      "pool": {
+        "type": [
+          "string",
+          "null"
+        ]
+      },
+      "priceUsd": {
+        "type": "number"
+      },
+      "quote": {
+        "enum": [
+          "USDC",
+          "WETH"
+        ],
+        "type": "string"
+      },
+      "source": {
+        "type": "string"
+      },
+      "symbol": {
+        "type": [
+          "string",
+          "null"
+        ]
+      },
+      "token": {
+        "type": "string"
+      }
+    },
+    "required": [
+      "token",
+      "symbol",
+      "decimals",
+      "priceUsd",
+      "quote",
+      "pool",
+      "feeTier",
+      "depthUsd",
+      "blockNumber",
+      "source"
+    ],
+    "type": "object"
+  },
+  {
+    "description": "x402 PaymentRequired (returned with isError when payment is needed)",
+    "properties": {
+      "accepts": {
+        "items": {
+          "type": "object"
+        },
+        "type": "array"
+      },
+      "error": {
+        "type": "string"
+      },
+      "extensions": {
+        "type": "object"
+      },
+      "resource": {
+        "type": "object"
+      },
+      "x402Version": {
+        "type": "integer"
+      }
+    },
+    "required": [
+      "x402Version",
+      "accepts"
+    ],
+    "type": "object"
+  }
+]

Changedblackwood_wallet_balances1 field changed

changedOutput schema / anyOf

Previous value: -[
-  {
-    "additionalProperties": false,
-    "properties": {
-      "address": {
-        "type": "string"
-      },
-      "blockNumber": {
-        "maximum": 9007199254740991,
-        "minimum": -9007199254740991,
-        "type": "integer"
-      },
-      "checkedTokens": {
-        "maximum": 9007199254740991,
-        "minimum": -9007199254740991,
-        "type": "integer"
-      },
-      "native": {
-        "additionalProperties": false,
-        "properties": {
-          "balance": {
-            "type": "string"
-          },
-          "raw": {
-            "type": "string"
-          },
-          "symbol": {
-            "const": "ETH",
-            "type": "string"
-          }
-        },
-        "required": [
-          "symbol",
-          "balance",
-          "raw"
-        ],
-        "type": "object"
-      },
-      "network": {
-        "const": "eip155:8453",
-        "type": "string"
-      },
-      "notTokens": {
-        "items": {
-          "type": "string"
-        },
-        "type": "array"
-      },
-      "tokens": {
-        "items": {
-          "additionalProperties": false,
-          "properties": {
-            "balance": {
-              "type": "string"
-            },
-            "decimals": {
-              "maximum": 9007199254740991,
-              "minimum": -9007199254740991,
-              "type": "integer"
-            },
-            "raw": {
-              "type": "string"
-            },
-            "symbol": {
-              "type": [
-                "string",
-                "null"
-              ]
-            },
-            "token": {
-              "type": "string"
-            }
-          },
-          "required": [
-            "token",
-            "symbol",
-            "decimals",
-            "balance",
-            "raw"
-          ],
-          "type": "object"
-        },
-        "type": "array"
-      }
-    },
-    "required": [
-      "address",
-      "network",
-      "blockNumber",
-      "native",
-      "tokens",
-      "notTokens",
-      "checkedTokens"
-    ],
-    "type": "object"
-  },
-  {
-    "description": "x402 PaymentRequired (returned with isError when payment is needed)",
-    "properties": {
-      "accepts": {
-        "items": {
-          "type": "object"
-        },
-        "type": "array"
-      },
-      "error": {
-        "type": "string"
-      },
-      "extensions": {
-        "type": "object"
-      },
-      "resource": {
-        "type": "object"
-      },
-      "x402Version": {
-        "type": "integer"
-      }
-    },
-    "required": [
-      "x402Version",
-      "accepts"
-    ],
-    "type": "object"
-  }
-]New value: +[
+  {
+    "additionalProperties": false,
+    "properties": {
+      "address": {
+        "type": "string"
+      },
+      "blockNumber": {
+        "maximum": 9007199254740991,
+        "minimum": -9007199254740991,
+        "type": "integer"
+      },
+      "checkedTokens": {
+        "maximum": 9007199254740991,
+        "minimum": -9007199254740991,
+        "type": "integer"
+      },
+      "native": {
+        "additionalProperties": false,
+        "properties": {
+          "balance": {
+            "type": "string"
+          },
+          "raw": {
+            "type": "string"
+          },
+          "symbol": {
+            "const": "ETH",
+            "type": "string"
+          }
+        },
+        "required": [
+          "symbol",
+          "balance",
+          "raw"
+        ],
+        "type": "object"
+      },
+      "network": {
+        "const": "eip155:8453",
+        "type": "string"
+      },
+      "next": {
+        "additionalProperties": false,
+        "description": "Suggested next paid call in the same family (call it in a loop when the task continues)",
+        "properties": {
+          "method": {
+            "enum": [
+              "GET",
+              "POST"
+            ],
+            "type": "string"
+          },
+          "sample": {
+            "description": "Free fixed sample of the whole family",
+            "type": "string"
+          },
+          "service": {
+            "description": "Service id of the suggested next paid call",
+            "type": "string"
+          },
+          "tool": {
+            "description": "MCP tool name of the same call",
+            "type": "string"
+          },
+          "url": {
+            "description": "Paid route of the next call",
+            "type": "string"
+          },
+          "useWhen": {
+            "description": "When the next call is the right one",
+            "type": "string"
+          }
+        },
+        "required": [
+          "service",
+          "tool",
+          "method",
+          "url",
+          "useWhen",
+          "sample"
+        ],
+        "type": "object"
+      },
+      "notTokens": {
+        "items": {
+          "type": "string"
+        },
+        "type": "array"
+      },
+      "tokens": {
+        "items": {
+          "additionalProperties": false,
+          "properties": {
+            "balance": {
+              "type": "string"
+            },
+            "decimals": {
+              "maximum": 9007199254740991,
+              "minimum": -9007199254740991,
+              "type": "integer"
+            },
+            "raw": {
+              "type": "string"
+            },
+            "symbol": {
+              "type": [
+                "string",
+                "null"
+              ]
+            },
+            "token": {
+              "type": "string"
+            }
+          },
+          "required": [
+            "token",
+            "symbol",
+            "decimals",
+            "balance",
+            "raw"
+          ],
+          "type": "object"
+        },
+        "type": "array"
+      }
+    },
+    "required": [
+      "address",
+      "network",
+      "blockNumber",
+      "native",
+      "tokens",
+      "notTokens",
+      "checkedTokens"
+    ],
+    "type": "object"
+  },
+  {
+    "description": "x402 PaymentRequired (returned with isError when payment is needed)",
+    "properties": {
+      "accepts": {
+        "items": {
+          "type": "object"
+        },
+        "type": "array"
+      },
+      "error": {
+        "type": "string"
+      },
+      "extensions": {
+        "type": "object"
+      },
+      "resource": {
+        "type": "object"
+      },
+      "x402Version": {
+        "type": "integer"
+      }
+    },
+    "required": [
+      "x402Version",
+      "accepts"
+    ],
+    "type": "object"
+  }
+]

Changedblackwood_weather_forecast1 field changed

changedOutput schema / anyOf

Previous value: -[
-  {
-    "additionalProperties": false,
-    "properties": {
-      "altitudeM": {
-        "type": [
-          "number",
-          "null"
-        ]
-      },
-      "attribution": {
-        "type": "string"
-      },
-      "hours": {
-        "items": {
-          "additionalProperties": false,
-          "properties": {
-            "cloudPct": {
-              "type": [
-                "number",
-                "null"
-              ]
-            },
-            "humidityPct": {
-              "type": [
-                "number",
-                "null"
-              ]
-            },
-            "precipitationHours": {
-              "anyOf": [
-                {
-                  "anyOf": [
-                    {
-                      "const": 1,
-                      "type": "number"
-                    },
-                    {
-                      "const": 6,
-                      "type": "number"
-                    }
-                  ]
-                },
-                {
-                  "type": "null"
-                }
-              ]
-            },
-            "precipitationMm": {
-              "type": [
-                "number",
-                "null"
-              ]
-            },
-            "pressureHpa": {
-              "type": [
-                "number",
-                "null"
-              ]
-            },
-            "symbol": {
-              "type": [
-                "string",
-                "null"
-              ]
-            },
-            "temperatureC": {
-              "type": [
-                "number",
-                "null"
-              ]
-            },
-            "time": {
-              "type": "string"
-            },
-            "windFromDeg": {
-              "type": [
-                "number",
-                "null"
-              ]
-            },
-            "windSpeedMs": {
-              "type": [
-                "number",
-                "null"
-              ]
-            }
-          },
-          "required": [
-            "time",
-            "temperatureC",
-            "precipitationMm",
-            "precipitationHours",
-            "windSpeedMs",
-            "windFromDeg",
-            "humidityPct",
-            "cloudPct",
-            "pressureHpa",
-            "symbol"
-          ],
-          "type": "object"
-        },
-        "type": "array"
-      },
-      "latitude": {
-        "type": "number"
-      },
-      "longitude": {
-        "type": "number"
-      },
-      "updatedAt": {
-        "type": "string"
-      }
-    },
-    "required": [
-      "latitude",
-      "longitude",
-      "altitudeM",
-      "updatedAt",
-      "hours",
-      "attribution"
-    ],
-    "type": "object"
-  },
-  {
-    "description": "x402 PaymentRequired (returned with isError when payment is needed)",
-    "properties": {
-      "accepts": {
-        "items": {
-          "type": "object"
-        },
-        "type": "array"
-      },
-      "error": {
-        "type": "string"
-      },
-      "extensions": {
-        "type": "object"
-      },
-      "resource": {
-        "type": "object"
-      },
-      "x402Version": {
-        "type": "integer"
-      }
-    },
-    "required": [
-      "x402Version",
-      "accepts"
-    ],
-    "type": "object"
-  }
-]New value: +[
+  {
+    "additionalProperties": false,
+    "properties": {
+      "altitudeM": {
+        "type": [
+          "number",
+          "null"
+        ]
+      },
+      "attribution": {
+        "type": "string"
+      },
+      "hours": {
+        "items": {
+          "additionalProperties": false,
+          "properties": {
+            "cloudPct": {
+              "type": [
+                "number",
+                "null"
+              ]
+            },
+            "humidityPct": {
+              "type": [
+                "number",
+                "null"
+              ]
+            },
+            "precipitationHours": {
+              "anyOf": [
+                {
+                  "anyOf": [
+                    {
+                      "const": 1,
+                      "type": "number"
+                    },
+                    {
+                      "const": 6,
+                      "type": "number"
+                    }
+                  ]
+                },
+                {
+                  "type": "null"
+                }
+              ]
+            },
+            "precipitationMm": {
+              "type": [
+                "number",
+                "null"
+              ]
+            },
+            "pressureHpa": {
+              "type": [
+                "number",
+                "null"
+              ]
+            },
+            "symbol": {
+              "type": [
+                "string",
+                "null"
+              ]
+            },
+            "temperatureC": {
+              "type": [
+                "number",
+                "null"
+              ]
+            },
+            "time": {
+              "type": "string"
+            },
+            "windFromDeg": {
+              "type": [
+                "number",
+                "null"
+              ]
+            },
+            "windSpeedMs": {
+              "type": [
+                "number",
+                "null"
+              ]
+            }
+          },
+          "required": [
+            "time",
+            "temperatureC",
+            "precipitationMm",
+            "precipitationHours",
+            "windSpeedMs",
+            "windFromDeg",
+            "humidityPct",
+            "cloudPct",
+            "pressureHpa",
+            "symbol"
+          ],
+          "type": "object"
+        },
+        "type": "array"
+      },
+      "latitude": {
+        "type": "number"
+      },
+      "longitude": {
+        "type": "number"
+      },
+      "next": {
+        "additionalProperties": false,
+        "description": "Suggested next paid call in the same family (call it in a loop when the task continues)",
+        "properties": {
+          "method": {
+            "enum": [
+              "GET",
+              "POST"
+            ],
+            "type": "string"
+          },
+          "sample": {
+            "description": "Free fixed sample of the whole family",
+            "type": "string"
+          },
+          "service": {
+            "description": "Service id of the suggested next paid call",
+            "type": "string"
+          },
+          "tool": {
+            "description": "MCP tool name of the same call",
+            "type": "string"
+          },
+          "url": {
+            "description": "Paid route of the next call",
+            "type": "string"
+          },
+          "useWhen": {
+            "description": "When the next call is the right one",
+            "type": "string"
+          }
+        },
+        "required": [
+          "service",
+          "tool",
+          "method",
+          "url",
+          "useWhen",
+          "sample"
+        ],
+        "type": "object"
+      },
+      "updatedAt": {
+        "type": "string"
+      }
+    },
+    "required": [
+      "latitude",
+      "longitude",
+      "altitudeM",
+      "updatedAt",
+      "hours",
+      "attribution"
+    ],
+    "type": "object"
+  },
+  {
+    "description": "x402 PaymentRequired (returned with isError when payment is needed)",
+    "properties": {
+      "accepts": {
+        "items": {
+          "type": "object"
+        },
+        "type": "array"
+      },
+      "error": {
+        "type": "string"
+      },
+      "extensions": {
+        "type": "object"
+      },
+      "resource": {
+        "type": "object"
+      },
+      "x402Version": {
+        "type": "integer"
+      }
+    },
+    "required": [
+      "x402Version",
+      "accepts"
+    ],
+    "type": "object"
+  }
+]

Changedblackwood_webpage_markdown1 field changed

changedOutput schema / anyOf

Previous value: -[
-  {
-    "additionalProperties": false,
-    "properties": {
-      "canonical": {
-        "type": [
-          "string",
-          "null"
-        ]
-      },
-      "description": {
-        "type": [
-          "string",
-          "null"
-        ]
-      },
-      "finalUrl": {
-        "type": "string"
-      },
-      "lang": {
-        "type": [
-          "string",
-          "null"
-        ]
-      },
-      "links": {
-        "items": {
-          "additionalProperties": false,
-          "properties": {
-            "href": {
-              "type": "string"
-            },
-            "text": {
-              "type": "string"
-            }
-          },
-          "required": [
-            "text",
-            "href"
-          ],
-          "type": "object"
-        },
-        "type": "array"
-      },
-      "markdown": {
-        "type": "string"
-      },
-      "status": {
-        "maximum": 9007199254740991,
-        "minimum": -9007199254740991,
-        "type": "integer"
-      },
-      "title": {
-        "type": [
-          "string",
-          "null"
-        ]
-      },
-      "truncated": {
-        "type": "boolean"
-      },
-      "url": {
-        "type": "string"
-      },
-      "wordCount": {
-        "maximum": 9007199254740991,
-        "minimum": -9007199254740991,
-        "type": "integer"
-      }
-    },
-    "required": [
-      "url",
-      "finalUrl",
-      "status",
-      "title",
-      "description",
-      "lang",
-      "canonical",
-      "markdown",
-      "links",
-      "wordCount",
-      "truncated"
-    ],
-    "type": "object"
-  },
-  {
-    "description": "x402 PaymentRequired (returned with isError when payment is needed)",
-    "properties": {
-      "accepts": {
-        "items": {
-          "type": "object"
-        },
-        "type": "array"
-      },
-      "error": {
-        "type": "string"
-      },
-      "extensions": {
-        "type": "object"
-      },
-      "resource": {
-        "type": "object"
-      },
-      "x402Version": {
-        "type": "integer"
-      }
-    },
-    "required": [
-      "x402Version",
-      "accepts"
-    ],
-    "type": "object"
-  }
-]New value: +[
+  {
+    "additionalProperties": false,
+    "properties": {
+      "canonical": {
+        "type": [
+          "string",
+          "null"
+        ]
+      },
+      "description": {
+        "type": [
+          "string",
+          "null"
+        ]
+      },
+      "finalUrl": {
+        "type": "string"
+      },
+      "lang": {
+        "type": [
+          "string",
+          "null"
+        ]
+      },
+      "links": {
+        "items": {
+          "additionalProperties": false,
+          "properties": {
+            "href": {
+              "type": "string"
+            },
+            "text": {
+              "type": "string"
+            }
+          },
+          "required": [
+            "text",
+            "href"
+          ],
+          "type": "object"
+        },
+        "type": "array"
+      },
+      "markdown": {
+        "type": "string"
+      },
+      "next": {
+        "additionalProperties": false,
+        "description": "Suggested next paid call in the same family (call it in a loop when the task continues)",
+        "properties": {
+          "method": {
+            "enum": [
+              "GET",
+              "POST"
+            ],
+            "type": "string"
+          },
+          "sample": {
+            "description": "Free fixed sample of the whole family",
+            "type": "string"
+          },
+          "service": {
+            "description": "Service id of the suggested next paid call",
+            "type": "string"
+          },
+          "tool": {
+            "description": "MCP tool name of the same call",
+            "type": "string"
+          },
+          "url": {
+            "description": "Paid route of the next call",
+            "type": "string"
+          },
+          "useWhen": {
+            "description": "When the next call is the right one",
+            "type": "string"
+          }
+        },
+        "required": [
+          "service",
+          "tool",
+          "method",
+          "url",
+          "useWhen",
+          "sample"
+        ],
+        "type": "object"
+      },
+      "status": {
+        "maximum": 9007199254740991,
+        "minimum": -9007199254740991,
+        "type": "integer"
+      },
+      "title": {
+        "type": [
+          "string",
+          "null"
+        ]
+      },
+      "truncated": {
+        "type": "boolean"
+      },
+      "url": {
+        "type": "string"
+      },
+      "wordCount": {
+        "maximum": 9007199254740991,
+        "minimum": -9007199254740991,
+        "type": "integer"
+      }
+    },
+    "required": [
+      "url",
+      "finalUrl",
+      "status",
+      "title",
+      "description",
+      "lang",
+      "canonical",
+      "markdown",
+      "links",
+      "wordCount",
+      "truncated"
+    ],
+    "type": "object"
+  },
+  {
+    "description": "x402 PaymentRequired (returned with isError when payment is needed)",
+    "properties": {
+      "accepts": {
+        "items": {
+          "type": "object"
+        },
+        "type": "array"
+      },
+      "error": {
+        "type": "string"
+      },
+      "extensions": {
+        "type": "object"
+      },
+      "resource": {
+        "type": "object"
+      },
+      "x402Version": {
+        "type": "integer"
+      }
+    },
+    "required": [
+      "x402Version",
+      "accepts"
+    ],
+    "type": "object"
+  }
+]

Changedblackwood_x402_check1 field changed

changedOutput schema / anyOf

Previous value: -[
-  {
-    "additionalProperties": false,
-    "properties": {
-      "accepts": {
-        "items": {
-          "additionalProperties": false,
-          "properties": {
-            "amount": {
-              "type": [
-                "string",
-                "null"
-              ]
-            },
-            "amountUsd": {
-              "type": [
-                "number",
-                "null"
-              ]
-            },
-            "asset": {
-              "type": [
-                "string",
-                "null"
-              ]
-            },
-            "maxTimeoutSeconds": {
-              "type": [
-                "number",
-                "null"
-              ]
-            },
-            "network": {
-              "type": [
-                "string",
-                "null"
-              ]
-            },
-            "payTo": {
-              "type": [
-                "string",
-                "null"
-              ]
-            },
-            "scheme": {
-              "type": [
-                "string",
-                "null"
-              ]
-            }
-          },
-          "required": [
-            "scheme",
-            "network",
-            "asset",
-            "amount",
-            "amountUsd",
-            "payTo",
-            "maxTimeoutSeconds"
-          ],
-          "type": "object"
-        },
-        "type": "array"
-      },
-      "bazaar": {
-        "additionalProperties": false,
-        "properties": {
-          "inputSchema": {
-            "type": "boolean"
-          },
-          "outputSchema": {
-            "type": "boolean"
-          },
-          "present": {
-            "type": "boolean"
-          }
-        },
-        "required": [
-          "present",
-          "inputSchema",
-          "outputSchema"
-        ],
-        "type": "object"
-      },
-      "checkedAt": {
-        "type": "string"
-      },
-      "finalUrl": {
-        "type": "string"
-      },
-      "problems": {
-        "items": {
-          "type": "string"
-        },
-        "type": "array"
-      },
-      "resource": {
-        "anyOf": [
-          {
-            "additionalProperties": false,
-            "properties": {
-              "description": {
-                "type": [
-                  "string",
-                  "null"
-                ]
-              },
-              "mimeType": {
-                "type": [
-                  "string",
-                  "null"
-                ]
-              },
-              "url": {
-                "type": [
-                  "string",
-                  "null"
-                ]
-              }
-            },
-            "required": [
-              "url",
-              "description",
-              "mimeType"
-            ],
-            "type": "object"
-          },
-          {
-            "type": "null"
-          }
-        ]
-      },
-      "status": {
-        "type": "number"
-      },
-      "url": {
-        "type": "string"
-      },
-      "version": {
-        "type": [
-          "number",
-          "null"
-        ]
-      },
-      "x402": {
-        "type": "boolean"
-      }
-    },
-    "required": [
-      "url",
-      "finalUrl",
-      "status",
-      "x402",
-      "version",
-      "resource",
-      "accepts",
-      "bazaar",
-      "problems",
-      "checkedAt"
-    ],
-    "type": "object"
-  },
-  {
-    "description": "x402 PaymentRequired (returned with isError when payment is needed)",
-    "properties": {
-      "accepts": {
-        "items": {
-          "type": "object"
-        },
-        "type": "array"
-      },
-      "error": {
-        "type": "string"
-      },
-      "extensions": {
-        "type": "object"
-      },
-      "resource": {
-        "type": "object"
-      },
-      "x402Version": {
-        "type": "integer"
-      }
-    },
-    "required": [
-      "x402Version",
-      "accepts"
-    ],
-    "type": "object"
-  }
-]New value: +[
+  {
+    "additionalProperties": false,
+    "properties": {
+      "accepts": {
+        "items": {
+          "additionalProperties": false,
+          "properties": {
+            "amount": {
+              "type": [
+                "string",
+                "null"
+              ]
+            },
+            "amountUsd": {
+              "type": [
+                "number",
+                "null"
+              ]
+            },
+            "asset": {
+              "type": [
+                "string",
+                "null"
+              ]
+            },
+            "maxTimeoutSeconds": {
+              "type": [
+                "number",
+                "null"
+              ]
+            },
+            "network": {
+              "type": [
+                "string",
+                "null"
+              ]
+            },
+            "payTo": {
+              "type": [
+                "string",
+                "null"
+              ]
+            },
+            "scheme": {
+              "type": [
+                "string",
+                "null"
+              ]
+            }
+          },
+          "required": [
+            "scheme",
+            "network",
+            "asset",
+            "amount",
+            "amountUsd",
+            "payTo",
+            "maxTimeoutSeconds"
+          ],
+          "type": "object"
+        },
+        "type": "array"
+      },
+      "bazaar": {
+        "additionalProperties": false,
+        "properties": {
+          "inputSchema": {
+            "type": "boolean"
+          },
+          "outputSchema": {
+            "type": "boolean"
+          },
+          "present": {
+            "type": "boolean"
+          }
+        },
+        "required": [
+          "present",
+          "inputSchema",
+          "outputSchema"
+        ],
+        "type": "object"
+      },
+      "checkedAt": {
+        "type": "string"
+      },
+      "finalUrl": {
+        "type": "string"
+      },
+      "next": {
+        "additionalProperties": false,
+        "description": "Suggested next paid call in the same family (call it in a loop when the task continues)",
+        "properties": {
+          "method": {
+            "enum": [
+              "GET",
+              "POST"
+            ],
+            "type": "string"
+          },
+          "sample": {
+            "description": "Free fixed sample of the whole family",
+            "type": "string"
+          },
+          "service": {
+            "description": "Service id of the suggested next paid call",
+            "type": "string"
+          },
+          "tool": {
+            "description": "MCP tool name of the same call",
+            "type": "string"
+          },
+          "url": {
+            "description": "Paid route of the next call",
+            "type": "string"
+          },
+          "useWhen": {
+            "description": "When the next call is the right one",
+            "type": "string"
+          }
+        },
+        "required": [
+          "service",
+          "tool",
+          "method",
+          "url",
+          "useWhen",
+          "sample"
+        ],
+        "type": "object"
+      },
+      "problems": {
+        "items": {
+          "type": "string"
+        },
+        "type": "array"
+      },
+      "resource": {
+        "anyOf": [
+          {
+            "additionalProperties": false,
+            "properties": {
+              "description": {
+                "type": [
+                  "string",
+                  "null"
+                ]
+              },
+              "mimeType": {
+                "type": [
+                  "string",
+                  "null"
+                ]
+              },
+              "url": {
+                "type": [
+                  "string",
+                  "null"
+                ]
+              }
+            },
+            "required": [
+              "url",
+              "description",
+              "mimeType"
+            ],
+            "type": "object"
+          },
+          {
+            "type": "null"
+          }
+        ]
+      },
+      "status": {
+        "type": "number"
+      },
+      "url": {
+        "type": "string"
+      },
+      "version": {
+        "type": [
+          "number",
+          "null"
+        ]
+      },
+      "x402": {
+        "type": "boolean"
+      }
+    },
+    "required": [
+      "url",
+      "finalUrl",
+      "status",
+      "x402",
+      "version",
+      "resource",
+      "accepts",
+      "bazaar",
+      "problems",
+      "checkedAt"
+    ],
+    "type": "object"
+  },
+  {
+    "description": "x402 PaymentRequired (returned with isError when payment is needed)",
+    "properties": {
+      "accepts": {
+        "items": {
+          "type": "object"
+        },
+        "type": "array"
+      },
+      "error": {
+        "type": "string"
+      },
+      "extensions": {
+        "type": "object"
+      },
+      "resource": {
+        "type": "object"
+      },
+      "x402Version": {
+        "type": "integer"
+      }
+    },
+    "required": [
+      "x402Version",
+      "accepts"
+    ],
+    "type": "object"
+  }
+]

45 tool updatesOct 17, 2026
- Addedblackwood_airport_delays
- Addedblackwood_audio_transcribe
- Addedblackwood_audio_transcribe_status
- Addedblackwood_credits_balance
- Addedblackwood_crypto_news
- Addedblackwood_domain_intel
- Addedblackwood_email_check
- Addedblackwood_fx_rates
- Addedblackwood_headers_audit
- Addedblackwood_image_generate
- Addedblackwood_image_generate_status
- Addedblackwood_llm_chat
- Addedblackwood_llm_chat_status
- Addedblackwood_news_search
- Addedblackwood_pdf_extract
- Addedblackwood_pdf_extract_status
- Addedblackwood_qrcode_generate
- Addedblackwood_random_generate
- Addedblackwood_sec_facts
- Addedblackwood_speech_synthesize
- Addedblackwood_text_sentiment
- Addedblackwood_text_summarize
- Addedblackwood_text_translate
- Addedblackwood_timezone_convert
- Addedblackwood_token_price
- Addedblackwood_wallet_balances
- Addedblackwood_weather_forecast
- Addedblackwood_webpage_markdown
- Addedblackwood_x402_check
- Removeddomain-intel_v1
- Removedemail-check_v1
- Removedimage-gen_v1
- Removedimage-gen_v1_status
- Removedllm-chat_v1
- Removedllm-chat_v1_status
- Removednews-headlines_v1
- Removedpdf-text_v1
- Removedpdf-text_v1_status
- Removedsec-facts_v1
- Removedspeech-to-text_v1
- Removedspeech-to-text_v1_status
- Removedtoken-price_v1
- Removedwallet-balances_v1
- Removedweather-forecast_v1
- Removedweb-markdown_v1
11 tool updatesOct 17, 2026
- Addedemail-check_v1
- Addedimage-gen_v1
- Addedimage-gen_v1_status
- Addedllm-chat_v1
- Addedllm-chat_v1_status
- Addednews-headlines_v1
- Addedspeech-to-text_v1
- Addedspeech-to-text_v1_status
- Addedtoken-price_v1
- Addedwallet-balances_v1
- Addedweather-forecast_v1
5 tool updatesOct 17, 2026
- First observeddomain-intel_v1
- First observedpdf-text_v1
- First observedpdf-text_v1_status
- First observedsec-facts_v1
- First observedweb-markdown_v1

Related MCP Connectors

BlixtworksA
com.blixtworks.www
63 pay-per-call tools for agents: vision, text, data, web, blockchain. USDC on Base via x402.
Blockchain Cryptocurrency AI & Machine Learning
681
https://www.blixtworks.com/mcp
Baron Power PlayB
io.github.MintMachineHQ
Pay-per-call AI infra for agents: DeFi market data, LLM inference, STT/TTS. x402 v2, USDC on Base.
AI & Machine Learning Speech Processing Cryptocurrency
51
https://baron-power-play.baronpowerplay.workers.dev/mcp
MimirAPIA
io.github.Latimer-Woods-Tech
Pay-per-call agent tools over x402 (USDC on Base) — no signup or API key.
Payments & Billing Cryptocurrency Blockchain
61
https://mimirapi.com/mcp
x402 Agent ToolsA
io.github.signal-forge-ai
Pay-per-call web, Base onchain and crypto-alert tools for agents. USDC on Base via x402, no API key.
Blockchain Cryptocurrency Payments & Billing
91
https://x402-agent-tools.x402agenttools.workers.dev/mcp

Related MCP Servers

@blackwood-state/mcp
Blockchain Payments & Billing Finance
Blackwood-State
A
license
A
quality
C
maintenance
Enables AI agents to call 33 pay-per-call tools for onchain data, ECB exchange rates, text utilities, and more, using USDC on Base over x402 with optional prepaid credit or wallet-based payments.
Updated 18 days ago (2026-10-20 05:50 UTC)
34
46 npm
MIT
dyoe-agent-tools-mcp
Autonomous Agents Cryptocurrency Web Scraping
bjyoe2016
A
license
A
quality
C
maintenance
Trust layer for AI agents: 22 pay-per-call x402 tools for scam and fraud checks, payment pre-flight, wallet screening, policy approvals, contact extraction and company research. Free preview with no wallet; paid calls settle in USDC on Base.
Updated 16 days ago (2026-10-21 17:12 UTC)
22
80 npm
MIT
CyberWareX MCP Serversofficial
Cryptocurrency Web Scraping Speech Processing
cyberwareX
A
license
A
quality
B
maintenance
Pay-per-call x402 APIs for AI agents: DeFi token safety (honeypot/tax simulation, A-F grade), EVM chain data, web access (markdown/screenshot/PDF), speech-to-text. USDC on Base, no account, no API key
Updated 19 hours ago (2026-11-06 04:00 UTC)
3
MIT
Beggar Bot
Cryptocurrency Payments & Billing Blockchain
beggar-bot-x402
A
license
Not graded
quality
B
maintenance
x402 utilities for AI agents on Base: USDC payment verification, wallet risk scores and signed receipts. $0.01 USDC per call via x402.
Updated 14 days ago (2026-10-24 08:31 UTC)
MIT

Try in Browser

Context Every Agent Can ShareAgents share what they learn, hand off work, and keep it when you switch models. Start with 5 GB free.fulcradynamics.comAd

Glama MCP Gateway

Add one secure layer between your agents and this server.

Resources

Need Help?

Server Details

Available Tools

Output Schema

Output Schema

Output Schema

Output Schema

Output Schema

Output Schema

Output Schema

Output Schema

Output Schema

Output Schema

Output Schema

Output Schema

Output Schema

Output Schema

Output Schema

Output Schema

Output Schema

Output Schema

Output Schema

Output Schema

Output Schema

Output Schema

Output Schema

Output Schema

Output Schema

Output Schema

Output Schema

Output Schema

Output Schema

Output Schema

Output Schema

Output Schema

Output Schema

Output Schema

Output Schema

Output Schema

Output Schema

Tool Schema Changelog

Related MCP Connectors

Related MCP Servers

CyberWareX MCP Serversofficial

Glama MCP Gateway

Resources