x402-data-gateway

Name: x402-data-gateway
Author: epistemedeus

by io.github.epistemedeus

Overview Discussions Admin

Server Details

Agent tools for discovery, payment safety, data extraction, and DeFi.

Ownership verified

Status: Healthy
Uptime: 96.3% over 77 days
Last Tested: 2026-11-02 05:47
Transport: Streamable HTTP · MCP 2025-11-25
URL
Repository: epistemedeus/x402-url-extractor
GitHub Stars: 1
Server Listing: x402-data-gateway

TDQS

A3.7/5.0

Scored 2026-10-28 04:50 across 30 tools

Disambiguation3/5

Most tools occupy distinct niches (DeFi underwriting vs. web extraction vs. settlement verification), and the descriptions aggressively cross-reference each other with 'use X instead when…' guidance. However there is real functional overlap among the five commerce/discovery auditors (agent_discoverability_audit, agent_surface_budget_audit, seller_integrity_audit, payment_offer_preflight, contract_qualified_search), and deep_audit is explicitly the union of enrich plus schemaforge, which forces agents to reason about superset-vs-subset selection. The four read/extract/trial_read tools and the recover/report paid-result pair add further near-collisions that only very careful reading of long descriptions resolves.

Naming Consistency3/5

Casing is uniformly snake_case, which is a plus, and domain grouping via prefixes (morpho_*, wallet_*, agent_*) aids scanning. But the convention is mixed: some names are bare verbs (read, extract, enrich, scan), some are bare nouns (careers_board, page_change, settlement_proof, transaction_receipt), and others are long noun phrases with no verb (stateful_wallet_policy_conformance). There is no predictable verb_noun pattern, so an agent cannot infer action from name alone.

Tool Count3/5

Thirty tools exceed the comfortable range, but this is genuinely an aggregation gateway spanning web extraction, company enrichment, DeFi/Morpho risk, chain receipts, wallet profiling, security policy conformance, and x402 commerce audits, so breadth is somewhat earned. Still, several entries look like scaffolding rather than products (trial_read, page_change, report_caller_result, recover_paid_result, careers_board_cold), pushing the surface past what an agent can comfortably hold in context.

Completeness4/5

The paid-call lifecycle is unusually well covered: discovery/preflight before authorization, seller contract audit, trial reads, post-hoc settlement_proof/transaction_receipt verification, plus recover_paid_result and report_caller_result for failure and feedback loops. Domain families (Morpho market/position/protection/replay, read/extract/batch/change, wallet enrich/policy) are internally coherent. Gaps are minor by design: everything is read-only (no signing, broadcast, or write operations), and there is no generic capability search outside the contract-qualified variant.

Available Tools

30 tools

agent_discoverability_auditAudit Agent Service DiscoverabilityAInspect

Measure one service's brand-blind rank, source-family coverage, expected-route presence, canonical-vs-alias listing identity, duplicate records, competitors, and exact-price drift across ten public machine-service discovery views. Supply runtimeUrl with an exact GET route to derive the comparison price from one coherent live unsigned x402 or MPP offer; otherwise expectedPriceUsd remains caller-supplied. Set surfaceAudit to check the target's public Agent Card, ERC-8004 registration document, and action catalog. Set materializationAudit with an exact GET or POST route to distinguish Coinbase seller ineligibility from provider acceptance without exact-resource Bazaar materialization. Catalog queries use no credentials or payments. Results are point-in-time provider and catalog evidence, not demand, seller trust, settlement, or future-rank proof. Payment challenge and credentials are bound to GET https://agents.samedaydesk.com/distribution/agent-discoverability-audit, not mcp://. Retry the identical authorized arguments and credential.

Name	Required	Description
`payTo`	No	Optional EVM payTo for alias matching
`route`	No	Optional expected exact path
`intent`	Yes	Brand-blind capability description
`method`	No	Exact route method for the optional Coinbase materialization audit. Defaults to GET; runtimeUrl is GET-only.
`origin`	Yes	Public HTTPS service origin
`runtimeUrl`	No	Optional exact same-origin HTTPS GET URL whose unpaid x402 or MPP offer supplies the runtime price reference. Requires route and an exactly matching pathname.
`surfaceAudit`	No	When true, inspect the target's public Agent Card, ERC-8004 registration document, and action catalog for the expected route through bounded same-origin fetches.
`expectedPriceUsd`	No	Optional exact route price expected by the caller. A coherent runtimeUrl offer takes precedence and caller drift is reported.
`materializationAudit`	No	When true with route and method, distinguish Coinbase seller ineligibility from provider acceptance without exact-resource Bazaar materialization.

TDQS

A4/5.0

Behavior5/5

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

With no annotations, the description carries the full burden and does so richly: it discloses that catalog queries need no credentials or payments, that results are point-in-time evidence and not demand/trust/settlement/future-rank proof, that the payment challenge is bound to a specific GET URL rather than mcp://, and that retries must repeat identical authorized arguments and credential. This is exactly the auth, retry, and limitation context an agent needs.

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

Conciseness4/5

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

Despite being one dense paragraph, it is front-loaded with the core purpose and every sentence contributes operational information (parameter conditions, auth behavior, result limits). It is appropriately sized for a 9-parameter audit tool, though the lack of sentence-level structure makes it harder to scan.

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 complex 9-parameter tool with no annotations and no output schema, the description covers purpose, parameter conditions, auth/payment behavior, and result limitations thoroughly. The main remaining gap is the shape of the returned evidence, which is not described and there is no output schema to compensate.

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 already 100%, so the baseline is 3, but the description adds real meaning beyond the schema: it states runtimeUrl takes precedence over expectedPriceUsd, that runtimeUrl is GET-only and requires a matching pathname, and that method defaults to GET. That precedence and constraint information is not derivable from the schema alone.

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 precise verb+resource: it measures one service's brand-blind rank, source-family coverage, canonical-vs-alias identity, duplicates, competitors, and price drift across ten discovery views. It is highly specific about scope, but it never names or differentiates itself from plausible siblings like agent_surface_budget_audit or seller_integrity_audit, so an agent must infer the boundary.

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

Usage Guidelines3/5

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

It gives conditional guidance for internal knobs (set surfaceAudit to check X, materializationAudit to distinguish Y, supply runtimeUrl over expectedPriceUsd since the runtime offer takes precedence). However, it gives no explicit when-to-use-this-tool-vs-alternatives routing among the many sibling audits, leaving the agent to infer the choice.

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

agent_surface_budget_auditAudit Agent Surface BudgetAInspect

Measure one public service's credential-free MCP tools/list, OpenAPI, or both declared discovery surfaces before any tool call or target payment. Use agent_discoverability_audit for catalog reach and rank, seller_integrity_audit for one exact operation's response contract, or this tool for byte budgets, heaviest definitions, missing selection contracts, and progressive-discovery fixes. Unselected surfaces are not fetched or judged. It follows no redirect, calls no target tool, sends no credential or target payment, and returns no target schema, response body, or session identifier. Payment challenge and credentials are bound to GET https://agents.samedaydesk.com/distribution/agent-surface-budget-audit, not mcp://. Retry the identical authorized arguments and credential.

Name	Required	Description	Default
`origin`	Yes	Credential-free public HTTPS service origin on port 443, with no path or query.
`mcpPath`	No	Exact root-relative MCP streamable-HTTP path.	/mcp
`openApiPath`	No	Exact root-relative OpenAPI JSON path.	/openapi.json
`surfaceMode`	No	Audit MCP only, OpenAPI only, or both. Unselected surfaces are not fetched or judged.	both
`mcpBudgetBytes`	No	Maximum preferred raw MCP tools/list response size in bytes.
`openApiBudgetBytes`	No	Maximum preferred raw OpenAPI document size in bytes.

Output Schema

Name	Required	Description
`ok`	Yes
`mcp`	Yes
`actions`	Yes
`openapi`	Yes
`product`	Yes
`request`	Yes
`version`	Yes
`boundary`	Yes
`decision`	Yes
`checkedAt`	Yes

TDQS

A4.6/5.0

Behavior5/5

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

With no annotations, the description carries the full burden and does: it declares unselected surfaces are not fetched, no redirects are followed, no target tool is called, no credential or payment is sent, and no target schema, response body, or session identifier is returned. It also discloses the payment-challenge/credential binding endpoint (GET https://agents.samedaydesk.com/... rather than mcp://) and the retry contract (identical authorized arguments and credential).

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?

Purpose, sibling routing, safety guarantees, and payment binding are front-loaded in a logical order, and each sentence carries substantive content. There is mild redundancy — the 'unselected surfaces are not fetched or judged' clause duplicates the surfaceMode schema description — which keeps it short of a 5.

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

Completeness5/5

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

For a 6-parameter audit tool with an output schema, the description need not explain return values, and it instead covers the things the schema cannot: safety profile, payment/credential binding, and retry behavior. 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 coverage is 100%, so all six parameters are already documented in the schema, including the surfaceMode enum and byte-budget bounds. The description only echoes one of these semantics ('Unselected surfaces are not fetched or judged') and adds no syntax, format, or interaction detail beyond the schema. 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?

States a precise verb and resource: measure one public service's credential-free MCP tools/list, OpenAPI, or both declared discovery surfaces. It also names the two sibling audits it is not and the specific concerns it owns (byte budgets, heaviest definitions, missing selection contracts, progressive-discovery fixes), 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?

Explicitly partitions the sibling set: agent_discoverability_audit for catalog reach and rank, seller_integrity_audit for one exact operation's response contract, this tool for byte budgets and discovery-surface sizing. The when-to-use condition is stated alongside both alternatives, and the pre-condition (before any tool call or target payment) is front-loaded.

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

careers_boardRead Named Public Careers BoardAInspect

Read one configured public careers board and return title, location or null, posting URL, source, fetchedAt, and explicit coverage. Use careers_board_cold for the acquired free recipe. Partial, missing, duplicate, listed, empty, and changed stay explicit. A source failure is unavailable and is not an empty board. Price is $0.005 USDC. Payment challenge and credentials are bound to GET https://agents.samedaydesk.com/data/careers-board, not mcp://. Retry the identical authorized arguments and credential.

Name	Required	Description	Default
`board`	Yes	Named board id or alias. Initial reference ids are acxiom and liveramp.
`company`	No	Optional alias. When board is also set, both must resolve to the same id.

Output Schema

Name	Required	Description
`ok`	Yes
`rows`	Yes
`board`	Yes
`source`	Yes
`charged`	Yes
`outcome`	Yes
`product`	Yes
`coverage`	Yes
`fetchedAt`	Yes
`roleFilter`	Yes

TDQS

A4.3/5.0

Behavior5/5

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

With no annotations, the description carries the full burden and largely discharges it: it discloses the $0.005 USDC price, that the payment challenge and credentials bind to the GET URL rather than mcp://, retry semantics with identical authorized arguments, and that a source failure surfaces as unavailable rather than an empty board. That is unusually rich behavioral context for a paid, auth-gated read.

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 purpose and return shape, and most sentences earn their place. Some fragments ("the acquired free recipe," "Partial, missing, duplicate, listed, empty, and changed stay explicit") are dense jargon that costs clarity without much added meaning.

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 re-explained, and the description still covers payment, failure, and retry behavior for a paid tool with no annotations. The residual gap is the undefined state vocabulary ("listed," "changed") that an agent may not be able to interpret.

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 `board` and `company` (including the alias-must-resolve-to-same-id rule) are already documented in the schema. The description adds no parameter syntax or format detail beyond "one configured public careers board," 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 ("Read one configured public careers board") and enumerates the returned fields, so the agent knows exactly what comes back. It also names the sibling it is not (careers_board_cold), making the distinction inferable 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?

Explicitly routes the agent to `careers_board_cold` for the "acquired free recipe," which is real when-to-use guidance against an alternative. However, the phrasing is cryptic and it never states the positive condition for choosing this tool over the cold variant, leaving some inference required.

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

careers_board_coldReturn Acquired Careers Board RecipeAInspect

Return the acquired cold careers-board recipe and its public tests. This tool is free: charged is false, it does not fetch a live board, and it does not accept payment. Use careers_board when you need one named-board observation. Direct free execution remains available.

Name	Required	Description	Default
No parameters

TDQS

A3.7/5.0

Behavior3/5

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

With no annotations, the description carries the full burden. It discloses useful behavioral facts (charged is false, does not fetch a live board, does not accept payment, free execution remains available), but says nothing about what the returned recipe/tests actually contain or their format. For a mutation-free read this is adequate but not rich.

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

Conciseness4/5

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

Three sentences, front-loaded with the core action. The billing point is somewhat repeated ('free: charged is false' and 'does not accept payment'), which is mild redundancy, but overall it is tight.

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

Completeness3/5

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

No annotations and no output schema, so the description is the only source of behavioral context. It covers the payment/fetch profile but leaves the nature of the 'recipe' and 'public tests' vague, and 'Direct free execution remains available' is unclear in meaning. Enough to call it, but with notable gaps.

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?

The schema has zero parameters and 100% description coverage, so the baseline of 4 applies. There are no parameter semantics the description needs to compensate for.

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 clear verb ('Return') and resource ('acquired cold careers-board recipe and its public tests'), and explicitly distinguishes itself from the sibling `careers_board` (one named-board observation). The term 'acquired cold recipe' is somewhat jargon-heavy, but an agent can still tell what category of artifact this returns.

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?

Explicitly routes the agent: 'Use `careers_board` when you need one named-board observation,' implying this tool serves the offline/recipe case instead. It also clarifies the free/no-payment condition. It does not state an explicit when-not for itself, but the alternative is named with its selecting condition.

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

contract_qualified_searchSearch Contract-Qualified ServicesAInspect

Search Agent402 and the official MPP catalog for paid machine services that both match a capability intent and guarantee buyer-required JSON response paths. Use agent_discoverability_audit when you are measuring one known seller's catalog reach or rank, seller_integrity_audit when you already know the exact seller route to inspect, or payment_offer_preflight when you already have one exact callable GET URL. This search excludes SameDayDesk-owned supply and unresolved routes before audit, uses no credential or wallet, sends no seller POST or target payment, reads no paid response body, and returns only a query digest. Payment challenge and credentials are bound to GET https://agents.samedaydesk.com/commerce/contract-qualified-search, not mcp://. Retry the identical authorized arguments and credential.

Name	Required	Description
`limit`	No	Maximum candidates audited and returned across Agent402 and MPP.
`query`	Yes	Capability intent sent to Agent402 and used locally to rank MPP catalog metadata. Do not include credentials or private values.
`requiredPaths`	Yes	Buyer-required dotted success-response paths that every returned seller schema must guarantee recursively.
`maxPriceDisplayUnits`	No	Maximum advertised per-call price in each source's display currency.

Output Schema

Name	Required	Description
`ok`	Yes
`product`	Yes
`request`	Yes
`sources`	Yes
`version`	Yes
`boundary`	Yes
`decision`	Yes
`rejected`	Yes
`checkedAt`	Yes
`qualified`	Yes

TDQS

A4.6/5.0

Behavior5/5

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

With no annotations, the description carries the full burden and delivers: it discloses pre-audit exclusions (SameDayDesk-owned supply, unresolved routes), the no-credential/no-wallet posture, that it sends no seller POST and reads no paid response body, and returns only a query digest. It also surfaces the payment-challenge binding to a specific GET URL rather than mcp:// and the retry semantics.

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?

Purpose and the sibling-routing alternatives are front-loaded, and every sentence carries signal. The trailing payment-binding and retry instructions are operational caveats that slightly pad length but remain relevant, keeping it just short of maximally tight.

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

Completeness5/5

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

An output schema exists, so return values need not be explained, and the description still covers exclusions, safety posture, routing, and credential/retry behavior. For a four-parameter, no-annotation tool, nothing an agent needs to invoke it correctly is missing.

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

Parameters3/5

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

Schema description coverage is 100%, so all four parameters (limit, query, requiredPaths, maxPriceDisplayUnits) are already fully documented in the schema. The description restates the intent ('capability intent', 'buyer-required JSON response paths') 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 (Search) and resource (Agent402 and the official MPP catalog for paid machine services) with a clear qualifying scope: capability intent plus guaranteed buyer-required JSON response paths. It is instantly distinguishable from the audit and preflight siblings it names.

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 routes the agent away from this tool by naming three alternatives with the exact condition selecting each: agent_discoverability_audit for one known seller's reach/rank, seller_integrity_audit for a known seller route, and payment_offer_preflight for one exact callable GET URL. 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.

deep_auditAudit Complete AI Search ReadinessAInspect

Run one read-only AI-search-readiness audit for a public business domain: company, technology, contact, and DNS/email evidence from enrich, plus the live structured-data gap analysis and paste-ready JSON-LD template from schemaforge. Use enrich for company facts only or schemaforge for structured-data remediation only. The template contains placeholders for real data; the score is diagnostic, no site changes are made, and it does not guarantee AI citations. Payment challenge and credentials are bound to GET https://agents.samedaydesk.com/deep-audit, not mcp://. Retry the identical authorized arguments and credential.

Name	Required	Description
`city`	No	Optional city the business serves; used only to contextualize the generated structured-data template.
`domain`	Yes	Public business domain or URL. The hostname is normalized and the audit starts at its HTTPS homepage; any supplied path or query is ignored.
`vertical`	No	Optional structured-data template profile. med-spas is currently specialized; unsupported values fall back to it.

TDQS

A4.4/5.0

Behavior4/5

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

With no annotations, the description carries the full burden and does well: it declares read-only/no-site-change behavior, that the template contains placeholders rather than real data, and that the score is diagnostic only. It also discloses a non-obvious operational trait — the payment challenge and credentials are bound to a GET URL rather than mcp://, with instructions to retry identical authorized arguments. It stops short of describing failure modes (unreachable or non-public domains) or rate/limit behavior, so not quite 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?

The definition is front-loaded with the core action and the sibling routing rule, and every sentence carries information (composition, exclusions, template caveat, payment binding, retry). The first sentence is heavily loaded with a long enumeration, but nothing is padding.

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?

Although there is no output schema, the description states what the audit returns (enrich-derived evidence plus gap analysis and a paste-ready JSON-LD template) and covers the unusual auth/payment and retry path. For a three-parameter composite tool, an agent has everything needed to invoke it and interpret the result.

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 three parameters (domain, city, vertical) are already documented with normalization, fallback, and contextualization semantics. The description adds only marginal framing (public business domain, placeholders in the template) and 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?

The description names a specific verb and composite resource ('Run one read-only AI-search-readiness audit for a public business domain') and enumerates exactly what it aggregates: company/technology/contact/DNS evidence from `enrich` plus structured-data gap analysis and a JSON-LD template from `schemaforge`. It explicitly distinguishes itself from those two sibling tools, so an agent can route correctly 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?

It gives an explicit alternative-selection rule: 'Use `enrich` for company facts only or `schemaforge` for structured-data remediation only,' which defines when to prefer the narrower siblings over this composite. It also clarifies the diagnostic framing ('no site changes are made', 'does not guarantee AI citations'), preventing over-expectation of the result.

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

enrichEnrich Company DomainAInspect

Inspect a public company domain and return structured identity, technology, social, contact, DNS, email-infrastructure, and AI-readiness evidence. Use schemaforge instead for a paste-ready JSON-LD template and remediation diff, or deep_audit when both outputs are required together. Public data only; this tool makes no site changes. Payment challenge and credentials are bound to GET https://agents.samedaydesk.com/enrich, not mcp://. Retry the identical authorized arguments and credential.

Name	Required	Description	Default
`domain`	Yes	Public company domain or URL, for example stripe.com. Use enrich for company evidence; use wallet_enrich for an EVM address.

TDQS

A4.3/5.0

Behavior4/5

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

With no annotations, the description carries the burden and does disclose key traits: public data only, no site changes, and a payment-challenge/credential flow bound to an HTTP GET rather than mcp://, plus retry semantics for authorized arguments. Gaps remain around actual auth prerequisites and rate limits, and the payment sentence is dense, but this is well beyond a bare description.

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 core purpose and the sibling routing in the second sentence; no filler sentences. The closing payment/retry sentences are necessary auth context but are jargon-heavy and slightly harder to parse than the rest.

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?

No output schema exists, so the description must convey returns — it does so by listing the evidence categories. Safety (no site changes), data scope (public only), and the payment/auth channel are all covered, leaving only partial gaps on failure modes and credential requirements.

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 and schema description coverage is 100%, so the schema already documents `domain` including the wallet_enrich fork. The description adds no syntax or format detail beyond that, which matches the baseline 3 when structured data 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 (inspect) and resource (public company domain) and enumerates the evidence categories returned: identity, technology, social, contact, DNS, email-infrastructure, AI-readiness. It explicitly distinguishes itself from schemaforge, deep_audit, and (via the schema) wallet_enrich, so an agent can route correctly without opening other schemas.

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

Usage Guidelines5/5

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

Gives explicit alternative selection conditions: use `schemaforge` for a paste-ready JSON-LD template and remediation diff, and `deep_audit` when both outputs are required together. This is a clean when/when-not/alternative statement rather than implied context.

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

extractExtract Web Page as Structured JSONAInspect

Fetch a public HTTP(S) page and return compact extraction signals for programmatic inspection: title, meta description, Open Graph/Twitter metadata, JSON-LD, headings, links, text excerpt, and AI-readiness flags. Use read instead when you need the page body as LLM-ready Markdown rather than metadata or a link inventory. Does not execute JavaScript; follows redirects and applies SSRF, timeout, and response-size guards. Payment challenge and credentials are bound to GET https://agents.samedaydesk.com/extract, not mcp://. Retry the identical authorized arguments and credential.

Name	Required	Description	Default
`url`	Yes	Public HTTP(S) URL. Choose extract for metadata, JSON-LD, headings, links, and a bounded text excerpt; use read for longer bounded Markdown. Content is fetched without JavaScript rendering. Check status/sourceOk/error/capture; ok means a typed extract record, not source completeness.
`textExcerptLimitChars`	No	Optional excerpt budget. Default 1200. Maximum 40000. Rejected before fetch. Does not purchase /read or change the price.

Output Schema

Name	Required	Description
`ok`	Yes
`url`	Yes
`lang`	Yes
`text`	Yes
`error`	Yes
`links`	Yes
`title`	Yes
`jsonLd`	Yes
`status`	Yes
`capture`	Yes
`twitter`	Yes
`finalUrl`	Yes
`headings`	Yes
`sourceOk`	Yes
`canonical`	Yes
`fetchedAt`	Yes
`openGraph`	Yes
`aiReadiness`	Yes
`contentType`	Yes
`description`	Yes
`requestedUrl`	Yes

TDQS

A4.8/5.0

Behavior5/5

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

With no annotations, the description carries the full burden and does so richly: no JavaScript execution, redirect following, SSRF/timeout/response-size guards, and the payment/credential binding to the GET endpoint rather than mcp://, plus retry semantics. These are exactly the non-obvious operational traits an agent needs before calling a fetcher.

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 core action and return set, followed by routing, behavioral limits, and payment/retry notes. Dense but every sentence carries information; the payment-binding sentence is slightly cryptic but not 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?

For a two-parameter fetch tool with an output schema available, the definition covers purpose, the sibling routing decision, JS/redirect/guard behavior, and auth/retry handling. An agent has everything needed to call it correctly and interpret failure via status/sourceOk/error.

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 the schema already documents url and textExcerptLimitChars (default 1200, max 40000, rejected pre-fetch). The description adds only the general notion of a bounded excerpt, which is already implied upstream; it does not add new semantics, so the high-coverage baseline applies with a slight bump for reinforcing the budget concept.

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 (Fetch) and resource (public HTTP(S) page) and enumerates the returned artifact set (title, meta, OG/Twitter, JSON-LD, headings, links, excerpt, AI-readiness flags). It explicitly contrasts itself with the `read` sibling, so an agent can distinguish the two 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?

Names the alternative tool and the exact condition that selects it: 'Use `read` instead when you need the page body as LLM-ready Markdown rather than metadata or a link inventory.' The url parameter description reinforces the same routing rule, 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.

extract_batchExtract Public URLs in BatchAInspect

Fetch one to five public HTTPS URLs and return bounded structured fields for each source in one paid attempt. Supply urls as a JSON array and optional unique fields. Use extract for a single URL when you do not need batch accounting. Charge is one flat introductory 0.01 USDC quote for the bounded attempt, not a guarantee that every URL succeeds. Automatic retries are disabled; unknown outcomes must not be re-paid automatically. Payment challenge and credentials are bound to POST https://agents.samedaydesk.com/extract/batch, not mcp://. Retry the identical authorized arguments and credential.

Name	Required	Description
`urls`	Yes	One to five public HTTPS URLs as a JSON array. Charge is one flat introductory attempt, not per-URL success.
`fields`	No	Optional unique bounded subset of structured extraction fields.
`textExcerptLimitChars`	No	Optional per-item excerpt budget. Omitted requests keep 1200. A value that cannot fit the batch response ceiling is rejected before fetch. Does not change the price.

Output Schema

Name	Required	Description
`ok`	Yes
`error`	No
`jobId`	Yes
`quote`	Yes
`charged`	Yes
`partial`	Yes
`product`	Yes
`sources`	Yes
`boundary`	Yes
`jobStatus`	Yes
`accounting`	Yes
`costInputs`	Yes
`stopReason`	Yes
`schemaVersion`	Yes

TDQS

A4.6/5.0

Behavior5/5

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

With no annotations, the description carries the full burden and does so: it discloses a flat 0.01 USDC introductory charge that is not a per-URL success guarantee, disables automatic retries, warns against re-paying unknown outcomes, and specifies that the payment challenge is bound to the HTTPS POST endpoint rather than mcp://. This is exactly the behavioral context an agent needs for a paid, non-idempotent 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?

It is front-loaded with purpose and scoping, and most sentences earn their place by covering cost, retry, and credential binding. There is mild redundancy, since the flat charge is stated in both the description and the `urls` schema, keeping it just short of a 5.

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

Completeness5/5

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

An output schema exists so return values need not be explained, and the description still supplies the payment, retry, and endpoint-binding context that annotations would otherwise provide. Nothing an agent needs to invoke this paid batch tool correctly appears to be 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 `urls`, `fields`, and the excerpt budget. The description restates `urls` and `fields` semantics but never mentions `textExcerptLimitChars`, adding 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 opening sentence states a concrete verb+resource+scope ('Fetch one to five public HTTPS URLs and return bounded structured fields for each source in one paid attempt'). It also explicitly distinguishes itself from the sibling `extract` for single-URL use, so an agent can route between them without opening schemas.

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

Usage Guidelines5/5

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

It names the alternative ('Use `extract` for a single URL when you do not need batch accounting') with the selecting condition, and gives explicit retry guidance ('Retry the identical authorized arguments and credential') plus a when-not ('unknown outcomes must not be re-paid automatically').

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

lockfile_pin_deltaInspect Lockfile Pin DeltaAInspect

Inspect two caller-supplied npm package-lock.json objects and return added, removed, and changed name+version+integrity+resolved pins. Supply JSON before and after lockfile objects, not filesystem paths, URLs, or commands. An identical pin set is informational, not a failure. HTML, package.json, and unsupported lockfileVersion values are refused before payment. This is not an npm install, audit, or purchase. Ordinary wallets sign through examples/customer-x402 (inspect, explicit approve, attempt-receipt, read-only reconcile), not a precomputed signature. Initial live release accepts x402 only. Payment challenge and credentials are bound to POST https://agents.samedaydesk.com/lockfile-pin-delta, not mcp://. Retry the identical authorized arguments and credential.

Name	Required	Description	Default
`after`	Yes	npm package-lock.json object (lockfileVersion 2 or 3). Not a filesystem path, URL, or command.
`before`	Yes	npm package-lock.json object (lockfileVersion 2 or 3). Not a filesystem path, URL, or command.

Output Schema

Name	Required	Description
`ok`	Yes
`error`	No
`quote`	Yes
`digest`	Yes
`engine`	Yes
`limits`	Yes
`charged`	Yes
`product`	Yes
`analysis`	Yes
`boundary`	Yes
`markdown`	No
`transport`	Yes
`costInputs`	Yes
`owedDelivery`	No
`schemaVersion`	Yes
`markdownOmitted`	No
`engineProvenance`	Yes

TDQS

A4.4/5.0

Behavior5/5

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

With no annotations, the description carries the full burden and discharges it: identical pin sets are informational rather than failures, HTML/package.json/unsupported lockfileVersion are refused before payment, only x402 is accepted in the live release, credentials are bound to the POST endpoint rather than mcp://, and identical authorized arguments should be retried. This is unusually complete behavioral disclosure.

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?

Purpose and return values are front-loaded, and every sentence carries operative information (input format, no-op semantics, refusal cases, payment, auth binding, retry). It is a dense multi-topic paragraph, but nothing is filler and the ordering is sensible.

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 a nested-object input and a paid/authenticated flow, the description covers inputs, refusals, payment scheme, credential binding, and retry behavior, and an output schema exists so return details need not be restated. 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 coverage is 100% and both parameter descriptions already state 'npm package-lock.json object... Not a filesystem path, URL, or command.' The description repeats that constraint verbatim, adding no new syntax, size, or version 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 and resource ('Inspect two caller-supplied npm package-lock.json objects') plus the exact output shape ('added, removed, and changed name+version+integrity+resolved pins'). The closing negatives ('not an npm install, audit, or purchase') fence off plausible confusions, so an agent can identify the operation 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?

Gives explicit input expectations ('Supply JSON before and after lockfile objects, not filesystem paths, URLs, or commands') and explicit exclusions ('not an npm install, audit, or purchase'), plus the required wallet signing flow. It does not name any sibling tool by name, but the sibling list is a different domain, so routing risk is low.

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

morpho_market_underwriteUnderwrite Morpho MarketAInspect

Underwrite one Base Morpho market with independent GraphQL, REST, and direct-RPC evidence for configuration integrity, liquidity, utilization, concentration, borrower health bands, recent history, bad debt, and PreLiquidation availability. Use morpho_position or morpho_protection for one borrower's current position or protection plan, and morpho_preliquidation_replay for the economics of one completed historical event. Read-only evidence with explicit disagreements; no opaque risk score or transaction action. Payment challenge and credentials are bound to GET https://agents.samedaydesk.com/defi/morpho-market-underwrite, not mcp://. Retry the identical authorized arguments and credential.

Name	Required	Description	Default
`marketId`	Yes	Morpho market ID on Base mainnet

TDQS

A4.5/5.0

Behavior5/5

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

No annotations are provided, so the description carries the full burden and does so: it discloses read-only nature, that evidence is gathered from three independent sources (GraphQL, REST, direct-RPC), that disagreements are surfaced explicitly rather than resolved into an opaque risk score, that no transaction action occurs, and that payment/credentials are bound to a specific GET URL rather than mcp://.

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 purpose, then alternatives, then behavioral constraints; every sentence earns its place. Slightly dense with a long evidence enumeration, but there is no filler or repetition.

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 no output schema and no annotations, the description does the work of describing the return content by enumerating the evidence dimensions, and it covers read-only semantics, routing, and payment/retry handling. It stops short of describing the response shape or error surface in detail, which is a minor gap for a single-param tool.

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

Parameters3/5

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

Schema description coverage is 100% — marketId is fully documented with a hex pattern and 'Base mainnet' qualifier. The description adds only the implicit scoping ('one Base Morpho market') and no additional syntax or format 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 (underwrite) and resource (one Base Morpho market) and enumerates exactly what evidence is produced (configuration integrity, liquidity, utilization, concentration, borrower health, bad debt, PreLiquidation availability). It also explicitly names the sibling tools it is not (morpho_position, morpho_protection, morpho_preliquidation_replay), so an agent can route without opening another 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?

Names the alternatives and the exact conditions that select them: morpho_position/morpho_protection for a single borrower's current state, morpho_preliquidation_replay for the economics of one completed historical event. It also states when-not (no transaction action) and the retry condition for identical authorized arguments.

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

morpho_positionInspect Morpho Borrower PositionAInspect

Inspect one Base borrower across Morpho markets and return position balances, LTV, health factor, liquidation headroom, direct-RPC verification, and caller-selected collateral-price stress scenarios. Use morpho_protection when you need exact repay or add-collateral amounts and unsigned transaction templates, morpho_market_underwrite for market-wide risk, or morpho_preliquidation_replay for one completed historical event. Read-only; no wallet, signing, broadcast, or custody. Payment challenge and credentials are bound to GET https://agents.samedaydesk.com/defi/morpho-position, not mcp://. Retry the identical authorized arguments and credential.

Name	Required	Description	Default
`shocks`	No	Collateral price shocks in percent
`address`	Yes	Borrower EVM address on Base mainnet

TDQS

A4.3/5.0

Behavior4/5

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

With no annotations provided, the description carries the full behavioral burden and does well: it declares read-only scope ('no wallet, signing, broadcast, or custody'), discloses the payment/credential binding endpoint (GET https://..., not mcp://), and gives retry semantics. It stops short of noting rate limits or pagination/caching behavior, so it is strong but not exhaustive.

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

Conciseness4/5

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

The purpose is front-loaded, followed by alternatives and then operational caveats. Every sentence carries information, though the payment-endpoint and retry clause makes it dense. Slightly tighter grouping of the operational notes would improve it.

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?

No output schema exists, and the description compensates by listing the returned fields (balances, LTV, health factor, liquidation headroom, direct-RPC verification, stress scenarios). Combined with the read-only declaration and payment/retry notes, an agent has what it needs to invoke correctly; only minor edges like pagination are omitted.

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 (address, shocks) are already documented in the schema, which sets the baseline at 3. The description's mention of 'caller-selected collateral-price stress scenarios' loosely maps to the shocks parameter but adds no syntax, range, or format detail beyond what the schema provides.

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 ('Inspect one Base borrower across Morpho markets') and enumerates the outputs returned (balances, LTV, health factor, liquidation headroom, stress scenarios). It clearly distinguishes itself from sibling tools by naming what those tools do instead, so an agent can separate it 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 routes the agent: 'Use morpho_protection when you need exact repay or add-collateral amounts...', 'morpho_market_underwrite for market-wide risk', 'morpho_preliquidation_replay for one completed historical event.' When-to-use and when-to-use-alternatives are both stated with conditions.

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

morpho_preliquidation_replayReplay Morpho PreLiquidationAInspect

Reconstruct one successful Base Morpho PreLiquidation transaction from its receipt and the exact block state, returning repaid and seized assets, protocol-oracle valuation, gross incentive, configured health window, and transaction gas before off-chain costs. Use morpho_market_underwrite for current market risk, morpho_position for a current borrower, or morpho_protection for a future protection plan. Historical read-only evidence; no transaction simulation, wallet, signing, or broadcast. Payment challenge and credentials are bound to GET https://agents.samedaydesk.com/defi/morpho-preliquidation-replay, not mcp://. Retry the identical authorized arguments and credential.

Name	Required	Description	Default
`transactionHash`	Yes	Successful Base transaction containing a Morpho PreLiquidate event

Output Schema

Name	Required	Description
`ok`	Yes
`chain`	Yes
`events`	Yes
`product`	Yes
`version`	Yes
`boundary`	Yes
`eventCount`	Yes
`transaction`	Yes
`verification`	Yes

TDQS

A4.3/5.0

Behavior4/5

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

With no annotations, the description carries the full burden and does most of it: it declares the operation read-only historical evidence with no simulation, wallet, signing, or broadcast, and discloses the payment-challenge/credential binding to a GET endpoint rather than mcp://, plus retry semantics. It stops short of stating auth/rate-limit specifics or failure modes, 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.

Conciseness4/5

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

Front-loaded with purpose, then alternatives, then behavioral caveats — a sensible order. Dense but each clause carries information; the endpoint/credential sentence is slightly heavy but is genuinely non-obvious operational detail.

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 enumerated (the description does anyway, harmlessly). The read-only scope, payment binding and retry instruction cover the operational essentials for a one-parameter tool; only explicit auth/permission expectations are absent.

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 single transactionHash parameter is fully documented with a pattern and the constraint that it must contain a Morpho PreLiquidate event. The description 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 ('Reconstruct'), a precise resource (one successful Base Morpho PreLiquidation transaction), its inputs (receipt + exact block state) and its outputs (repaid/seized assets, oracle valuation, incentive, health window, gas). It explicitly names three sibling tools it is not, so an agent can distinguish it without opening schemas.

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

Usage Guidelines5/5

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

Routes the agent explicitly: morpho_market_underwrite for current market risk, morpho_position for a current borrower, morpho_protection for a future plan — this tool is for historical replay of one settled transaction. The 'no transaction simulation' line further rules out a plausible misuse.

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

morpho_protectionPlan Morpho Borrower ProtectionAInspect

Calculate two alternative protection plans for one Base Morpho borrower under a selected collateral-price shock and target health factor: partial repayment or added collateral. Each plan includes the bounded asset amount, expected stressed health factor, evidence basis, and unsigned ERC-20 approval plus Morpho call templates. Use morpho_position for diagnosis without an action plan, morpho_market_underwrite for market-wide risk, or morpho_preliquidation_replay for a completed historical event. Read-only; no wallet, signing, broadcast, or custody. Payment challenge and credentials are bound to GET https://agents.samedaydesk.com/defi/morpho-protection, not mcp://. Retry the identical authorized arguments and credential.

Name	Required	Description
`address`	Yes	Borrower EVM address on Base mainnet.
`executionBufferBps`	No	Additional repayment or collateral amount buffer in basis points for debt accrual and integer rounding; 25 means 0.25%.
`targetHealthFactor`	No	Target Morpho health factor after the selected collateral-price shock; must be greater than 1 and at most 5.
`protectAgainstShockPct`	No	Collateral-price shock percentage to withstand, from -99 through 0; for example -10 models a 10% price decline.

Output Schema

Name	Required	Description
`ok`	Yes
`chain`	Yes
`inputs`	Yes
`quotes`	Yes
`source`	Yes
`address`	Yes
`product`	Yes
`version`	Yes
`boundary`	Yes
`fetchedAt`	Yes
`invariants`	Yes
`positionCount`	Yes
`actionableCount`	Yes
`latestIndexedAt`	Yes
`unverifiedCount`	Yes

TDQS

A4.6/5.0

Behavior5/5

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

With no annotations, the description carries the full burden and does so: it declares read-only operation and explicitly excludes wallet, signing, broadcast, and custody. It also discloses the outputs included (bounded asset amount, stressed health factor, evidence basis, unsigned approval/call templates) and the payment/credential mechanism with the retry instruction.

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 core purpose and the alternative routing before the operational details. Mostly efficient, though the payment-challenge/credential sentence is dense and slightly tangential for a tool-selection reader.

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 planning tool with a full output schema, no annotations, and 100% schema coverage, the description is complete: it covers purpose, alternative selection, safety profile, and output contents. Nothing an agent needs to invoke it correctly is missing.

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

Parameters3/5

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

Schema description coverage is 100%, so the schema already documents address, executionBufferBps, targetHealthFactor, and protectAgainstShockPct thoroughly. The description references the shock and target health factor conceptually but adds no format or unit 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 ('Calculate') and resource ('two alternative protection plans for one Base Morpho borrower') with the exact scope (partial repayment vs added collateral, one shock, one target health factor). It names and distinguishes each relevant sibling, so an agent can tell it apart from morpho_position, morpho_market_underwrite, and morpho_preliquidation_replay without opening a schema.

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

Usage Guidelines5/5

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

Explicitly routes the agent to alternatives with the condition that selects each: morpho_position for diagnosis without an action plan, morpho_market_underwrite for market-wide risk, morpho_preliquidation_replay for a completed historical event. Leaves nothing to inference about when this tool is the right choice.

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

opportunity_preflightPreflight Agent Work OpportunityAInspect

Agent work opportunity -> deterministic attempt, verify-first, or abandon preflight using caller-supplied cost and selection assumptions plus dated platform evidence. Returns break-even probability, expected surplus, hard gates, and source-linked evidence. No claim, bid, payment, or submission. Payment challenge and credentials are bound to GET https://agents.samedaydesk.com/work/opportunity-preflight, not mcp://. Retry the identical authorized arguments and credential.

Name	Required	Description	Default
`hours`	Yes	Estimated human and agent work time in hours for one complete attempt.
`slots`	No	Number of independently paid winner or worker slots.
`platform`	No	Optional platform slug used to attach dated platform-health evidence when a matching card exists.
`rewardUsd`	Yes	Maximum gross reward in USD if the opportunity is selected and paid.
`acceptance`	No	How completion is accepted: deterministic proof, machine score, review deadline, discretionary judgment, or unknown.	unknown
`computeUsd`	No	Expected model, API, hosting, and compute spend in USD for one attempt.
`settlement`	No	How the reward is funded and paid: direct, escrow, platform balance, discretionary, unfunded, or unknown.	unknown
`agentAccess`	No	Whether the platform explicitly allows agent participation, is agent-only, mixes agents and humans, is human-only, or remains unknown.	unknown
`competition`	No	Known number of competing submissions or workers; use 0 when unknown.
`hourlyCostUsd`	Yes	Internal opportunity cost per hour in USD.
`reusableValueUsd`	No	Conservative USD value of reusable code, research, distribution, or other assets created by the attempt.
`mandatorySpendUsd`	No	Non-recoverable cash spend in USD required before the opportunity can settle.
`selectionProbabilityPct`	No	Caller-supplied probability, from 0 to 100, of receiving the reward; omit to receive a verify-first decision.

Output Schema

Name	Required	Description
`ok`	Yes
`gates`	Yes
`input`	Yes
`product`	Yes
`version`	Yes
`boundary`	Yes
`decision`	Yes
`economics`	Yes
`platformEvidence`	Yes

TDQS

A3.7/5.0

Behavior4/5

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

With no annotations, the description carries the full burden and does so well: it discloses the absence of side effects ('No claim, bid, payment, or submission'), the auth model (payment challenge and credentials bound to the GET URL, not mcp://), and retry semantics ('Retry the identical authorized arguments and credential'). It stops short of describing rate limits or evidence freshness beyond 'dated'.

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

Conciseness4/5

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

Three sentences are front-loaded with the purpose and outcome set, with no redundant restatement of the title. The arrow notation and dense jargon are slightly awkward, and the credential-binding sentence could be tighter, but nothing is wasted.

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 13-parameter decision tool with an output schema and no annotations, the description covers the essential behavioral facts an agent needs: no mutation, the decision outputs, auth binding, and retry rule. It is nearly complete, missing only guidance on input trust sources.

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 13 parameters are already documented with units, ranges, defaults, and enums. The description only gestures at 'cost and selection assumptions' generally and adds no syntax or interpretation guidance 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.

Purpose4/5

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

The description states a specific verb and resource ('preflight' an 'agent work opportunity') and names the three decision outcomes (deterministic attempt, verify-first, abandon). It partially distinguishes itself from payment tools by stating 'No claim, bid, payment, or submission,' but does not explicitly differentiate from the adjacent payment_offer_preflight sibling.

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

Usage Guidelines3/5

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

Usage is implied: it consumes 'caller-supplied cost and selection assumptions plus dated platform evidence' and the schema notes that omitting selectionProbabilityPct yields a verify-first decision. However, there is no explicit when-to-use versus when-to-skip guidance or a named alternative, leaving routing to inference.

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

page_changeCompare Held Page ExtractsAInspect

Compare two already-held extract-batch JSON artifacts. charged is false. Not a paid SKU. Does not fetch, pay, or schedule a second observation. Compare only the explicitly selected data keys present on both matched rows. Missing keys are coverage unknown, not deletions; explicit null is a present value. Unselected metadata is not a content delta. SYNTHETIC offline construction example only. No URL fetch, payment, receipt, observation or freshness is evidenced. Complete request example (title changes, description stays unchanged): {"before":{"ok":true,"product":"samedaydesk-extract-batch","schemaVersion":"samedaydesk.extract-batch.v0","quote":{"amountAtomic":"10000","displayUsdc":"0.01","meaning":"SYNTHETIC offline construction example only. No URL fetch, payment, receipt, observation or freshness is evidenced."},"jobId":"0000000000000000000000000000000000000000000000000000000000000000","jobStatus":"completed","stopReason":null,"partial":false,"sources":[{"id":"item-001","source":"https://synthetic.example.invalid/page","status":"success","data":{"title":"Synthetic title before","description":"Stable synthetic description"},"notes":[],"error":null,"provenance":{"transport":"synthetic","note":"SYNTHETIC offline construction example only. No URL fetch, payment, receipt, observation or freshness is evidenced."}}],"accounting":{"requests":0,"bytes":0,"wallMs":0,"retries":0,"succeeded":0,"partial":0,"failed":0,"unknown":0,"skippedDuplicate":0},"costInputs":{"note":"SYNTHETIC offline construction example only. No URL fetch, payment, receipt, observation or freshness is evidenced."},"charged":false,"boundary":{"guaranteedUrlSuccess":false,"introductoryPrice":true,"sourceFetchBeforeAuthorization":false,"automaticRetries":false}},"after":{"ok":true,"product":"samedaydesk-extract-batch","schemaVersion":"samedaydesk.extract-batch.v0","quote":{"amountAtomic":"10000","displayUsdc":"0.01","meaning":"SYNTHETIC offline construction example only. No URL fetch, payment, receipt, observation or freshness is evidenced."},"jobId":"1111111111111111111111111111111111111111111111111111111111111111","jobStatus":"completed","stopReason":null,"partial":false,"sources":[{"id":"item-001","source":"https://synthetic.example.invalid/page","status":"success","data":{"title":"Synthetic title after","description":"Stable synthetic description"},"notes":[],"error":null,"provenance":{"transport":"synthetic","note":"SYNTHETIC offline construction example only. No URL fetch, payment, receipt, observation or freshness is evidenced."}}],"accounting":{"requests":0,"bytes":0,"wallMs":0,"retries":0,"succeeded":0,"partial":0,"failed":0,"unknown":0,"skippedDuplicate":0},"costInputs":{"note":"SYNTHETIC offline construction example only. No URL fetch, payment, receipt, observation or freshness is evidenced."},"charged":false,"boundary":{"guaranteedUrlSuccess":false,"introductoryPrice":true,"sourceFetchBeforeAuthorization":false,"automaticRetries":false}},"fields":["title","description"]}

Name	Required	Description
`after`	Yes
`clock`	No	Optional caller UTC ISO-8601 timestamp with trailing Z, accepted for compatibility only; cannot attest freshness.
`before`	Yes	Already held JSON artifact or JSON envelope, never a path or URL to dereference. Stable source identity, separate from row id and observation time. Matching normalizes source strings (URL fragments removed). Use the same non-empty identity on both sides; duplicate active identities are ambiguous. Synthetic URL STRINGS are inert and are never fetched by this transform. The structured branches describe representative comparable inputs. Incomplete objects remain admitted for diagnostic reports, subject to unchanged HTTP safety checks; HTTP 200 does not establish completeness or usefulness.
`fields`	Yes	Explicit non-empty unique subset of supported fields. Compare only the explicitly selected data keys present on both matched rows. Missing keys are coverage unknown, not deletions; explicit null is a present value. Unselected metadata is not a content delta.
`maxStaleMs`	No	Optional freshness horizon, not a compute ceiling or freshness authority.
`allowFreshClaim`	No	Supplied inputs cannot attest freshness. True is rejected.

TDQS

A4/5.0

Behavior4/5

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

With no annotations, the description carries the full burden and does substantial work: charged is false, no payment/receipt/freshness is evidenced, and it defines the comparison semantics (missing keys mean coverage unknown, explicit null is a present value, unselected metadata is not a delta). It does not describe the shape of the comparison result or failure behavior, which keeps it short of a 5.

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

Conciseness2/5

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

The purpose is correctly front-loaded, but the body then repeats the identical 'SYNTHETIC offline construction example only' disclaimer roughly eight times and embeds a multi-hundred-token JSON example that largely restates the input schema. A large fraction of the text does not add information beyond what the schema already encodes.

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

Completeness3/5

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

Inputs, safety boundaries, and matching semantics are well covered for a six-parameter tool, but there is no output schema and the description never says what a comparison result looks like (delta structure, per-field changed/added/removed reporting). An agent knows how to call it but not how to interpret the response.

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 already 83%, so the baseline is 3, but the description earns more: it explains that 'fields' selects which data keys are compared and that matching happens on the same non-empty source identity, with duplicate identities ambiguous. The worked before/after/fields example also clarifies how the required parameters compose.

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 first sentence states a specific verb and resource: 'Compare two already-held extract-batch JSON artifacts.' The negative scope ('Does not fetch, pay, or schedule a second observation') separates it from extract/extract_batch, which actually observe pages, so an agent can pick the right tool 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?

Establishes a clear precondition, namely that both artifacts are already in hand, and rules out re-observation or payment. It never names an alternative sibling (e.g. extract_batch) as the tool to use when you do need a fresh observation, so the routing guidance is implicit rather than explicit.

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

payment_offer_preflightPreflight x402 and MPP OfferAInspect

Compare x402 and MPP payment challenges, terms, and seller-declared JSON success-response readiness for one exact public HTTPS GET route before buyer authorization, including URL and realm binding, expiry, cross-protocol economic parity, and exact-route OpenAPI evidence. Use agent_discoverability_audit instead when you need to know whether catalogs rank or expose a service. This tool uses no target credential, signature, or target payment, follows no redirect, never reads the paid target body, and reads only the same-origin public OpenAPI document under a strict size cap. A seller declaration is advisory and does not establish runtime validity, seller trust, utility, or settlement reliability. Payment challenge and credentials are bound to GET https://agents.samedaydesk.com/commerce/payment-offer-preflight, not mcp://. Retry the identical authorized arguments and credential.

Name	Required	Description	Default
`url`	Yes	Exact public HTTPS GET route whose unpaid x402 and MPP challenge headers and same-origin OpenAPI success-response declaration should be inspected before buyer authorization. Credential-like query keys, fragments, unresolved parameters, local hosts, redirects, and non-public IPs are rejected.
`catalog`	No	Optional caller-supplied catalog candidate. When present, the tool compares it with every live unsigned offer across request, protocol, amount, network, asset, recipient, and expiry.

Output Schema

Name	Required	Description
`ok`	Yes
`offers`	Yes
`parity`	Yes
`target`	Yes
`product`	Yes
`version`	Yes
`boundary`	Yes
`decision`	Yes
`findings`	Yes
`checkedAt`	Yes
`protocols`	Yes
`offerCount`	Yes
`catalogCoherence`	Yes
`responseContract`	Yes
`responseContractAcquisition`	Yes

TDQS

A4.5/5.0

Behavior5/5

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

With no annotations, the description carries the full burden and discharges it: no target credential, signature, or payment is used; no redirects followed; paid target body never read; only the same-origin public OpenAPI document is fetched under a strict size cap. It also warns that a seller declaration is advisory and does not establish runtime validity, trust, utility, or settlement reliability.

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

Conciseness3/5

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

The purpose is front-loaded and every claim is informative, but the payload arrives as one dense four-sentence block with heavy clause stacking and redundant restatement of URL/route binding. It is information-rich but not well-structured or skimmable.

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

Completeness5/5

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

An output schema exists, so return values need no explanation, and the absence of annotations is fully compensated by explicit disclosure of what the tool does not touch (credentials, signatures, redirects, target body) and the retry guidance. Nothing needed to call it correctly is missing.

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

Parameters3/5

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

Schema description coverage is 100%, so both the `url` and nested `catalog` object fields are already fully documented in the schema. The description only restates the exact-route scoping already covered by the `url` schema description, so it adds little beyond the structured fields — 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 scope: compare x402 and MPP challenges, terms, and seller-declared JSON success-response readiness for one exact public HTTPS GET route. It explicitly distinguishes itself from the sibling `agent_discoverability_audit` by naming the different question that tool answers.

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 ('before buyer authorization') and an explicit alternative with its selecting condition ('use `agent_discoverability_audit` instead when you need to know whether catalogs rank or expose a service'). Nothing is left to inference for tool selection.

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

readRead Web Page as MarkdownAInspect

Fetch a public HTTP(S) page and return its readable body as cleaned Markdown for LLM context, preserving headings, links, and lists while dropping navigation, ads, scripts, headers, footers, asides, and forms. Use extract instead when you need metadata, JSON-LD, Open Graph/Twitter tags, or a link inventory. Markdown is capped at 40,000 characters and no JavaScript is executed. Payment challenge and credentials are bound to GET https://agents.samedaydesk.com/read, not mcp://. Retry the identical authorized arguments and credential.

Name	Required	Description	Default
`url`	Yes	Public HTTP(S) URL whose readable body is needed as Markdown. Content is fetched without JavaScript rendering and may be truncated at 40,000 characters. Check status/sourceOk/error/truncated/capture; missing discussion text is not proof of absence.

Output Schema

Name	Required	Description
`ok`	Yes
`url`	Yes
`error`	Yes
`title`	Yes
`status`	Yes
`capture`	Yes
`finalUrl`	Yes
`markdown`	Yes
`sourceOk`	Yes
`fetchedAt`	Yes
`truncated`	Yes
`wordCount`	Yes
`requestedUrl`	Yes

TDQS

A4.3/5.0

Behavior4/5

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

No annotations are present, so the description carries the full burden, and it does well: it discloses that Markdown is capped at 40,000 characters, no JavaScript is executed, and which DOM regions are stripped. It also surfaces the payment-challenge/credential binding and retry behavior. The last two sentences are confident but somewhat cryptic about the challenge flow, keeping it just 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-loads purpose and return format, then alternatives, then constraints. Mostly efficient, though the trailing payment-challenge/credential sentences are dense and their relevance to an ordinary read call is not obvious.

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 spelled out, and the description covers scope, alternatives, truncation, and JS behavior. The one gap is a clean explanation of the payment-challenge/credential flow, which is asserted rather than described.

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% for the single `url` parameter, and the schema already documents no-JS fetching, the 40,000-char truncation, and the status/sourceOk/error/truncated/capture review. The description adds no format or syntax 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 (fetch) and resource (public HTTP(S) page) and the exact return shape (readable body as cleaned Markdown for LLM context), including what is preserved and dropped. It explicitly differentiates itself from the sibling `extract` tool. An agent can distinguish it from siblings without opening a schema.

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

Usage Guidelines5/5

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

Explicitly routes the agent: use `extract` instead when metadata, JSON-LD, Open Graph/Twitter tags, or a link inventory are needed. This is a clear when-to-use-this-vs-alternative rule, plus retry guidance for the payment/credential case.

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

recover_paid_resultBInspect

Read the stored outcome of an earlier native paid call using its original input and credential. This call cannot execute or pay.

Name	Required	Description	Default
`name`	Yes
`arguments`	Yes

TDQS

B3.3/5.0

Behavior3/5

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

With no annotations, the description must carry full behavioral burden. It does disclose two important traits: the operation is read-only ('cannot execute or pay') and it requires a credential. It omits permission/auth specifics, behavior on a missing or expired result, and any side effects or rate limits.

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

Conciseness5/5

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

Two sentences, zero waste. The purpose leads and the critical constraint ('cannot execute or pay') is front-loaded and unambiguous.

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

Completeness3/5

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

For a recovery tool with no annotations, no output schema, and 0% schema coverage, the description covers the core intent and a key safety constraint but leaves parameter mapping, credential/authorization handling, and failure behavior undocumented. Adequate but with clear gaps.

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

Parameters2/5

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

Schema description coverage is 0% for two required parameters (`name`, `arguments`), so the description must compensate. The phrase 'original input and credential' gestures at the inputs but never clearly maps to `name` vs `arguments`, leaving the agent to guess which field carries the tool identity versus the stored invocation payload.

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 (Read) applied to a specific resource (the stored outcome of an earlier native paid call), which is a clear, non-tautological purpose. It does not, however, name or distinguish itself from plausible siblings like `read` or `report_caller_result`, so it falls short of full sibling differentiation.

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

Usage Guidelines3/5

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

Implied usage is clear: retrieve a prior paid result 'using its original input and credential.' The clause 'This call cannot execute or pay' usefully distinguishes it from the original paying operation, but there is no explicit when/when-not guidance or named alternative for cases where recovery is not appropriate.

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

report_caller_resultReport One Caller ResultAInspect

Optionally state whether the current paid morpho_position result was useful or not_useful. This tool is free: charged is false, it does not repay, and it does not change the delivered purchase. Read the capability only from the paid result meta samedaydesk/mcp-caller-result. Schema success is not a statement. Absence is not useful or not_useful. Do not follow a link, do not send the capability to another origin, and do not pay again to report.

Name	Required	Description
`token`	Yes	Capability copied from the paid result meta. Not a payer, price, or event id.
`disposition`	Yes	Explicit statement after you inspect the result.
`reasonCategory`	No	Optional reason. Omit it to leave the reason empty.

TDQS

A3.7/5.0

Behavior4/5

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

With no annotations, the description carries the full burden and it delivers real behavioral facts: the call is free ('charged is false'), it does not repay, and it does not alter the delivered purchase. It also adds safety constraints (don't follow a link, don't send the capability elsewhere, don't pay again) and a precondition on where the capability may be read from. It stops short of describing the outcome/return of the report itself.

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

Conciseness3/5

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

The purpose is front-loaded in the first clause, but the body is a dense pile of negative constraints delivered in a slightly circular way, and the closing prohibitions overlap with earlier statements about not paying again and the capability source. It is information-bearing but not tightly edited.

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 free, no-annotation reporting tool with no output schema, the description covers cost, non-mutating behavior, capability provenance, and the interpretation of absence and schema success. The main gaps are the result of a successful report and any routing to sibling recovery/proof tools.

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 genuine meaning: 'Read the capability only from the paid result meta samedaydesk/mcp-caller-result' constrains where the token must come from, and 'Schema success is not a statement. Absence is not useful or not_useful' clarifies the disposition semantics beyond the enum labels.

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 first sentence names a specific action (state useful/not_useful) applied to a specific resource (the current paid morpho_position result), so an agent knows what the tool records and against which result. It does not name nearby siblings such as recover_paid_result or settlement_proof to differentiate itself, so the differentiation is only partial.

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

Usage Guidelines3/5

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

The word 'optionally' and the rules 'Schema success is not a statement' and 'Absence is not useful or not_useful' imply it is used only after inspecting a delivered paid result, which is useful guidance. However it never states when to call it versus recover_paid_result or any other reporting/proof tool, and no explicit exclusions are given.

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

scanScan GitHub Repository Before InstallAInspect

Static supply-chain security scan of a public GitHub repo before an agent installs/runs it. Flags exfil sinks, obfuscation, credential reads, install-time curl|bash. risk=clean|suspicious|dangerous. Payment challenge and credentials are bound to GET https://agents.samedaydesk.com/scan, not mcp://. Retry the identical authorized arguments and credential.

Name	Required	Description	Default
`repo`	Yes	Public GitHub repo: owner/name or URL

Output Schema

Name	Required	Description
`ok`	Yes
`repo`	Yes
`risk`	Yes
`branch`	Yes
`summary`	Yes
`findings`	Yes
`scannedAt`	Yes
`disclaimer`	Yes
`filesScanned`	Yes

TDQS

A4.1/5.0

Behavior4/5

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

With no annotations, the description carries the full burden and largely meets it: it discloses the analysis type, the specific threat classes flagged (exfil sinks, obfuscation, credential reads, install-time curl|bash), and the risk taxonomy. It also surfaces an unusual operational quirk — that the payment challenge and credential are bound to a GET URL rather than mcp://, with retry guidance. Missing auth/permission prerequisites and rate-limit or read-only confirmation, 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.

Conciseness4/5

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

Front-loaded with purpose, then flagged threats, then risk values, then the payment/retry note. Sentences are dense and every one carries information, though the payment-binding sentence is terse enough to require a second read.

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 format need not be spelled out, and the description still names the risk values. Given zero annotations, the description covers the important behavioral ground (what it checks, the payment flow, retry semantics); it stops short of permissions or timing expectations but is broadly sufficient for a one-parameter scan tool.

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

Parameters3/5

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

Schema description coverage is 100% and the single 'repo' parameter is fully documented in the schema ('Public GitHub repo: owner/name or URL'). The description adds 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 and resource: 'Static supply-chain security scan of a public GitHub repo before an agent installs/runs it.' No sibling tool overlaps this function, so the agent can identify it immediately. The risk-level vocabulary (clean|suspicious|dangerous) further pins down what it produces.

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?

The trigger is explicit and contextual: run this 'before an agent installs/runs it,' which tells the agent exactly when the tool applies. It does not name alternatives or when-not-to-use, but no sibling provides comparable repo-scanning capability, so this is close to complete.

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

schemaforgeGenerate Business JSON-LDAInspect

Analyze a public business site and return a deterministic, paste-ready JSON-LD template plus the live structured-data gap diff and ranked fixes. Use deep_audit instead when the same call must also return company, technology, contact, and DNS/email evidence. Generated markup contains placeholders that must be replaced with real business values; this tool makes no site changes and does not guarantee AI citations. Payment challenge and credentials are bound to GET https://agents.samedaydesk.com/schemaforge, not mcp://. Retry the identical authorized arguments and credential.

Name	Required	Description
`city`	No	Optional city the business serves; used to contextualize the generated structured-data template.
`site`	Yes	Public business homepage or representative landing-page URL. Live HTML must be directly fetchable; JavaScript is not executed.
`vertical`	No	Optional structured-data template profile. med-spas is currently the specialized profile; unsupported values fall back to it.

TDQS

A4.1/5.0

Behavior4/5

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

With no annotations, the description carries the full burden and does substantial work: it declares this makes no site changes, warns the output contains placeholders needing real values, disclaims citation guarantees, and documents an unusual operational trait (payment challenge and credentials bound to the GET URL, not mcp://, with retry using identical authorized arguments). It still omits rate limits, failure modes beyond payment, and caching behavior, so it falls short of exhaustive.

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

Conciseness4/5

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

Purpose and the deep_audit alternative are front-loaded, and each sentence adds a distinct caveat or constraint. The closing payment/credential/retry sentence is operationally important but tacked on and reads more like a troubleshooting note than part of a clean structure.

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 no output schema, the description still names what is returned (deterministic paste-ready JSON-LD template, live structured-data gap diff, ranked fixes) and flags the placeholder caveat, which is the key thing an agent must convey to a user. A three-parameter, single-required-param tool is adequately covered, though return-format and error-handling details remain thin.

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 site, city, and vertical are already fully documented, including the med-spas fallback behavior for vertical. The description adds no parameter-level 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 and resource (analyze a public business site, return a JSON-LD template plus gap diff and ranked fixes) and explicitly names the sibling it is not (deep_audit). An agent can distinguish it from deep_audit and the other audit 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?

Gives an explicit alternative and the condition that selects it: use deep_audit when the call must also return company, technology, contact, and DNS/email evidence. It does not state the inverse trigger ('use this when you only need JSON-LD') or rule out other audit siblings, but the routing guidance is concrete rather than implied.

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

seller_integrity_auditAudit Seller Machine BuyabilityAInspect

Use this after a buyer integration fails, a seller changes a paid route, or before the next paid retry or release. Audit one exact paid GET or POST seller route against buyer-required JSON success paths. GET verifies constructible non-secret input, exact request binding, live x402 and MPP economics, and optional Bazaar eligibility; POST performs static-safe OpenAPI contract analysis and sends no target request. Use payment_offer_preflight instead when you already have one exact callable GET URL and only need its current unpaid offer before buyer authorization, or agent_discoverability_audit for catalog rank and identity. Uses no target credential, signature, or target payment and retains no seller schema, body, or query values. Payment challenge and credentials are bound to GET https://agents.samedaydesk.com/commerce/seller-integrity-audit, not mcp://. Retry the identical authorized arguments and credential.

Name	Required	Description	Default
`route`	Yes	Exact paid GET or POST path declared by the seller, without query or template parameters.
`method`	No	POST receives static OpenAPI response-contract analysis without sending a target request.	GET
`origin`	Yes	Credential-free public HTTPS seller origin on port 443.
`referral`	No	Optional x402 receipt-derived acquisition label. It cannot change payment or delivery.
`requireBazaar`	No	When true, missing Bazaar discovery metadata becomes a repair finding for live-probed GET routes.
`requiredPaths`	No	Buyer-required dotted success-response paths that the seller schema must guarantee recursively.

TDQS

A4.7/5.0

Behavior5/5

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

With no annotations, the description carries the full burden and does so: it discloses that no target credential/signature/payment is used, that no seller schema/body/query values are retained, that POST sends no target request, and that the payment challenge is bound to a specific HTTPS endpoint rather than mcp://. This is exactly the safety and side-effect context an agent needs for a security-sensitive audit.

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 core action, then flows into mode behavior and routing alternatives. It is dense but the payment-challenge binding and retry sentence are somewhat technical filler relative to the rest, keeping it just short of a 5.

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

Completeness4/5

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

For a complex, credential-adjacent audit tool with no output schema and six parameters, the description covers usage, mode differences, privacy posture, and even retry semantics. It does not describe the shape of the audit findings (beyond naming repair findings), leaving a small gap for return interpretation.

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

Parameters4/5

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

Schema coverage is 100%, so the baseline is 3; the description adds genuine meaning by explaining that GET verifies constructible input, live x402/MPP economics, and optional Bazaar eligibility while POST performs static OpenAPI analysis, which frames how method and requireBazaar interact. It stops short of enriching requiredPaths or referral beyond the schema.

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

Purpose5/5

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

States a specific verb (audit) and resource (one exact paid GET or POST seller route) and contrasts both GET and POST modes. It explicitly names two siblings it is not (payment_offer_preflight, agent_discoverability_audit), so an agent can disambiguate without opening any schema.

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

Usage Guidelines5/5

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

Gives concrete triggering conditions ('after a buyer integration fails', 'a seller changes a paid route', 'before the next paid retry or release') and names the alternative tools with the exact conditions that select them. Both when-to-use and when-to-use-something-else are covered.

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

settlement_proofVerify Base USDC SettlementAInspect

Verify one claimed canonical Base USDC settlement after execution by matching a successful transaction receipt to the exact recipient, atomic amount, and optional payer. Use payment_offer_preflight before authorization when you need to inspect an unpaid x402 or MPP offer instead. This tool reads only public Base receipt and log data; it reads no merchant ledger and performs no wallet, signing, broadcast, custody, or execution action. Payment challenge and credentials are bound to GET https://agents.samedaydesk.com/commerce/settlement-proof, not mcp://. Retry the identical authorized arguments and credential.

Name	Required	Description
`payer`	No	Optional expected canonical Base USDC payer.
`recipient`	Yes	Expected canonical Base USDC recipient.
`amountAtomic`	Yes	Expected positive USDC amount in six-decimal atomic units.
`transactionHash`	Yes	Base mainnet transaction hash containing the claimed canonical USDC transfer.

Output Schema

Name	Required	Description
`ok`	Yes
`asset`	Yes
`chain`	Yes
`product`	Yes
`request`	Yes
`version`	Yes
`boundary`	Yes
`decision`	Yes
`findings`	Yes
`checkedAt`	Yes
`settlement`	Yes
`transaction`	Yes

TDQS

A4.6/5.0

Behavior5/5

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

With no annotations, the description carries the full burden and does so: it declares read-only scope (public Base receipt and log data only), explicitly disclaims merchant ledger reads and any wallet, signing, broadcast, custody, or execution action, and discloses the credential/URL binding and retry semantics.

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 core action, then routing, then safety constraints, then credential/retry notes. Four dense sentences with little waste, though the credential-binding sentence is somewhat operational detail that could be tighter.

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. The description covers the prerequisites, the read-only safety envelope, the alternative tool, and the retry contract, leaving nothing an agent needs to invoke this correctly.

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

Parameters3/5

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

Schema description coverage is 100%, so the schema already documents payer, recipient, amountAtomic, and transactionHash with patterns. The description mirrors the semantics (exact recipient, atomic amount, optional payer) but adds no format or edge-case 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?

The first sentence gives a precise verb (verify), resource (a claimed canonical Base USDC settlement), and the exact matching criteria (transaction receipt vs. recipient, atomic amount, optional payer). It is clearly distinguishable from siblings like transaction_receipt and payment_offer_preflight.

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 states the trigger (after execution, verifying a claimed settlement) and names the alternative for the adjacent case: use payment_offer_preflight before authorization for an unpaid x402 or MPP offer. It also tells the agent what to do on failure: retry the identical authorized arguments and credential.

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

solana_transaction_receiptInspect Solana Transaction ReceiptAInspect

Inspect one finalized Solana mainnet transaction signature and return normalized success or failure status, slot, block time, fee, SPL-token owner deltas, and canonical USDC deltas. Supply recipient, amount, and optional payer when an exact settlement claim must be verified; use transaction_receipt for Base or Ethereum. Raw instructions and logs are excluded, and this tool performs no wallet, signing, broadcast, custody, or execution action. Payment challenge and credentials are bound to GET https://agents.samedaydesk.com/chain/solana-transaction-receipt, not mcp://. Retry the identical authorized arguments and credential.

Name	Required	Description
`mint`	No	Optional SPL-token mint; defaults to canonical Solana USDC.
`payer`	No	Optional expected token payer owner; requires recipient and amountAtomic.
`recipient`	No	Optional expected token recipient owner.
`signature`	Yes	Finalized Solana mainnet transaction signature.
`amountAtomic`	No	Optional expected positive token amount in atomic units; requires recipient.

TDQS

A4.3/5.0

Behavior4/5

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

With no annotations the description carries the full safety burden, and it does so well: it declares the operation read-only by excluding wallet, signing, broadcast, custody, and execution actions, and it discloses that raw instructions and logs are excluded from the response. It stops short of error modes or rate-limit behavior, so it is strong but not exhaustive.

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

Conciseness4/5

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

Purpose and scope are front-loaded in the first sentence, followed by usage, exclusions, and auth/retry notes in a logical order. It is dense and the payment-challenge/credentials sentence is operational overhead, but each sentence conveys distinct 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?

There is no output schema, so the description properly compensates by enumerating the returned fields (status, slot, block time, fee, SPL-token owner deltas, USDC deltas). Combined with the explicit side-effect exclusions and the cross-chain alternative, an agent has what it needs 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 each parameter's format and the recipient/amountAtomic/payer interdependencies. The description reinforces the verification intent 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?

The description names a specific verb (Inspect) and resource (one finalized Solana mainnet transaction signature), enumerates the normalized fields returned, and explicitly contrasts itself with the sibling `transaction_receipt` for Base/Ethereum. An agent can distinguish it from the other receipt/wallet tools without opening the schema.

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

Usage Guidelines5/5

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

It states the trigger for the optional verification mode ('Supply recipient, amount, and optional payer when an exact settlement claim must be verified') and names the alternative tool plus the chain condition that selects it. It also tells the agent to retry the identical authorized arguments and credential, which is actionable routing guidance.

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

stateful_wallet_policy_conformanceEvaluate Stateful Wallet Policy ConformanceAInspect

Evaluate safe standardized observations from wallet policies that track prior or concurrent requests. Use wallet_policy_conformance instead for one-request action shape, method, chain, token, recipient, amount, and function controls. This tool separately tests sequential cumulative limits, signed-but-unbroadcast accounting, ABI extraction, concurrent oversubscription, counter-reference failure, and application serialization. It accepts no credentials, counter values, wallet or resource IDs, signatures, transactions, or raw provider responses and does not run the provider tests itself. Payment challenge and credentials are bound to POST https://agents.samedaydesk.com/security/stateful-wallet-policy-conformance, not mcp://. Retry the identical authorized arguments and credential.

Name	Required	Description
`network`	Yes	Network identifier used by the tested stateful profile.
`protocol`	Yes	Payment or execution protocol bound by the tested stateful profile.
`provider`	Yes	Wallet or delegated-signer provider name.
`profileId`	Yes	Caller-defined stateful policy profile identifier with no credential, wallet, or counter secret.
`observations`	Yes	Unique standardized stateful observations. Raw provider responses, signatures, transactions, counter values, credentials, wallet IDs, and resource IDs are rejected.

Output Schema

Name	Required	Description
`product`	Yes
`profile`	Yes
`results`	Yes
`boundary`	Yes
`complete`	Yes
`decision`	Yes
`evaluatedAt`	Yes
`unsafeCases`	Yes
`schemaVersion`	Yes
`inconclusiveCases`	Yes
`strictBudgetPassed`	Yes
`applicationVerified`	Yes
`missingRequiredCases`	Yes
`standardSchemaVersion`	Yes
`providerNativeVerified`	Yes
`providerNativeUnverified`	Yes

TDQS

A3.8/5.0

Behavior4/5

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

With no annotations provided, the description carries the full burden and does well: it discloses that no credentials, counter values, wallet/resource IDs, signatures, transactions, or raw provider responses are accepted, that the tool does not run provider tests itself, and that payment challenge/credentials are bound to a specific POST URL rather than mcp://. It lacks a clear statement of traditional auth requirements or rate limits, keeping it below 5.

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

Conciseness3/5

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

The core scope statement is front-loaded, which is good. However the description runs to five dense sentences with some redundancy and tangential clauses (the payment-challenge/URL binding sentence reads as operational boilerplate), making it heavier than necessary for the information conveyed.

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?

The tool is complex and has an output schema, so return values need not be explained. With 100% schema coverage plus stated purpose, alternative routing, rejection constraints, and auth binding, an agent has nearly everything needed to call it correctly; only explicit auth/rate-limit expectations are 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 all five parameters (profileId, provider, network, protocol, observations) including nested enum semantics. The description reinforces the rejection constraints but adds no syntax or format detail beyond what the schema provides, so the baseline 3 applies.

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

Purpose4/5

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

The description states a specific verb (Evaluate) and resource (standardized observations from stateful wallet policies) and explicitly distinguishes the scope from the stateless sibling wallet_policy_conformance. It enumerates the stateful scenarios tested (sequential cumulative limits, signed-but-unbroadcast accounting, concurrency, counter-reference failure, serialization). The phrase 'safe standardized observations' is somewhat abstract but the overall purpose is discernible.

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 explicitly names the alternative ('Use wallet_policy_conformance instead for one-request action shape...') and gives the condition that selects it, which is exactly the routing an agent needs. It does not spell out further when-not-to-use conditions, but the primary alternative routing is clear.

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

transaction_receiptInspect Transaction ReceiptAInspect

Inspect one Base or Ethereum transaction hash and return normalized success or revert status, block time, gas and fee fields, decoded ERC-20 Transfer events, and canonical USDC transfers. Use settlement_proof instead when you must verify an exact canonical Base USDC recipient, amount, and optional payer claim. Raw logs are excluded; this tool performs no wallet, signing, broadcast, custody, or execution action. Payment challenge and credentials are bound to GET https://agents.samedaydesk.com/chain/transaction-receipt, not mcp://. Retry the identical authorized arguments and credential.

Name	Required	Description	Default
`network`	No	Receipt network. Defaults to Base mainnet.	base
`transactionHash`	Yes	Mined Base or Ethereum transaction hash whose normalized receipt should be returned.

TDQS

A4.6/5.0

Behavior5/5

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

With no annotations, the description carries the full burden and does so well: it declares the absence of side effects ('no wallet, signing, broadcast, custody, or execution action'), notes raw logs are excluded, and discloses auth/payment binding and retry semantics ('Retry the identical authorized arguments and credential'). This is a rich safety and reliability profile well beyond what structured fields provide.

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?

Purpose and scope are front-loaded in the first sentence, and the alternative-tool routing follows immediately. The trailing sentences about payment binding ('not mcp://') and retry are useful but mechanically worded and slightly break the flow, keeping it from a full 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?

No output schema exists, so the description must explain return values — and it does, listing status, block time, gas/fee fields, and decoded transfer events. Combined with the usage routing and auth/retry disclosure, an agent has everything needed to call this correctly.

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

Parameters3/5

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

Schema description coverage is 100%, so both parameters (network enum and transactionHash pattern) are already fully documented in the schema. The description's 'one Base or Ethereum transaction hash' adds only marginal framing over 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?

States a specific verb (Inspect) and resource (one Base or Ethereum transaction hash) and enumerates exactly what is returned: success/revert status, block time, gas and fee fields, decoded ERC-20 Transfer events, and canonical USDC transfers. It explicitly differentiates itself from the settlement_proof sibling, so an agent can route correctly 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 an explicit when-to-use-elsewhere rule: 'Use settlement_proof instead when you must verify an exact canonical Base USDC recipient, amount, and optional payer claim.' That names both the alternative tool and the precise condition that selects it, 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.

trial_readRead Public Page Under Shared TrialAInspect

Read one public HTTP(S) page as bounded Markdown through the existing walletless trial. Read and extract share the same original authority, remaining hops, expiry and one concurrent operation. No separate reader allowance. Optional markdownLimitChars is an integer from 1 through 40000; omitted calls use 40000. charged is false. This is not the paid read tool and it returns no payment or settlement receipt. The paid next path stays GET /read?url={encodedPublicUrl}. Each attempted DNS, HTTP, or redirect hop consumes one durable start before I/O. The call is not idempotent or effect-free; a retry spends another hop and does not refund a lost response. Existing readMarkdown JSON: inspect ok, sourceOk, status, error, markdown, truncated and capture. Bounded native HTML tables preserve blank cells, spans and links inside Markdown; unsupported tables are explicitly omitted with truncation. No JavaScript or completeness guarantee. HTTP 200 may report source or fetch failure. No payment or settlement receipt.

Name	Required	Description	Default
`url`	Yes	Caller public http(s) URL. Private, loopback, and non-public hosts are refused.
`markdownLimitChars`	No	Optional Markdown character limit from 1 through 40000. Omitted calls use 40000.

Output Schema

Name	Required	Description
`ok`	Yes
`url`	Yes
`error`	Yes
`title`	Yes
`status`	Yes
`capture`	Yes
`charged`	Yes
`finalUrl`	Yes
`markdown`	Yes
`sourceOk`	Yes
`fetchedAt`	Yes
`truncated`	Yes
`wordCount`	Yes
`requestedUrl`	Yes

TDQS

A4.3/5.0

Behavior5/5

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

Goes well beyond the annotations: explains that each DNS/HTTP/redirect hop consumes a durable start before I/O, that the call is not idempotent and does not refund a lost response, that no JavaScript runs and completeness is not guaranteed, and that HTTP 200 can still carry a source/fetch failure. It also explains why readOnlyHint=false for an ostensibly 'read' tool. No contradictions with annotations.

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

Conciseness3/5

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

The scope and trial framing are front-loaded well, but the text is padded: 'No payment or settlement receipt' is stated twice, and the enumeration of readMarkdown JSON fields (ok, sourceOk, status, error, markdown, truncated, capture) duplicates the existing output schema. Several sentences could be merged without losing meaning.

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 network fetch with high-impact billing semantics, the description covers cost accounting, idempotency, failure modes, content fidelity limits (tables, no JS), and truncation behavior. With an output schema and full annotation coverage already present, nothing an agent needs in order to call this safely 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 both parameters are already documented with bounds and defaults. The description restates the markdownLimitChars range (1-40000, default 40000) without adding new semantics, and says nothing extra about the url parameter beyond what the schema's 'Private, loopback, and non-public hosts are refused' already covers. 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 ('Read one public HTTP(S) page as bounded Markdown') plus the access mode ('walletless trial'). It explicitly separates itself from the paid sibling read tool and from extract ('Read and extract share the same original authority, remaining hops, expiry...'), so an agent can route correctly without opening any schema.

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

Usage Guidelines4/5

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

Clear usage context: this is the walletless, allowance-consuming trial path, with the paid alternative spelled out ('The paid next path stays GET /read?url={encodedPublicUrl}'). It also warns that retries spend another hop, which is effectively a when-not-to-retry guideline. It stops short of an explicit 'use this when you have no wallet/settlement credits' statement, leaving the selection condition lightly implied.

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

wallet_enrichEnrich Base Wallet or ContractAInspect

Inspect a public Base or EVM address and return an agent-ready on-chain profile: EOA or contract type, native and curated token holdings, token/NFT metadata, proxy evidence, activity, and a derived profile label. Use enrich for a company domain; the two tools accept different identifiers and return different evidence. Read-only public chain data; no wallet action or custody. Payment challenge and credentials are bound to GET https://agents.samedaydesk.com/wallet-enrich, not mcp://. Retry the identical authorized arguments and credential.

Name	Required	Description	Default
`address`	Yes	Public Base or EVM 0x address. Use wallet_enrich for on-chain evidence; use enrich for a company domain.

TDQS

A4.5/5.0

Behavior5/5

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

With no annotations, the description carries the full behavioral burden and does so: read-only public chain data, no wallet action or custody, a payment challenge bound to a specific HTTP endpoint rather than mcp://, and retry semantics for identical authorized arguments. That is auth, safety, and error-recovery context an agent could not derive from structured fields.

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

Conciseness4/5

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

Three sentences, front-loaded with the capability and its outputs before the sibling distinction and the payment/retry note. Every sentence carries information, though the payment-challenge sentence is dense and slightly opaque in phrasing.

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?

There is no output schema, so the description must characterize returns — it does by enumerating the profile fields. It also covers the payment/credential path and retry behavior, leaving only edge cases such as unsupported chains or failure modes unaddressed.

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 there is a single parameter, so the schema already documents the address format and its routing hint. The description restates 'public Base or EVM address' without adding syntax or format detail beyond what the schema provides, which is the 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?

The description names a specific verb and resource ('Inspect a public Base or EVM address') and enumerates the returned evidence: address type, holdings, token/NFT metadata, proxy evidence, activity, and a derived label. It also explicitly separates itself from the sibling `enrich`, which handles company domains, so an agent can route 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?

It names the alternative tool explicitly ('Use `enrich` for a company domain') and states the discriminating condition ('the two tools accept different identifiers and return different evidence'). It also gives a retry directive for the authorized-arguments case, leaving little to inference.

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

wallet_policy_conformanceEvaluate Agent Wallet Policy ConformanceAInspect

Evaluate safe standardized allow, deny, and error observations from an agent wallet or delegated signer. Use this after running a bounded provider policy test matrix to distinguish explicit provider-policy enforcement from validation or generic provider failures and to test exact execution shape separately from operation allowlisting. Accepts no credentials, wallet IDs, signatures, transactions, or raw provider responses; it evaluates caller-supplied observations and does not run the provider tests itself. Payment challenge and credentials are bound to POST https://agents.samedaydesk.com/security/wallet-policy-conformance, not mcp://. Retry the identical authorized arguments and credential.

Name	Required	Description
`network`	Yes	Network identifier used by the tested profile.
`protocol`	Yes	Payment or execution protocol bound by the tested profile.
`provider`	Yes	Wallet or delegated-signer provider name.
`profileId`	Yes	Caller-defined policy profile identifier with no credential or wallet secret.
`observations`	Yes	Unique standardized observations. Raw provider responses, signatures, transactions, credentials, and wallet IDs are rejected.

Output Schema

Name	Required	Description
`product`	Yes
`profile`	Yes
`results`	Yes
`boundary`	Yes
`complete`	Yes
`decision`	Yes
`evaluatedAt`	Yes
`unsafeCases`	Yes
`schemaVersion`	Yes
`exactShapePassed`	Yes
`inconclusiveCases`	Yes
`missingRequiredCases`	Yes
`standardSchemaVersion`	Yes
`providerNativeVerified`	Yes
`providerNativeUnverified`	Yes
`notEvaluatedByWalletPolicy`	Yes

TDQS

A3.9/5.0

Behavior4/5

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

With no annotations, the description carries the full burden and does well: it discloses what is rejected (credentials, wallet IDs, signatures, transactions, raw provider responses), that it only evaluates caller-supplied observations, and adds payment/credential binding to a POST URL rather than mcp:// plus retry semantics. It stops short of describing rate limits or output behavior, but this is strong disclosure for an annotation-free tool.

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 core action, then intent, input constraints, and transport/retry details in a compact sequence. Sentences are dense but every one carries information; no filler.

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 explained, and the description covers input constraints, the intended workflow placement, transport binding, and retry guidance. The one real gap is sibling differentiation against stateful_wallet_policy_conformance, which is relevant given how close the names are.

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 all five parameters, including the nested observation fields. The description reinforces input constraints (no credentials/wallet IDs/raw responses) and the observation-standardization intent but adds no field-level syntax or format beyond the schema, so baseline 3 applies.

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

Purpose4/5

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

States a specific verb and resource: evaluate standardized allow/deny/error observations from an agent wallet or delegated signer. Clear and concrete, but it never distinguishes itself from the near-identically-named sibling 'stateful_wallet_policy_conformance', so an agent cannot route between the two from this text alone.

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

Usage Guidelines4/5

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

Gives explicit context: use it after running a bounded provider policy test matrix, to separate provider-policy enforcement from validation/generic failures and to test execution shape vs. operation allowlisting. It also flags a boundary ('does not run the provider tests itself'), but names no alternative tool, leaving the sibling ambiguity unresolved.

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

Tool Schema Changelog

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

1 tool updateOct 28, 2026
- Addedtrial_read

1 tool updateOct 26, 2026

Changedpage_change4 fields changed

addedInput schema / properties / after / $ref
```
Added value: +"#/properties/before"
```

removedInput schema / properties / after / anyOf

Removed value: -[
-  {
-    "additionalProperties": false,
-    "description": "Representative merchant structure for useful comparisons; not a new paid request or proof of payment. Compare only the explicitly selected data keys present on both matched rows. Missing keys are coverage unknown, not deletions; explicit null is a present value. Unselected metadata is not a content delta.",
-    "properties": {
-      "accounting": {
-        "additionalProperties": true,
-        "properties": {},
-        "type": "object"
-      },
-      "boundary": {
-        "additionalProperties": true,
-        "properties": {},
-        "type": "object"
-      },
-      "charged": {
-        "type": "boolean"
-      },
-      "costInputs": {
-        "additionalProperties": true,
-        "properties": {},
-        "type": "object"
-      },
-      "error": {
-        "type": "string"
-      },
-      "jobId": {
-        "pattern": "^[a-f0-9]{64}$",
-        "type": "string"
-      },
-      "jobStatus": {
-        "enum": [
-          "running",
-          "completed",
-          "completed_with_unknown",
-          "stopped",
-          "interrupted"
-        ],
-        "type": "string"
-      },
-      "ok": {
-        "type": "boolean"
-      },
-      "partial": {
-        "type": "boolean"
-      },
-      "product": {
-        "const": "samedaydesk-extract-batch",
-        "type": "string"
-      },
-      "quote": {
-        "additionalProperties": true,
-        "properties": {
-          "amountAtomic": {
-            "const": "10000",
-            "type": "string"
-          },
-          "displayUsdc": {
-            "const": "0.01",
-            "type": "string"
-          },
-          "meaning": {
-            "type": "string"
-          }
-        },
-        "required": [
-          "amountAtomic",
-          "displayUsdc",
-          "meaning"
-        ],
-        "type": "object"
-      },
-      "schemaVersion": {
-        "const": "samedaydesk.extract-batch.v0",
-        "type": "string"
-      },
-      "sources": {
-        "items": {
-          "additionalProperties": true,
-          "properties": {
-            "data": {
-              "anyOf": [
-                {
-                  "additionalProperties": true,
-                  "description": "Compare only the explicitly selected data keys present on both matched rows. Missing keys are coverage unknown, not deletions; explicit null is a present value. Unselected metadata is not a content delta.",
-                  "properties": {
-                    "aiReadiness": {
-                      "description": "Selected extraction value: aiReadiness."
-                    },
-                    "canonical": {
-                      "description": "Selected extraction value: canonical."
-                    },
-                    "description": {
-                      "description": "Selected extraction value: description."
-                    },
-                    "headings": {
-                      "description": "Selected extraction value: headings."
-                    },
-                    "jsonLd": {
-                      "description": "Selected extraction value: jsonLd."
-                    },
-                    "lang": {
-                      "description": "Selected extraction value: lang."
-                    },
-                    "links": {
-                      "description": "Selected extraction value: links."
-                    },
-                    "openGraph": {
-                      "description": "Selected extraction value: openGraph."
-                    },
-                    "text": {
-                      "description": "Selected extraction value: text."
-                    },
-                    "title": {
-                      "description": "Selected extraction value: title."
-                    },
-                    "twitter": {
-                      "description": "Selected extraction value: twitter."
-                    }
-                  },
-                  "type": "object"
-                },
-                {
-                  "description": "Compare only the explicitly selected data keys present on both matched rows. Missing keys are coverage unknown, not deletions; explicit null is a present value. Unselected metadata is not a content delta.",
-                  "type": "null"
-                }
-              ],
-              "description": "Compare only the explicitly selected data keys present on both matched rows. Missing keys are coverage unknown, not deletions; explicit null is a present value. Unselected metadata is not a content delta."
-            },
-            "error": {
-              "anyOf": [
-                {
-                  "additionalProperties": true,
-                  "properties": {},
-                  "type": "object"
-                },
-                {
-                  "type": "null"
-                }
-              ]
-            },
-            "finalUrl": {
-              "type": [
-                "string",
-                "null"
-              ]
-            },
-            "httpStatus": {
-              "anyOf": [
-                {
-                  "type": "integer"
-                },
-                {
-                  "type": "null"
-                }
-              ]
-            },
-            "id": {
-              "description": "Row identifier; does not replace source identity.",
-              "type": "string"
-            },
-            "notes": {
-              "type": "array"
-            },
-            "provenance": {
-              "anyOf": [
-                {
-                  "additionalProperties": true,
-                  "properties": {},
-                  "type": "object"
-                },
-                {
-                  "type": "null"
-                }
-              ]
-            },
-            "source": {
-              "description": "Stable source identity, separate from row id and observation time. Matching normalizes source strings (URL fragments removed). Use the same non-empty identity on both sides; duplicate active identities are ambiguous. Synthetic URL STRINGS are inert and are never fetched by this transform.",
-              "minLength": 1,
-              "pattern": "\\S",
-              "type": "string"
-            },
-            "status": {
-              "enum": [
-                "pending",
-                "success",
-                "partial",
-                "failure",
-                "unknown",
-                "skipped_duplicate"
-              ],
-              "type": "string"
-            }
-          },
-          "required": [
-            "id",
-            "source",
-            "status",
-            "data",
-            "notes",
-            "error",
-            "provenance"
-          ],
-          "type": "object"
-        },
-        "maxItems": 5,
-        "minItems": 1,
-        "type": "array"
-      },
-      "stopReason": {
-        "type": [
-          "string",
-          "null"
-        ]
-      }
-    },
-    "required": [
-      "ok",
-      "product",
-      "schemaVersion",
-      "quote",
-      "jobId",
-      "jobStatus",
-      "stopReason",
-      "partial",
-      "sources",
-      "accounting",
-      "costInputs",
-      "charged",
-      "boundary"
-    ],
-    "type": "object"
-  },
-  {
-    "additionalProperties": true,
-    "description": "Existing C1 result compatibility. No merchant product/schemaVersion is required. Compare only the explicitly selected data keys present on both matched rows. Missing keys are coverage unknown, not deletions; explicit null is a present value. Unselected metadata is not a content delta.",
-    "properties": {
-      "accounting": {
-        "additionalProperties": true,
-        "properties": {},
-        "type": "object"
-      },
-      "costParameters": {
-        "additionalProperties": true,
-        "properties": {},
-        "type": "object"
-      },
-      "items": {
-        "items": {
-          "additionalProperties": true,
-          "properties": {
-            "data": {
-              "anyOf": [
-                {
-                  "additionalProperties": true,
-                  "description": "Compare only the explicitly selected data keys present on both matched rows. Missing keys are coverage unknown, not deletions; explicit null is a present value. Unselected metadata is not a content delta.",
-                  "properties": {
-                    "aiReadiness": {
-                      "description": "Selected extraction value: aiReadiness."
-                    },
-                    "canonical": {
-                      "description": "Selected extraction value: canonical."
-                    },
-                    "description": {
-                      "description": "Selected extraction value: description."
-                    },
-                    "headings": {
-                      "description": "Selected extraction value: headings."
-                    },
-                    "jsonLd": {
-                      "description": "Selected extraction value: jsonLd."
-                    },
-                    "lang": {
-                      "description": "Selected extraction value: lang."
-                    },
-                    "links": {
-                      "description": "Selected extraction value: links."
-                    },
-                    "openGraph": {
-                      "description": "Selected extraction value: openGraph."
-                    },
-                    "text": {
-                      "description": "Selected extraction value: text."
-                    },
-                    "title": {
-                      "description": "Selected extraction value: title."
-                    },
-                    "twitter": {
-                      "description": "Selected extraction value: twitter."
-                    }
-                  },
-                  "type": "object"
-                },
-                {
-                  "description": "Compare only the explicitly selected data keys present on both matched rows. Missing keys are coverage unknown, not deletions; explicit null is a present value. Unselected metadata is not a content delta.",
-                  "type": "null"
-                }
-              ],
-              "description": "Compare only the explicitly selected data keys present on both matched rows. Missing keys are coverage unknown, not deletions; explicit null is a present value. Unselected metadata is not a content delta."
-            },
-            "error": {
-              "anyOf": [
-                {
-                  "additionalProperties": true,
-                  "properties": {},
-                  "type": "object"
-                },
-                {
-                  "type": "null"
-                }
-              ]
-            },
-            "finalUrl": {
-              "type": [
-                "string",
-                "null"
-              ]
-            },
-            "httpStatus": {
-              "anyOf": [
-                {
-                  "type": "integer"
-                },
-                {
-                  "type": "null"
-                }
-              ]
-            },
-            "id": {
-              "description": "Row identifier; does not replace source identity.",
-              "type": "string"
-            },
-            "notes": {
-              "type": "array"
-            },
-            "provenance": {
-              "anyOf": [
-                {
-                  "additionalProperties": true,
-                  "properties": {},
-                  "type": "object"
-                },
-                {
-                  "type": "null"
-                }
-              ]
-            },
-            "source": {
-              "description": "Stable source identity, separate from row id and observation time. Matching normalizes source strings (URL fragments removed). Use the same non-empty identity on both sides; duplicate active identities are ambiguous. Synthetic URL STRINGS are inert and are never fetched by this transform.",
-              "minLength": 1,
-              "pattern": "\\S",
-              "type": "string"
-            },
-            "status": {
-              "enum": [
-                "pending",
-                "success",
-                "partial",
-                "failure",
-                "unknown",
-                "skipped_duplicate"
-              ],
-              "type": "string"
-            }
-          },
-          "required": [
-            "id",
-            "source",
-            "status",
-            "data",
-            "notes",
-            "error",
-            "provenance"
-          ],
-          "type": "object"
-        },
-        "maxItems": 32,
-        "minItems": 1,
-        "type": "array"
-      },
-      "jobId": {
-        "type": "string"
-      },
-      "status": {
-        "type": "string"
-      }
-    },
-    "required": [
-      "jobId",
-      "status",
-      "costParameters",
-      "accounting",
-      "items"
-    ],
-    "type": "object"
-  },
-  {
-    "additionalProperties": false,
-    "properties": {
-      "body": {
-        "anyOf": [
-          {
-            "additionalProperties": false,
-            "description": "Representative merchant structure for useful comparisons; not a new paid request or proof of payment. Compare only the explicitly selected data keys present on both matched rows. Missing keys are coverage unknown, not deletions; explicit null is a present value. Unselected metadata is not a content delta.",
-            "properties": {
-              "accounting": {
-                "additionalProperties": true,
-                "properties": {},
-                "type": "object"
-              },
-              "boundary": {
-                "additionalProperties": true,
-                "properties": {},
-                "type": "object"
-              },
-              "charged": {
-                "type": "boolean"
-              },
-              "costInputs": {
-                "additionalProperties": true,
-                "properties": {},
-                "type": "object"
-              },
-              "error": {
-                "type": "string"
-              },
-              "jobId": {
-                "pattern": "^[a-f0-9]{64}$",
-                "type": "string"
-              },
-              "jobStatus": {
-                "enum": [
-                  "running",
-                  "completed",
-                  "completed_with_unknown",
-                  "stopped",
-                  "interrupted"
-                ],
-                "type": "string"
-              },
-              "ok": {
-                "type": "boolean"
-              },
-              "partial": {
-                "type": "boolean"
-              },
-              "product": {
-                "const": "samedaydesk-extract-batch",
-                "type": "string"
-              },
-              "quote": {
-                "additionalProperties": true,
-                "properties": {
-                  "amountAtomic": {
-                    "const": "10000",
-                    "type": "string"
-                  },
-                  "displayUsdc": {
-                    "const": "0.01",
-                    "type": "string"
-                  },
-                  "meaning": {
-                    "type": "string"
-                  }
-                },
-                "required": [
-                  "amountAtomic",
-                  "displayUsdc",
-                  "meaning"
-                ],
-                "type": "object"
-              },
-              "schemaVersion": {
-                "const": "samedaydesk.extract-batch.v0",
-                "type": "string"
-              },
-              "sources": {
-                "items": {
-                  "additionalProperties": true,
-                  "properties": {
-                    "data": {
-                      "anyOf": [
-                        {
-                          "additionalProperties": true,
-                          "description": "Compare only the explicitly selected data keys present on both matched rows. Missing keys are coverage unknown, not deletions; explicit null is a present value. Unselected metadata is not a content delta.",
-                          "properties": {
-                            "aiReadiness": {
-                              "description": "Selected extraction value: aiReadiness."
-                            },
-                            "canonical": {
-                              "description": "Selected extraction value: canonical."
-                            },
-                            "description": {
-                              "description": "Selected extraction value: description."
-                            },
-                            "headings": {
-                              "description": "Selected extraction value: headings."
-                            },
-                            "jsonLd": {
-                              "description": "Selected extraction value: jsonLd."
-                            },
-                            "lang": {
-                              "description": "Selected extraction value: lang."
-                            },
-                            "links": {
-                              "description": "Selected extraction value: links."
-                            },
-                            "openGraph": {
-                              "description": "Selected extraction value: openGraph."
-                            },
-                            "text": {
-                              "description": "Selected extraction value: text."
-                            },
-                            "title": {
-                              "description": "Selected extraction value: title."
-                            },
-                            "twitter": {
-                              "description": "Selected extraction value: twitter."
-                            }
-                          },
-                          "type": "object"
-                        },
-                        {
-                          "description": "Compare only the explicitly selected data keys present on both matched rows. Missing keys are coverage unknown, not deletions; explicit null is a present value. Unselected metadata is not a content delta.",
-                          "type": "null"
-                        }
-                      ],
-                      "description": "Compare only the explicitly selected data keys present on both matched rows. Missing keys are coverage unknown, not deletions; explicit null is a present value. Unselected metadata is not a content delta."
-                    },
-                    "error": {
-                      "anyOf": [
-                        {
-                          "additionalProperties": true,
-                          "properties": {},
-                          "type": "object"
-                        },
-                        {
-                          "type": "null"
-                        }
-                      ]
-                    },
-                    "finalUrl": {
-                      "type": [
-                        "string",
-                        "null"
-                      ]
-                    },
-                    "httpStatus": {
-                      "anyOf": [
-                        {
-                          "type": "integer"
-                        },
-                        {
-                          "type": "null"
-                        }
-                      ]
-                    },
-                    "id": {
-                      "description": "Row identifier; does not replace source identity.",
-                      "type": "string"
-                    },
-                    "notes": {
-                      "type": "array"
-                    },
-                    "provenance": {
-                      "anyOf": [
-                        {
-                          "additionalProperties": true,
-                          "properties": {},
-                          "type": "object"
-                        },
-                        {
-                          "type": "null"
-                        }
-                      ]
-                    },
-                    "source": {
-                      "description": "Stable source identity, separate from row id and observation time. Matching normalizes source strings (URL fragments removed). Use the same non-empty identity on both sides; duplicate active identities are ambiguous. Synthetic URL STRINGS are inert and are never fetched by this transform.",
-                      "minLength": 1,
-                      "pattern": "\\S",
-                      "type": "string"
-                    },
-                    "status": {
-                      "enum": [
-                        "pending",
-                        "success",
-                        "partial",
-                        "failure",
-                        "unknown",
-                        "skipped_duplicate"
-                      ],
-                      "type": "string"
-                    }
-                  },
-                  "required": [
-                    "id",
-                    "source",
-                    "status",
-                    "data",
-                    "notes",
-                    "error",
-                    "provenance"
-                  ],
-                  "type": "object"
-                },
-                "maxItems": 5,
-                "minItems": 1,
-                "type": "array"
-              },
-              "stopReason": {
-                "type": [
-                  "string",
-                  "null"
-                ]
-              }
-            },
-            "required": [
-              "ok",
-              "product",
-              "schemaVersion",
-              "quote",
-              "jobId",
-              "jobStatus",
-              "stopReason",
-              "partial",
-              "sources",
-              "accounting",
-              "costInputs",
-              "charged",
-              "boundary"
-            ],
-            "type": "object"
-          },
-          {
-            "additionalProperties": true,
-            "description": "Existing C1 result compatibility. No merchant product/schemaVersion is required. Compare only the explicitly selected data keys present on both matched rows. Missing keys are coverage unknown, not deletions; explicit null is a present value. Unselected metadata is not a content delta.",
-            "properties": {
-              "accounting": {
-                "additionalProperties": true,
-                "properties": {},
-                "type": "object"
-              },
-              "costParameters": {
-                "additionalProperties": true,
-                "properties": {},
-                "type": "object"
-              },
-              "items": {
-                "items": {
-                  "additionalProperties": true,
-                  "properties": {
-                    "data": {
-                      "anyOf": [
-                        {
-                          "additionalProperties": true,
-                          "description": "Compare only the explicitly selected data keys present on both matched rows. Missing keys are coverage unknown, not deletions; explicit null is a present value. Unselected metadata is not a content delta.",
-                          "properties": {
-                            "aiReadiness": {
-                              "description": "Selected extraction value: aiReadiness."
-                            },
-                            "canonical": {
-                              "description": "Selected extraction value: canonical."
-                            },
-                            "description": {
-                              "description": "Selected extraction value: description."
-                            },
-                            "headings": {
-                              "description": "Selected extraction value: headings."
-                            },
-                            "jsonLd": {
-                              "description": "Selected extraction value: jsonLd."
-                            },
-                            "lang": {
-                              "description": "Selected extraction value: lang."
-                            },
-                            "links": {
-                              "description": "Selected extraction value: links."
-                            },
-                            "openGraph": {
-                              "description": "Selected extraction value: openGraph."
-                            },
-                            "text": {
-                              "description": "Selected extraction value: text."
-                            },
-                            "title": {
-                              "description": "Selected extraction value: title."
-                            },
-                            "twitter": {
-                              "description": "Selected extraction value: twitter."
-                            }
-                          },
-                          "type": "object"
-                        },
-                        {
-                          "description": "Compare only the explicitly selected data keys present on both matched rows. Missing keys are coverage unknown, not deletions; explicit null is a present value. Unselected metadata is not a content delta.",
-                          "type": "null"
-                        }
-                      ],
-                      "description": "Compare only the explicitly selected data keys present on both matched rows. Missing keys are coverage unknown, not deletions; explicit null is a present value. Unselected metadata is not a content delta."
-                    },
-                    "error": {
-                      "anyOf": [
-                        {
-                          "additionalProperties": true,
-                          "properties": {},
-                          "type": "object"
-                        },
-                        {
-                          "type": "null"
-                        }
-                      ]
-                    },
-                    "finalUrl": {
-                      "type": [
-                        "string",
-                        "null"
-                      ]
-                    },
-                    "httpStatus": {
-                      "anyOf": [
-                        {
-                          "type": "integer"
-                        },
-                        {
-                          "type": "null"
-                        }
-                      ]
-                    },
-                    "id": {
-                      "description": "Row identifier; does not replace source identity.",
-                      "type": "string"
-                    },
-                    "notes": {
-                      "type": "array"
-                    },
-                    "provenance": {
-                      "anyOf": [
-                        {
-                          "additionalProperties": true,
-                          "properties": {},
-                          "type": "object"
-                        },
-                        {
-                          "type": "null"
-                        }
-                      ]
-                    },
-                    "source": {
-                      "description": "Stable source identity, separate from row id and observation time. Matching normalizes source strings (URL fragments removed). Use the same non-empty identity on both sides; duplicate active identities are ambiguous. Synthetic URL STRINGS are inert and are never fetched by this transform.",
-                      "minLength": 1,
-                      "pattern": "\\S",
-                      "type": "string"
-                    },
-                    "status": {
-                      "enum": [
-                        "pending",
-                        "success",
-                        "partial",
-                        "failure",
-                        "unknown",
-                        "skipped_duplicate"
-                      ],
-                      "type": "string"
-                    }
-                  },
-                  "required": [
-                    "id",
-                    "source",
-                    "status",
-                    "data",
-                    "notes",
-                    "error",
-                    "provenance"
-                  ],
-                  "type": "object"
-                },
-                "maxItems": 32,
-                "minItems": 1,
-                "type": "array"
-              },
-              "jobId": {
-                "type": "string"
-              },
-              "status": {
-                "type": "string"
-              }
-            },
-            "required": [
-              "jobId",
-              "status",
-              "costParameters",
-              "accounting",
-              "items"
-            ],
-            "type": "object"
-          }
-        ]
-      },
-      "mediaType": {
-        "const": "application/json",
-        "type": "string"
-      },
-      "observedAt": {
-        "description": "Caller observation metadata only; does not attest freshness.",
-        "type": [
-          "string",
-          "null"
-        ]
-      },
-      "status": {
-        "type": "string"
-      }
-    },
-    "required": [
-      "body"
-    ],
-    "type": "object"
-  },
-  {
-    "additionalProperties": true,
-    "description": "Intentionally permissive diagnostic alternative, not a template for a useful comparison. Missing/wrong schemas, keys, source identities or fields do not become valid comparison evidence. A missing snapshot can be supplied as {missing:true}. Safety admission still rejects paths, URL dereference, limit raises and invalid envelopes.",
-    "properties": {},
-    "type": "object"
-  }
-]

removedInput schema / properties / after / description

Removed value: -"Already held JSON artifact or JSON envelope, never a path or URL to dereference. Stable source identity, separate from row id and observation time. Matching normalizes source strings (URL fragments removed). Use the same non-empty identity on both sides; duplicate active identities are ambiguous. Synthetic URL STRINGS are inert and are never fetched by this transform. The structured branches describe representative comparable inputs. Incomplete objects remain admitted for diagnostic reports, subject to unchanged HTTP safety checks; HTTP 200 does not establish completeness or usefulness."

changedInput schema / properties / before / anyOf

Previous value: -[
-  {
-    "additionalProperties": false,
-    "description": "Representative merchant structure for useful comparisons; not a new paid request or proof of payment. Compare only the explicitly selected data keys present on both matched rows. Missing keys are coverage unknown, not deletions; explicit null is a present value. Unselected metadata is not a content delta.",
-    "properties": {
-      "accounting": {
-        "additionalProperties": true,
-        "properties": {},
-        "type": "object"
-      },
-      "boundary": {
-        "additionalProperties": true,
-        "properties": {},
-        "type": "object"
-      },
-      "charged": {
-        "type": "boolean"
-      },
-      "costInputs": {
-        "additionalProperties": true,
-        "properties": {},
-        "type": "object"
-      },
-      "error": {
-        "type": "string"
-      },
-      "jobId": {
-        "pattern": "^[a-f0-9]{64}$",
-        "type": "string"
-      },
-      "jobStatus": {
-        "enum": [
-          "running",
-          "completed",
-          "completed_with_unknown",
-          "stopped",
-          "interrupted"
-        ],
-        "type": "string"
-      },
-      "ok": {
-        "type": "boolean"
-      },
-      "partial": {
-        "type": "boolean"
-      },
-      "product": {
-        "const": "samedaydesk-extract-batch",
-        "type": "string"
-      },
-      "quote": {
-        "additionalProperties": true,
-        "properties": {
-          "amountAtomic": {
-            "const": "10000",
-            "type": "string"
-          },
-          "displayUsdc": {
-            "const": "0.01",
-            "type": "string"
-          },
-          "meaning": {
-            "type": "string"
-          }
-        },
-        "required": [
-          "amountAtomic",
-          "displayUsdc",
-          "meaning"
-        ],
-        "type": "object"
-      },
-      "schemaVersion": {
-        "const": "samedaydesk.extract-batch.v0",
-        "type": "string"
-      },
-      "sources": {
-        "items": {
-          "additionalProperties": true,
-          "properties": {
-            "data": {
-              "anyOf": [
-                {
-                  "additionalProperties": true,
-                  "description": "Compare only the explicitly selected data keys present on both matched rows. Missing keys are coverage unknown, not deletions; explicit null is a present value. Unselected metadata is not a content delta.",
-                  "properties": {
-                    "aiReadiness": {
-                      "description": "Selected extraction value: aiReadiness."
-                    },
-                    "canonical": {
-                      "description": "Selected extraction value: canonical."
-                    },
-                    "description": {
-                      "description": "Selected extraction value: description."
-                    },
-                    "headings": {
-                      "description": "Selected extraction value: headings."
-                    },
-                    "jsonLd": {
-                      "description": "Selected extraction value: jsonLd."
-                    },
-                    "lang": {
-                      "description": "Selected extraction value: lang."
-                    },
-                    "links": {
-                      "description": "Selected extraction value: links."
-                    },
-                    "openGraph": {
-                      "description": "Selected extraction value: openGraph."
-                    },
-                    "text": {
-                      "description": "Selected extraction value: text."
-                    },
-                    "title": {
-                      "description": "Selected extraction value: title."
-                    },
-                    "twitter": {
-                      "description": "Selected extraction value: twitter."
-                    }
-                  },
-                  "type": "object"
-                },
-                {
-                  "description": "Compare only the explicitly selected data keys present on both matched rows. Missing keys are coverage unknown, not deletions; explicit null is a present value. Unselected metadata is not a content delta.",
-                  "type": "null"
-                }
-              ],
-              "description": "Compare only the explicitly selected data keys present on both matched rows. Missing keys are coverage unknown, not deletions; explicit null is a present value. Unselected metadata is not a content delta."
-            },
-            "error": {
-              "anyOf": [
-                {
-                  "additionalProperties": true,
-                  "properties": {},
-                  "type": "object"
-                },
-                {
-                  "type": "null"
-                }
-              ]
-            },
-            "finalUrl": {
-              "type": [
-                "string",
-                "null"
-              ]
-            },
-            "httpStatus": {
-              "anyOf": [
-                {
-                  "type": "integer"
-                },
-                {
-                  "type": "null"
-                }
-              ]
-            },
-            "id": {
-              "description": "Row identifier; does not replace source identity.",
-              "type": "string"
-            },
-            "notes": {
-              "type": "array"
-            },
-            "provenance": {
-              "anyOf": [
-                {
-                  "additionalProperties": true,
-                  "properties": {},
-                  "type": "object"
-                },
-                {
-                  "type": "null"
-                }
-              ]
-            },
-            "source": {
-              "description": "Stable source identity, separate from row id and observation time. Matching normalizes source strings (URL fragments removed). Use the same non-empty identity on both sides; duplicate active identities are ambiguous. Synthetic URL STRINGS are inert and are never fetched by this transform.",
-              "minLength": 1,
-              "pattern": "\\S",
-              "type": "string"
-            },
-            "status": {
-              "enum": [
-                "pending",
-                "success",
-                "partial",
-                "failure",
-                "unknown",
-                "skipped_duplicate"
-              ],
-              "type": "string"
-            }
-          },
-          "required": [
-            "id",
-            "source",
-            "status",
-            "data",
-            "notes",
-            "error",
-            "provenance"
-          ],
-          "type": "object"
-        },
-        "maxItems": 5,
-        "minItems": 1,
-        "type": "array"
-      },
-      "stopReason": {
-        "type": [
-          "string",
-          "null"
-        ]
-      }
-    },
-    "required": [
-      "ok",
-      "product",
-      "schemaVersion",
-      "quote",
-      "jobId",
-      "jobStatus",
-      "stopReason",
-      "partial",
-      "sources",
-      "accounting",
-      "costInputs",
-      "charged",
-      "boundary"
-    ],
-    "type": "object"
-  },
-  {
-    "additionalProperties": true,
-    "description": "Existing C1 result compatibility. No merchant product/schemaVersion is required. Compare only the explicitly selected data keys present on both matched rows. Missing keys are coverage unknown, not deletions; explicit null is a present value. Unselected metadata is not a content delta.",
-    "properties": {
-      "accounting": {
-        "additionalProperties": true,
-        "properties": {},
-        "type": "object"
-      },
-      "costParameters": {
-        "additionalProperties": true,
-        "properties": {},
-        "type": "object"
-      },
-      "items": {
-        "items": {
-          "additionalProperties": true,
-          "properties": {
-            "data": {
-              "anyOf": [
-                {
-                  "additionalProperties": true,
-                  "description": "Compare only the explicitly selected data keys present on both matched rows. Missing keys are coverage unknown, not deletions; explicit null is a present value. Unselected metadata is not a content delta.",
-                  "properties": {
-                    "aiReadiness": {
-                      "description": "Selected extraction value: aiReadiness."
-                    },
-                    "canonical": {
-                      "description": "Selected extraction value: canonical."
-                    },
-                    "description": {
-                      "description": "Selected extraction value: description."
-                    },
-                    "headings": {
-                      "description": "Selected extraction value: headings."
-                    },
-                    "jsonLd": {
-                      "description": "Selected extraction value: jsonLd."
-                    },
-                    "lang": {
-                      "description": "Selected extraction value: lang."
-                    },
-                    "links": {
-                      "description": "Selected extraction value: links."
-                    },
-                    "openGraph": {
-                      "description": "Selected extraction value: openGraph."
-                    },
-                    "text": {
-                      "description": "Selected extraction value: text."
-                    },
-                    "title": {
-                      "description": "Selected extraction value: title."
-                    },
-                    "twitter": {
-                      "description": "Selected extraction value: twitter."
-                    }
-                  },
-                  "type": "object"
-                },
-                {
-                  "description": "Compare only the explicitly selected data keys present on both matched rows. Missing keys are coverage unknown, not deletions; explicit null is a present value. Unselected metadata is not a content delta.",
-                  "type": "null"
-                }
-              ],
-              "description": "Compare only the explicitly selected data keys present on both matched rows. Missing keys are coverage unknown, not deletions; explicit null is a present value. Unselected metadata is not a content delta."
-            },
-            "error": {
-              "anyOf": [
-                {
-                  "additionalProperties": true,
-                  "properties": {},
-                  "type": "object"
-                },
-                {
-                  "type": "null"
-                }
-              ]
-            },
-            "finalUrl": {
-              "type": [
-                "string",
-                "null"
-              ]
-            },
-            "httpStatus": {
-              "anyOf": [
-                {
-                  "type": "integer"
-                },
-                {
-                  "type": "null"
-                }
-              ]
-            },
-            "id": {
-              "description": "Row identifier; does not replace source identity.",
-              "type": "string"
-            },
-            "notes": {
-              "type": "array"
-            },
-            "provenance": {
-              "anyOf": [
-                {
-                  "additionalProperties": true,
-                  "properties": {},
-                  "type": "object"
-                },
-                {
-                  "type": "null"
-                }
-              ]
-            },
-            "source": {
-              "description": "Stable source identity, separate from row id and observation time. Matching normalizes source strings (URL fragments removed). Use the same non-empty identity on both sides; duplicate active identities are ambiguous. Synthetic URL STRINGS are inert and are never fetched by this transform.",
-              "minLength": 1,
-              "pattern": "\\S",
-              "type": "string"
-            },
-            "status": {
-              "enum": [
-                "pending",
-                "success",
-                "partial",
-                "failure",
-                "unknown",
-                "skipped_duplicate"
-              ],
-              "type": "string"
-            }
-          },
-          "required": [
-            "id",
-            "source",
-            "status",
-            "data",
-            "notes",
-            "error",
-            "provenance"
-          ],
-          "type": "object"
-        },
-        "maxItems": 32,
-        "minItems": 1,
-        "type": "array"
-      },
-      "jobId": {
-        "type": "string"
-      },
-      "status": {
-        "type": "string"
-      }
-    },
-    "required": [
-      "jobId",
-      "status",
-      "costParameters",
-      "accounting",
-      "items"
-    ],
-    "type": "object"
-  },
-  {
-    "additionalProperties": false,
-    "properties": {
-      "body": {
-        "anyOf": [
-          {
-            "additionalProperties": false,
-            "description": "Representative merchant structure for useful comparisons; not a new paid request or proof of payment. Compare only the explicitly selected data keys present on both matched rows. Missing keys are coverage unknown, not deletions; explicit null is a present value. Unselected metadata is not a content delta.",
-            "properties": {
-              "accounting": {
-                "additionalProperties": true,
-                "properties": {},
-                "type": "object"
-              },
-              "boundary": {
-                "additionalProperties": true,
-                "properties": {},
-                "type": "object"
-              },
-              "charged": {
-                "type": "boolean"
-              },
-              "costInputs": {
-                "additionalProperties": true,
-                "properties": {},
-                "type": "object"
-              },
-              "error": {
-                "type": "string"
-              },
-              "jobId": {
-                "pattern": "^[a-f0-9]{64}$",
-                "type": "string"
-              },
-              "jobStatus": {
-                "enum": [
-                  "running",
-                  "completed",
-                  "completed_with_unknown",
-                  "stopped",
-                  "interrupted"
-                ],
-                "type": "string"
-              },
-              "ok": {
-                "type": "boolean"
-              },
-              "partial": {
-                "type": "boolean"
-              },
-              "product": {
-                "const": "samedaydesk-extract-batch",
-                "type": "string"
-              },
-              "quote": {
-                "additionalProperties": true,
-                "properties": {
-                  "amountAtomic": {
-                    "const": "10000",
-                    "type": "string"
-                  },
-                  "displayUsdc": {
-                    "const": "0.01",
-                    "type": "string"
-                  },
-                  "meaning": {
-                    "type": "string"
-                  }
-                },
-                "required": [
-                  "amountAtomic",
-                  "displayUsdc",
-                  "meaning"
-                ],
-                "type": "object"
-              },
-              "schemaVersion": {
-                "const": "samedaydesk.extract-batch.v0",
-                "type": "string"
-              },
-              "sources": {
-                "items": {
-                  "additionalProperties": true,
-                  "properties": {
-                    "data": {
-                      "anyOf": [
-                        {
-                          "additionalProperties": true,
-                          "description": "Compare only the explicitly selected data keys present on both matched rows. Missing keys are coverage unknown, not deletions; explicit null is a present value. Unselected metadata is not a content delta.",
-                          "properties": {
-                            "aiReadiness": {
-                              "description": "Selected extraction value: aiReadiness."
-                            },
-                            "canonical": {
-                              "description": "Selected extraction value: canonical."
-                            },
-                            "description": {
-                              "description": "Selected extraction value: description."
-                            },
-                            "headings": {
-                              "description": "Selected extraction value: headings."
-                            },
-                            "jsonLd": {
-                              "description": "Selected extraction value: jsonLd."
-                            },
-                            "lang": {
-                              "description": "Selected extraction value: lang."
-                            },
-                            "links": {
-                              "description": "Selected extraction value: links."
-                            },
-                            "openGraph": {
-                              "description": "Selected extraction value: openGraph."
-                            },
-                            "text": {
-                              "description": "Selected extraction value: text."
-                            },
-                            "title": {
-                              "description": "Selected extraction value: title."
-                            },
-                            "twitter": {
-                              "description": "Selected extraction value: twitter."
-                            }
-                          },
-                          "type": "object"
-                        },
-                        {
-                          "description": "Compare only the explicitly selected data keys present on both matched rows. Missing keys are coverage unknown, not deletions; explicit null is a present value. Unselected metadata is not a content delta.",
-                          "type": "null"
-                        }
-                      ],
-                      "description": "Compare only the explicitly selected data keys present on both matched rows. Missing keys are coverage unknown, not deletions; explicit null is a present value. Unselected metadata is not a content delta."
-                    },
-                    "error": {
-                      "anyOf": [
-                        {
-                          "additionalProperties": true,
-                          "properties": {},
-                          "type": "object"
-                        },
-                        {
-                          "type": "null"
-                        }
-                      ]
-                    },
-                    "finalUrl": {
-                      "type": [
-                        "string",
-                        "null"
-                      ]
-                    },
-                    "httpStatus": {
-                      "anyOf": [
-                        {
-                          "type": "integer"
-                        },
-                        {
-                          "type": "null"
-                        }
-                      ]
-                    },
-                    "id": {
-                      "description": "Row identifier; does not replace source identity.",
-                      "type": "string"
-                    },
-                    "notes": {
-                      "type": "array"
-                    },
-                    "provenance": {
-                      "anyOf": [
-                        {
-                          "additionalProperties": true,
-                          "properties": {},
-                          "type": "object"
-                        },
-                        {
-                          "type": "null"
-                        }
-                      ]
-                    },
-                    "source": {
-                      "description": "Stable source identity, separate from row id and observation time. Matching normalizes source strings (URL fragments removed). Use the same non-empty identity on both sides; duplicate active identities are ambiguous. Synthetic URL STRINGS are inert and are never fetched by this transform.",
-                      "minLength": 1,
-                      "pattern": "\\S",
-                      "type": "string"
-                    },
-                    "status": {
-                      "enum": [
-                        "pending",
-                        "success",
-                        "partial",
-                        "failure",
-                        "unknown",
-                        "skipped_duplicate"
-                      ],
-                      "type": "string"
-                    }
-                  },
-                  "required": [
-                    "id",
-                    "source",
-                    "status",
-                    "data",
-                    "notes",
-                    "error",
-                    "provenance"
-                  ],
-                  "type": "object"
-                },
-                "maxItems": 5,
-                "minItems": 1,
-                "type": "array"
-              },
-              "stopReason": {
-                "type": [
-                  "string",
-                  "null"
-                ]
-              }
-            },
-            "required": [
-              "ok",
-              "product",
-              "schemaVersion",
-              "quote",
-              "jobId",
-              "jobStatus",
-              "stopReason",
-              "partial",
-              "sources",
-              "accounting",
-              "costInputs",
-              "charged",
-              "boundary"
-            ],
-            "type": "object"
-          },
-          {
-            "additionalProperties": true,
-            "description": "Existing C1 result compatibility. No merchant product/schemaVersion is required. Compare only the explicitly selected data keys present on both matched rows. Missing keys are coverage unknown, not deletions; explicit null is a present value. Unselected metadata is not a content delta.",
-            "properties": {
-              "accounting": {
-                "additionalProperties": true,
-                "properties": {},
-                "type": "object"
-              },
-              "costParameters": {
-                "additionalProperties": true,
-                "properties": {},
-                "type": "object"
-              },
-              "items": {
-                "items": {
-                  "additionalProperties": true,
-                  "properties": {
-                    "data": {
-                      "anyOf": [
-                        {
-                          "additionalProperties": true,
-                          "description": "Compare only the explicitly selected data keys present on both matched rows. Missing keys are coverage unknown, not deletions; explicit null is a present value. Unselected metadata is not a content delta.",
-                          "properties": {
-                            "aiReadiness": {
-                              "description": "Selected extraction value: aiReadiness."
-                            },
-                            "canonical": {
-                              "description": "Selected extraction value: canonical."
-                            },
-                            "description": {
-                              "description": "Selected extraction value: description."
-                            },
-                            "headings": {
-                              "description": "Selected extraction value: headings."
-                            },
-                            "jsonLd": {
-                              "description": "Selected extraction value: jsonLd."
-                            },
-                            "lang": {
-                              "description": "Selected extraction value: lang."
-                            },
-                            "links": {
-                              "description": "Selected extraction value: links."
-                            },
-                            "openGraph": {
-                              "description": "Selected extraction value: openGraph."
-                            },
-                            "text": {
-                              "description": "Selected extraction value: text."
-                            },
-                            "title": {
-                              "description": "Selected extraction value: title."
-                            },
-                            "twitter": {
-                              "description": "Selected extraction value: twitter."
-                            }
-                          },
-                          "type": "object"
-                        },
-                        {
-                          "description": "Compare only the explicitly selected data keys present on both matched rows. Missing keys are coverage unknown, not deletions; explicit null is a present value. Unselected metadata is not a content delta.",
-                          "type": "null"
-                        }
-                      ],
-                      "description": "Compare only the explicitly selected data keys present on both matched rows. Missing keys are coverage unknown, not deletions; explicit null is a present value. Unselected metadata is not a content delta."
-                    },
-                    "error": {
-                      "anyOf": [
-                        {
-                          "additionalProperties": true,
-                          "properties": {},
-                          "type": "object"
-                        },
-                        {
-                          "type": "null"
-                        }
-                      ]
-                    },
-                    "finalUrl": {
-                      "type": [
-                        "string",
-                        "null"
-                      ]
-                    },
-                    "httpStatus": {
-                      "anyOf": [
-                        {
-                          "type": "integer"
-                        },
-                        {
-                          "type": "null"
-                        }
-                      ]
-                    },
-                    "id": {
-                      "description": "Row identifier; does not replace source identity.",
-                      "type": "string"
-                    },
-                    "notes": {
-                      "type": "array"
-                    },
-                    "provenance": {
-                      "anyOf": [
-                        {
-                          "additionalProperties": true,
-                          "properties": {},
-                          "type": "object"
-                        },
-                        {
-                          "type": "null"
-                        }
-                      ]
-                    },
-                    "source": {
-                      "description": "Stable source identity, separate from row id and observation time. Matching normalizes source strings (URL fragments removed). Use the same non-empty identity on both sides; duplicate active identities are ambiguous. Synthetic URL STRINGS are inert and are never fetched by this transform.",
-                      "minLength": 1,
-                      "pattern": "\\S",
-                      "type": "string"
-                    },
-                    "status": {
-                      "enum": [
-                        "pending",
-                        "success",
-                        "partial",
-                        "failure",
-                        "unknown",
-                        "skipped_duplicate"
-                      ],
-                      "type": "string"
-                    }
-                  },
-                  "required": [
-                    "id",
-                    "source",
-                    "status",
-                    "data",
-                    "notes",
-                    "error",
-                    "provenance"
-                  ],
-                  "type": "object"
-                },
-                "maxItems": 32,
-                "minItems": 1,
-                "type": "array"
-              },
-              "jobId": {
-                "type": "string"
-              },
-              "status": {
-                "type": "string"
-              }
-            },
-            "required": [
-              "jobId",
-              "status",
-              "costParameters",
-              "accounting",
-              "items"
-            ],
-            "type": "object"
-          }
-        ]
-      },
-      "mediaType": {
-        "const": "application/json",
-        "type": "string"
-      },
-      "observedAt": {
-        "description": "Caller observation metadata only; does not attest freshness.",
-        "type": [
-          "string",
-          "null"
-        ]
-      },
-      "status": {
-        "type": "string"
-      }
-    },
-    "required": [
-      "body"
-    ],
-    "type": "object"
-  },
-  {
-    "additionalProperties": true,
-    "description": "Intentionally permissive diagnostic alternative, not a template for a useful comparison. Missing/wrong schemas, keys, source identities or fields do not become valid comparison evidence. A missing snapshot can be supplied as {missing:true}. Safety admission still rejects paths, URL dereference, limit raises and invalid envelopes.",
-    "properties": {},
-    "type": "object"
-  }
-]New value: +[
+  {
+    "additionalProperties": false,
+    "description": "Representative merchant structure for useful comparisons; not a new paid request or proof of payment. Compare only the explicitly selected data keys present on both matched rows. Missing keys are coverage unknown, not deletions; explicit null is a present value. Unselected metadata is not a content delta.",
+    "properties": {
+      "accounting": {
+        "$ref": "#/properties/before/anyOf/0/properties/sources/items/properties/error/anyOf/0"
+      },
+      "boundary": {
+        "$ref": "#/properties/before/anyOf/0/properties/sources/items/properties/error/anyOf/0"
+      },
+      "charged": {
+        "$ref": "#/properties/before/anyOf/0/properties/ok"
+      },
+      "costInputs": {
+        "$ref": "#/properties/before/anyOf/0/properties/sources/items/properties/error/anyOf/0"
+      },
+      "error": {
+        "$ref": "#/properties/before/anyOf/0/properties/quote/properties/meaning"
+      },
+      "jobId": {
+        "pattern": "^[a-f0-9]{64}$",
+        "type": "string"
+      },
+      "jobStatus": {
+        "enum": [
+          "running",
+          "completed",
+          "completed_with_unknown",
+          "stopped",
+          "interrupted"
+        ],
+        "type": "string"
+      },
+      "ok": {
+        "type": "boolean"
+      },
+      "partial": {
+        "$ref": "#/properties/before/anyOf/0/properties/ok"
+      },
+      "product": {
+        "const": "samedaydesk-extract-batch",
+        "type": "string"
+      },
+      "quote": {
+        "additionalProperties": true,
+        "properties": {
+          "amountAtomic": {
+            "const": "10000",
+            "type": "string"
+          },
+          "displayUsdc": {
+            "const": "0.01",
+            "type": "string"
+          },
+          "meaning": {
+            "type": "string"
+          }
+        },
+        "required": [
+          "amountAtomic",
+          "displayUsdc",
+          "meaning"
+        ],
+        "type": "object"
+      },
+      "schemaVersion": {
+        "const": "samedaydesk.extract-batch.v0",
+        "type": "string"
+      },
+      "sources": {
+        "items": {
+          "additionalProperties": true,
+          "properties": {
+            "data": {
+              "anyOf": [
+                {
+                  "additionalProperties": true,
+                  "description": "Compare only the explicitly selected data keys present on both matched rows. Missing keys are coverage unknown, not deletions; explicit null is a present value. Unselected metadata is not a content delta.",
+                  "properties": {
+                    "aiReadiness": {
+                      "description": "Selected extraction value: aiReadiness."
+                    },
+                    "canonical": {
+                      "description": "Selected extraction value: canonical."
+                    },
+                    "description": {
+                      "description": "Selected extraction value: description."
+                    },
+                    "headings": {
+                      "description": "Selected extraction value: headings."
+                    },
+                    "jsonLd": {
+                      "description": "Selected extraction value: jsonLd."
+                    },
+                    "lang": {
+                      "description": "Selected extraction value: lang."
+                    },
+                    "links": {
+                      "description": "Selected extraction value: links."
+                    },
+                    "openGraph": {
+                      "description": "Selected extraction value: openGraph."
+                    },
+                    "text": {
+                      "description": "Selected extraction value: text."
+                    },
+                    "title": {
+                      "description": "Selected extraction value: title."
+                    },
+                    "twitter": {
+                      "description": "Selected extraction value: twitter."
+                    }
+                  },
+                  "type": "object"
+                },
+                {
+                  "description": "Compare only the explicitly selected data keys present on both matched rows. Missing keys are coverage unknown, not deletions; explicit null is a present value. Unselected metadata is not a content delta.",
+                  "type": "null"
+                }
+              ],
+              "description": "Compare only the explicitly selected data keys present on both matched rows. Missing keys are coverage unknown, not deletions; explicit null is a present value. Unselected metadata is not a content delta."
+            },
+            "error": {
+              "anyOf": [
+                {
+                  "additionalProperties": true,
+                  "properties": {},
+                  "type": "object"
+                },
+                {
+                  "type": "null"
+                }
+              ]
+            },
+            "finalUrl": {
+              "$ref": "#/properties/before/anyOf/0/properties/stopReason"
+            },
+            "httpStatus": {
+              "anyOf": [
+                {
+                  "type": "integer"
+                },
+                {
+                  "$ref": "#/properties/before/anyOf/0/properties/sources/items/properties/error/anyOf/1"
+                }
+              ]
+            },
+            "id": {
+              "description": "Row identifier; does not replace source identity.",
+              "type": "string"
+            },
+            "notes": {
+              "type": "array"
+            },
+            "provenance": {
+              "$ref": "#/properties/before/anyOf/0/properties/sources/items/properties/error"
+            },
+            "source": {
+              "description": "Stable source identity, separate from row id and observation time. Matching normalizes source strings (URL fragments removed). Use the same non-empty identity on both sides; duplicate active identities are ambiguous. Synthetic URL STRINGS are inert and are never fetched by this transform.",
+              "minLength": 1,
+              "pattern": "\\S",
+              "type": "string"
+            },
+            "status": {
+              "enum": [
+                "pending",
+                "success",
+                "partial",
+                "failure",
+                "unknown",
+                "skipped_duplicate"
+              ],
+              "type": "string"
+            }
+          },
+          "required": [
+            "id",
+            "source",
+            "status",
+            "data",
+            "notes",
+            "error",
+            "provenance"
+          ],
+          "type": "object"
+        },
+        "maxItems": 5,
+        "minItems": 1,
+        "type": "array"
+      },
+      "stopReason": {
+        "type": [
+          "string",
+          "null"
+        ]
+      }
+    },
+    "required": [
+      "ok",
+      "product",
+      "schemaVersion",
+      "quote",
+      "jobId",
+      "jobStatus",
+      "stopReason",
+      "partial",
+      "sources",
+      "accounting",
+      "costInputs",
+      "charged",
+      "boundary"
+    ],
+    "type": "object"
+  },
+  {
+    "additionalProperties": true,
+    "description": "Existing C1 result compatibility. No merchant product/schemaVersion is required. Compare only the explicitly selected data keys present on both matched rows. Missing keys are coverage unknown, not deletions; explicit null is a present value. Unselected metadata is not a content delta.",
+    "properties": {
+      "accounting": {
+        "$ref": "#/properties/before/anyOf/0/properties/sources/items/properties/error/anyOf/0"
+      },
+      "costParameters": {
+        "$ref": "#/properties/before/anyOf/0/properties/sources/items/properties/error/anyOf/0"
+      },
+      "items": {
+        "items": {
+          "$ref": "#/properties/before/anyOf/0/properties/sources/items"
+        },
+        "maxItems": 32,
+        "minItems": 1,
+        "type": "array"
+      },
+      "jobId": {
+        "$ref": "#/properties/before/anyOf/0/properties/quote/properties/meaning"
+      },
+      "status": {
+        "$ref": "#/properties/before/anyOf/0/properties/quote/properties/meaning"
+      }
+    },
+    "required": [
+      "jobId",
+      "status",
+      "costParameters",
+      "accounting",
+      "items"
+    ],
+    "type": "object"
+  },
+  {
+    "additionalProperties": false,
+    "properties": {
+      "body": {
+        "anyOf": [
+          {
+            "$ref": "#/properties/before/anyOf/0"
+          },
+          {
+            "$ref": "#/properties/before/anyOf/1"
+          }
+        ]
+      },
+      "mediaType": {
+        "const": "application/json",
+        "type": "string"
+      },
+      "observedAt": {
+        "description": "Caller observation metadata only; does not attest freshness.",
+        "type": [
+          "string",
+          "null"
+        ]
+      },
+      "status": {
+        "$ref": "#/properties/before/anyOf/0/properties/quote/properties/meaning"
+      }
+    },
+    "required": [
+      "body"
+    ],
+    "type": "object"
+  },
+  {
+    "additionalProperties": true,
+    "description": "Intentionally permissive diagnostic alternative, not a template for a useful comparison. Missing/wrong schemas, keys, source identities or fields do not become valid comparison evidence. A missing snapshot can be supplied as {missing:true}. Safety admission still rejects paths, URL dereference, limit raises and invalid envelopes.",
+    "properties": {},
+    "type": "object"
+  }
+]

1 tool updateOct 26, 2026

Changedpage_change13 fields changed

removedInput schema / properties / after / additionalProperties
```
Removed value: -{}
```

addedInput schema / properties / after / anyOf

Added value: +[
+  {
+    "additionalProperties": false,
+    "description": "Representative merchant structure for useful comparisons; not a new paid request or proof of payment. Compare only the explicitly selected data keys present on both matched rows. Missing keys are coverage unknown, not deletions; explicit null is a present value. Unselected metadata is not a content delta.",
+    "properties": {
+      "accounting": {
+        "additionalProperties": true,
+        "properties": {},
+        "type": "object"
+      },
+      "boundary": {
+        "additionalProperties": true,
+        "properties": {},
+        "type": "object"
+      },
+      "charged": {
+        "type": "boolean"
+      },
+      "costInputs": {
+        "additionalProperties": true,
+        "properties": {},
+        "type": "object"
+      },
+      "error": {
+        "type": "string"
+      },
+      "jobId": {
+        "pattern": "^[a-f0-9]{64}$",
+        "type": "string"
+      },
+      "jobStatus": {
+        "enum": [
+          "running",
+          "completed",
+          "completed_with_unknown",
+          "stopped",
+          "interrupted"
+        ],
+        "type": "string"
+      },
+      "ok": {
+        "type": "boolean"
+      },
+      "partial": {
+        "type": "boolean"
+      },
+      "product": {
+        "const": "samedaydesk-extract-batch",
+        "type": "string"
+      },
+      "quote": {
+        "additionalProperties": true,
+        "properties": {
+          "amountAtomic": {
+            "const": "10000",
+            "type": "string"
+          },
+          "displayUsdc": {
+            "const": "0.01",
+            "type": "string"
+          },
+          "meaning": {
+            "type": "string"
+          }
+        },
+        "required": [
+          "amountAtomic",
+          "displayUsdc",
+          "meaning"
+        ],
+        "type": "object"
+      },
+      "schemaVersion": {
+        "const": "samedaydesk.extract-batch.v0",
+        "type": "string"
+      },
+      "sources": {
+        "items": {
+          "additionalProperties": true,
+          "properties": {
+            "data": {
+              "anyOf": [
+                {
+                  "additionalProperties": true,
+                  "description": "Compare only the explicitly selected data keys present on both matched rows. Missing keys are coverage unknown, not deletions; explicit null is a present value. Unselected metadata is not a content delta.",
+                  "properties": {
+                    "aiReadiness": {
+                      "description": "Selected extraction value: aiReadiness."
+                    },
+                    "canonical": {
+                      "description": "Selected extraction value: canonical."
+                    },
+                    "description": {
+                      "description": "Selected extraction value: description."
+                    },
+                    "headings": {
+                      "description": "Selected extraction value: headings."
+                    },
+                    "jsonLd": {
+                      "description": "Selected extraction value: jsonLd."
+                    },
+                    "lang": {
+                      "description": "Selected extraction value: lang."
+                    },
+                    "links": {
+                      "description": "Selected extraction value: links."
+                    },
+                    "openGraph": {
+                      "description": "Selected extraction value: openGraph."
+                    },
+                    "text": {
+                      "description": "Selected extraction value: text."
+                    },
+                    "title": {
+                      "description": "Selected extraction value: title."
+                    },
+                    "twitter": {
+                      "description": "Selected extraction value: twitter."
+                    }
+                  },
+                  "type": "object"
+                },
+                {
+                  "description": "Compare only the explicitly selected data keys present on both matched rows. Missing keys are coverage unknown, not deletions; explicit null is a present value. Unselected metadata is not a content delta.",
+                  "type": "null"
+                }
+              ],
+              "description": "Compare only the explicitly selected data keys present on both matched rows. Missing keys are coverage unknown, not deletions; explicit null is a present value. Unselected metadata is not a content delta."
+            },
+            "error": {
+              "anyOf": [
+                {
+                  "additionalProperties": true,
+                  "properties": {},
+                  "type": "object"
+                },
+                {
+                  "type": "null"
+                }
+              ]
+            },
+            "finalUrl": {
+              "type": [
+                "string",
+                "null"
+              ]
+            },
+            "httpStatus": {
+              "anyOf": [
+                {
+                  "type": "integer"
+                },
+                {
+                  "type": "null"
+                }
+              ]
+            },
+            "id": {
+              "description": "Row identifier; does not replace source identity.",
+              "type": "string"
+            },
+            "notes": {
+              "type": "array"
+            },
+            "provenance": {
+              "anyOf": [
+                {
+                  "additionalProperties": true,
+                  "properties": {},
+                  "type": "object"
+                },
+                {
+                  "type": "null"
+                }
+              ]
+            },
+            "source": {
+              "description": "Stable source identity, separate from row id and observation time. Matching normalizes source strings (URL fragments removed). Use the same non-empty identity on both sides; duplicate active identities are ambiguous. Synthetic URL STRINGS are inert and are never fetched by this transform.",
+              "minLength": 1,
+              "pattern": "\\S",
+              "type": "string"
+            },
+            "status": {
+              "enum": [
+                "pending",
+                "success",
+                "partial",
+                "failure",
+                "unknown",
+                "skipped_duplicate"
+              ],
+              "type": "string"
+            }
+          },
+          "required": [
+            "id",
+            "source",
+            "status",
+            "data",
+            "notes",
+            "error",
+            "provenance"
+          ],
+          "type": "object"
+        },
+        "maxItems": 5,
+        "minItems": 1,
+        "type": "array"
+      },
+      "stopReason": {
+        "type": [
+          "string",
+          "null"
+        ]
+      }
+    },
+    "required": [
+      "ok",
+      "product",
+      "schemaVersion",
+      "quote",
+      "jobId",
+      "jobStatus",
+      "stopReason",
+      "partial",
+      "sources",
+      "accounting",
+      "costInputs",
+      "charged",
+      "boundary"
+    ],
+    "type": "object"
+  },
+  {
+    "additionalProperties": true,
+    "description": "Existing C1 result compatibility. No merchant product/schemaVersion is required. Compare only the explicitly selected data keys present on both matched rows. Missing keys are coverage unknown, not deletions; explicit null is a present value. Unselected metadata is not a content delta.",
+    "properties": {
+      "accounting": {
+        "additionalProperties": true,
+        "properties": {},
+        "type": "object"
+      },
+      "costParameters": {
+        "additionalProperties": true,
+        "properties": {},
+        "type": "object"
+      },
+      "items": {
+        "items": {
+          "additionalProperties": true,
+          "properties": {
+            "data": {
+              "anyOf": [
+                {
+                  "additionalProperties": true,
+                  "description": "Compare only the explicitly selected data keys present on both matched rows. Missing keys are coverage unknown, not deletions; explicit null is a present value. Unselected metadata is not a content delta.",
+                  "properties": {
+                    "aiReadiness": {
+                      "description": "Selected extraction value: aiReadiness."
+                    },
+                    "canonical": {
+                      "description": "Selected extraction value: canonical."
+                    },
+                    "description": {
+                      "description": "Selected extraction value: description."
+                    },
+                    "headings": {
+                      "description": "Selected extraction value: headings."
+                    },
+                    "jsonLd": {
+                      "description": "Selected extraction value: jsonLd."
+                    },
+                    "lang": {
+                      "description": "Selected extraction value: lang."
+                    },
+                    "links": {
+                      "description": "Selected extraction value: links."
+                    },
+                    "openGraph": {
+                      "description": "Selected extraction value: openGraph."
+                    },
+                    "text": {
+                      "description": "Selected extraction value: text."
+                    },
+                    "title": {
+                      "description": "Selected extraction value: title."
+                    },
+                    "twitter": {
+                      "description": "Selected extraction value: twitter."
+                    }
+                  },
+                  "type": "object"
+                },
+                {
+                  "description": "Compare only the explicitly selected data keys present on both matched rows. Missing keys are coverage unknown, not deletions; explicit null is a present value. Unselected metadata is not a content delta.",
+                  "type": "null"
+                }
+              ],
+              "description": "Compare only the explicitly selected data keys present on both matched rows. Missing keys are coverage unknown, not deletions; explicit null is a present value. Unselected metadata is not a content delta."
+            },
+            "error": {
+              "anyOf": [
+                {
+                  "additionalProperties": true,
+                  "properties": {},
+                  "type": "object"
+                },
+                {
+                  "type": "null"
+                }
+              ]
+            },
+            "finalUrl": {
+              "type": [
+                "string",
+                "null"
+              ]
+            },
+            "httpStatus": {
+              "anyOf": [
+                {
+                  "type": "integer"
+                },
+                {
+                  "type": "null"
+                }
+              ]
+            },
+            "id": {
+              "description": "Row identifier; does not replace source identity.",
+              "type": "string"
+            },
+            "notes": {
+              "type": "array"
+            },
+            "provenance": {
+              "anyOf": [
+                {
+                  "additionalProperties": true,
+                  "properties": {},
+                  "type": "object"
+                },
+                {
+                  "type": "null"
+                }
+              ]
+            },
+            "source": {
+              "description": "Stable source identity, separate from row id and observation time. Matching normalizes source strings (URL fragments removed). Use the same non-empty identity on both sides; duplicate active identities are ambiguous. Synthetic URL STRINGS are inert and are never fetched by this transform.",
+              "minLength": 1,
+              "pattern": "\\S",
+              "type": "string"
+            },
+            "status": {
+              "enum": [
+                "pending",
+                "success",
+                "partial",
+                "failure",
+                "unknown",
+                "skipped_duplicate"
+              ],
+              "type": "string"
+            }
+          },
+          "required": [
+            "id",
+            "source",
+            "status",
+            "data",
+            "notes",
+            "error",
+            "provenance"
+          ],
+          "type": "object"
+        },
+        "maxItems": 32,
+        "minItems": 1,
+        "type": "array"
+      },
+      "jobId": {
+        "type": "string"
+      },
+      "status": {
+        "type": "string"
+      }
+    },
+    "required": [
+      "jobId",
+      "status",
+      "costParameters",
+      "accounting",
+      "items"
+    ],
+    "type": "object"
+  },
+  {
+    "additionalProperties": false,
+    "properties": {
+      "body": {
+        "anyOf": [
+          {
+            "additionalProperties": false,
+            "description": "Representative merchant structure for useful comparisons; not a new paid request or proof of payment. Compare only the explicitly selected data keys present on both matched rows. Missing keys are coverage unknown, not deletions; explicit null is a present value. Unselected metadata is not a content delta.",
+            "properties": {
+              "accounting": {
+                "additionalProperties": true,
+                "properties": {},
+                "type": "object"
+              },
+              "boundary": {
+                "additionalProperties": true,
+                "properties": {},
+                "type": "object"
+              },
+              "charged": {
+                "type": "boolean"
+              },
+              "costInputs": {
+                "additionalProperties": true,
+                "properties": {},
+                "type": "object"
+              },
+              "error": {
+                "type": "string"
+              },
+              "jobId": {
+                "pattern": "^[a-f0-9]{64}$",
+                "type": "string"
+              },
+              "jobStatus": {
+                "enum": [
+                  "running",
+                  "completed",
+                  "completed_with_unknown",
+                  "stopped",
+                  "interrupted"
+                ],
+                "type": "string"
+              },
+              "ok": {
+                "type": "boolean"
+              },
+              "partial": {
+                "type": "boolean"
+              },
+              "product": {
+                "const": "samedaydesk-extract-batch",
+                "type": "string"
+              },
+              "quote": {
+                "additionalProperties": true,
+                "properties": {
+                  "amountAtomic": {
+                    "const": "10000",
+                    "type": "string"
+                  },
+                  "displayUsdc": {
+                    "const": "0.01",
+                    "type": "string"
+                  },
+                  "meaning": {
+                    "type": "string"
+                  }
+                },
+                "required": [
+                  "amountAtomic",
+                  "displayUsdc",
+                  "meaning"
+                ],
+                "type": "object"
+              },
+              "schemaVersion": {
+                "const": "samedaydesk.extract-batch.v0",
+                "type": "string"
+              },
+              "sources": {
+                "items": {
+                  "additionalProperties": true,
+                  "properties": {
+                    "data": {
+                      "anyOf": [
+                        {
+                          "additionalProperties": true,
+                          "description": "Compare only the explicitly selected data keys present on both matched rows. Missing keys are coverage unknown, not deletions; explicit null is a present value. Unselected metadata is not a content delta.",
+                          "properties": {
+                            "aiReadiness": {
+                              "description": "Selected extraction value: aiReadiness."
+                            },
+                            "canonical": {
+                              "description": "Selected extraction value: canonical."
+                            },
+                            "description": {
+                              "description": "Selected extraction value: description."
+                            },
+                            "headings": {
+                              "description": "Selected extraction value: headings."
+                            },
+                            "jsonLd": {
+                              "description": "Selected extraction value: jsonLd."
+                            },
+                            "lang": {
+                              "description": "Selected extraction value: lang."
+                            },
+                            "links": {
+                              "description": "Selected extraction value: links."
+                            },
+                            "openGraph": {
+                              "description": "Selected extraction value: openGraph."
+                            },
+                            "text": {
+                              "description": "Selected extraction value: text."
+                            },
+                            "title": {
+                              "description": "Selected extraction value: title."
+                            },
+                            "twitter": {
+                              "description": "Selected extraction value: twitter."
+                            }
+                          },
+                          "type": "object"
+                        },
+                        {
+                          "description": "Compare only the explicitly selected data keys present on both matched rows. Missing keys are coverage unknown, not deletions; explicit null is a present value. Unselected metadata is not a content delta.",
+                          "type": "null"
+                        }
+                      ],
+                      "description": "Compare only the explicitly selected data keys present on both matched rows. Missing keys are coverage unknown, not deletions; explicit null is a present value. Unselected metadata is not a content delta."
+                    },
+                    "error": {
+                      "anyOf": [
+                        {
+                          "additionalProperties": true,
+                          "properties": {},
+                          "type": "object"
+                        },
+                        {
+                          "type": "null"
+                        }
+                      ]
+                    },
+                    "finalUrl": {
+                      "type": [
+                        "string",
+                        "null"
+                      ]
+                    },
+                    "httpStatus": {
+                      "anyOf": [
+                        {
+                          "type": "integer"
+                        },
+                        {
+                          "type": "null"
+                        }
+                      ]
+                    },
+                    "id": {
+                      "description": "Row identifier; does not replace source identity.",
+                      "type": "string"
+                    },
+                    "notes": {
+                      "type": "array"
+                    },
+                    "provenance": {
+                      "anyOf": [
+                        {
+                          "additionalProperties": true,
+                          "properties": {},
+                          "type": "object"
+                        },
+                        {
+                          "type": "null"
+                        }
+                      ]
+                    },
+                    "source": {
+                      "description": "Stable source identity, separate from row id and observation time. Matching normalizes source strings (URL fragments removed). Use the same non-empty identity on both sides; duplicate active identities are ambiguous. Synthetic URL STRINGS are inert and are never fetched by this transform.",
+                      "minLength": 1,
+                      "pattern": "\\S",
+                      "type": "string"
+                    },
+                    "status": {
+                      "enum": [
+                        "pending",
+                        "success",
+                        "partial",
+                        "failure",
+                        "unknown",
+                        "skipped_duplicate"
+                      ],
+                      "type": "string"
+                    }
+                  },
+                  "required": [
+                    "id",
+                    "source",
+                    "status",
+                    "data",
+                    "notes",
+                    "error",
+                    "provenance"
+                  ],
+                  "type": "object"
+                },
+                "maxItems": 5,
+                "minItems": 1,
+                "type": "array"
+              },
+              "stopReason": {
+                "type": [
+                  "string",
+                  "null"
+                ]
+              }
+            },
+            "required": [
+              "ok",
+              "product",
+              "schemaVersion",
+              "quote",
+              "jobId",
+              "jobStatus",
+              "stopReason",
+              "partial",
+              "sources",
+              "accounting",
+              "costInputs",
+              "charged",
+              "boundary"
+            ],
+            "type": "object"
+          },
+          {
+            "additionalProperties": true,
+            "description": "Existing C1 result compatibility. No merchant product/schemaVersion is required. Compare only the explicitly selected data keys present on both matched rows. Missing keys are coverage unknown, not deletions; explicit null is a present value. Unselected metadata is not a content delta.",
+            "properties": {
+              "accounting": {
+                "additionalProperties": true,
+                "properties": {},
+                "type": "object"
+              },
+              "costParameters": {
+                "additionalProperties": true,
+                "properties": {},
+                "type": "object"
+              },
+              "items": {
+                "items": {
+                  "additionalProperties": true,
+                  "properties": {
+                    "data": {
+                      "anyOf": [
+                        {
+                          "additionalProperties": true,
+                          "description": "Compare only the explicitly selected data keys present on both matched rows. Missing keys are coverage unknown, not deletions; explicit null is a present value. Unselected metadata is not a content delta.",
+                          "properties": {
+                            "aiReadiness": {
+                              "description": "Selected extraction value: aiReadiness."
+                            },
+                            "canonical": {
+                              "description": "Selected extraction value: canonical."
+                            },
+                            "description": {
+                              "description": "Selected extraction value: description."
+                            },
+                            "headings": {
+                              "description": "Selected extraction value: headings."
+                            },
+                            "jsonLd": {
+                              "description": "Selected extraction value: jsonLd."
+                            },
+                            "lang": {
+                              "description": "Selected extraction value: lang."
+                            },
+                            "links": {
+                              "description": "Selected extraction value: links."
+                            },
+                            "openGraph": {
+                              "description": "Selected extraction value: openGraph."
+                            },
+                            "text": {
+                              "description": "Selected extraction value: text."
+                            },
+                            "title": {
+                              "description": "Selected extraction value: title."
+                            },
+                            "twitter": {
+                              "description": "Selected extraction value: twitter."
+                            }
+                          },
+                          "type": "object"
+                        },
+                        {
+                          "description": "Compare only the explicitly selected data keys present on both matched rows. Missing keys are coverage unknown, not deletions; explicit null is a present value. Unselected metadata is not a content delta.",
+                          "type": "null"
+                        }
+                      ],
+                      "description": "Compare only the explicitly selected data keys present on both matched rows. Missing keys are coverage unknown, not deletions; explicit null is a present value. Unselected metadata is not a content delta."
+                    },
+                    "error": {
+                      "anyOf": [
+                        {
+                          "additionalProperties": true,
+                          "properties": {},
+                          "type": "object"
+                        },
+                        {
+                          "type": "null"
+                        }
+                      ]
+                    },
+                    "finalUrl": {
+                      "type": [
+                        "string",
+                        "null"
+                      ]
+                    },
+                    "httpStatus": {
+                      "anyOf": [
+                        {
+                          "type": "integer"
+                        },
+                        {
+                          "type": "null"
+                        }
+                      ]
+                    },
+                    "id": {
+                      "description": "Row identifier; does not replace source identity.",
+                      "type": "string"
+                    },
+                    "notes": {
+                      "type": "array"
+                    },
+                    "provenance": {
+                      "anyOf": [
+                        {
+                          "additionalProperties": true,
+                          "properties": {},
+                          "type": "object"
+                        },
+                        {
+                          "type": "null"
+                        }
+                      ]
+                    },
+                    "source": {
+                      "description": "Stable source identity, separate from row id and observation time. Matching normalizes source strings (URL fragments removed). Use the same non-empty identity on both sides; duplicate active identities are ambiguous. Synthetic URL STRINGS are inert and are never fetched by this transform.",
+                      "minLength": 1,
+                      "pattern": "\\S",
+                      "type": "string"
+                    },
+                    "status": {
+                      "enum": [
+                        "pending",
+                        "success",
+                        "partial",
+                        "failure",
+                        "unknown",
+                        "skipped_duplicate"
+                      ],
+                      "type": "string"
+                    }
+                  },
+                  "required": [
+                    "id",
+                    "source",
+                    "status",
+                    "data",
+                    "notes",
+                    "error",
+                    "provenance"
+                  ],
+                  "type": "object"
+                },
+                "maxItems": 32,
+                "minItems": 1,
+                "type": "array"
+              },
+              "jobId": {
+                "type": "string"
+              },
+              "status": {
+                "type": "string"
+              }
+            },
+            "required": [
+              "jobId",
+              "status",
+              "costParameters",
+              "accounting",
+              "items"
+            ],
+            "type": "object"
+          }
+        ]
+      },
+      "mediaType": {
+        "const": "application/json",
+        "type": "string"
+      },
+      "observedAt": {
+        "description": "Caller observation metadata only; does not attest freshness.",
+        "type": [
+          "string",
+          "null"
+        ]
+      },
+      "status": {
+        "type": "string"
+      }
+    },
+    "required": [
+      "body"
+    ],
+    "type": "object"
+  },
+  {
+    "additionalProperties": true,
+    "description": "Intentionally permissive diagnostic alternative, not a template for a useful comparison. Missing/wrong schemas, keys, source identities or fields do not become valid comparison evidence. A missing snapshot can be supplied as {missing:true}. Safety admission still rejects paths, URL dereference, limit raises and invalid envelopes.",
+    "properties": {},
+    "type": "object"
+  }
+]

changedInput schema / properties / after / description

Previous value: -"Already delivered batch JSON object. Not a URL or filesystem path."New value: +"Already held JSON artifact or JSON envelope, never a path or URL to dereference. Stable source identity, separate from row id and observation time. Matching normalizes source strings (URL fragments removed). Use the same non-empty identity on both sides; duplicate active identities are ambiguous. Synthetic URL STRINGS are inert and are never fetched by this transform. The structured branches describe representative comparable inputs. Incomplete objects remain admitted for diagnostic reports, subject to unchanged HTTP safety checks; HTTP 200 does not establish completeness or usefulness."

removedInput schema / properties / after / type
```
Removed value: -"object"
```

addedInput schema / properties / allowFreshClaim

Added value: +{
+  "const": false,
+  "description": "Supplied inputs cannot attest freshness. True is rejected.",
+  "type": "boolean"
+}

removedInput schema / properties / before / additionalProperties
```
Removed value: -{}
```

addedInput schema / properties / before / anyOf

Added value: +[
+  {
+    "additionalProperties": false,
+    "description": "Representative merchant structure for useful comparisons; not a new paid request or proof of payment. Compare only the explicitly selected data keys present on both matched rows. Missing keys are coverage unknown, not deletions; explicit null is a present value. Unselected metadata is not a content delta.",
+    "properties": {
+      "accounting": {
+        "additionalProperties": true,
+        "properties": {},
+        "type": "object"
+      },
+      "boundary": {
+        "additionalProperties": true,
+        "properties": {},
+        "type": "object"
+      },
+      "charged": {
+        "type": "boolean"
+      },
+      "costInputs": {
+        "additionalProperties": true,
+        "properties": {},
+        "type": "object"
+      },
+      "error": {
+        "type": "string"
+      },
+      "jobId": {
+        "pattern": "^[a-f0-9]{64}$",
+        "type": "string"
+      },
+      "jobStatus": {
+        "enum": [
+          "running",
+          "completed",
+          "completed_with_unknown",
+          "stopped",
+          "interrupted"
+        ],
+        "type": "string"
+      },
+      "ok": {
+        "type": "boolean"
+      },
+      "partial": {
+        "type": "boolean"
+      },
+      "product": {
+        "const": "samedaydesk-extract-batch",
+        "type": "string"
+      },
+      "quote": {
+        "additionalProperties": true,
+        "properties": {
+          "amountAtomic": {
+            "const": "10000",
+            "type": "string"
+          },
+          "displayUsdc": {
+            "const": "0.01",
+            "type": "string"
+          },
+          "meaning": {
+            "type": "string"
+          }
+        },
+        "required": [
+          "amountAtomic",
+          "displayUsdc",
+          "meaning"
+        ],
+        "type": "object"
+      },
+      "schemaVersion": {
+        "const": "samedaydesk.extract-batch.v0",
+        "type": "string"
+      },
+      "sources": {
+        "items": {
+          "additionalProperties": true,
+          "properties": {
+            "data": {
+              "anyOf": [
+                {
+                  "additionalProperties": true,
+                  "description": "Compare only the explicitly selected data keys present on both matched rows. Missing keys are coverage unknown, not deletions; explicit null is a present value. Unselected metadata is not a content delta.",
+                  "properties": {
+                    "aiReadiness": {
+                      "description": "Selected extraction value: aiReadiness."
+                    },
+                    "canonical": {
+                      "description": "Selected extraction value: canonical."
+                    },
+                    "description": {
+                      "description": "Selected extraction value: description."
+                    },
+                    "headings": {
+                      "description": "Selected extraction value: headings."
+                    },
+                    "jsonLd": {
+                      "description": "Selected extraction value: jsonLd."
+                    },
+                    "lang": {
+                      "description": "Selected extraction value: lang."
+                    },
+                    "links": {
+                      "description": "Selected extraction value: links."
+                    },
+                    "openGraph": {
+                      "description": "Selected extraction value: openGraph."
+                    },
+                    "text": {
+                      "description": "Selected extraction value: text."
+                    },
+                    "title": {
+                      "description": "Selected extraction value: title."
+                    },
+                    "twitter": {
+                      "description": "Selected extraction value: twitter."
+                    }
+                  },
+                  "type": "object"
+                },
+                {
+                  "description": "Compare only the explicitly selected data keys present on both matched rows. Missing keys are coverage unknown, not deletions; explicit null is a present value. Unselected metadata is not a content delta.",
+                  "type": "null"
+                }
+              ],
+              "description": "Compare only the explicitly selected data keys present on both matched rows. Missing keys are coverage unknown, not deletions; explicit null is a present value. Unselected metadata is not a content delta."
+            },
+            "error": {
+              "anyOf": [
+                {
+                  "additionalProperties": true,
+                  "properties": {},
+                  "type": "object"
+                },
+                {
+                  "type": "null"
+                }
+              ]
+            },
+            "finalUrl": {
+              "type": [
+                "string",
+                "null"
+              ]
+            },
+            "httpStatus": {
+              "anyOf": [
+                {
+                  "type": "integer"
+                },
+                {
+                  "type": "null"
+                }
+              ]
+            },
+            "id": {
+              "description": "Row identifier; does not replace source identity.",
+              "type": "string"
+            },
+            "notes": {
+              "type": "array"
+            },
+            "provenance": {
+              "anyOf": [
+                {
+                  "additionalProperties": true,
+                  "properties": {},
+                  "type": "object"
+                },
+                {
+                  "type": "null"
+                }
+              ]
+            },
+            "source": {
+              "description": "Stable source identity, separate from row id and observation time. Matching normalizes source strings (URL fragments removed). Use the same non-empty identity on both sides; duplicate active identities are ambiguous. Synthetic URL STRINGS are inert and are never fetched by this transform.",
+              "minLength": 1,
+              "pattern": "\\S",
+              "type": "string"
+            },
+            "status": {
+              "enum": [
+                "pending",
+                "success",
+                "partial",
+                "failure",
+                "unknown",
+                "skipped_duplicate"
+              ],
+              "type": "string"
+            }
+          },
+          "required": [
+            "id",
+            "source",
+            "status",
+            "data",
+            "notes",
+            "error",
+            "provenance"
+          ],
+          "type": "object"
+        },
+        "maxItems": 5,
+        "minItems": 1,
+        "type": "array"
+      },
+      "stopReason": {
+        "type": [
+          "string",
+          "null"
+        ]
+      }
+    },
+    "required": [
+      "ok",
+      "product",
+      "schemaVersion",
+      "quote",
+      "jobId",
+      "jobStatus",
+      "stopReason",
+      "partial",
+      "sources",
+      "accounting",
+      "costInputs",
+      "charged",
+      "boundary"
+    ],
+    "type": "object"
+  },
+  {
+    "additionalProperties": true,
+    "description": "Existing C1 result compatibility. No merchant product/schemaVersion is required. Compare only the explicitly selected data keys present on both matched rows. Missing keys are coverage unknown, not deletions; explicit null is a present value. Unselected metadata is not a content delta.",
+    "properties": {
+      "accounting": {
+        "additionalProperties": true,
+        "properties": {},
+        "type": "object"
+      },
+      "costParameters": {
+        "additionalProperties": true,
+        "properties": {},
+        "type": "object"
+      },
+      "items": {
+        "items": {
+          "additionalProperties": true,
+          "properties": {
+            "data": {
+              "anyOf": [
+                {
+                  "additionalProperties": true,
+                  "description": "Compare only the explicitly selected data keys present on both matched rows. Missing keys are coverage unknown, not deletions; explicit null is a present value. Unselected metadata is not a content delta.",
+                  "properties": {
+                    "aiReadiness": {
+                      "description": "Selected extraction value: aiReadiness."
+                    },
+                    "canonical": {
+                      "description": "Selected extraction value: canonical."
+                    },
+                    "description": {
+                      "description": "Selected extraction value: description."
+                    },
+                    "headings": {
+                      "description": "Selected extraction value: headings."
+                    },
+                    "jsonLd": {
+                      "description": "Selected extraction value: jsonLd."
+                    },
+                    "lang": {
+                      "description": "Selected extraction value: lang."
+                    },
+                    "links": {
+                      "description": "Selected extraction value: links."
+                    },
+                    "openGraph": {
+                      "description": "Selected extraction value: openGraph."
+                    },
+                    "text": {
+                      "description": "Selected extraction value: text."
+                    },
+                    "title": {
+                      "description": "Selected extraction value: title."
+                    },
+                    "twitter": {
+                      "description": "Selected extraction value: twitter."
+                    }
+                  },
+                  "type": "object"
+                },
+                {
+                  "description": "Compare only the explicitly selected data keys present on both matched rows. Missing keys are coverage unknown, not deletions; explicit null is a present value. Unselected metadata is not a content delta.",
+                  "type": "null"
+                }
+              ],
+              "description": "Compare only the explicitly selected data keys present on both matched rows. Missing keys are coverage unknown, not deletions; explicit null is a present value. Unselected metadata is not a content delta."
+            },
+            "error": {
+              "anyOf": [
+                {
+                  "additionalProperties": true,
+                  "properties": {},
+                  "type": "object"
+                },
+                {
+                  "type": "null"
+                }
+              ]
+            },
+            "finalUrl": {
+              "type": [
+                "string",
+                "null"
+              ]
+            },
+            "httpStatus": {
+              "anyOf": [
+                {
+                  "type": "integer"
+                },
+                {
+                  "type": "null"
+                }
+              ]
+            },
+            "id": {
+              "description": "Row identifier; does not replace source identity.",
+              "type": "string"
+            },
+            "notes": {
+              "type": "array"
+            },
+            "provenance": {
+              "anyOf": [
+                {
+                  "additionalProperties": true,
+                  "properties": {},
+                  "type": "object"
+                },
+                {
+                  "type": "null"
+                }
+              ]
+            },
+            "source": {
+              "description": "Stable source identity, separate from row id and observation time. Matching normalizes source strings (URL fragments removed). Use the same non-empty identity on both sides; duplicate active identities are ambiguous. Synthetic URL STRINGS are inert and are never fetched by this transform.",
+              "minLength": 1,
+              "pattern": "\\S",
+              "type": "string"
+            },
+            "status": {
+              "enum": [
+                "pending",
+                "success",
+                "partial",
+                "failure",
+                "unknown",
+                "skipped_duplicate"
+              ],
+              "type": "string"
+            }
+          },
+          "required": [
+            "id",
+            "source",
+            "status",
+            "data",
+            "notes",
+            "error",
+            "provenance"
+          ],
+          "type": "object"
+        },
+        "maxItems": 32,
+        "minItems": 1,
+        "type": "array"
+      },
+      "jobId": {
+        "type": "string"
+      },
+      "status": {
+        "type": "string"
+      }
+    },
+    "required": [
+      "jobId",
+      "status",
+      "costParameters",
+      "accounting",
+      "items"
+    ],
+    "type": "object"
+  },
+  {
+    "additionalProperties": false,
+    "properties": {
+      "body": {
+        "anyOf": [
+          {
+            "additionalProperties": false,
+            "description": "Representative merchant structure for useful comparisons; not a new paid request or proof of payment. Compare only the explicitly selected data keys present on both matched rows. Missing keys are coverage unknown, not deletions; explicit null is a present value. Unselected metadata is not a content delta.",
+            "properties": {
+              "accounting": {
+                "additionalProperties": true,
+                "properties": {},
+                "type": "object"
+              },
+              "boundary": {
+                "additionalProperties": true,
+                "properties": {},
+                "type": "object"
+              },
+              "charged": {
+                "type": "boolean"
+              },
+              "costInputs": {
+                "additionalProperties": true,
+                "properties": {},
+                "type": "object"
+              },
+              "error": {
+                "type": "string"
+              },
+              "jobId": {
+                "pattern": "^[a-f0-9]{64}$",
+                "type": "string"
+              },
+              "jobStatus": {
+                "enum": [
+                  "running",
+                  "completed",
+                  "completed_with_unknown",
+                  "stopped",
+                  "interrupted"
+                ],
+                "type": "string"
+              },
+              "ok": {
+                "type": "boolean"
+              },
+              "partial": {
+                "type": "boolean"
+              },
+              "product": {
+                "const": "samedaydesk-extract-batch",
+                "type": "string"
+              },
+              "quote": {
+                "additionalProperties": true,
+                "properties": {
+                  "amountAtomic": {
+                    "const": "10000",
+                    "type": "string"
+                  },
+                  "displayUsdc": {
+                    "const": "0.01",
+                    "type": "string"
+                  },
+                  "meaning": {
+                    "type": "string"
+                  }
+                },
+                "required": [
+                  "amountAtomic",
+                  "displayUsdc",
+                  "meaning"
+                ],
+                "type": "object"
+              },
+              "schemaVersion": {
+                "const": "samedaydesk.extract-batch.v0",
+                "type": "string"
+              },
+              "sources": {
+                "items": {
+                  "additionalProperties": true,
+                  "properties": {
+                    "data": {
+                      "anyOf": [
+                        {
+                          "additionalProperties": true,
+                          "description": "Compare only the explicitly selected data keys present on both matched rows. Missing keys are coverage unknown, not deletions; explicit null is a present value. Unselected metadata is not a content delta.",
+                          "properties": {
+                            "aiReadiness": {
+                              "description": "Selected extraction value: aiReadiness."
+                            },
+                            "canonical": {
+                              "description": "Selected extraction value: canonical."
+                            },
+                            "description": {
+                              "description": "Selected extraction value: description."
+                            },
+                            "headings": {
+                              "description": "Selected extraction value: headings."
+                            },
+                            "jsonLd": {
+                              "description": "Selected extraction value: jsonLd."
+                            },
+                            "lang": {
+                              "description": "Selected extraction value: lang."
+                            },
+                            "links": {
+                              "description": "Selected extraction value: links."
+                            },
+                            "openGraph": {
+                              "description": "Selected extraction value: openGraph."
+                            },
+                            "text": {
+                              "description": "Selected extraction value: text."
+                            },
+                            "title": {
+                              "description": "Selected extraction value: title."
+                            },
+                            "twitter": {
+                              "description": "Selected extraction value: twitter."
+                            }
+                          },
+                          "type": "object"
+                        },
+                        {
+                          "description": "Compare only the explicitly selected data keys present on both matched rows. Missing keys are coverage unknown, not deletions; explicit null is a present value. Unselected metadata is not a content delta.",
+                          "type": "null"
+                        }
+                      ],
+                      "description": "Compare only the explicitly selected data keys present on both matched rows. Missing keys are coverage unknown, not deletions; explicit null is a present value. Unselected metadata is not a content delta."
+                    },
+                    "error": {
+                      "anyOf": [
+                        {
+                          "additionalProperties": true,
+                          "properties": {},
+                          "type": "object"
+                        },
+                        {
+                          "type": "null"
+                        }
+                      ]
+                    },
+                    "finalUrl": {
+                      "type": [
+                        "string",
+                        "null"
+                      ]
+                    },
+                    "httpStatus": {
+                      "anyOf": [
+                        {
+                          "type": "integer"
+                        },
+                        {
+                          "type": "null"
+                        }
+                      ]
+                    },
+                    "id": {
+                      "description": "Row identifier; does not replace source identity.",
+                      "type": "string"
+                    },
+                    "notes": {
+                      "type": "array"
+                    },
+                    "provenance": {
+                      "anyOf": [
+                        {
+                          "additionalProperties": true,
+                          "properties": {},
+                          "type": "object"
+                        },
+                        {
+                          "type": "null"
+                        }
+                      ]
+                    },
+                    "source": {
+                      "description": "Stable source identity, separate from row id and observation time. Matching normalizes source strings (URL fragments removed). Use the same non-empty identity on both sides; duplicate active identities are ambiguous. Synthetic URL STRINGS are inert and are never fetched by this transform.",
+                      "minLength": 1,
+                      "pattern": "\\S",
+                      "type": "string"
+                    },
+                    "status": {
+                      "enum": [
+                        "pending",
+                        "success",
+                        "partial",
+                        "failure",
+                        "unknown",
+                        "skipped_duplicate"
+                      ],
+                      "type": "string"
+                    }
+                  },
+                  "required": [
+                    "id",
+                    "source",
+                    "status",
+                    "data",
+                    "notes",
+                    "error",
+                    "provenance"
+                  ],
+                  "type": "object"
+                },
+                "maxItems": 5,
+                "minItems": 1,
+                "type": "array"
+              },
+              "stopReason": {
+                "type": [
+                  "string",
+                  "null"
+                ]
+              }
+            },
+            "required": [
+              "ok",
+              "product",
+              "schemaVersion",
+              "quote",
+              "jobId",
+              "jobStatus",
+              "stopReason",
+              "partial",
+              "sources",
+              "accounting",
+              "costInputs",
+              "charged",
+              "boundary"
+            ],
+            "type": "object"
+          },
+          {
+            "additionalProperties": true,
+            "description": "Existing C1 result compatibility. No merchant product/schemaVersion is required. Compare only the explicitly selected data keys present on both matched rows. Missing keys are coverage unknown, not deletions; explicit null is a present value. Unselected metadata is not a content delta.",
+            "properties": {
+              "accounting": {
+                "additionalProperties": true,
+                "properties": {},
+                "type": "object"
+              },
+              "costParameters": {
+                "additionalProperties": true,
+                "properties": {},
+                "type": "object"
+              },
+              "items": {
+                "items": {
+                  "additionalProperties": true,
+                  "properties": {
+                    "data": {
+                      "anyOf": [
+                        {
+                          "additionalProperties": true,
+                          "description": "Compare only the explicitly selected data keys present on both matched rows. Missing keys are coverage unknown, not deletions; explicit null is a present value. Unselected metadata is not a content delta.",
+                          "properties": {
+                            "aiReadiness": {
+                              "description": "Selected extraction value: aiReadiness."
+                            },
+                            "canonical": {
+                              "description": "Selected extraction value: canonical."
+                            },
+                            "description": {
+                              "description": "Selected extraction value: description."
+                            },
+                            "headings": {
+                              "description": "Selected extraction value: headings."
+                            },
+                            "jsonLd": {
+                              "description": "Selected extraction value: jsonLd."
+                            },
+                            "lang": {
+                              "description": "Selected extraction value: lang."
+                            },
+                            "links": {
+                              "description": "Selected extraction value: links."
+                            },
+                            "openGraph": {
+                              "description": "Selected extraction value: openGraph."
+                            },
+                            "text": {
+                              "description": "Selected extraction value: text."
+                            },
+                            "title": {
+                              "description": "Selected extraction value: title."
+                            },
+                            "twitter": {
+                              "description": "Selected extraction value: twitter."
+                            }
+                          },
+                          "type": "object"
+                        },
+                        {
+                          "description": "Compare only the explicitly selected data keys present on both matched rows. Missing keys are coverage unknown, not deletions; explicit null is a present value. Unselected metadata is not a content delta.",
+                          "type": "null"
+                        }
+                      ],
+                      "description": "Compare only the explicitly selected data keys present on both matched rows. Missing keys are coverage unknown, not deletions; explicit null is a present value. Unselected metadata is not a content delta."
+                    },
+                    "error": {
+                      "anyOf": [
+                        {
+                          "additionalProperties": true,
+                          "properties": {},
+                          "type": "object"
+                        },
+                        {
+                          "type": "null"
+                        }
+                      ]
+                    },
+                    "finalUrl": {
+                      "type": [
+                        "string",
+                        "null"
+                      ]
+                    },
+                    "httpStatus": {
+                      "anyOf": [
+                        {
+                          "type": "integer"
+                        },
+                        {
+                          "type": "null"
+                        }
+                      ]
+                    },
+                    "id": {
+                      "description": "Row identifier; does not replace source identity.",
+                      "type": "string"
+                    },
+                    "notes": {
+                      "type": "array"
+                    },
+                    "provenance": {
+                      "anyOf": [
+                        {
+                          "additionalProperties": true,
+                          "properties": {},
+                          "type": "object"
+                        },
+                        {
+                          "type": "null"
+                        }
+                      ]
+                    },
+                    "source": {
+                      "description": "Stable source identity, separate from row id and observation time. Matching normalizes source strings (URL fragments removed). Use the same non-empty identity on both sides; duplicate active identities are ambiguous. Synthetic URL STRINGS are inert and are never fetched by this transform.",
+                      "minLength": 1,
+                      "pattern": "\\S",
+                      "type": "string"
+                    },
+                    "status": {
+                      "enum": [
+                        "pending",
+                        "success",
+                        "partial",
+                        "failure",
+                        "unknown",
+                        "skipped_duplicate"
+                      ],
+                      "type": "string"
+                    }
+                  },
+                  "required": [
+                    "id",
+                    "source",
+                    "status",
+                    "data",
+                    "notes",
+                    "error",
+                    "provenance"
+                  ],
+                  "type": "object"
+                },
+                "maxItems": 32,
+                "minItems": 1,
+                "type": "array"
+              },
+              "jobId": {
+                "type": "string"
+              },
+              "status": {
+                "type": "string"
+              }
+            },
+            "required": [
+              "jobId",
+              "status",
+              "costParameters",
+              "accounting",
+              "items"
+            ],
+            "type": "object"
+          }
+        ]
+      },
+      "mediaType": {
+        "const": "application/json",
+        "type": "string"
+      },
+      "observedAt": {
+        "description": "Caller observation metadata only; does not attest freshness.",
+        "type": [
+          "string",
+          "null"
+        ]
+      },
+      "status": {
+        "type": "string"
+      }
+    },
+    "required": [
+      "body"
+    ],
+    "type": "object"
+  },
+  {
+    "additionalProperties": true,
+    "description": "Intentionally permissive diagnostic alternative, not a template for a useful comparison. Missing/wrong schemas, keys, source identities or fields do not become valid comparison evidence. A missing snapshot can be supplied as {missing:true}. Safety admission still rejects paths, URL dereference, limit raises and invalid envelopes.",
+    "properties": {},
+    "type": "object"
+  }
+]

changedInput schema / properties / before / description

Previous value: -"Already delivered batch JSON object. Not a URL or filesystem path."New value: +"Already held JSON artifact or JSON envelope, never a path or URL to dereference. Stable source identity, separate from row id and observation time. Matching normalizes source strings (URL fragments removed). Use the same non-empty identity on both sides; duplicate active identities are ambiguous. Synthetic URL STRINGS are inert and are never fetched by this transform. The structured branches describe representative comparable inputs. Incomplete objects remain admitted for diagnostic reports, subject to unchanged HTTP safety checks; HTTP 200 does not establish completeness or usefulness."

removedInput schema / properties / before / type
```
Removed value: -"object"
```

addedInput schema / properties / clock

Added value: +{
+  "description": "Optional caller UTC ISO-8601 timestamp with trailing Z, accepted for compatibility only; cannot attest freshness.",
+  "type": [
+    "string",
+    "null"
+  ]
+}

changedInput schema / properties / fields / description

Previous value: -"Explicit field names to compare."New value: +"Explicit non-empty unique subset of supported fields. Compare only the explicitly selected data keys present on both matched rows. Missing keys are coverage unknown, not deletions; explicit null is a present value. Unselected metadata is not a content delta."

addedInput schema / properties / fields / items / enum

Added value: +[
+  "title",
+  "description",
+  "canonical",
+  "lang",
+  "openGraph",
+  "twitter",
+  "jsonLd",
+  "headings",
+  "links",
+  "text",
+  "aiReadiness"
+]

addedInput schema / properties / maxStaleMs

Added value: +{
+  "anyOf": [
+    {
+      "description": "Optional freshness horizon, not a compute ceiling or freshness authority.",
+      "minimum": 0,
+      "type": "integer"
+    },
+    {
+      "description": "Optional freshness horizon, not a compute ceiling or freshness authority.",
+      "type": "null"
+    }
+  ],
+  "description": "Optional freshness horizon, not a compute ceiling or freshness authority."
+}

1 tool updateOct 12, 2026
- Addedrecover_paid_result
1 tool updateOct 10, 2026
- Addedreport_caller_result
2 tool updatesOct 7, 2026
- Addedcareers_board
- Addedcareers_board_cold

2 tool updatesOct 4, 2026

Changedextract1 field changed

addedInput schema / properties / textExcerptLimitChars

Added value: +{
+  "description": "Optional excerpt budget. Default 1200. Maximum 40000. Rejected before fetch. Does not purchase /read or change the price.",
+  "maximum": 40000,
+  "minimum": 1,
+  "type": "integer"
+}

Changedextract_batch1 field changed

addedInput schema / properties / textExcerptLimitChars

Added value: +{
+  "description": "Optional per-item excerpt budget. Omitted requests keep 1200. A value that cannot fit the batch response ceiling is rejected before fetch. Does not change the price.",
+  "maximum": 40000,
+  "minimum": 1,
+  "type": "integer"
+}

1 tool updateSep 23, 2026
- Addedpage_change
1 tool updateSep 12, 2026
- Addedlockfile_pin_delta

2 tool updatesSep 10, 2026

Changedextract7 fields changed

changedInput schema / properties / url / description

Previous value: -"Public HTTP(S) URL. Choose extract for metadata, JSON-LD, headings, links, and a text excerpt; use read for cleaned full-body Markdown. Content is fetched without JavaScript rendering."New value: +"Public HTTP(S) URL. Choose extract for metadata, JSON-LD, headings, links, and a bounded text excerpt; use read for longer bounded Markdown. Content is fetched without JavaScript rendering. Check status/sourceOk/error/capture; ok means a typed extract record, not source completeness."

addedOutput schema / properties / capture

Added value: +{
+  "additionalProperties": false,
+  "properties": {
+    "bodyBytes": {
+      "minimum": 0,
+      "type": "integer"
+    },
+    "bodyTruncated": {
+      "type": "boolean"
+    },
+    "charset": {
+      "type": [
+        "string",
+        "null"
+      ]
+    },
+    "charsetSource": {
+      "enum": [
+        "content-type",
+        "html-meta",
+        "default-utf-8",
+        "invalid-charset-fallback"
+      ],
+      "type": "string"
+    },
+    "javascriptExecuted": {
+      "const": false,
+      "type": "boolean"
+    },
+    "markdownLimitChars": {
+      "anyOf": [
+        {
+          "type": "integer"
+        },
+        {
+          "type": "null"
+        }
+      ]
+    },
+    "maxBodyBytes": {
+      "type": "integer"
+    },
+    "method": {
+      "const": "http-get-no-javascript",
+      "type": "string"
+    },
+    "textExcerptLimitChars": {
+      "anyOf": [
+        {
+          "type": "integer"
+        },
+        {
+          "type": "null"
+        }
+      ]
+    },
+    "textTruncated": {
+      "type": "boolean"
+    }
+  },
+  "required": [
+    "method",
+    "javascriptExecuted",
+    "maxBodyBytes",
+    "textExcerptLimitChars",
+    "markdownLimitChars",
+    "bodyBytes",
+    "bodyTruncated",
+    "textTruncated",
+    "charset",
+    "charsetSource"
+  ],
+  "type": "object"
+}

addedOutput schema / properties / error

Added value: +{
+  "anyOf": [
+    {
+      "additionalProperties": false,
+      "properties": {
+        "code": {
+          "type": "string"
+        },
+        "message": {
+          "type": "string"
+        }
+      },
+      "required": [
+        "code",
+        "message"
+      ],
+      "type": "object"
+    },
+    {
+      "type": "null"
+    }
+  ]
+}

addedOutput schema / properties / finalUrl
```
Added value: +{
+  "type": "string"
+}
```
addedOutput schema / properties / requestedUrl
```
Added value: +{
+  "type": "string"
+}
```
addedOutput schema / properties / sourceOk
```
Added value: +{
+  "type": "boolean"
+}
```

changedOutput schema / required

Previous value: -[
-  "ok",
-  "url",
-  "status",
-  "contentType",
-  "title",
-  "description",
-  "canonical",
-  "lang",
-  "openGraph",
-  "twitter",
-  "jsonLd",
-  "headings",
-  "links",
-  "text",
-  "aiReadiness",
-  "fetchedAt"
-]New value: +[
+  "ok",
+  "requestedUrl",
+  "finalUrl",
+  "url",
+  "status",
+  "sourceOk",
+  "error",
+  "contentType",
+  "title",
+  "description",
+  "canonical",
+  "lang",
+  "openGraph",
+  "twitter",
+  "jsonLd",
+  "headings",
+  "links",
+  "text",
+  "aiReadiness",
+  "capture",
+  "fetchedAt"
+]

Changedread2 fields changed

changedInput schema / properties / url / description

Previous value: -"Public HTTP(S) URL whose readable body is needed as Markdown. Content is fetched without JavaScript rendering and may be truncated at 40,000 characters."New value: +"Public HTTP(S) URL whose readable body is needed as Markdown. Content is fetched without JavaScript rendering and may be truncated at 40,000 characters. Check status/sourceOk/error/truncated/capture; missing discussion text is not proof of absence."

changedOutput schema / (root)

Previous value: -nullNew value: +{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "additionalProperties": false,
+  "properties": {
+    "capture": {
+      "additionalProperties": false,
+      "properties": {
+        "bodyBytes": {
+          "minimum": 0,
+          "type": "integer"
+        },
+        "bodyTruncated": {
+          "type": "boolean"
+        },
+        "charset": {
+          "type": [
+            "string",
+            "null"
+          ]
+        },
+        "charsetSource": {
+          "enum": [
+            "content-type",
+            "html-meta",
+            "default-utf-8",
+            "invalid-charset-fallback"
+          ],
+          "type": "string"
+        },
+        "javascriptExecuted": {
+          "const": false,
+          "type": "boolean"
+        },
+        "markdownLimitChars": {
+          "anyOf": [
+            {
+              "type": "integer"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "maxBodyBytes": {
+          "type": "integer"
+        },
+        "method": {
+          "const": "http-get-no-javascript",
+          "type": "string"
+        },
+        "textExcerptLimitChars": {
+          "anyOf": [
+            {
+              "type": "integer"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "textTruncated": {
+          "type": "boolean"
+        }
+      },
+      "required": [
+        "method",
+        "javascriptExecuted",
+        "maxBodyBytes",
+        "textExcerptLimitChars",
+        "markdownLimitChars",
+        "bodyBytes",
+        "bodyTruncated",
+        "textTruncated",
+        "charset",
+        "charsetSource"
+      ],
+      "type": "object"
+    },
+    "error": {
+      "anyOf": [
+        {
+          "additionalProperties": false,
+          "properties": {
+            "code": {
+              "type": "string"
+            },
+            "message": {
+              "type": "string"
+            }
+          },
+          "required": [
+            "code",
+            "message"
+          ],
+          "type": "object"
+        },
+        {
+          "type": "null"
+        }
+      ]
+    },
+    "fetchedAt": {
+      "format": "date-time",
+      "type": "string"
+    },
+    "finalUrl": {
+      "type": "string"
+    },
+    "markdown": {
+      "type": "string"
+    },
+    "ok": {
+      "const": true,
+      "type": "boolean"
+    },
+    "requestedUrl": {
+      "type": "string"
+    },
+    "sourceOk": {
+      "type": "boolean"
+    },
+    "status": {
+      "type": "integer"
+    },
+    "title": {
+      "type": "string"
+    },
+    "truncated": {
+      "type": "boolean"
+    },
+    "url": {
+      "type": "string"
+    },
+    "wordCount": {
+      "minimum": 0,
+      "type": "integer"
+    }
+  },
+  "required": [
+    "ok",
+    "requestedUrl",
+    "finalUrl",
+    "url",
+    "status",
+    "sourceOk",
+    "error",
+    "title",
+    "markdown",
+    "wordCount",
+    "truncated",
+    "capture",
+    "fetchedAt"
+  ],
+  "type": "object"
+}

Related MCP Connectors

agentforge B
io.github.acarchidi
DeFi safety layer for AI agents: wallet safety, token risk, tx decode/simulate. 20 tools.
Blockchain Web3 & Decentralized Tech Autonomous Agents
202
https://agentforge-taupe.vercel.app/mcp
DropEngine x402 Agent Services A
io.github.Ahmet11159
AI Agent Utility Layer for agent safety, web monitoring, crypto research and tool discovery.
Blockchain Cryptocurrency Security
241
https://mcp.dropenginehq.com/api/agent-services
Tanod A
dev.tanod
Pay-per-call agent tools: PDF, OCR, translation, news search, prediction markets, web, chain reads.
Blockchain Penetration Testing Security
3081
https://tanod.dev/mcp
Apollo Intelligence Network C
io.github.bnmbnmai
54 AI agent tools: OSINT, intel feeds, DeFi, crypto, weather, DNS, proxies. x402 micropayments.
Search Web Scraping Blockchain
22
https://apolloai.team/mcp

Related MCP Servers

Voltix MCP
clearcheck-uk
A
license
Not graded
quality
D
maintenance
A set of nine tools for AI agents with micropayments in USDC on Base, including on-chain intelligence, web search, document parsing, and more.
Updated 3 months ago (2026-07-23 18:59 UTC)
32 npm
MIT
Axon Research MCP Server
AI & Machine Learning Blockchain Research & Data
raysker
A
license
B
quality
D
maintenance
Provides AI agents with research tools for AI agent ecosystem analysis, DeFi protocol analysis, and general market research.
Updated 8 months ago (2026-02-24 14:04 UTC)
3
29 npm
MIT
Theagora MCP Server
Autonomous Agents Finance Blockchain
theagoralabs
A
license
A
quality
D
maintenance
Enables AI agents to participate in a marketplace for buying, selling, and trading services with atomic escrow and cryptographic verification. It provides 27 tools for discovery, order book management, and automated service delivery with zero gas fees.
Updated 8 months ago (2026-02-24 04:14 UTC)
32
16 npm
MIT
hyre-mcp
Blockchain Cryptocurrency Finance
cryptoeights
A
license
B
quality
D
maintenance
Provides 13 Solana DeFi intelligence tools for AI agents, paid per-call via micropayments (USDC). Enables pulling live DeFi data and automatic payment settlement.
Updated 4 months ago (2026-06-26 10:04 UTC)
13
35 npm
2
MIT

Try in Browser

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

Glama MCP Gateway

Add one secure layer between your agents and this server.

Server Details

Available Tools

Output Schema

Output Schema

Output Schema

Output Schema

Output Schema

Output Schema

Output Schema

Output Schema

Output Schema

Output Schema

Output Schema

Output Schema

Output Schema

Output Schema

Output Schema

Output Schema

Tool Schema Changelog

Related MCP Connectors

Related MCP Servers

Glama MCP Gateway

Resources