A
licenseNot graded
qualityC
maintenanceEnables agents to discover, sample, and pay per call in USDC for live threat intelligence, ZK proof generation, and arbitrage signals via the x402 protocol.
MIT
Blackwood State
Server Details
Blackwood State: pay-per-call tools for agents (web, SEC, PDF, domain), USDC over 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
- Last Tested
- Transport
- Streamable HTTP · MCP 2025-11-25
- URL
TDQS
A4.2/5.0
Scored across 37 tools
Disambiguation4/5
Most tools target distinct resources and actions, with explicit 'use when' and 'do not use' boundaries. However, several bundles (company_dossier, news_briefing) and clusters (wallet_balances/portfolio/value, text_summarize vs llm_chat) overlap enough that misselection is possible.
Naming Consistency5/5
All tool names follow a predictable blackwood_<snake_case> pattern with resource_action or resource_noun structure. There is no mixing of camelCase, and the convention is applied consistently across all 37 tools.
Tool Count3/5
37 tools is heavy for an MCP server and risks overwhelming an agent's selection process. The breadth is somewhat justified because each tool is a distinct paid micro-service, but the set is still borderline excessive for a single server surface.
Completeness4/5
The surface covers many domains with few dead ends, and each tool is complete for its narrow task. Notable gaps remain, such as geocoding for weather inputs, OCR for scanned PDFs, and general web search, but agents can often work around these.
Available Tools
37 toolsblackwood_airport_delaysAirport delaysARead-onlyIdempotentInspect
Use when you need airport delays or flight status context for a US airport, such as ground stops or departure delays right now. 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.
ParametersJSON Schema
| 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
ParametersJSON 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 readOnlyHint, idempotentHint and openWorldHint, so the safety profile is covered. The description adds genuinely non-structured context – cost of 0.007 USDC per call, p95 latency of ~1500 ms, and the FAA data pedigree – which materially affects an agent's invocation decision. It stops short of describing caching or rate-limit behavior.
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?
It is front-loaded with the usage decision, then the return shape, then cost and latency. Every clause carries information an agent needs to select or budget the call; nothing is 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 explain return values, yet it still summarizes the payload categories. Combined with the negative scope, pricing and latency disclosure, an agent has everything required 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%, so both parameters are already fully documented (the airport code pattern and the concise/detailed enum semantics). The description restates 'for all airports or one' but adds no syntax or format detail beyond the schema. 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?
The description states a specific verb+resource ('airport delays or flight status context for a US airport') and immediately scopes it with concrete data types (ground stops, departure delays). It also explicitly separates itself from the closest ambiguities – flight-number status and non-US airports – so an agent can route 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 trigger ('Use when you need airport delays... right now') and three explicit exclusions ('status of a flight number, airports outside the US, historical delays'). This is the when/when-not pattern at its clearest, even without naming a sibling tool.
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 textARead-onlyIdempotentInspect
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.
ParametersJSON Schema
| Name | Required | Description | Default |
|---|---|---|---|
| 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
ParametersJSON 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)ARead-onlyIdempotentInspect
Free. Status and result of a job created by blackwood_audio_transcribe. Poll until done is true.
ParametersJSON Schema
| Name | Required | Description | Default |
|---|---|---|---|
| jobId | Yes |
Output Schema
ParametersJSON 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 dossierARead-onlyInspect
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.
ParametersJSON Schema
| Name | Required | Description | Default |
|---|---|---|---|
| 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
ParametersJSON 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 balanceARead-onlyIdempotentInspect
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.
ParametersJSON Schema
| 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 newsARead-onlyIdempotentInspect
Use when you need crypto news headlines about bitcoin, ethereum, a token or the crypto 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 and blockchain news headlines from the last 72 hours (title, link, source, time, tone, people and organizations), from the GDELT global news graph for 0.005 USDC per call. Typical response time 1500 ms (p95). Category: Search.
ParametersJSON Schema
| Name | Required | Description | Default |
|---|---|---|---|
| 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
ParametersJSON Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
A4.5/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 adds genuinely new operational context: a per-call cost of 0.005 USDC, a p95 latency of 1500 ms, and the upstream source (the GDELT global news graph). That is exactly the kind of cost/latency/source disclosure an agent needs before calling a metered endpoint.
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 use condition, immediately followed by the exclusion list, then the return shape, source, cost and latency in one dense sentence. No filler and 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?
With an output schema present, return values need not be enumerated, yet the description still summarizes the payload (title, link, source, time, tone, people, organizations). Combined with cost, latency and source, an agent has everything needed to select and invoke 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% with bounds, defaults and an enum all documented, so the schema does the heavy lifting and a baseline of 3 applies. The description adds the 72-hour horizon and the returned fields but no extra parameter syntax or semantics 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 description names a specific verb and resource ('crypto news headlines about bitcoin, ethereum, a token or the crypto market from recent articles') and scopes it to a 72-hour window, which separates it from blackwood_news_search and the price-oriented siblings without requiring the agent to open 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?
It gives explicit when-to-use ('need crypto news headlines') and when-not-to-use conditions ('prices, full article text, social media posts or news older than 72 hours'), which map implicitly to blackwood_token_price and blackwood_webpage_markdown. The alternative tools are not named outright, so the routing requires a small 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 intelligenceARead-onlyIdempotentInspect
Use when you need a whois or domain lookup, dns records, email security checks or certificate transparency data for osint or due diligence. Do not use for historical whois, registrant personal data (redacted by registries) or port and vulnerability scans. Returns JSON with a domain's registration (RDAP: registrar, dates, status, DNSSEC), DNS records, SPF and DMARC, and recent TLS certificates for 0.02 USDC per call. Typical response time 4000 ms (p95). Category: Data.
ParametersJSON Schema
| Name | Required | Description | Default |
|---|---|---|---|
| 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
ParametersJSON Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
A4.5/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), and the description adds value beyond them: cost of 0.02 USDC per call, p95 latency of 4000 ms, and confirmation that results are idempotent lookups against public registries. Billing and latency disclosures are exactly the kind of 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 trigger condition and tightly packed with no filler. Slightly over-compressed — pricing, latency, return contents and category are run together in one sentence, which dilutes scanability, but nothing is redundant.
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 not strictly required, yet pricing, latency and data sources are all disclosed. The only gap is that 'domain' must be punycode/ASCII, which lives only in the schema — minor for a single-param lookup.
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 'domain', 'certificates' and 'response_format' are already fully documented in the schema. The description mentions certificates as part of the return payload but adds no new semantics such as format constraints or when to prefer 'detailed'. 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 set of resources (whois/RDAP registration, DNS records, SPF/DMARC, TLS certificates) with clear verbs (lookup, checks). An agent can distinguish this from sibling audit-style tools such as blackwood_email_check or blackwood_headers_audit based on the stated scope alone.
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...' trigger list is followed by concrete exclusions: historical whois, registrant personal data, port and vulnerability scans. That is a genuine when/when-not split, so the agent knows both where this tool applies and where it does not.
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 checkARead-onlyIdempotentInspect
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.
ParametersJSON Schema
| 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
ParametersJSON 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 address checkARead-onlyIdempotentInspect
Use when you need email validation or to verify email addresses (domain, MX records) before sending, signup or lead scoring. Do not use for confirming that the mailbox itself exists (no SMTP probe is done) or sending email. Returns JSON with an email address check: syntax, domain and 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.
ParametersJSON Schema
| Name | Required | Description | Default |
|---|---|---|---|
| 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
ParametersJSON 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?
Beyond annotations (readOnly/idempotent/non-destructive/openWorld), it discloses the absence of an SMTP probe, the per-call price (0.005 USDC), and p95 latency (800 ms) – none of which are in the annotations or schema. These are material traits for cost- and time-aware agents.
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 packs when/when-not/cost/latency into a compact block, ending with a category tag. Dense but each clause carries information; slightly overloaded into few sentences.
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, yet the description still summarizes the verdict fields, and it covers prerequisites, exclusions, cost and latency. Nothing an agent needs 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 coverage is 100%, with both 'email' and the 'response_format' enum fully described in the schema, so the description adds no parameter semantics beyond structured data. 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.
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 ('email validation / verify email addresses') and scopes exactly what is checked (domain, MX records). It clearly differentiates from the sibling blackwood_email_batch and from mailbox-verification semantics by naming what it does not 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?
It gives explicit positive triggers ('before sending, signup or lead scoring') and explicit exclusions ('Do not use for confirming that the mailbox itself exists... or sending email'). An agent can route to or away from this tool without inspecting siblings.
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 lookupARead-onlyIdempotentInspect
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.005 USDC per call. Typical response time 2000 ms (p95). Category: Data.
ParametersJSON Schema
| Name | Required | Description | Default |
|---|---|---|---|
| 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
ParametersJSON 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 declare readOnly/idempotent/openWorld/non-destructive, so the safety profile is covered. The description adds genuinely useful context those annotations cannot: cost (0.005 USDC per call) and latency (2000 ms p95). It does not cover auth/API-key needs or rate limits, so it falls 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?
Usage and exclusions are front-loaded, then cost/latency/category. Every sentence carries information, though a few clauses ('Returns JSON with an ENS lookup on Ethereum in one call') are slightly redundant against the existing output schema.
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 explain return shapes, and it covers the details an agent still needs: use cases, exclusions, per-call cost, and expected latency. 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 already documents name, address, texts, and response_format, including the mutually-exclusive 'send name or address, not both' rule. The description restates the semantic intent (name->address, address->reverse, record keys) without adding syntax or defaulting details beyond what the schema provides; 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 pair (resolve ENS names / reverse-resolve addresses / read ENS records) and explicitly distinguishes itself from registration and non-ENS naming (Solana SNS). An agent can select this tool without ambiguity among 30+ siblings.
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 triggers ('resolve an ENS name', 'reverse-resolve an address', 'read avatar and profile records') and explicit exclusions ('Do not use for registering or renewing names, or non-ENS naming such as Solana SNS'). 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_fx_historyFX rate historyARead-onlyIdempotentInspect
Use when you need historical exchange rates, forex history or the recent trend of a currency. Do not use for rates older than 90 days, live quotes or crypto (one ECB rate per business day). Returns JSON with 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 we calculate, with min, max and percent change for 0.005 USDC per call. Typical response time 1500 ms (p95). Category: Data.
ParametersJSON Schema
| Name | Required | Description | Default |
|---|---|---|---|
| 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
ParametersJSON Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
A4.5/5.0
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare the safe read-only, idempotent, open-world profile, and the description adds genuinely non-structured behavior: one ECB rate per business day (data granularity), free source at ecb.europa.eu, cost of 0.005 USDC per call, and p95 latency of 1500 ms. That is exactly the kind of pricing, freshness and performance context an agent cannot get from 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, then scope, then cost/latency; nearly every clause carries information. The trailing 'Category: Data.' is low-value taxonomy padding that slightly dilutes an otherwise tight block.
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 it correctly does not need to explain return shape, and it covers limits, cost, latency and data granularity. It omits edge behavior an agent might need (unknown/unsupported ISO codes, holiday gaps, behavior when startDate and days conflict), so it is strong but not exhaustive.
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 adds real semantics beyond it: rebasing to any base is computed as cross rates (the schema only says 'Base currency, ISO 4217'), and the 90-day cap is framed as the hard product limit rather than just a maximum. It does not clarify startDate vs days precedence, which the schema handles instead.
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 plus scope: '90 days of daily ECB euro reference rates ... for up to 10 currencies, rebased to any base as cross rates we calculate, with min, max and percent change.' An agent can distinguish this from blackwood_fx_rates and other data 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 Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicit trigger ('Use when you need historical exchange rates, forex history or the recent trend of a currency') and explicit exclusions ('Do not use for rates older than 90 days, live quotes or crypto'). It stops short of naming the alternative sibling (blackwood_fx_rates) for live quotes, so routing is implied rather than stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
blackwood_fx_ratesFX ratesARead-onlyIdempotentInspect
Use when you need currency exchange rates, forex conversion of an amount or a reference rate between two currencies. Do not use for live trading quotes, intraday or crypto rates (ECB rates update once per business day). Returns JSON with the ECB euro reference rates (free at ecb.europa.eu) for about 30 currencies, rebased to any of them as cross rates we calculate, with an optional amount conversion and the ECB date for 0.005 USDC per call. Typical response time 1500 ms (p95). Category: Data.
ParametersJSON Schema
| Name | Required | Description | Default |
|---|---|---|---|
| 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
ParametersJSON 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 cover read-only/idempotent/destructive, but the description adds materially more: the data source (ECB euro reference rates), the once-per-business-day refresh cadence, cross-rate rebasing it computes itself, an optional amount conversion, per-call cost (0.005 USDC), and p95 latency of 1500 ms. Cost and latency are behavioral facts an agent cannot get from annotations or schema.
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 exclusions, then pricing and return shape. Dense but every clause carries information; the trailing 'Category: Data.' is minor 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?
An output schema exists, so return values need not be restated, and the description still covers source, update frequency, defaults, cost, and latency. Nothing an agent needs to decide to call it or to interpret the cadence is missing.
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 description coverage is 100%, so baseline is 3; the description still adds meaning by explaining the cross-rate rebasing model, that amount is optional conversion, and the currency-selection scope. It does not explain response_format, but the schema's own enum description handles that.
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 specific verbs and resources: 'currency exchange rates', 'forex conversion of an amount', 'reference rate between two currencies'. An agent can immediately distinguish it from blackwood_fx_history and blackwood_token_price, and the description even names the exact currency universe (~30 ECB currencies).
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 positive trigger ('Use when you need currency exchange rates...') plus explicit exclusions ('Do not use for live trading quotes, intraday or crypto rates') with the reason given (ECB rates update once per business day). This is exactly the when/when-not routing 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_gas_feesGas feesARead-onlyInspect
Use when you need a gas price or fee estimate before a transaction on Ethereum, Base or Solana, 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 live gas fees for Ethereum and Base (base fee, slow, standard and fast EIP-1559 priority and max fees in gwei, transfer cost) and Solana priority fees, in one call for 0.003 USDC per call. Typical response time 1500 ms (p95). Category: Data.
ParametersJSON Schema
| 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
ParametersJSON 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 (readOnly, non-destructive, openWorld), and the description adds genuinely new operational context: cost of 0.003 USDC per call, p95 latency of 1500 ms, and the shape of the returned payload. Nothing contradicts the annotations; live-and-changing fees are consistent with idempotentHint=false.
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 one dense but efficient paragraph; exclusions follow the positive case. Minor filler ('Category: Data') and some return-detail that duplicates the output schema keep 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 and the description still summarizes the return shape, plus it discloses pricing, latency and chain scope. Everything an agent needs to decide to call it and what to expect is present.
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 both parameters (chains, response_format) are already fully documented with defaults and enums in the schema. The description adds nothing parameter-level, 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 (gas price / fee estimate) and enumerates the exact supported chains (Ethereum, Base, Solana), which lets an agent distinguish it from siblings like blackwood_token_price or blackwood_fx_rates 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 gives when to use (pre-transaction fee estimate, cross-chain comparison) and when not to use (gas units of a given transaction, gas history, unsupported chains). Alternatives/conditions are stated rather than inferred.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
blackwood_headers_auditSecurity headersARead-onlyIdempotentInspect
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.
ParametersJSON Schema
| 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
ParametersJSON 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_generateText to imageARead-onlyIdempotentInspect
Use when you need image generation or text to image from a prompt for illustrations or mockups. Do not use for image edits, specific sizes, photos of real people or more than one image per call. Returns JSON with a 1024x1024 JPEG generated from a text prompt 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.
ParametersJSON Schema
| Name | Required | Description | Default |
|---|---|---|---|
| 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
ParametersJSON 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?
Goes well beyond the annotations (readOnlyHint/idempotent/openWorld/non-destructive) by disclosing fixed 1024x1024 output, wire format (JSON with base64), model, per-call price of 0.03 USDC, latency of about 10000 ms, and the free polling escape hatch. This is exactly the extra behavioral 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-loads usage and exclusions before the technical details, and every sentence carries information (cost, latency, format, fallback). Slightly overpacked with the redundant 'image generation or text to image' restatement and a run-on final sentence, but 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?
For a paid generation tool with an output schema, the description covers usage boundaries, cost, latency, return format, and the async fallback path. An agent has everything needed to decide whether to call it and what to expect back.
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 already 100%, so steps, prompt, and response_format are fully documented in the schema. The description adds only the fixed size and single-image constraint, which relate to absent parameters rather than clarifying the three present ones. 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 (generate an image from a text prompt) with the intended use case (illustrations, mockups) and explicitly contrasts with image editing. It also pegs the exact output (1024x1024 JPEG via FLUX.1 schnell) and names the status sibling so the tool is distinguishable from the other 29 tools.
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?
Provides explicit when-to-use (illustrations/mockups) and when-not-to-use (image edits, specific sizes, photos of real people, more than one image per call), plus a routing rule to the free status tool if the call runs long. 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_image_generate_statusText to image (status)ARead-onlyIdempotentInspect
Free. Status and result of a job created by blackwood_image_generate. Poll until done is true.
ParametersJSON Schema
| Name | Required | Description | Default |
|---|---|---|---|
| jobId | Yes |
Output Schema
ParametersJSON 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, and non-destructive. The description adds value beyond them: 'Free' discloses cost, and 'Poll until done is true' discloses the async polling contract. It does not mention backoff, rate limits, or failure semantics, so not 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 short sentences, zero filler, cost and polling constraint front-loaded. Every sentence earns its place.
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 not be described. The description covers purpose, cost, polling, and job origin. Only failure/terminal-status behavior is absent, a minor gap for a 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 must compensate. It does indicate the jobId originates from blackwood_image_generate, which is useful provenance, but gives no format, length, or validity guidance, so it only partially compensates.
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 ties it to the exact sibling that creates the job ('blackwood_image_generate'). An agent can distinguish it from the sibling generate tool 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 operational guidance on how to use it, and the reference to the originating job implies it is only used after blackwood_image_generate. It does not state what to do on failure or a terminal error state, so it stops short of full when/when-not coverage.
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 completionARead-onlyIdempotentInspect
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.
ParametersJSON Schema
| Name | Required | Description | Default |
|---|---|---|---|
| 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
ParametersJSON 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)ARead-onlyIdempotentInspect
Free. Status and result of a job created by blackwood_llm_chat. Poll until done is true.
ParametersJSON Schema
| Name | Required | Description | Default |
|---|---|---|---|
| jobId | Yes |
Output Schema
ParametersJSON 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 briefingARead-onlyInspect
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.
ParametersJSON Schema
| Name | Required | Description | Default |
|---|---|---|---|
| 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
ParametersJSON 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 searchARead-onlyIdempotentInspect
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.
ParametersJSON Schema
| Name | Required | Description | Default |
|---|---|---|---|
| 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
ParametersJSON 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 textARead-onlyIdempotentInspect
Use when you need to extract text from a pdf for document parsing, search or an LLM. Do not use for scanned PDFs (no OCR), password-protected files or files over 15 MB. Returns JSON with the text of each page of a PDF (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.
ParametersJSON Schema
| 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
ParametersJSON 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?
Beyond the annotations (readOnly/idempotent/openWorld), it discloses pricing (0.0025 USDC/page, 0.05 cap), the 20-page truncation, latency (~10000 ms), and the free polling fallback via a status tool. These are exactly the operational traits an agent needs to plan 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.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Front-loaded with the 'Use when...' clause, then exclusions, then return/pricing/latency details. Dense but every clause is load-bearing; only the trailing 'Category: Data' is 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?
Despite an existing output schema, it still summarizes the return shape and adds the pricing, latency, async fallback and input limits needed to invoke correctly. 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 coverage is 100%, so both url and response_format are fully documented in the schema itself; the description adds only the 15 MB constraint, which is already in the schema. Baseline 3 is appropriate when the schema carries the parameter burden.
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 ('extract text from a pdf') and immediately signals the use cases (document parsing, search, LLM). It is clearly distinguishable from the sibling blackwood_pdf_extract_status.
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 positive conditions plus explicit exclusions ('Do not use for scanned PDFs (no OCR), password-protected files or files over 15 MB'). It also routes to the status tool when the call runs long, naming the alternative and the condition that selects it.
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)ARead-onlyIdempotentInspect
Free. Status and result of a job created by blackwood_pdf_extract. Poll until done is true.
ParametersJSON Schema
| Name | Required | Description | Default |
|---|---|---|---|
| jobId | Yes |
Output Schema
ParametersJSON 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 codeARead-onlyIdempotentInspect
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.
ParametersJSON Schema
| Name | Required | Description | Default |
|---|---|---|---|
| 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
ParametersJSON 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 numbersARead-onlyIdempotentInspect
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.
ParametersJSON Schema
| Name | Required | Description | Default |
|---|---|---|---|
| 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
ParametersJSON 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 financialsARead-onlyIdempotentInspect
Use when you need sec filings company financials, earnings or fundamentals for a stock ticker for the last two fiscal years. Do not use for quarterly numbers, real-time prices, non-US companies or filings older than two years. Returns JSON with a US-listed company's annual revenue, net and operating income, diluted EPS, operating cash flow and year-end balance sheet from SEC filings for 0.02 USDC per call. Typical response time 300 ms (p95). Category: Data.
ParametersJSON Schema
| 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
ParametersJSON 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 safety (readOnly, idempotent, non-destructive, closed-world), and the description adds genuine context beyond them: 0.02 USDC cost per call, ~300 ms p95 latency, and the exact data vintage (annual, last two fiscal years). It does not mention rate limits or failure modes, but the safety profile is well covered.
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, then return contents, pricing and latency; every sentence carries information. The trailing 'Category: Data.' is low-value boilerplate but costs little.
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 with a full output schema, the description supplies everything an agent needs to decide and call: scope, exclusions, cost, latency and the returned metric set. No gaps remain.
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 the ticker description already notes 'a company that files with the SEC, e.g. AAPL', so the description's US-listed/two-year framing adds only marginal meaning. The response_format enum is fully explained in the schema, not the description, 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 and resource (SEC filings company financials) plus the scope constraint (last two fiscal years, US-listed tickers), and the sibling list contains no overlapping data source, so an agent can route to it unambiguously.
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 and four when-not conditions (quarterly numbers, real-time prices, non-US companies, filings older than two years). No competing sibling exists, so no named alternative is required.
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 speechARead-onlyIdempotentInspect
Use when you need text to speech, a voice audio file or 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 your text read aloud as WAV 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.
ParametersJSON Schema
| Name | Required | Description | Default |
|---|---|---|---|
| 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
ParametersJSON 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/non-destructive and openWorld, so the safety profile is covered; the description goes well beyond by disclosing the return format (base64 WAV, 44.1 kHz mono), the engine (MeloTTS on Workers AI), supported languages, cost (0.023 USDC per call), and p95 latency (8000 ms). This is exactly the extra behavioral 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.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Front-loaded with the trigger condition, followed by exclusions, then the return/engine/cost/latency facts. Dense but every clause earns its place; no filler sentences.
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?
The tool is simple (3 params, one required) and the description covers usage boundaries, output shape, engine, language scope, cost and latency. With an output schema present, return values need no further explanation, leaving nothing an agent needs 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 coverage is 100%, so the enum values for lang and response_format are already documented. The description echoes the language list and the 'short text' / 'two minutes' length constraint but adds no syntax or default guidance 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+resource ('text to speech, a voice audio file or narration of a short text') and immediately distinguishes itself from adjacent capabilities such as voice cloning and SSML. An agent can identify the tool 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?
Provides explicit when-to-use (
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
blackwood_text_sentimentSentimentARead-onlyIdempotentInspect
Use when you need sentiment analysis of text such as reviews, comments or headlines in English. Do not use for neutral or emotion labels, non-English text or aspect-level sentiment. Returns JSON with the sentiment of English text (positive or negative 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.
ParametersJSON Schema
| Name | Required | Description | Default |
|---|---|---|---|
| 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
ParametersJSON 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 (readOnly, idempotent, non-destructive), and the description adds substantial context beyond them: the backing model (DistilBERT SST-2 on Workers AI), cost (0.004 USDC per call), batch ceiling of 20, and p95 latency of 1500 ms. Pricing and latency disclosure is behaviorally important for an agent deciding whether to 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?
Usage guidance is front-loaded and the operational facts are packed into one dense sentence with no filler. It loses a point for mild repetition ('English text' appears three times), but every sentence still 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?
With an output schema present, return values need not be re-explained, yet the description still summarizes the positive/negative-with-confidence output. Combined with model, cost, latency, batch limit, and exclusions, an agent has everything needed to invoke 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%, so the schema already documents text, texts, and response_format, including the enum semantics for response_format. The description restates the one-or-batch-of-20 choice but adds no syntax or format detail beyond the schema, so the baseline 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb+resource ('sentiment analysis of text') and scopes the input domain ('reviews, comments or headlines in English'). It is clearly separable from siblings like blackwood_text_summarize 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?
Explicitly names when-not-to-use cases ('neutral or emotion labels, non-English text or aspect-level sentiment'), which routes the agent away from this tool for the wrong sentiment variants. This is exactly the when/when-not guidance the dimension asks for.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
blackwood_text_summarizeSummarize textARead-onlyIdempotentInspect
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.
ParametersJSON Schema
| Name | Required | Description | Default |
|---|---|---|---|
| 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
ParametersJSON 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 textARead-onlyIdempotentInspect
Use when you need to translate text, a language 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 your text translated between about 100 languages by Meta M2M100 1.2B on Workers AI, with the source and target languages used for 0.012 USDC per call. Typical response time 5000 ms (p95). Category: Inference.
ParametersJSON Schema
| Name | Required | Description | Default |
|---|---|---|---|
| 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
ParametersJSON 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 further by naming the underlying model (Meta M2M100 1.2B on Workers AI), the ~100-language coverage, the per-call cost (0.012 USDC), and typical p95 latency (5000 ms). Cost and latency are operational facts the annotations cannot express, so this is real added value, not repetition.
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 trigger, followed by exclusions, then the return/cost/latency block, so the most decision-relevant content comes first. It is a dense, somewhat run-on single block, but each clause carries distinct information (model, cost, latency, response contents), so little 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 and annotations covering the safety profile, the description only needs to add what structured fields cannot: model identity, cost, latency, and language breadth, all of which it supplies. Nothing an agent needs to invoke this 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 (to, from, text, response_format) are already documented with patterns, limits, and enum semantics. The description adds only the approximate language count ('about 100 languages'), which helps set expectations for the 'to'/'from' codes but adds no syntax 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+resource ('translate text ... between two languages') with the unit of work ('a sentence or paragraph'), which cleanly separates it from siblings like blackwood_text_summarize or blackwood_text_sentiment. An agent can identify its 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?
Explicit 'Use when you need to translate text' plus concrete exclusions: formatting-preserving, certified/legal translation, and speech, with the redirect 'transcribe first' pointing to the audio_transcribe siblings. Both selection and rejection conditions are spelled out.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
blackwood_timezone_convertTime zonesARead-onlyIdempotentInspect
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.
ParametersJSON Schema
| Name | Required | Description | Default |
|---|---|---|---|
| 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
ParametersJSON 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 BaseARead-onlyIdempotentInspect
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.003 USDC per call. Typical response time 1200 ms (p95). Category: Trading.
ParametersJSON Schema
| 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
ParametersJSON 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 cover safety (readOnly, idempotent, non-destructive), so the description adds the operational context that matters: cost of 0.003 USDC per call, p95 latency of 1200 ms, and the on-chain methodology (deepest Uniswap v3 pool against USDC or WETH, plus pool/fee-tier/depth 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.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Front-loads the use condition, then exclusions, then response, cost, and latency. Every sentence carries distinct information an agent needs; 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?
Given an output schema exists, the description needn't explain return shape, yet it usefully previews the fields. Exclusions, cost, latency, and data source are all present, leaving no gap an agent needs before calling.
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 both the token identifier format and response_format enum are already documented. The description adds data-source context but no syntax or format detail beyond the schema, 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?
States a specific verb+resource ('crypto token price or market data for a Base token'), scopes it to on-chain liquidity, and explicitly distinguishes itself from siblings like blackwood_fx_rates and blackwood_wallet_balances by naming Base-only coverage.
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 (Base token price/market data) and when-not-to-use (tokens that trade only off-Base, other DEXs, Aerodrome not read, price history or OHLC). Nothing about 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_wallet_balancesWallet balances on BaseARead-onlyIdempotentInspect
Use when you need the ERC20 token balance or wallet balance of an address on Base for onchain data checks. Do not use for ethereum mainnet or other chains, NFTs, transaction history or USD values. Returns JSON with the ETH and ERC20 token balances of a wallet on Base, read on-chain in one block: 21 major tokens plus any you list for 0.004 USDC per call. Typical response time 1200 ms (p95). Category: Data.
ParametersJSON Schema
| Name | Required | Description | Default |
|---|---|---|---|
| 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
ParametersJSON Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
A4.6/5.0
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, idempotentHint=true and destructiveHint=false, so safety is covered. The description adds real behavioral context the annotations do not: per-call cost (0.004 USDC), p95 latency (1200 ms), single-block read semantics, and the 21-major-token baseline. It stops short of describing pagination or output error behavior, so not quite top marks.
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 exclusions before the return/cost details, and every sentence carries information. Slightly dense as a single run-on block, but no wasted sentences.
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 purpose, exclusions, cost, latency, and result shape; an output schema exists so it need not explain return structure, yet it still orients the agent with the ETH-plus-ERC20 JSON shape. Everything needed to call the tool correctly is present.
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 adds meaningful context for the `tokens` parameter by explaining the 21-major-token baseline plus any listed tokens and the per-call cost. It does not add semantics for includeZero or response_format beyond the schema, keeping it at a 4 rather than 5.
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 ETH and ERC20 token balances of an address) and pins the scope to Base, which cleanly separates it from the many unrelated siblings. An agent can identify the purpose 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?
"Use when you need..." plus an explicit exclusions list (Ethereum mainnet/other chains, NFTs, transaction history, USD values) tells the agent both when to select this and when a different tool like blackwood_token_price is the right call. 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_wallet_portfolioWallet portfolio and historyARead-onlyInspect
Use when you need a multi-chain wallet balance, a wallet portfolio or the recent transaction history of an address 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 wallet's native and major-token balances on Ethereum, Base or Solana plus its latest transfers in and out, in one call, leaving airdrop spam out for 0.005 USDC per call. Typical response time 3000 ms (p95). Category: Data.
ParametersJSON Schema
| Name | Required | Description | Default |
|---|---|---|---|
| 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
ParametersJSON 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 already establish read-only, non-destructive, open-world behavior, so the bar is low, yet the description adds genuinely new operational context: 0.005 USDC per call, 3000 ms p95 response time, and airdrop-spam filtering. It also discloses what the payload contains (native plus major-token balances and latest transfers in/out) in a single 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 and exclusions, and nearly every clause carries load. Minor waste remains: the chain list 'Ethereum, Base or Solana' is repeated twice in adjacent sentences, and the trailing 'Category: Data.' adds nothing operational.
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-shape explanation is not required, and the description still characterizes the payload plus spam filtering. Cost, latency, supported chains, exclusions and the address-family constraint are all covered, leaving nothing critical an agent needs before invoking it.
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 address formats, chain enumeration and historyLimit bounds; that sets the baseline at 3. The description confirms the supported chains and that history returns transfers in and out, but adds no syntax, defaults, or edge-case guidance beyond what the schema already carries.
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?
The description states a specific resource and scope: multi-chain wallet balances, portfolio, and recent transaction history for an address, restricted to Ethereum, Base and Solana. An agent can tell exactly what data comes back. It does not, however, differentiate itself from the sibling blackwood_wallet_balances, which an agent could plausibly confuse with the 'wallet balance' framing used here.
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 use trigger ('when you need a multi-chain wallet balance... or recent transaction history') and a thorough when-not list: uSD values, NFTs, DeFi positions, long-tail tokens, and chains beyond the three supported. The exclusions are the harder half of routing and they are spelled out rather than implied.
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 USDARead-onlyIdempotentInspect
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.005 USDC per call. Typical response time 5000 ms (p95). Category: Trading.
ParametersJSON Schema
| Name | Required | Description | Default |
|---|---|---|---|
| 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
ParametersJSON Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
A3.9/5.0
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Adds real context beyond the readOnly/idempotent/openWorld annotations: pricing methodology (on-chain Uniswap v3 pools on Base), the pricing gap (tokens left unpriced), the cost model (0.005 USDC per call) and latency (5000 ms p95). These are exactly the kind of operational details 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?
Information-dense and front-loaded: the when-to-use clause and exclusions come first, followed by return/cost/latency details in a single compact block. The trailing 'Category: Trading' is filler that does not earn its place.
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?
Even though an output schema exists, the description usefully signals cost, per-call latency, supported chains, pricing source and the unpriced-token caveat. What remains thin is sibling differentiation against wallet_portfolio/wallet_balances, the main thing an agent still needs to decide.
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 address, chains and response_format. The description reinforces chain coverage (Ethereum and Base) and the 0x address shape but adds little parameter meaning 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.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb and resource ('wallet portfolio value in USD', 'net worth', 'token balances with USD value'), which is more concrete than the title. However, it never distinguishes itself from the very close siblings blackwood_wallet_portfolio and blackwood_wallet_balances, leaving the agent to infer which of the three to pick.
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' clause and a concrete 'do not use for' list (solana wallets, transaction history, NFTs, DeFi positions, long-tail tokens), which is strong boundary-setting. It stops short of a 5 because it never names the alternative sibling tools an agent should route to for those excluded cases or for the overlapping portfolio/balances cases.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
blackwood_weather_forecastWeather forecastARead-onlyIdempotentInspect
Use when you need a weather forecast, temperature or precipitation for the next hours or days at a place given by coordinates. Do not use for historical weather, severe weather alerts or places given only by name (geocode first). Returns JSON with the hourly weather forecast for a latitude and longitude: temperature, precipitation, wind, humidity, cloud cover and a weather symbol, from MET Norway for 0.003 USDC per call. Typical response time 1500 ms (p95). Category: Data.
ParametersJSON Schema
| Name | Required | Description | Default |
|---|---|---|---|
| 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
ParametersJSON 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/openWorld/non-destructive, so the safety profile is covered. The description goes further with data provider (MET Norway), per-call price (0.003 USDC) and p95 latency (1500 ms), which an agent cannot infer from annotations and which matter for planning and cost control. It stops short of covering freshness, error behavior or caching.
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 trigger and exclusions, then the return payload, then operational facts (provider, cost, latency), then category. Every sentence carries information; no filler or restated title.
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 spelled out, yet the description still summarizes them. Combined with usage rules, exclusions, pricing and latency, an agent has everything needed to select and invoke 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%, so latitude/longitude ranges, WGS84 formatting, the 1-240 hour range, the 48-hour default and the meaning of the concise/detailed enum are all already documented in the schema. The description only alludes to 'next hours or days' and adds no syntax or edge-case guidance beyond it, 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 ('weather forecast... for the next hours or days at a place given by coordinates') and enumerates the returned fields (temperature, precipitation, wind, humidity, cloud cover, weather symbol). No sibling covers weather, but the coordinate-based scope still pins the tool down precisely.
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' trigger plus explicit exclusions: not for historical weather, not for severe weather alerts, and not for name-only places with a concrete remediation ('geocode first'). This is exactly the when/when-not/alternative pattern.
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 MarkdownARead-onlyIdempotentInspect
Use when you need to scrape a web page, extract content from a url or read an article as markdown 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 plus its title, description, language, canonical URL and links for 0.01 USDC per call. Typical response time 2500 ms (p95). Category: Data.
ParametersJSON Schema
| Name | Required | Description | Default |
|---|---|---|---|
| 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
ParametersJSON 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/safe, and the description adds substantial extra context: cost (0.01 USDC per call), p95 latency (2500 ms), the failure modes (JS-rendered, paywalled, non-HTML), and the shape of the return payload. This goes well beyond what structured fields convey.
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 tightly packed sentences: usage trigger first, exclusions and alternative second, return/cost/latency third. Every sentence carries load and nothing is redundant.
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, yet the description still summarizes the payload usefully. With pricing, latency, exclusions, and sibling routing all present, nothing an agent needs to call this 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 coverage is 100%, so the schema already documents url, maxChars, and response_format including the enum semantics. The description adds no syntax or default detail beyond what the schema provides; 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 ('scrape', 'extract', 'read as markdown') and resource ('web page', 'url', 'article') and explicitly distinguishes itself from the PDF sibling tool. An agent can identify this 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?
Gives explicit when-to-use ('scrape a web page, extract content from a url, read an article as markdown for an LLM') and explicit when-NOT-to-use ('JavaScript to render, behind a login or paywall, or are not HTML'), plus routing to the alternative (blackwood_pdf_extract). 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_x402_checkx402 checkARead-onlyIdempotentInspect
Use when you need an x402 endpoint test or validation of a paid API before integrating or listing it. Do not use for actually paying the endpoint, or endpoints behind authentication. Returns JSON checking an x402 endpoint without paying: whether it answers 402, the parsed payment options (scheme, network, asset, amount, payTo), Bazaar discovery metadata and problems found for 0.007 USDC per call. Typical response time 2500 ms (p95). Category: Infrastructure.
ParametersJSON Schema
| Name | Required | Description | Default |
|---|---|---|---|
| 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
ParametersJSON 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?
Beyond the annotations (readOnly, idempotent, non-destructive, open-world), the description adds critical operational context: no payment is ever attached, cost is 0.007 USDC per call, and p95 latency is 2500 ms. Cost disclosure for a paid tool is especially valuable.
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 usage conditions, then behavior, then cost/latency. The enumeration of return fields is slightly long, and somewhat redundant given an output schema exists, but every sentence 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?
Given a paid endpoint-test tool with full schema coverage and an output schema, the description supplies the remaining essentials: billing cost, latency, safety behavior, and explicit exclusions. Nothing an agent needs 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% and enums are documented, so the schema carries the parameter burden. The description adds no new parameter syntax or format detail beyond the schema, making the 3 baseline correct.
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 (test/validate) and resource (x402 endpoint) with clear scope: validating a paid API before integrating or listing it. An agent can distinguish this from siblings like blackwood_headers_audit or blackwood_wallet_balances 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 gives both when to use ('before integrating or listing it') and when not to use ('Do not use for actually paying the endpoint, or endpoints behind authentication'). This is a rare, complete guidance statement with named exclusions.
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 update
- Added
blackwood_wallet_value
3 tool updates
- Added
blackwood_company_dossier - Added
blackwood_news_briefing - Added
blackwood_wallet_portfolio
2 tool updates
- Added
blackwood_ens_lookup - Added
blackwood_gas_fees
26 tool updates
- Changed
blackwood_airport_delays1 field changed- changed
Output schema / anyOfPrevious 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" + } +]
- Changed
blackwood_audio_transcribe1 field changed- changed
Output schema / anyOfPrevious 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" + } +]
- Changed
blackwood_crypto_news1 field changed- changed
Output schema / anyOfPrevious 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" + } +]
- Changed
blackwood_domain_intel1 field changed- changed
Output schema / anyOfPrevious 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" + } +]
- Added
blackwood_email_batch - Changed
blackwood_email_check1 field changed- changed
Output schema / anyOfPrevious 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" + } +]
- Added
blackwood_fx_history - Changed
blackwood_fx_rates1 field changed- changed
Output schema / anyOfPrevious 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" + } +]
- Changed
blackwood_headers_audit1 field changed- changed
Output schema / anyOfPrevious 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" + } +]
- Changed
blackwood_image_generate1 field changed- changed
Output schema / anyOfPrevious 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" + } +]
- Changed
blackwood_llm_chat1 field changed- changed
Output schema / anyOfPrevious 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" + } +]
- Changed
blackwood_news_search1 field changed- changed
Output schema / anyOfPrevious 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" + } +]
- Changed
blackwood_pdf_extract1 field changed- changed
Output schema / anyOfPrevious 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" + } +]
- Changed
blackwood_qrcode_generate1 field changed- changed
Output schema / anyOfPrevious 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" + } +]
- Changed
blackwood_random_generate1 field changed- changed
Output schema / anyOfPrevious 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" + } +]
- Changed
blackwood_sec_facts1 field changed- changed
Output schema / anyOfPrevious 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" + } +]
- Changed
blackwood_speech_synthesize1 field changed- changed
Output schema / anyOfPrevious 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" + } +]
- Changed
blackwood_text_sentiment1 field changed- changed
Output schema / anyOfPrevious 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" + } +]
- Changed
blackwood_text_summarize1 field changed- changed
Output schema / anyOfPrevious 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" + } +]
- Changed
blackwood_text_translate1 field changed- changed
Output schema / anyOfPrevious 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" + } +]
- Changed
blackwood_timezone_convert1 field changed- changed
Output schema / anyOfPrevious 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" + } +]
- Changed
blackwood_token_price1 field changed- changed
Output schema / anyOfPrevious 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" + } +]
- Changed
blackwood_wallet_balances1 field changed- changed
Output schema / anyOfPrevious 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" + } +]
- Changed
blackwood_weather_forecast1 field changed- changed
Output schema / anyOfPrevious 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" + } +]
- Changed
blackwood_webpage_markdown1 field changed- changed
Output schema / anyOfPrevious 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" + } +]
- Changed
blackwood_x402_check1 field changed- changed
Output schema / anyOfPrevious 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 updates
- Added
blackwood_airport_delays - Added
blackwood_audio_transcribe - Added
blackwood_audio_transcribe_status - Added
blackwood_credits_balance - Added
blackwood_crypto_news - Added
blackwood_domain_intel - Added
blackwood_email_check - Added
blackwood_fx_rates - Added
blackwood_headers_audit - Added
blackwood_image_generate - Added
blackwood_image_generate_status - Added
blackwood_llm_chat - Added
blackwood_llm_chat_status - Added
blackwood_news_search - Added
blackwood_pdf_extract - Added
blackwood_pdf_extract_status - Added
blackwood_qrcode_generate - Added
blackwood_random_generate - Added
blackwood_sec_facts - Added
blackwood_speech_synthesize - Added
blackwood_text_sentiment - Added
blackwood_text_summarize - Added
blackwood_text_translate - Added
blackwood_timezone_convert - Added
blackwood_token_price - Added
blackwood_wallet_balances - Added
blackwood_weather_forecast - Added
blackwood_webpage_markdown - Added
blackwood_x402_check - Removed
domain-intel_v1 - Removed
email-check_v1 - Removed
image-gen_v1 - Removed
image-gen_v1_status - Removed
llm-chat_v1 - Removed
llm-chat_v1_status - Removed
news-headlines_v1 - Removed
pdf-text_v1 - Removed
pdf-text_v1_status - Removed
sec-facts_v1 - Removed
speech-to-text_v1 - Removed
speech-to-text_v1_status - Removed
token-price_v1 - Removed
wallet-balances_v1 - Removed
weather-forecast_v1 - Removed
web-markdown_v1
11 tool updates
- Added
email-check_v1 - Added
image-gen_v1 - Added
image-gen_v1_status - Added
llm-chat_v1 - Added
llm-chat_v1_status - Added
news-headlines_v1 - Added
speech-to-text_v1 - Added
speech-to-text_v1_status - Added
token-price_v1 - Added
wallet-balances_v1 - Added
weather-forecast_v1
5 tool updates
- First observed
domain-intel_v1 - First observed
pdf-text_v1 - First observed
pdf-text_v1_status - First observed
sec-facts_v1 - First observed
web-markdown_v1
Related MCP Connectors
26 pay-per-call tools for agents: scrape, verify, guards, crypto. x402 USDC on Base.
Pay-per-call DNS, WHOIS/RDAP, IP and domain reports for agents. x402 USDC on Base or Algorand.
232 pay-per-call agent tools: LLMs, search, browser, OCR, media, vision, email. x402 USDC.
Pay-per-call crypto data for agents: metrics, claims, custom briefs. USDC via x402.
Related MCP Servers
- AlicenseAqualityDmaintenancePay-per-call tools for AI agents including trust checks, due diligence, market data, and human-verified approvals, settled in USDC on Base via the x402 protocol.16MIT
- AlicenseAqualityCmaintenanceProvides AI agents with 10 pay-per-call utility tools (QR generation, DNS lookup, OCR, etc.) using USDC on Base via the x402 protocol, with agent's private key never leaving the agent.1136 npmMIT
- AlicenseNot gradedqualityBmaintenanceWebsite intelligence tools for AI agents. Ten pay-per-call tools via x402 micropayments (USDC on Base) — no accounts, no API keys.1MIT
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.