Read-only verifier for 25 ProofRelay MCP tools and non-confidential evidence bundles.
Scored across 26 tools
Most tools are clearly separated by domain qualifiers (title, payment, lender, MCP risk), but there is some overlap risk among the evidence-projection tools: adapt_x402_payment_proof and normalize_payment_proof both target payment_context, and scan_mcp_risk vs review_vendor_risk_profile cover adjacent concerns. Agents could occasionally misselect, but descriptions generally disambiguate the intended use.
All tools follow a uniform proofrelay.<verb>_<object> snake_case pattern, with verbs like build, verify, map, review, and describe. While some verbs are semantically similar, the naming convention itself is completely consistent and predictable.
At 26 tools, the server exceeds the 25-tool threshold for 'too many' and feels heavy for a single verifier MCP. The broad domain coverage explains some specialization, but many build_* and evidence-mapping tools are variations on the same conceptual operation and could likely be consolidated.
The toolset covers the core stateless verifier lifecycle well: status discovery, evidence mapping, bundle building, verification, replay planning, readiness signals, and risk review. The lack of signing or submission tools is explicitly intentional, so there are no major dead ends; minor gaps exist around managing or retrieving prior verification results.
Map Concordium, ERC-8004, DID, domain, wallet-controller, or IAM identity references into a hash-only PREP-3 input. ProofRelay accepts identity as evidence; it does not issue identity or certify people.
| Name | Required | Description | Default |
|---|---|---|---|
| identity | Yes |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, openWorldHint=false, idempotentHint=true, destructiveHint=false. The text adds useful context: it accepts evidence without issuing identity or certifying people, which is not encoded in annotations. It does not expose hashing internals, failure modes, or normalization behavior, 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.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences provide the core semantics with modest structure. Some jargon ('PREP-3', 'hash-only') adds density; no fluff.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Rich context: nested input schema with enums (provider variants), annotation hints, output schema true, and many sibling tools for comparison. However, no return-value explanation, error/gql edge cases, and does not clearly describe the trust-proof procedure or output hash format; the output schema exists but the narrative doesn't fully synthesize the overall result.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 0% and parameter descriptions are absent. The specification only enumerates the location of identity parameter objects; provider enum values provide top-level content, but nested fields (e.g. issuer, timestamps, hashes, register hash) have no semantic description; the documentation's 'identity' does not explain those particular fields. A fairly deep parameter gap.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb+resource: "Map ... identity references into a hash-only PREP-3 input." It also indicates a behavioral boundary ('accepts identity as evidence; does not issue identity or certify people'). Some domain jargon ('PREP-3', 'hash-only') is not defined, and it doesn't explicitly distinguish itself from sibling tools, but the core action is clear.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Notes that the tool accepts evidence and does not issue identity, which implies a read/transform role; however, it does not state when to prefer this over sibling tools, provide alternative conditions, or explicitly specify prerequisites for input identity formats.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Map public-safe x402 request, 402 challenge, payment payload, facilitator response, and resource response hashes into ProofRelay's payment_context evidence profile.
| Name | Required | Description | Default |
|---|---|---|---|
| x402 | Yes |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so safety is covered. The description adds that the tool maps hashes into an 'evidence profile', implying a transformation, but it doesn't specify whether it computes anything, validates, or stores. No contradiction with annotations; no additional behavioral traits (e.g., side effects, required credentials) are disclosed.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence, which is efficient. It front-loads the action and lists the components. No wasted words, but it could benefit from a brief parameter-level clarification. It is structured acceptably for a concise description.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool processes a complex nested object with many hashes, and there is an output schema. The description explains the high-level intent but not the semantics of each hash field, nor does it clarify how the output profile is used. Given the complexity, the description is adequate but lacks detail on field meanings and potential transformations.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must explain the 'x402' object and its fields. It only mentions 'request, 402 challenge, payment payload, facilitator response, and resource response hashes', which correspond to some fields, but doesn't explain the meaning of 'payment_required_hash' (402 challenge), 'facilitator_hash', or optional fields like amount, network, currency, replay_key. Most fields remain ambiguously named in the schema and are not elaborated in the description.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific verb ('Map') and resource (x402 payment proof components into 'payment_context evidence profile'), which clearly indicates the tool's function. It distinguishes from siblings like 'normalize_payment_proof' by focusing on mapping hashes into a specific evidence profile, though it doesn't explicitly contrast with 'normalize_payment_proof' or other mapping tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage when an x402 payment flow's hashes need to be structured into ProofRelay's payment_context profile. It provides no explicit when-to-use or when-not-to-use guidance, and no alternatives are mentioned. Sibling names like 'normalize_payment_proof' could be alternative, but no comparison is made.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Build a portable hash-only audit pack manifest from bundle, verifier, policy, and evidence hashes without uploading private files or logs.
| Name | Required | Description | Default |
|---|---|---|---|
| audit_pack | Yes |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Adds that it does not upload private files, complementing the readOnly hint.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Single concise sentence with relevant extra context.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Missing explanations for many parameters and no mention of output.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Only mentions bundle, verifier, and policy hashes, leaving other schema fields like pack_id, control_refs, generated_at, evidence_hashes unexplained.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Clearly states it builds a hash-only audit pack manifest, distinguishing it from other build_* tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Implies usage for creating manifests but does not explicitly compare to alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Build a canonical, unsigned, non-attesting ProofRelay bundle draft from public-safe event hashes. The public MCP server does not sign or certify caller-provided facts.
| Name | Required | Description | Default |
|---|---|---|---|
| draft | Yes |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate readOnly, idempotent, and non-destructive behavior. The description adds that it 'does not sign or certify caller-provided facts' and only accepts 'public-safe event hashes', providing extra transparency about limitations and data handling beyond the annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise, consisting of two sentences that deliver the essential purpose and key behavioral constraint without unnecessary detail or verbosity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Despite having an output schema, the tool's input is a highly nested object with multiple required fields (service, created_ts_ms, events) and a complex payment_context. The description omits critical guidance on constructing the 'draft' parameter, making it insufficient for an agent to use correctly in real scenarios.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema describes a single complex 'draft' parameter with many required and optional fields, but schema coverage in the description is 0%. The description only hints at 'public-safe event hashes' without explaining the object structure, required fields, or semantics of nested objects. Given low coverage, the description does not compensate adequately.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action (build) and the resource (canonical, unsigned, non-attesting ProofRelay bundle draft), and specifies that it operates on 'public-safe event hashes'. This distinguishes it from sibling tools that verify, attest, or produce signed bundles.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage when a draft bundle is needed without signing or attestation, and mentions 'public-safe' inputs, which guides context. However, it does not explicitly contrast with alternative build tools or state when not to use it, leaving some ambiguity.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Build a hash-only closing proof pack manifest from settlement, title, lender, funding, notary, disbursement, and approval hashes. The tool does not authorize closing or disbursement.
| Name | Required | Description | Default |
|---|---|---|---|
| closing_pack | Yes |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnly and idempotent hints, which are consistent with the description's 'hash-only' and non-authorizing nature. The description adds valuable context by explicitly stating the tool does not authorize closing or disbursement, which is a behavioral constraint not conveyed by annotations alone. It also clarifies that the tool works only with hashes, not actual documents, providing extra transparency beyond 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.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences, tightly packed. The first sentence identifies the purpose and scope, and the second provides a critical caveat about what the tool does not do. Every word earns its place, and there is no redundant or filler language.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (nested object with multiple optional fields) and the presence of an output schema (which likely describes the returned manifest), the description covers the essential inputs and the tool's non-authorizing behavior. It lists all hash categories and explicitly says it is hash-only. Minor omissions include the format of hash values and the meaning of non_secret_refs, but these are partially addressed by the schema and do not severely hinder correct invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Though the schema description coverage is 0%, the description compensates by enumerating all the hash categories (settlement, title, lender, funding, notary, disbursement, approval) that correspond to the nested closing_pack fields. This gives semantic meaning beyond the bare schema definitions, though it doesn't explain non_secret_refs or the structure of closing_pack itself. Since the schema is rich and nested, the description's enumeration of hash types adds significant value.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: to build a hash-only closing proof pack manifest from a specific set of hash categories (settlement, title, lender, funding, notary, disbursement, approval). It also explicitly notes what it does not do (authorize closing or disbursement), distinguishing it from potential sibling tools like build_audit_pack_manifest or build_bundle_draft.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies the tool is used when you need to assemble a closing proof pack from hashes, and it clarifies it does not authorize actions. However, it does not explicitly state when to use this tool versus alternatives like build_audit_pack_manifest or other build_* siblings, nor does it mention any prerequisites or exclusions beyond the authorization caveat.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Build an unsigned, hash-only human approval receipt draft for authority, policy, and subject evidence. The tool does not create approval authority or certify the approver's identity.
| Name | Required | Description | Default |
|---|---|---|---|
| approval | Yes |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description discloses that the receipt is unsigned and hash-only, and explicitly states it does not create authority or certify identity, adding behavioral context beyond the readOnlyHint and idempotentHint annotations. It doesn't contradict any annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise with two informative sentences, front-loading the purpose and adding a clarifying limitation without waste.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with a nested approval object and output schema, the description covers the purpose and limitations but does not explain how to structure the approval parameter or what the output contains. It is somewhat incomplete for a complex tool, but adequate given the output schema exists.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description gives a high-level hint that the approval object contains authority, policy, and subject evidence, but does not explain the specific fields or their semantics. With 0% schema coverage, it partially compensates but lacks detail on the approval object structure.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool builds an unsigned, hash-only human approval receipt draft, specifying the resource and scope. It also distinguishes itself from sibling tools by emphasizing it does not create approval authority or certify identity.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives clear context that this tool only drafts an unsigned receipt and does not create approval authority or certify identity, providing negative use cases. However, it doesn't explicitly mention alternative tools or positive when-to-use scenarios.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Build a public-safe ProofRelay Registry entry draft for an agent, API, MCP server, workflow, or adapter using only hashes and profile markers.
| Name | Required | Description | Default |
|---|---|---|---|
| entry | Yes |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotation contradiction. The description says 'Build a registry entry draft,' implying a create/write operation, but readOnlyHint: true is set, which asserts no state modification. No other behavioral side effects are disclosed (e.g., persistence status, hashing process, approval controls).
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
One long but readable sentence. No padding, clear phrasing, aligned with the tool name and title. Could be slightly smaller by removing the entity list, but acceptable.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool is complex: a single deeply-nested entry parameter, ~22 optional or conditional fields, no parameter descriptions, and no output schema documentation. The description covers the type of target at a high level but never mentions return formats, behavior on validation failure, ordering constraints, or related chain interactions.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Input schema coverage is 0%, and the nested 'entry' object with many fields/options is not explained. The description only says it accepts hashes/profile markers, but does not explain the per-field meanings (entry_type, subject_hash, profile markers, status, hash references, etc.).
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a clear action ('build') and object ('registry entry draft'), and enumerates acceptable entity types (agent, API server, MCP server, workflow, adapter). Does not explicitly contrast with sibling tools, but the name 'build_registry_entry' is specific enough to distinguish registry creation from audit/bundle/verification operations.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Gives an implicit constraint ('using only hashes and profile markers'), but no explicit when-to-use vs alternatives, no exclusions/alternatives, and no prerequisites or postconditions for creating a registry draft.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Build a hash-only title production evidence profile from order, property, title-search, commitment, exception, and tax-cert hashes. The tool does not certify title status or legal sufficiency.
| Name | Required | Description | Default |
|---|---|---|---|
| title_evidence | Yes |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description adds the information that it does not certify title status or legal sufficiency, which complements the annotations indicating read-only and idempotent behavior, though it does not detail all side effects.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences, concise and well-structured with no unnecessary information, clearly articulating the tool's core functionality and boundary.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description lacks details on the output format, optional fields, and the meaning of production_status, making it incomplete for complex usage despite having an output schema.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description mentions the types of hashes but does not explain individual fields such as non_secret_refs or production_status, leaving ambiguity for some parameters.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool builds a hash-only title production evidence profile from specific hash types (order, property, title-search, commitment, exception, tax-cert), providing a specific verb and resource.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description does not specify when to use this tool versus alternatives, lacking explicit usage guidance or conditions for invocation.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Compute a public-safe readiness signal from title, closing, wire, lender-condition, approval, exception, and risk hashes/counts. The tool does not certify readiness to close or fund.
| Name | Required | Description | Default |
|---|---|---|---|
| readiness | Yes |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering safety and idempotency. The description adds value beyond these by clarifying that the output is 'public-safe' and explicitly stating it does not certify readiness, which provides additional behavioral context about the tool's limitations and output nature.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences, front-loaded with the core purpose, and includes a succinct caveat. There is no fluff, and every word adds value. It is appropriately concise for the tool's complexity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (a nested object with 10 properties and an output schema), the description is minimal. It covers the purpose and input categories but does not explain the nature of the computed 'readiness signal' (e.g., what it represents, its format, or how to interpret it). While the output schema exists, the description does not add enough context to make the tool fully self-contained.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate. It does list high-level categories (title, closing, wire, etc.) that map to the nested object fields, but it does not explain individual parameter meanings or the structure of the required 'readiness' object. It provides some context but not enough detail to fully understand each field without relying on names and types.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'Compute' and the resource 'a public-safe readiness signal', and lists the specific input categories (title, closing, wire, etc.). It also includes a scope limitation ('does not certify readiness to close or fund'), which helps differentiate it from potential certification tools. This is specific and not tautological.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides a clear negative usage guideline by stating the tool does not certify readiness, which tells the agent when not to use it for certification. However, it does not explicitly name alternative tools for certification or provide a positive 'use when' scenario, so it lacks full alternative guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Return public-safe setup guidance for connecting MCP clients to ProofRelay and preparing hash-only evidence inputs without exposing secrets or requiring package installation.
| Name | Required | Description | Default |
|---|---|---|---|
| helper | Yes |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare read-only, idempotent, and non-destructive behavior. The description adds important context by mentioning 'public-safe', 'without exposing secrets', and 'without requiring package installation', which are not captured by the annotations. This provides additional behavioral transparency about the output's constraints and safety.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, well-structured sentence that is front-loaded with the main action ('Return public-safe setup guidance') and quickly conveys the scope and constraints. No unnecessary words or redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (one parameter, no complex behavior), the description covers the essential purpose and key constraints. The annotations provide safety guarantees, and the output schema (if present) would handle return format specifics. The description is complete for an informational tool, though it could mention the parameter structure explicitly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, meaning the schema provides no explanations for the 'helper' object or its properties. The description does not mention the parameter at all, nor does it explain what 'client' or 'endpoint' mean. While the purpose gives some implicit clues, the description fails to compensate for the lack of schema documentation, leaving parameter semantics underspecified.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: it returns setup guidance for connecting MCP clients to ProofRelay and preparing hash-only evidence inputs. The verb 'Return' specifies the output, and the resource is well-defined. It distinguishes itself from siblings that focus on building, verifying, or adapting evidence, making it a unique informational tool.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies its usage context—when an agent needs setup guidance for connecting clients or preparing evidence inputs—and contrasts with the mutating/adapting tools. However, it does not explicitly state when to use it over alternatives or provide exclusions, so it falls short of a 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Return the agent-native Stripe checkout entitlement workflow for ProofRelay paid verification, including token, status, redemption, and replay expectations.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is established. The description adds that the tool returns workflow expectations including token, status, redemption, and replay, which provides semantic context beyond annotations. However, it does not disclose output format details, error behavior, or what 'agent-native' means operationally—leaving some behavioral traits implicit. No contradiction 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.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, well-structured sentence that front-loads the core action and resource, then lists the key coverage areas. Every phrase earns its place: 'agent-native', 'Stripe checkout entitlement workflow', 'ProofRelay paid verification', and the four expectations. No redundancy or filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With zero parameters, a strong output schema, and comprehensive annotations, the description needs relatively little to complete the picture. It communicates the tool's purpose and scope effectively. The only minor gap is that it doesn't explicitly state the return value shape beyond the schema, but the presence of an output schema reduces that burden. This is complete enough for its complexity.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, so the schema is trivial and covers 100% of the parameter space. Per the rubric, a zero-parameter tool gets a baseline of 4. The description correctly does not attempt to explain non-existent parameters. There is no additional semantic burden for the description here.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('Return') and identifies a clear resource ('agent-native Stripe checkout entitlement workflow for ProofRelay paid verification'). It also lists key content areas (token, status, redemption, replay expectations), making the tool's focus understandable. However, it does not explicitly distinguish the tool from siblings like proofrelay.normalize_payment_proof or proofrelay.describe_cli_sdk_helper, though the named resource is fairly distinct.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies when this tool is relevant—when an agent needs the Stripe checkout entitlement workflow for ProofRelay paid verification. It does not explicitly state when not to use it or name alternative tools among the siblings. Given the descriptive intent, the usage context is clear but lacks exclusion criteria or direct sibling differentiation.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Generate an unsigned, hash-only paid MCP/API tool receipt draft that callers can include in a signed ProofRelay bundle. The tool does not charge, redeem, settle, or attest to external facts.
| Name | Required | Description | Default |
|---|---|---|---|
| receipt | Yes |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds value by specifying 'unsigned, hash-only' and explicitly listing actions it does not perform (charge, redeem, settle, attest). This gives a clearer picture of side effects beyond safety hints. No contradiction with annotations observed.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise—two sentences—and the main action is stated in the first sentence. The second sentence adds necessary boundary conditions without redundancy. Every word earns its place, and the structure is front-loaded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Despite having an output schema, the tool has a complex nested input object that remains completely unexplained. The description does not mention the structure or required fields of the receipt parameter, nor any workflow context. Given the moderate complexity and the 0% parameter coverage, the description is insufficiently complete for an agent to use the tool correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description provides zero explanation of the single 'receipt' parameter and its nested structure. Schema description coverage is 0%, and the description does not compensate by describing required fields like tool_name, ts_ms, or hashes. The agent receives no guidance on how to construct the receipt object, making parameter usage unclear.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: to generate an unsigned, hash-only paid MCP/API tool receipt draft for inclusion in a signed ProofRelay bundle. The verb 'generate' and specific resource 'receipt draft' are unambiguous, and the 'does not charge, redeem, settle, or attest to external facts' line distinguishes it from other receipt or payment tools in the sibling set.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies when to use the tool: when a caller needs a receipt draft for a paid tool call to include in a ProofRelay bundle. It also clarifies limitations ('does not charge, redeem, settle'), which implicitly warns against using it for those actions. However, it does not explicitly name alternative tools or provide when-not-to-use conditions, so it falls short of a full 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Read the ProofRelay verifier status, accepted bundle shape, and trust boundary before submitting evidence. Use this first when an agent needs to understand what ProofRelay verifies and what it does not.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false. The description adds the context of being a prerequisite ('before submitting evidence') but does not describe additional side effects or error behavior. Since annotations cover the safety profile, the description provides minimal extra transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two concise sentences, directly stating what the tool does and when to use it. No redundant or extraneous information is present.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With no parameters and an output schema present, the description covers the essential context: what is read, when to use it, and its purpose as a first step. It is complete for a simple getter tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, so the schema fully covers the parameter space. The description does not need to explain any parameters, and it does not introduce ambiguity. Perfect score for a no-parameter tool.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool reads verifier status, accepted bundle shape, and trust boundary. It also explicitly says 'Use this first' to understand what ProofRelay verifies, distinguishing it from sibling tools that perform other actions.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides a clear when-to-use instruction ('Use this first when an agent needs to understand what ProofRelay verifies and what it does not'), but does not explicitly contrast with alternatives or mention when not to use it. The guidance is implicit and sufficient for most cases.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Build an unsigned ProofRelay evidence-conformance badge draft such as PREP-compatible, Verified Bundle, Verified MCP, or Replay Tested. This is not legal, security, model-safety, or platform certification.
| Name | Required | Description | Default |
|---|---|---|---|
| badge | Yes |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, so the description doesn't need to repeat safety. It adds value by clarifying the badge is 'unsigned' and not a certification, which is important behavioral context beyond annotations. No contradiction.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences, front-loaded with the main purpose. The second sentence adds a useful disclaimer. No wasted words, though it could be slightly more structured with explicit parameter guidance.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complex nested schema (1 param with 10 subfields) and no output schema details, the description is somewhat thin. It doesn't explain what the draft badge contains, how hashes are computed, or what the output looks like. The output schema exists, so return values are covered, but the input semantics are under-specified.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, but the description names the badge types and mentions 'unsigned' and 'draft', which adds some meaning. However, it doesn't explain the required fields (subject_hash, criteria_hash) or optional fields like profile, issued_at, expires_at. The nested object structure is complex, and the description doesn't compensate for the lack of parameter documentation.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool builds an unsigned ProofRelay evidence-conformance badge draft and lists specific badge types (PREP-compatible, Verified Bundle, Verified MCP, Replay Tested). It distinguishes from siblings by focusing on 'draft' and 'unsigned' badges, though it doesn't explicitly contrast with build_bundle_draft or build_registry_entry.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for creating badge drafts but doesn't provide explicit when-to-use vs alternatives. It mentions what it is not (legal, security, model-safety, platform certification), which adds some context, but no direct comparison to sibling tools like build_bundle_draft or verify_bundle.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Map lender condition text, evidence, reviewer, and waiver hashes into a portable condition profile without satisfying lender conditions.
| Name | Required | Description | Default |
|---|---|---|---|
| condition | Yes |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and destructiveHint=false, but the description adds the explicit note 'without satisfying lender conditions.' This clarifies that the tool does not alter condition fulfillment, which is important behavioral context beyond the annotations. The description does not contradict any annotation, and it provides a valuable additional constraint.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence that is concise and front-loaded with the action verb. It includes the core purpose and a key caveat without extraneous information. Every part is relevant and efficient.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool has a nested input object and an output schema (not shown), but the description does not explain the output 'portable condition profile' or any transformations. It explains the main behavior but omits details about hashing, output structure, or prerequisites. Given the complexity of the input schema and the presence of an output schema, the description is adequate but not thorough.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate for parameter meaning. It mentions 'lender condition text, evidence, reviewer, and waiver hashes' which map to some fields like condition, evidence_hashes, reviewer_hash, and waiver_hash, but it does not explain the required fields condition_id, condition_type, condition_hash, nor optional fields like status, non_secret_refs. The description offers a high-level concept but insufficient detail for the agent to understand each parameter's role.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool maps lender condition text, evidence, reviewer, and waiver hashes into a portable condition profile. The verb 'Map' and the resource 'lender condition evidence' are specific, and the caveat 'without satisfying lender conditions' distinguishes it from tools that would modify condition status. This is a clear purpose that differentiates from siblings like build_bundle_draft or verify_bundle.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage when a portable representation of condition evidence is needed without changing condition status, but it does not explicitly state when to use or not use this tool compared to alternatives. No alternative tools are referenced, and no exclusions are mentioned, so guidance is only implicit.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Map public OpenAPI operation metadata and schema hashes into a ProofRelay event plan with checkpoint recommendations for paid, mutating, or relied-upon API operations.
| Name | Required | Description | Default |
|---|---|---|---|
| operation | Yes |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds useful context by framing the tool as mapping metadata rather than invoking operations, and by highlighting paid, mutating, or relied-upon operations. It does not contradict annotations and provides enough behavioral context beyond the structured hints.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence with no filler. It states the action, the input, and the output efficiently, making it easy for an agent to parse quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has one nested parameter, an output schema, and annotations covering the safety profile, the description provides sufficient context for a mapping tool. It would benefit from explicit when-to-use guidance and a bit more parameter detail, but overall it is adequately complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate. It adds high-level meaning by referencing 'schema hashes' and 'paid, mutating, or relied-upon' categories, which align with fields like payment_required, idempotency_required, and method. However, it does not explain individual nested fields such as operation_id, path_template, server_url_hash, or security_scheme_refs.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('Map') with a clear object ('public OpenAPI operation metadata and schema hashes') and a distinct output ('ProofRelay event plan with checkpoint recommendations'). It differentiates from siblings like wrap_mcp_tool_evidence by naming the OpenAPI source and the event-plan output.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage when public OpenAPI operation metadata is available and checkpoint recommendations are needed, but it does not explicitly state when to choose this over alternatives like map_lender_condition_evidence or wrap_mcp_tool_evidence. No exclusions or alternative tool references are provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Validate rail-agnostic payment or entitlement proof hashes and return the ProofRelay payment_context evidence profile. This does not charge, settle, custody funds, or verify external payment finality.
| Name | Required | Description | Default |
|---|---|---|---|
| payment_proof | Yes |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, lowering the burden. The description adds valuable context beyond annotations by noting the tool is rail-agnostic and by clarifying that it does not charge, settle, custody funds, or verify external payment finality. It does not describe error handling, but annotations cover the safety profile well.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is exactly two sentences, each providing essential information. The first states the purpose and output; the second enumerates explicit non-goals. There is no redundancy, fluff, or irrelevant detail.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With rich annotations and an output schema, the description covers the key context: purpose, non-goals, and the resulting evidence profile type. However, given the complex nested input and zero parameter-level descriptions, a brief note on the structure or validation expectations would make it fully complete. Still, it is strong overall.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, and the description does not compensate for the complex nested payment_proof object. It only refers to 'payment or entitlement proof hashes' without explaining the meanings of required fields like challenge_or_session_hash or payment_proof_or_charge_hash. The property names are somewhat self-explanatory, but for constructing valid input, an agent would need more guidance.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's function: 'Validate rail-agnostic payment or entitlement proof hashes and return the ProofRelay payment_context evidence profile.' It uses specific verbs, names the resource, and explicitly lists non-goals ('does not charge, settle, custody funds, or verify external payment finality') to distinguish it from payment-execution siblings.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives clear context for when to use the tool (validating proof hashes and producing an evidence profile) and explicit exclusions (not for charging, settlement, custody, or finality verification). However, it does not name alternative sibling tools for protocol-specific adaptation, so it lacks explicit alternative guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Return a deterministic replay rejection test plan and optionally classify observed first/replay responses. The tool does not redeem tokens or call paid endpoints.
| Name | Required | Description | Default |
|---|---|---|---|
| replay_test | Yes |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, so a safe read is established. The description adds genuine, agent-critical value by explicitly stating 'does not redeem tokens or call paid endpoints' — a payment-domain behavior not captured in annotations. It also discloses determinism. No contradiction. A slightly deeper disclosure on the optional classification branch would merit a 5.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, roughly 25 words, front-loaded with the primary action and ending with the most important safety qualifier. Every clause earns its place with zero redundancy or filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the nested ReplayObservation schema, the payment-protocol enum, and the output schema, the description covers the two critical non-obvious aspects: the plan/classify dual modality and the absence of paid side effects. The presence of an output schema means return-value documentation is not the description's job. Only the thin framing of the tool's role in the broader payment-proof workflow keeps this from a 5.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0% schema description coverage, the description must compensate. It usefully clarifies that 'observed first/replay responses' maps to the nested ReplayObservation (first_status/second_status/error pairs) and clarifies the plan-vs-classify dual mode. However, it leaves the semantics of redeem_url, bundle_hash, entitlement_hash, and payment_protocol entirely unexplained — an agent cannot determine what these identifiers represent or when the enum values apply.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb+resource construct ('Return a deterministic replay rejection test plan') with a clear secondary behavior ('optionally classify observed first/replay responses') plus a key qualifier ('does not redeem tokens or call paid endpoints'). It cleanly distinguishes itself from its 26 build/verify/describe siblings, none of which cover replay rejection planning.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Usage context is only implied through the word 'plan' and the qualifier 'deterministic.' The no-side-effects statement hints that this is the safe, no-cost planning alternative, but no explicit when-to-use, when-not-to-use, or sibling alternatives are named. The agent must infer when this non-redeeming planner takes precedence over actionable payment tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Choose the next public-safe GENESIS checkpoint for a paid, material, or relied-upon agent workflow. Submit normalized context only; the tool returns reason codes without protected routing internals.
| Name | Required | Description | Default |
|---|---|---|---|
| workflow_context | Yes |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The annotations (readOnlyHint=true, idempotentHint=true) already establish this is a safe read operation. The description adds meaningful behavioral context beyond this: 'returns reason codes without protected routing internals' clarifies the privacy boundary of the output, and 'public-safe' sets expectations about what the tool will filter for. No contradiction 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.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, zero waste. The first sentence front-loads the core action and scope; the second covers the privacy model. Every word earns its place, covering what, when, and output characteristics in breakneck efficiency.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given an output schema exists, explaining returns would be redundant, and the annotations already provide safety context. However, with 26 sibling tools—several of which (e.g., build_bundle_draft, verify_bundle) overlap thematically with checkpoint/evidence concepts—the description should clarify where 'GENESIS checkpoint' fits relative to those alternatives. The undefined domain term and missing ecosystem positioning keep this from being complete for a nested, zero-coverage parameter.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0% schema coverage and a nested workflow_context object containing 12+ undocumented fields, the description must compensate—but 'Submit normalized context only' is the sole hint about parameter semantics. While field names are self-descriptive (e.g., payment_context_present), the description neither explains normalization requirements, field semantics, nor constraints, leaving a significant documentation gap for such a rich parameter.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb-resource pairing ('Choose the next... GENESIS checkpoint') with strong scope qualifiers ('public-safe,' 'paid, material, or relied-upon agent workflow') that clearly delimit the tool's domain. It distinguishes itself from siblings by implying a classification/eligibility role rather than an action tool, though the term 'GENESIS' remains an undefined domain term.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The phrase 'for a paid, material, or relied-upon agent workflow' provides clear context for when to invoke the tool. 'Submit normalized context only' gives input guidance. However, no sibling alternatives are named and there is no explicit when-not-to-use guidance, which would have made this a 5 given the large sibling ecosystem.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Review public vendor or MCP server risk metadata for governance signals using hashes and declared boundaries only. This is not legal, security, or procurement certification.
| Name | Required | Description | Default |
|---|---|---|---|
| vendor | Yes |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description discloses the tool's scope (public metadata, hashes, declared boundaries) and its non-certification limitation, aligning with the read-only and non-destructive annotations. It could be more explicit about the exact output format, but it is transparent about its intent.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise (two sentences) and well-structured, conveying essential information without unnecessary detail. It avoids fluff and directly communicates the tool's purpose and limitations.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description gives the tool's purpose and boundaries but does not specify the output structure, expected results, or any preconditions. While the core intent is clear, the lack of output context may leave the agent uncertain about what the tool actually returns.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description does not elaborate on the 'vendor' object parameters or their significance. The schema contains many fields (e.g., requires_payment, data_boundary) but the description adds no additional meaning, leaving the agent to infer usage from field names alone.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states that the tool reviews public vendor or MCP server risk metadata for governance signals, with explicit constraints on using hashes and declared boundaries. It differentiates itself from certification tasks, making its purpose specific and distinct from sibling tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides context on when to use the tool (for governance signals) and explicitly notes what it is not (legal, security, or procurement certification). However, it does not directly mention alternative tools or specific scenarios beyond the core review purpose.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Review hash-only wire, payoff, or disbursement change metadata for red flags and required controls without approving funds movement.
| Name | Required | Description | Default |
|---|---|---|---|
| wire_change | Yes |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description adds transparency by noting 'hash-only' (limiting to hashes) and 'without approving funds movement,' which aligns with readOnly and complements the annotations. It does not contradict annotations and provides extra context about the nature of the review.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, concise sentence that packs essential information without fluff. It is well-structured and directly states the action and scope.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity of the tool (an object parameter and likely analysis output), the description provides sufficient context for a user to understand the review's purpose and constraints. It implies what the review covers (red flags, required controls) but does not elaborate on return format, which is acceptable as an output schema exists.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description adds some semantic context by mentioning 'wire, payoff, or disbursement change metadata,' which maps to the change_type field, and 'hash-only' clarifies the data format. However, it does not explain individual properties within the wire_change object, so the schema remains the primary source for parameter details.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: reviewing hash-only wire, payoff, or disbursement change metadata for red flags and required controls. It distinguishes itself from sibling tools by focusing on wire/payoff changes and explicitly stating it does not approve funds movement.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implicitly guides usage by indicating it reviews changes and explicitly states 'without approving funds movement,' providing a clear when-not scenario. However, it does not explicitly mention alternatives or compare with sibling review tools, leaving some ambiguity.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Return a read-only, public-metadata MCP risk score from tool descriptors, schemas, and registry claims. Use before listing, integrating, or wrapping another MCP server; it does not fetch network data, require auth, mutate systems, inspect source code, or certify vulnerability status.
| Name | Required | Description | Default |
|---|---|---|---|
| risk_scan | Yes |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, and the description adds valuable context beyond those flags: it only uses public metadata, makes no network calls, requires no auth, mutates nothing, does not inspect source code, and does not certify vulnerabilities. These are concrete behavioral boundaries.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The entire description is one well-front-loaded sentence that states the output, the data sources, the use case, and the key exclusions. Every clause adds information and there is no filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the rich annotations and the presence of an output schema, the description covers the tool's role and limitations thoroughly. The main gap is that the nested risk_scan input object is not semantically described, and no alternative sibling tool is named for comparison, but the tool remains usable enough for an agent with the schema.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 0% and the description does not explain the risk_scan parameter or its nested properties such as server_name, declared_read_only, requires_authentication, or payment_or_entitlement_required. The phrase 'from tool descriptors, schemas, and registry claims' hints at inputs, but it does not compensate for the undocumented nested object structure.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool returns a read-only, public-metadata MCP risk score from tool descriptors, schemas, and registry claims. It uses a specific verb plus resource and defines the scope ('Use before listing, integrating, or wrapping another MCP server'), which separates it from the sibling build/wrap evidence tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives an explicit trigger: 'Use before listing, integrating, or wrapping another MCP server.' It also supplies when-not guidance by stating the tool does not fetch network data, require auth, mutate systems, inspect source code, or certify vulnerability status, so the agent knows its limitations.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Summarize public-safe agent action log counts and hashes into a governance review profile without ingesting raw logs or traces.
| Name | Required | Description | Default |
|---|---|---|---|
| action_log | Yes |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the barrier is low. The description adds valuable transparency by emphasizing it does not ingest raw logs or traces, which reassures the agent about privacy and scope. It does not contradict annotations, and the addition of 'public-safe' clarifies the security posture.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, well-formed sentence that is front-loaded with the primary action and includes a crucial negative ('without ingesting raw logs or traces'). No wasted words; every clause adds meaning.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool is relatively simple with one parameter and an output schema, and annotations cover safety aspects. The description is sufficient for basic usage, but given the nested object schema and the governance context, a bit more detail on expected inputs or output format would be helpful. Yet the output schema may compensate.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With schema description coverage at 0%, the description must compensate, and it partially does by conveying the 'action_log' parameter contains counts and hashes. However, it does not elaborate on individual nested fields like 'log_hash' or 'action_type_counts', relying on the schema for structure. This is acceptable given the single parameter and clear high-level intent.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: summarizing 'public-safe agent action log counts and hashes' into a 'governance review profile' while explicitly noting it does not ingest raw logs or traces. This distinguishes it from sibling tools that build evidence or proofs, and uses specific verbs and resources.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for governance review without needing to process raw logs, which provides clear context. However, it does not explicitly state when not to use this tool or mention alternatives, though the sibling list suggests related but distinct tools like 'build_audit_pack_manifest' or 'build_closing_proof_pack'.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Verify a submitted non-confidential ProofRelay V1 or V2 evidence bundle for hash integrity, monotonic ordering, signatures, and chain continuity. The tool does not charge, settle, mutate storage, or certify external facts.
| Name | Required | Description | Default |
|---|---|---|---|
| bundle | Yes | ||
| public_keys | No | ||
| require_chain | No | ||
| require_signature | No |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description explicitly states what the tool does NOT do (charge, settle, mutate storage, certify external facts), which goes beyond the readOnly and idempotent annotations. It also mentions the 'non-confidential' nature, providing additional context about data handling. However, it does not describe failure modes or return behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise, consisting of two short sentences, with no redundant words. It efficiently conveys the core action and key exclusions.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity of the schema (oneOf, nested objects, enums) and the lack of any parameter descriptions in the schema, the tool description is insufficient. It does not explain the required inputs, the meaning of 'require_chain' or 'require_signature', nor what the output contains. The description is too sparse to be complete for complex usage.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema provides no descriptions for parameters, and the tool description does not explain the meaning or usage of 'bundle', 'public_keys', 'require_chain', or 'require_signature'. The description only mentions the bundle implicitly, leaving all parameters under-specified for an AI agent.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: verifying a non-confidential evidence bundle for hash integrity, monotonic ordering, signatures, and chain integrity. It distinguishes from sibling tools (e.g., build_bundle_draft, verify_signed_attestation) by focusing on verification of bundle properties.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description does not specify when to use this tool versus alternatives. It lacks guidance on when verification is appropriate, what scenarios require it, or when other tools like verify_signed_attestation might be preferred. No prerequisites or contextual triggers are given.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Verify a legacy Ed25519 or V2 ES256 ProofRelay artifact using public key material and optional issuer/purpose pins. The tool never accepts private keys and does not sign caller claims.
| Name | Required | Description | Default |
|---|---|---|---|
| verification | Yes |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds valuable security context beyond annotations: 'never accepts private keys and does not sign caller claims.' This informs the agent about operational boundaries, which is meaningful added context.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, ~30 words, front-loaded with the primary action. Every phrase earns its place — no filler or redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a verification tool with a single nested parameter, an output schema, and rich annotations, the description covers the essential context well. It could mention validation edge cases (e.g., which key format to prefer when both are present), but nothing critical is missing.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0% schema description coverage, the description compensates by clarifying parameter groups: 'public key material' maps to public_jwk/public_key_hex, 'pins' maps to expected_issuer/expected_purpose, and 'artifact' maps to signed_artifact. The now/now_ms params remain unexplained, but the most important semantics are captured.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb+resource structure ('Verify a legacy Ed25519 or V2 ES256 ProofRelay artifact') and adds scoping ('using public key material and optional issuer/purpose pins') that differentiates it from siblings like verify_bundle. The version qualifiers ('legacy', 'V2') give concrete operational specificity.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Usage is implied through the 'Verify' verb and algorithm details, but there's no explicit when-to-use-versus-alternatives guidance (e.g., no comparison to verify_bundle). The second sentence hints at security-relevant non-behavior but doesn't direct tool selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Convert hash-only MCP tool request, response, schema, authority, and payment context references into a portable ProofRelay evidence wrapper without ingesting raw prompts, outputs, credentials, or logs.
| Name | Required | Description | Default |
|---|---|---|---|
| tool_evidence | Yes |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare this as readOnlyHint=true, idempotentHint=true, destructiveHint=false. The description meaningfully adds behavioral clarity: it explicitly states the tool only accepts hashes and does not ingest raw data—important context about privacy/safety boundaries beyond the annotations. It doesn't describe failure modes or error handling, but for a pure wrapping tool this is solid transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single, dense sentence that packs in verb, resource, constraints, portability outcome, and privacy exclusions. No wasted words. Front-loads the action and specifies the security boundary at the end.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the sensitive security context (hashing raw references, handling secrets), the description's note about 'non-secret refs' and the exclusion of 'raw... credentials' is well-placed. The annotations cover read-only/idempotency, the output schema exists, and the input schema is quite descriptive on its own. The description could theoretically mention what happens if invalid hashes are passed, but for a stateless wrapping operation this is near-complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, and the single parameter is a nested object with a mix of required and optional fields. The description provides security context (mentions 'payment context references', 'authority', 'non-secret refs'), which adds mild meaning beyond the field names. However, it doesn't describe field-level semantics like expected hash formats (hex? base64?), which would meaningfully help agents construct valid input. The description's 'hash-only' framing is helpful but doesn't fully compensate for the lack of field documentation.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb (Convert) and identifies a precise resource (hash-only MCP tool request/response references into a ProofRelay evidence wrapper). It clearly distinguishes itself from sibling tools by naming the wrapping/conversion functionality and the input constraints (hash-only, no raw data).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description clearly implies when to use this tool (when hash-only references are available and a portable wrapper is needed) and explicitly states what it does not do ('without ingesting raw prompts, outputs, credentials, or logs'). While alternatives are not named, the exclusion criteria is strong guidance for an agent deciding between this and related proof-construction tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
proofrelay.adapt_agent_identity_evidence6 fields changedInput schema / $defsRemoved value: -{
- "AgentIdentityEvidenceInput": {
- "description": "Hash-only external agent identity evidence accepted as PREP-3 input.",
- "properties": {
- "action_binding_hash": {
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ],
- "default": null,
- "description": "Optional hash binding this identity to an action bundle.",
- "title": "Action Binding Hash"
- },
- "agent_id_hash": {
- "description": "SHA-256 hash of external agent id.",
- "title": "Agent Id Hash",
- "type": "string"
- },
- "attestation_hash": {
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ],
- "default": null,
- "description": "Optional identity attestation or verifier transcript hash.",
- "title": "Attestation Hash"
- },
- "controller_hash": {
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ],
- "default": null,
- "description": "Optional controller, owner, account, or IAM subject hash.",
- "title": "Controller Hash"
- },
- "domain_hash": {
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ],
- "default": null,
- "description": "Optional domain-control or organization reference hash.",
- "title": "Domain Hash"
- },
- "expires_at": {
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ],
- "default": null,
- "description": "Optional ISO-8601 expiry time.",
- "title": "Expires At"
- },
- "issued_at": {
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ],
- "default": null,
- "description": "Optional ISO-8601 issue time.",
- "title": "Issued At"
- },
- "non_secret_refs": {
- "description": "Non-secret registry or profile references.",
- "items": {
- "type": "string"
- },
- "title": "Non Secret Refs",
- "type": "array"
- },
- "provider": {
- "description": "External identity or registry evidence source.",
- "enum": [
- "concordium_agent_registry",
- "erc_8004",
- "did",
- "domain_control",
- "wallet_controller",
- "enterprise_iam",
- "other"
- ],
- "title": "Provider",
- "type": "string"
- },
- "registry_record_hash": {
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ],
- "default": null,
- "description": "Optional registry record or metadata hash.",
- "title": "Registry Record Hash"
- },
- "verification_method_hash": {
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ],
- "default": null,
- "description": "Optional verification method or key-reference hash.",
- "title": "Verification Method Hash"
- }
- },
- "required": [
- "provider",
- "agent_id_hash"
- ],
- "title": "AgentIdentityEvidenceInput",
- "type": "object"
- }
-}Input schema / properties / identity / $refRemoved value: -"#/$defs/AgentIdentityEvidenceInput"Input schema / properties / identity / propertiesAdded value: +{
+ "action_binding_hash": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "agent_id_hash": {
+ "type": "string"
+ },
+ "attestation_hash": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "controller_hash": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "domain_hash": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "expires_at": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "issued_at": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "non_secret_refs": {
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+ },
+ "provider": {
+ "enum": [
+ "concordium_agent_registry",
+ "erc_8004",
+ "did",
+ "domain_control",
+ "wallet_controller",
+ "enterprise_iam",
+ "other"
+ ],
+ "type": "string"
+ },
+ "registry_record_hash": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "verification_method_hash": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ }
+}Input schema / properties / identity / requiredAdded value: +[
+ "provider",
+ "agent_id_hash"
+]Input schema / properties / identity / typeAdded value: +"object"Input schema / titleRemoved value: -"adapt_agent_identity_evidenceArguments"proofrelay.adapt_x402_payment_proof6 fields changedInput schema / $defsRemoved value: -{
- "X402EvidenceInput": {
- "description": "Public-safe x402 lifecycle hashes to adapt into ProofRelay payment context.",
- "properties": {
- "amount": {
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ],
- "default": null,
- "description": "Amount requested by the service.",
- "title": "Amount"
- },
- "currency": {
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ],
- "default": null,
- "description": "Payment currency or unit.",
- "title": "Currency"
- },
- "facilitator_hash": {
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ],
- "default": null,
- "description": "Optional SHA-256 hash of the facilitator identifier.",
- "title": "Facilitator Hash"
- },
- "network": {
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ],
- "default": null,
- "description": "x402 network identifier.",
- "title": "Network"
- },
- "payment_payload_hash": {
- "description": "SHA-256 hash of the submitted x402 payment payload.",
- "title": "Payment Payload Hash",
- "type": "string"
- },
- "payment_required_hash": {
- "description": "SHA-256 hash of the HTTP 402 challenge/instructions.",
- "title": "Payment Required Hash",
- "type": "string"
- },
- "payment_response_hash": {
- "description": "SHA-256 hash of facilitator or server payment response.",
- "title": "Payment Response Hash",
- "type": "string"
- },
- "replay_key": {
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ],
- "default": null,
- "description": "Replay key or idempotency key hash.",
- "title": "Replay Key"
- },
- "request_hash": {
- "description": "SHA-256 hash of the original request.",
- "title": "Request Hash",
- "type": "string"
- },
- "resource_response_hash": {
- "description": "SHA-256 hash of the resource delivered after payment.",
- "title": "Resource Response Hash",
- "type": "string"
- }
- },
- "required": [
- "request_hash",
- "payment_required_hash",
- "payment_payload_hash",
- "payment_response_hash",
- "resource_response_hash"
- ],
- "title": "X402EvidenceInput",
- "type": "object"
- }
-}Input schema / properties / x402 / $refRemoved value: -"#/$defs/X402EvidenceInput"Input schema / properties / x402 / propertiesAdded value: +{
+ "amount": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "currency": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "facilitator_hash": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "network": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "payment_payload_hash": {
+ "type": "string"
+ },
+ "payment_required_hash": {
+ "type": "string"
+ },
+ "payment_response_hash": {
+ "type": "string"
+ },
+ "replay_key": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "request_hash": {
+ "type": "string"
+ },
+ "resource_response_hash": {
+ "type": "string"
+ }
+}Input schema / properties / x402 / requiredAdded value: +[
+ "request_hash",
+ "payment_required_hash",
+ "payment_payload_hash",
+ "payment_response_hash",
+ "resource_response_hash"
+]Input schema / properties / x402 / typeAdded value: +"object"Input schema / titleRemoved value: -"adapt_x402_payment_proofArguments"proofrelay.build_audit_pack_manifest6 fields changedInput schema / $defsRemoved value: -{
- "AuditPackManifestInput": {
- "description": "Hash-only audit pack manifest input.",
- "properties": {
- "bundle_hashes": {
- "description": "Evidence bundle hashes.",
- "items": {
- "type": "string"
- },
- "title": "Bundle Hashes",
- "type": "array"
- },
- "control_refs": {
- "description": "Public-safe control references.",
- "items": {
- "type": "string"
- },
- "title": "Control Refs",
- "type": "array"
- },
- "evidence_hashes": {
- "description": "Additional evidence artifact hashes.",
- "items": {
- "type": "string"
- },
- "title": "Evidence Hashes",
- "type": "array"
- },
- "generated_at": {
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ],
- "default": null,
- "description": "Optional ISO-8601 time.",
- "title": "Generated At"
- },
- "pack_id": {
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ],
- "default": null,
- "description": "Optional audit pack id.",
- "title": "Pack Id"
- },
- "policy_hashes": {
- "description": "Policy or control hashes.",
- "items": {
- "type": "string"
- },
- "title": "Policy Hashes",
- "type": "array"
- },
- "subject_hash": {
- "description": "SHA-256 hash of audit subject.",
- "title": "Subject Hash",
- "type": "string"
- },
- "verifier_response_hashes": {
- "description": "Verifier response hashes.",
- "items": {
- "type": "string"
- },
- "title": "Verifier Response Hashes",
- "type": "array"
- }
- },
- "required": [
- "subject_hash"
- ],
- "title": "AuditPackManifestInput",
- "type": "object"
- }
-}Input schema / properties / audit_pack / $refRemoved value: -"#/$defs/AuditPackManifestInput"Input schema / properties / audit_pack / propertiesAdded value: +{
+ "bundle_hashes": {
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+ },
+ "control_refs": {
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+ },
+ "evidence_hashes": {
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+ },
+ "generated_at": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "pack_id": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "policy_hashes": {
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+ },
+ "subject_hash": {
+ "type": "string"
+ },
+ "verifier_response_hashes": {
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+ }
+}Input schema / properties / audit_pack / requiredAdded value: +[
+ "subject_hash"
+]Input schema / properties / audit_pack / typeAdded value: +"object"Input schema / titleRemoved value: -"build_audit_pack_manifestArguments"proofrelay.build_bundle_draft7 fields changedInput schema / $defsRemoved value: -{
- "BundleDraftEventInput": {
- "description": "Public-safe event draft used to build an unsigned ProofRelay bundle.",
- "properties": {
- "event_type": {
- "description": "Public-safe event category.",
- "title": "Event Type",
- "type": "string"
- },
- "payload": {
- "additionalProperties": true,
- "description": "Minimized metadata and hashes only; never include secrets.",
- "title": "Payload",
- "type": "object"
- },
- "policy_digest": {
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ],
- "default": null,
- "description": "Optional policy digest.",
- "title": "Policy Digest"
- },
- "receipt_id": {
- "description": "Stable receipt identifier.",
- "title": "Receipt Id",
- "type": "string"
- },
- "service": {
- "description": "Service or agent represented by the event.",
- "title": "Service",
- "type": "string"
- },
- "ts_ms": {
- "description": "Event timestamp in Unix milliseconds.",
- "title": "Ts Ms",
- "type": "integer"
- }
- },
- "required": [
- "receipt_id",
- "ts_ms",
- "service",
- "event_type"
- ],
- "title": "BundleDraftEventInput",
- "type": "object"
- },
- "BundleDraftInput": {
- "description": "Input for a non-attesting, unsigned ProofRelay bundle draft.",
- "properties": {
- "created_ts_ms": {
- "description": "Bundle creation timestamp in Unix milliseconds.",
- "title": "Created Ts Ms",
- "type": "integer"
- },
- "events": {
- "description": "Receipt events in any order.",
- "items": {
- "$ref": "#/$defs/BundleDraftEventInput"
- },
- "minItems": 1,
- "title": "Events",
- "type": "array"
- },
- "payment_context": {
- "anyOf": [
- {
- "$ref": "#/$defs/PaymentProofEnvelopeInput"
- },
- {
- "type": "null"
- }
- ],
- "default": null,
- "description": "Optional normalized payment context to attach to the first event."
- },
- "service": {
- "description": "Service represented by the bundle.",
- "title": "Service",
- "type": "string"
- }
- },
- "required": [
- "service",
- "created_ts_ms",
- "events"
- ],
- "title": "BundleDraftInput",
- "type": "object"
- },
- "PaymentProofEnvelopeInput": {
- "description": "Rail-agnostic payment proof hashes for a ProofRelay evidence profile.",
- "properties": {
- "amount": {
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ],
- "default": null,
- "description": "Public-safe amount label, if known.",
- "title": "Amount"
- },
- "challenge_or_session_hash": {
- "description": "SHA-256 hash of the challenge, checkout session, or quote.",
- "title": "Challenge Or Session Hash",
- "type": "string"
- },
- "currency": {
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ],
- "default": null,
- "description": "Currency or unit, if known.",
- "title": "Currency"
- },
- "expires_at": {
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ],
- "default": null,
- "description": "Optional ISO-8601 expiry time.",
- "title": "Expires At"
- },
- "non_secret_refs": {
- "description": "Non-secret references such as hashed event IDs or endpoint names.",
- "items": {
- "type": "string"
- },
- "title": "Non Secret Refs",
- "type": "array"
- },
- "payment_proof_or_charge_hash": {
- "description": "SHA-256 hash of the payment proof, charge, or facilitator result.",
- "title": "Payment Proof Or Charge Hash",
- "type": "string"
- },
- "protocol": {
- "description": "Public-safe protocol name for the paid action lifecycle.",
- "examples": [
- "stripe_checkout_session_webhook"
- ],
- "title": "Protocol",
- "type": "string"
- },
- "provider": {
- "description": "Payment rail or entitlement provider, for example stripe or x402.",
- "examples": [
- "stripe_agentic_commerce"
- ],
- "title": "Provider",
- "type": "string"
- },
- "replay_key": {
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ],
- "default": null,
- "description": "Public-safe replay key or hash.",
- "title": "Replay Key"
- },
- "request_hash": {
- "description": "SHA-256 hash of the request.",
- "title": "Request Hash",
- "type": "string"
- },
- "response_hash": {
- "description": "SHA-256 hash of the delivered resource or service response.",
- "title": "Response Hash",
- "type": "string"
- },
- "settlement_or_entitlement_hash": {
- "description": "SHA-256 hash of the settlement, receipt, or entitlement token.",
- "title": "Settlement Or Entitlement Hash",
- "type": "string"
- }
- },
- "required": [
- "provider",
- "protocol",
- "request_hash",
- "challenge_or_session_hash",
- "payment_proof_or_charge_hash",
- "settlement_or_entitlement_hash",
- "response_hash"
- ],
- "title": "PaymentProofEnvelopeInput",
- "type": "object"
- }
-}Input schema / properties / draft / $defsAdded value: +{
+ "BundleDraftEventInput": {
+ "properties": {
+ "event_type": {
+ "type": "string"
+ },
+ "payload": {
+ "additionalProperties": true,
+ "type": "object"
+ },
+ "policy_digest": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "receipt_id": {
+ "type": "string"
+ },
+ "service": {
+ "type": "string"
+ },
+ "ts_ms": {
+ "type": "integer"
+ }
+ },
+ "required": [
+ "receipt_id",
+ "ts_ms",
+ "service",
+ "event_type"
+ ],
+ "type": "object"
+ },
+ "PaymentProofEnvelopeInput": {
+ "properties": {
+ "amount": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "challenge_or_session_hash": {
+ "type": "string"
+ },
+ "currency": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "expires_at": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "non_secret_refs": {
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+ },
+ "payment_proof_or_charge_hash": {
+ "type": "string"
+ },
+ "protocol": {
+ "type": "string"
+ },
+ "provider": {
+ "type": "string"
+ },
+ "replay_key": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "request_hash": {
+ "type": "string"
+ },
+ "response_hash": {
+ "type": "string"
+ },
+ "settlement_or_entitlement_hash": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "provider",
+ "protocol",
+ "request_hash",
+ "challenge_or_session_hash",
+ "payment_proof_or_charge_hash",
+ "settlement_or_entitlement_hash",
+ "response_hash"
+ ],
+ "type": "object"
+ }
+}Input schema / properties / draft / $refRemoved value: -"#/$defs/BundleDraftInput"Input schema / properties / draft / propertiesAdded value: +{
+ "created_ts_ms": {
+ "type": "integer"
+ },
+ "events": {
+ "items": {
+ "$ref": "#/$defs/BundleDraftEventInput"
+ },
+ "minItems": 1,
+ "type": "array"
+ },
+ "payment_context": {
+ "anyOf": [
+ {
+ "$ref": "#/$defs/PaymentProofEnvelopeInput"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "service": {
+ "type": "string"
+ }
+}Input schema / properties / draft / requiredAdded value: +[
+ "service",
+ "created_ts_ms",
+ "events"
+]Input schema / properties / draft / typeAdded value: +"object"Input schema / titleRemoved value: -"build_bundle_draftArguments"proofrelay.build_closing_proof_pack6 fields changedInput schema / $defsRemoved value: -{
- "ClosingProofPackInput": {
- "description": "Hash-only closing proof pack input.",
- "properties": {
- "approval_receipt_hashes": {
- "description": "Human approval receipt hashes.",
- "items": {
- "type": "string"
- },
- "title": "Approval Receipt Hashes",
- "type": "array"
- },
- "closing_file_hash": {
- "description": "SHA-256 closing file hash.",
- "title": "Closing File Hash",
- "type": "string"
- },
- "disbursement_hashes": {
- "description": "Disbursement instruction hashes.",
- "items": {
- "type": "string"
- },
- "title": "Disbursement Hashes",
- "type": "array"
- },
- "funding_authorization_hash": {
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ],
- "default": null,
- "description": "Optional funding authorization hash.",
- "title": "Funding Authorization Hash"
- },
- "lender_package_hash": {
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ],
- "default": null,
- "description": "Optional lender package hash.",
- "title": "Lender Package Hash"
- },
- "non_secret_refs": {
- "description": "Public-safe closing references.",
- "items": {
- "type": "string"
- },
- "title": "Non Secret Refs",
- "type": "array"
- },
- "notary_hash": {
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ],
- "default": null,
- "description": "Optional notary event hash.",
- "title": "Notary Hash"
- },
- "settlement_statement_hash": {
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ],
- "default": null,
- "description": "Optional settlement statement hash.",
- "title": "Settlement Statement Hash"
- },
- "title_policy_hash": {
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ],
- "default": null,
- "description": "Optional title policy hash.",
- "title": "Title Policy Hash"
- }
- },
- "required": [
- "closing_file_hash"
- ],
- "title": "ClosingProofPackInput",
- "type": "object"
- }
-}Input schema / properties / closing_pack / $refRemoved value: -"#/$defs/ClosingProofPackInput"Input schema / properties / closing_pack / propertiesAdded value: +{
+ "approval_receipt_hashes": {
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+ },
+ "closing_file_hash": {
+ "type": "string"
+ },
+ "disbursement_hashes": {
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+ },
+ "funding_authorization_hash": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "lender_package_hash": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "non_secret_refs": {
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+ },
+ "notary_hash": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "settlement_statement_hash": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "title_policy_hash": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ }
+}Input schema / properties / closing_pack / requiredAdded value: +[
+ "closing_file_hash"
+]Input schema / properties / closing_pack / typeAdded value: +"object"Input schema / titleRemoved value: -"build_closing_proof_packArguments"proofrelay.build_human_approval_receipt6 fields changedInput schema / $defsRemoved value: -{
- "HumanApprovalReceiptInput": {
- "description": "Hash-only human approval receipt draft input.",
- "properties": {
- "approval_id": {
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ],
- "default": null,
- "description": "Optional approval id.",
- "title": "Approval Id"
- },
- "approved_at": {
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ],
- "default": null,
- "description": "Optional ISO-8601 time.",
- "title": "Approved At"
- },
- "approver_hash": {
- "description": "SHA-256 hash of approver identity.",
- "title": "Approver Hash",
- "type": "string"
- },
- "approver_role": {
- "description": "Public-safe approver role.",
- "title": "Approver Role",
- "type": "string"
- },
- "decision": {
- "description": "Approval decision.",
- "enum": [
- "approved",
- "rejected",
- "needs_changes"
- ],
- "title": "Decision",
- "type": "string"
- },
- "expires_at": {
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ],
- "default": null,
- "description": "Optional ISO-8601 expiry.",
- "title": "Expires At"
- },
- "non_secret_refs": {
- "description": "Non-secret evidence references.",
- "items": {
- "type": "string"
- },
- "title": "Non Secret Refs",
- "type": "array"
- },
- "policy_hash": {
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ],
- "default": null,
- "description": "Optional policy hash.",
- "title": "Policy Hash"
- },
- "reason_codes": {
- "description": "Public-safe approval reason codes.",
- "items": {
- "type": "string"
- },
- "title": "Reason Codes",
- "type": "array"
- },
- "scope_hash": {
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ],
- "default": null,
- "description": "Optional scope hash.",
- "title": "Scope Hash"
- },
- "subject_hash": {
- "description": "SHA-256 hash of approved subject.",
- "title": "Subject Hash",
- "type": "string"
- }
- },
- "required": [
- "approver_role",
- "approver_hash",
- "decision",
- "subject_hash"
- ],
- "title": "HumanApprovalReceiptInput",
- "type": "object"
- }
-}Input schema / properties / approval / $refRemoved value: -"#/$defs/HumanApprovalReceiptInput"Input schema / properties / approval / propertiesAdded value: +{
+ "approval_id": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "approved_at": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "approver_hash": {
+ "type": "string"
+ },
+ "approver_role": {
+ "type": "string"
+ },
+ "decision": {
+ "enum": [
+ "approved",
+ "rejected",
+ "needs_changes"
+ ],
+ "type": "string"
+ },
+ "expires_at": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "non_secret_refs": {
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+ },
+ "policy_hash": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "reason_codes": {
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+ },
+ "scope_hash": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "subject_hash": {
+ "type": "string"
+ }
+}Input schema / properties / approval / requiredAdded value: +[
+ "approver_role",
+ "approver_hash",
+ "decision",
+ "subject_hash"
+]Input schema / properties / approval / typeAdded value: +"object"Input schema / titleRemoved value: -"build_human_approval_receiptArguments"proofrelay.build_registry_entry6 fields changedInput schema / $defsRemoved value: -{
- "RegistryEntryInput": {
- "description": "Public-safe ProofRelay Registry entry draft input.",
- "properties": {
- "conformance_fixture_hash": {
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ],
- "default": null,
- "description": "Optional conformance fixture hash.",
- "title": "Conformance Fixture Hash"
- },
- "entry_type": {
- "description": "Registry subject category.",
- "enum": [
- "mcp_server",
- "agent",
- "api",
- "workflow",
- "adapter"
- ],
- "title": "Entry Type",
- "type": "string"
- },
- "evidence_bundle_hash": {
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ],
- "default": null,
- "description": "Optional bundle hash.",
- "title": "Evidence Bundle Hash"
- },
- "identity_reference_hash": {
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ],
- "default": null,
- "description": "Optional PREP-3 identity reference hash.",
- "title": "Identity Reference Hash"
- },
- "mcp_server_card_hash": {
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ],
- "default": null,
- "description": "Optional MCP server-card hash.",
- "title": "Mcp Server Card Hash"
- },
- "name": {
- "description": "Public display name, no secrets.",
- "title": "Name",
- "type": "string"
- },
- "non_secret_refs": {
- "description": "Public-safe listing references.",
- "items": {
- "type": "string"
- },
- "title": "Non Secret Refs",
- "type": "array"
- },
- "openapi_schema_hash": {
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ],
- "default": null,
- "description": "Optional OpenAPI schema hash.",
- "title": "Openapi Schema Hash"
- },
- "payment_context_hash": {
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ],
- "default": null,
- "description": "Optional payment context hash.",
- "title": "Payment Context Hash"
- },
- "profiles": {
- "description": "PREP profiles supported by the subject.",
- "items": {
- "type": "string"
- },
- "title": "Profiles",
- "type": "array"
- },
- "proof_envelope_hash": {
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ],
- "default": null,
- "description": "Optional proof hash.",
- "title": "Proof Envelope Hash"
- },
- "replay_test_hash": {
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ],
- "default": null,
- "description": "Optional replay test hash.",
- "title": "Replay Test Hash"
- },
- "status": {
- "default": "draft",
- "description": "Public registry workflow status.",
- "enum": [
- "draft",
- "evidence_submitted",
- "verified_bundle",
- "replay_tested",
- "listed"
- ],
- "title": "Status",
- "type": "string"
- },
- "subject_hash": {
- "description": "SHA-256 hash of registry subject.",
- "title": "Subject Hash",
- "type": "string"
- },
- "verifier_response_hash": {
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ],
- "default": null,
- "description": "Optional verifier response hash.",
- "title": "Verifier Response Hash"
- }
- },
- "required": [
- "entry_type",
- "name",
- "subject_hash"
- ],
- "title": "RegistryEntryInput",
- "type": "object"
- }
-}Input schema / properties / entry / $refRemoved value: -"#/$defs/RegistryEntryInput"Input schema / properties / entry / propertiesAdded value: +{
+ "conformance_fixture_hash": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "entry_type": {
+ "enum": [
+ "mcp_server",
+ "agent",
+ "api",
+ "workflow",
+ "adapter"
+ ],
+ "type": "string"
+ },
+ "evidence_bundle_hash": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "identity_reference_hash": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "mcp_server_card_hash": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "name": {
+ "type": "string"
+ },
+ "non_secret_refs": {
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+ },
+ "openapi_schema_hash": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "payment_context_hash": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "profiles": {
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+ },
+ "proof_envelope_hash": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "replay_test_hash": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "status": {
+ "enum": [
+ "draft",
+ "evidence_submitted",
+ "verified_bundle",
+ "replay_tested",
+ "listed"
+ ],
+ "type": "string"
+ },
+ "subject_hash": {
+ "type": "string"
+ },
+ "verifier_response_hash": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ }
+}Input schema / properties / entry / requiredAdded value: +[
+ "entry_type",
+ "name",
+ "subject_hash"
+]Input schema / properties / entry / typeAdded value: +"object"Input schema / titleRemoved value: -"build_registry_entryArguments"proofrelay.build_title_production_evidence6 fields changedInput schema / $defsRemoved value: -{
- "TitleProductionEvidenceInput": {
- "description": "Hash-only title production evidence profile input.",
- "properties": {
- "exception_hashes": {
- "description": "Hashes of title exceptions.",
- "items": {
- "type": "string"
- },
- "title": "Exception Hashes",
- "type": "array"
- },
- "non_secret_refs": {
- "description": "Public-safe file or order refs.",
- "items": {
- "type": "string"
- },
- "title": "Non Secret Refs",
- "type": "array"
- },
- "order_hash": {
- "description": "SHA-256 hash of title order.",
- "title": "Order Hash",
- "type": "string"
- },
- "production_status": {
- "default": "review_required",
- "description": "Declared public production status.",
- "enum": [
- "open",
- "clear",
- "exceptions",
- "review_required"
- ],
- "title": "Production Status",
- "type": "string"
- },
- "property_hash": {
- "description": "SHA-256 hash of property ref.",
- "title": "Property Hash",
- "type": "string"
- },
- "tax_cert_hash": {
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ],
- "default": null,
- "description": "Optional tax cert hash.",
- "title": "Tax Cert Hash"
- },
- "title_commitment_hash": {
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ],
- "default": null,
- "description": "Optional title commitment hash.",
- "title": "Title Commitment Hash"
- },
- "title_search_hash": {
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ],
- "default": null,
- "description": "Optional title search artifact hash.",
- "title": "Title Search Hash"
- }
- },
- "required": [
- "order_hash",
- "property_hash"
- ],
- "title": "TitleProductionEvidenceInput",
- "type": "object"
- }
-}Input schema / properties / title_evidence / $refRemoved value: -"#/$defs/TitleProductionEvidenceInput"Input schema / properties / title_evidence / propertiesAdded value: +{
+ "exception_hashes": {
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+ },
+ "non_secret_refs": {
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+ },
+ "order_hash": {
+ "type": "string"
+ },
+ "production_status": {
+ "enum": [
+ "open",
+ "clear",
+ "exceptions",
+ "review_required"
+ ],
+ "type": "string"
+ },
+ "property_hash": {
+ "type": "string"
+ },
+ "tax_cert_hash": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "title_commitment_hash": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "title_search_hash": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ }
+}Input schema / properties / title_evidence / requiredAdded value: +[
+ "order_hash",
+ "property_hash"
+]Input schema / properties / title_evidence / typeAdded value: +"object"Input schema / titleRemoved value: -"build_title_production_evidenceArguments"proofrelay.compute_readiness_signal6 fields changedInput schema / $defsRemoved value: -{
- "ReadinessSignalInput": {
- "description": "Hash-only real-estate workflow readiness signal input.",
- "properties": {
- "approval_receipt_hashes": {
- "description": "Human approval receipt hashes.",
- "items": {
- "type": "string"
- },
- "title": "Approval Receipt Hashes",
- "type": "array"
- },
- "closing_pack_hash": {
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ],
- "default": null,
- "description": "Closing pack hash.",
- "title": "Closing Pack Hash"
- },
- "critical_risk_count": {
- "default": 0,
- "description": "Critical risk count.",
- "minimum": 0,
- "title": "Critical Risk Count",
- "type": "integer"
- },
- "lender_condition_hashes": {
- "description": "Lender condition profile hashes.",
- "items": {
- "type": "string"
- },
- "title": "Lender Condition Hashes",
- "type": "array"
- },
- "open_condition_count": {
- "default": 0,
- "description": "Open condition count.",
- "minimum": 0,
- "title": "Open Condition Count",
- "type": "integer"
- },
- "target_milestone": {
- "description": "Milestone being assessed.",
- "enum": [
- "title_clear_to_close",
- "closing",
- "funding",
- "disbursement",
- "post_close"
- ],
- "title": "Target Milestone",
- "type": "string"
- },
- "title_evidence_hash": {
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ],
- "default": null,
- "description": "Title evidence hash.",
- "title": "Title Evidence Hash"
- },
- "unresolved_exception_count": {
- "default": 0,
- "description": "Public count of unresolved exceptions.",
- "minimum": 0,
- "title": "Unresolved Exception Count",
- "type": "integer"
- },
- "wire_review_hash": {
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ],
- "default": null,
- "description": "Wire review hash.",
- "title": "Wire Review Hash"
- },
- "workflow_hash": {
- "description": "SHA-256 workflow or file hash.",
- "title": "Workflow Hash",
- "type": "string"
- }
- },
- "required": [
- "workflow_hash",
- "target_milestone"
- ],
- "title": "ReadinessSignalInput",
- "type": "object"
- }
-}Input schema / properties / readiness / $refRemoved value: -"#/$defs/ReadinessSignalInput"Input schema / properties / readiness / propertiesAdded value: +{
+ "approval_receipt_hashes": {
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+ },
+ "closing_pack_hash": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "critical_risk_count": {
+ "minimum": 0,
+ "type": "integer"
+ },
+ "lender_condition_hashes": {
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+ },
+ "open_condition_count": {
+ "minimum": 0,
+ "type": "integer"
+ },
+ "target_milestone": {
+ "enum": [
+ "title_clear_to_close",
+ "closing",
+ "funding",
+ "disbursement",
+ "post_close"
+ ],
+ "type": "string"
+ },
+ "title_evidence_hash": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "unresolved_exception_count": {
+ "minimum": 0,
+ "type": "integer"
+ },
+ "wire_review_hash": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "workflow_hash": {
+ "type": "string"
+ }
+}Input schema / properties / readiness / requiredAdded value: +[
+ "workflow_hash",
+ "target_milestone"
+]Input schema / properties / readiness / typeAdded value: +"object"Input schema / titleRemoved value: -"compute_readiness_signalArguments"proofrelay.describe_cli_sdk_helper5 fields changedInput schema / $defsRemoved value: -{
- "CLIHelperInput": {
- "description": "Client helper options for ProofRelay MCP setup instructions.",
- "properties": {
- "client": {
- "default": "generic",
- "description": "MCP client family to describe.",
- "enum": [
- "generic",
- "claude",
- "cursor",
- "windsurf",
- "codex"
- ],
- "title": "Client",
- "type": "string"
- },
- "endpoint": {
- "default": "https://mcp.genesisre.io/mcp",
- "description": "MCP streamable HTTP endpoint to use.",
- "title": "Endpoint",
- "type": "string"
- }
- },
- "title": "CLIHelperInput",
- "type": "object"
- }
-}Input schema / properties / helper / $refRemoved value: -"#/$defs/CLIHelperInput"Input schema / properties / helper / propertiesAdded value: +{
+ "client": {
+ "enum": [
+ "generic",
+ "claude",
+ "cursor",
+ "windsurf",
+ "codex"
+ ],
+ "type": "string"
+ },
+ "endpoint": {
+ "type": "string"
+ }
+}Input schema / properties / helper / typeAdded value: +"object"Input schema / titleRemoved value: -"describe_cli_sdk_helperArguments"proofrelay.describe_stripe_entitlement_flow2 fields changedInput schema / requiredAdded value: +[]Input schema / titleRemoved value: -"describe_stripe_entitlement_flowArguments"proofrelay.generate_paid_tool_receipt6 fields changedInput schema / $defsRemoved value: -{
- "PaidToolReceiptInput": {
- "description": "Hash-only paid MCP/API tool receipt draft input.",
- "properties": {
- "authority_hash": {
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ],
- "default": null,
- "description": "Optional authority, policy, or scope hash.",
- "title": "Authority Hash"
- },
- "entitlement_hash": {
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ],
- "default": null,
- "description": "Optional public-safe entitlement hash.",
- "title": "Entitlement Hash"
- },
- "non_secret_refs": {
- "description": "Non-secret references to include.",
- "items": {
- "type": "string"
- },
- "title": "Non Secret Refs",
- "type": "array"
- },
- "payment_context_hash": {
- "description": "SHA-256 hash of normalized payment context.",
- "title": "Payment Context Hash",
- "type": "string"
- },
- "receipt_id": {
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ],
- "default": null,
- "description": "Optional stable receipt id.",
- "title": "Receipt Id"
- },
- "result_hash": {
- "description": "SHA-256 hash of the tool result.",
- "title": "Result Hash",
- "type": "string"
- },
- "tool_call_hash": {
- "description": "SHA-256 hash of the tool call.",
- "title": "Tool Call Hash",
- "type": "string"
- },
- "tool_name": {
- "description": "Paid tool or API operation name.",
- "title": "Tool Name",
- "type": "string"
- },
- "ts_ms": {
- "description": "Receipt timestamp in Unix milliseconds.",
- "title": "Ts Ms",
- "type": "integer"
- }
- },
- "required": [
- "tool_name",
- "ts_ms",
- "tool_call_hash",
- "result_hash",
- "payment_context_hash"
- ],
- "title": "PaidToolReceiptInput",
- "type": "object"
- }
-}Input schema / properties / receipt / $refRemoved value: -"#/$defs/PaidToolReceiptInput"Input schema / properties / receipt / propertiesAdded value: +{
+ "authority_hash": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "entitlement_hash": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "non_secret_refs": {
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+ },
+ "payment_context_hash": {
+ "type": "string"
+ },
+ "receipt_id": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "result_hash": {
+ "type": "string"
+ },
+ "tool_call_hash": {
+ "type": "string"
+ },
+ "tool_name": {
+ "type": "string"
+ },
+ "ts_ms": {
+ "type": "integer"
+ }
+}Input schema / properties / receipt / requiredAdded value: +[
+ "tool_name",
+ "ts_ms",
+ "tool_call_hash",
+ "result_hash",
+ "payment_context_hash"
+]Input schema / properties / receipt / typeAdded value: +"object"Input schema / titleRemoved value: -"generate_paid_tool_receiptArguments"proofrelay.get_verifier_status2 fields changedInput schema / requiredAdded value: +[]Input schema / titleRemoved value: -"get_verifier_statusArguments"proofrelay.issue_conformance_badge6 fields changedInput schema / $defsRemoved value: -{
- "ConformanceBadgeInput": {
- "description": "Unsigned ProofRelay conformance badge draft input.",
- "properties": {
- "badge_type": {
- "description": "Evidence-conformance badge type.",
- "enum": [
- "prep_compatible",
- "verified_bundle",
- "verified_mcp",
- "replay_tested"
- ],
- "title": "Badge Type",
- "type": "string"
- },
- "criteria_hash": {
- "description": "SHA-256 hash of badge criteria.",
- "title": "Criteria Hash",
- "type": "string"
- },
- "evidence_bundle_hash": {
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ],
- "default": null,
- "description": "Optional bundle hash.",
- "title": "Evidence Bundle Hash"
- },
- "expires_at": {
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ],
- "default": null,
- "description": "Optional ISO-8601 expiry time.",
- "title": "Expires At"
- },
- "issued_at": {
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ],
- "default": null,
- "description": "Optional ISO-8601 issue time.",
- "title": "Issued At"
- },
- "non_secret_refs": {
- "description": "Public-safe badge references.",
- "items": {
- "type": "string"
- },
- "title": "Non Secret Refs",
- "type": "array"
- },
- "profile": {
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ],
- "default": null,
- "description": "Optional PREP profile marker.",
- "title": "Profile"
- },
- "proof_envelope_hash": {
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ],
- "default": null,
- "description": "Optional envelope hash.",
- "title": "Proof Envelope Hash"
- },
- "registry_entry_hash": {
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ],
- "default": null,
- "description": "Optional ProofRelay Registry entry hash.",
- "title": "Registry Entry Hash"
- },
- "replay_test_hash": {
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ],
- "default": null,
- "description": "Optional replay test hash.",
- "title": "Replay Test Hash"
- },
- "subject_hash": {
- "description": "SHA-256 hash of the badge subject.",
- "title": "Subject Hash",
- "type": "string"
- },
- "verifier_response_hash": {
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ],
- "default": null,
- "description": "Optional verifier response hash.",
- "title": "Verifier Response Hash"
- }
- },
- "required": [
- "badge_type",
- "subject_hash",
- "criteria_hash"
- ],
- "title": "ConformanceBadgeInput",
- "type": "object"
- }
-}Input schema / properties / badge / $refRemoved value: -"#/$defs/ConformanceBadgeInput"Input schema / properties / badge / propertiesAdded value: +{
+ "badge_type": {
+ "enum": [
+ "prep_compatible",
+ "verified_bundle",
+ "verified_mcp",
+ "replay_tested"
+ ],
+ "type": "string"
+ },
+ "criteria_hash": {
+ "type": "string"
+ },
+ "evidence_bundle_hash": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "expires_at": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "issued_at": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "non_secret_refs": {
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+ },
+ "profile": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "proof_envelope_hash": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "registry_entry_hash": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "replay_test_hash": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "subject_hash": {
+ "type": "string"
+ },
+ "verifier_response_hash": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ }
+}Input schema / properties / badge / requiredAdded value: +[
+ "badge_type",
+ "subject_hash",
+ "criteria_hash"
+]Input schema / properties / badge / typeAdded value: +"object"Input schema / titleRemoved value: -"issue_conformance_badgeArguments"proofrelay.map_lender_condition_evidence6 fields changedInput schema / $defsRemoved value: -{
- "LenderConditionEvidenceInput": {
- "description": "Hash-only lender condition evidence input.",
- "properties": {
- "condition_hash": {
- "description": "SHA-256 condition text hash.",
- "title": "Condition Hash",
- "type": "string"
- },
- "condition_id": {
- "description": "Public lender condition id.",
- "title": "Condition Id",
- "type": "string"
- },
- "condition_type": {
- "description": "Public condition category.",
- "title": "Condition Type",
- "type": "string"
- },
- "evidence_hashes": {
- "description": "Evidence artifact hashes.",
- "items": {
- "type": "string"
- },
- "title": "Evidence Hashes",
- "type": "array"
- },
- "non_secret_refs": {
- "description": "Public-safe condition references.",
- "items": {
- "type": "string"
- },
- "title": "Non Secret Refs",
- "type": "array"
- },
- "reviewer_hash": {
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ],
- "default": null,
- "description": "Optional reviewer hash.",
- "title": "Reviewer Hash"
- },
- "status": {
- "default": "pending",
- "description": "Declared public condition status.",
- "enum": [
- "pending",
- "satisfied",
- "rejected",
- "waived",
- "needs_review"
- ],
- "title": "Status",
- "type": "string"
- },
- "waiver_hash": {
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ],
- "default": null,
- "description": "Optional waiver hash.",
- "title": "Waiver Hash"
- }
- },
- "required": [
- "condition_id",
- "condition_type",
- "condition_hash"
- ],
- "title": "LenderConditionEvidenceInput",
- "type": "object"
- }
-}Input schema / properties / condition / $refRemoved value: -"#/$defs/LenderConditionEvidenceInput"Input schema / properties / condition / propertiesAdded value: +{
+ "condition_hash": {
+ "type": "string"
+ },
+ "condition_id": {
+ "type": "string"
+ },
+ "condition_type": {
+ "type": "string"
+ },
+ "evidence_hashes": {
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+ },
+ "non_secret_refs": {
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+ },
+ "reviewer_hash": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "status": {
+ "enum": [
+ "pending",
+ "satisfied",
+ "rejected",
+ "waived",
+ "needs_review"
+ ],
+ "type": "string"
+ },
+ "waiver_hash": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ }
+}Input schema / properties / condition / requiredAdded value: +[
+ "condition_id",
+ "condition_type",
+ "condition_hash"
+]Input schema / properties / condition / typeAdded value: +"object"Input schema / titleRemoved value: -"map_lender_condition_evidenceArguments"proofrelay.map_openapi_operation_evidence6 fields changedInput schema / $defsRemoved value: -{
- "OpenAPIOperationEvidenceInput": {
- "description": "Public OpenAPI operation metadata mapped to ProofRelay evidence.",
- "properties": {
- "idempotency_required": {
- "default": false,
- "description": "True if the operation should require idempotency.",
- "title": "Idempotency Required",
- "type": "boolean"
- },
- "method": {
- "description": "HTTP method for the operation.",
- "enum": [
- "GET",
- "POST",
- "PUT",
- "PATCH",
- "DELETE"
- ],
- "title": "Method",
- "type": "string"
- },
- "operation_id": {
- "description": "OpenAPI operationId or stable id.",
- "title": "Operation Id",
- "type": "string"
- },
- "path_template": {
- "description": "Public path template, no secrets.",
- "title": "Path Template",
- "type": "string"
- },
- "payment_required": {
- "default": false,
- "description": "True if operation requires payment or entitlement.",
- "title": "Payment Required",
- "type": "boolean"
- },
- "request_schema_hash": {
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ],
- "default": null,
- "description": "Optional SHA-256 hash of the request schema.",
- "title": "Request Schema Hash"
- },
- "response_schema_hash": {
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ],
- "default": null,
- "description": "Optional SHA-256 hash of the response schema.",
- "title": "Response Schema Hash"
- },
- "security_scheme_refs": {
- "description": "Non-secret names of OpenAPI security schemes used.",
- "items": {
- "type": "string"
- },
- "title": "Security Scheme Refs",
- "type": "array"
- },
- "server_url_hash": {
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ],
- "default": null,
- "description": "Optional SHA-256 hash of the server URL.",
- "title": "Server Url Hash"
- }
- },
- "required": [
- "operation_id",
- "method",
- "path_template"
- ],
- "title": "OpenAPIOperationEvidenceInput",
- "type": "object"
- }
-}Input schema / properties / operation / $refRemoved value: -"#/$defs/OpenAPIOperationEvidenceInput"Input schema / properties / operation / propertiesAdded value: +{
+ "idempotency_required": {
+ "type": "boolean"
+ },
+ "method": {
+ "enum": [
+ "GET",
+ "POST",
+ "PUT",
+ "PATCH",
+ "DELETE"
+ ],
+ "type": "string"
+ },
+ "operation_id": {
+ "type": "string"
+ },
+ "path_template": {
+ "type": "string"
+ },
+ "payment_required": {
+ "type": "boolean"
+ },
+ "request_schema_hash": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "response_schema_hash": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "security_scheme_refs": {
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+ },
+ "server_url_hash": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ }
+}Input schema / properties / operation / requiredAdded value: +[
+ "operation_id",
+ "method",
+ "path_template"
+]Input schema / properties / operation / typeAdded value: +"object"Input schema / titleRemoved value: -"map_openapi_operation_evidenceArguments"proofrelay.normalize_payment_proof6 fields changedInput schema / $defsRemoved value: -{
- "PaymentProofEnvelopeInput": {
- "description": "Rail-agnostic payment proof hashes for a ProofRelay evidence profile.",
- "properties": {
- "amount": {
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ],
- "default": null,
- "description": "Public-safe amount label, if known.",
- "title": "Amount"
- },
- "challenge_or_session_hash": {
- "description": "SHA-256 hash of the challenge, checkout session, or quote.",
- "title": "Challenge Or Session Hash",
- "type": "string"
- },
- "currency": {
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ],
- "default": null,
- "description": "Currency or unit, if known.",
- "title": "Currency"
- },
- "expires_at": {
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ],
- "default": null,
- "description": "Optional ISO-8601 expiry time.",
- "title": "Expires At"
- },
- "non_secret_refs": {
- "description": "Non-secret references such as hashed event IDs or endpoint names.",
- "items": {
- "type": "string"
- },
- "title": "Non Secret Refs",
- "type": "array"
- },
- "payment_proof_or_charge_hash": {
- "description": "SHA-256 hash of the payment proof, charge, or facilitator result.",
- "title": "Payment Proof Or Charge Hash",
- "type": "string"
- },
- "protocol": {
- "description": "Public-safe protocol name for the paid action lifecycle.",
- "examples": [
- "stripe_checkout_session_webhook"
- ],
- "title": "Protocol",
- "type": "string"
- },
- "provider": {
- "description": "Payment rail or entitlement provider, for example stripe or x402.",
- "examples": [
- "stripe_agentic_commerce"
- ],
- "title": "Provider",
- "type": "string"
- },
- "replay_key": {
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ],
- "default": null,
- "description": "Public-safe replay key or hash.",
- "title": "Replay Key"
- },
- "request_hash": {
- "description": "SHA-256 hash of the request.",
- "title": "Request Hash",
- "type": "string"
- },
- "response_hash": {
- "description": "SHA-256 hash of the delivered resource or service response.",
- "title": "Response Hash",
- "type": "string"
- },
- "settlement_or_entitlement_hash": {
- "description": "SHA-256 hash of the settlement, receipt, or entitlement token.",
- "title": "Settlement Or Entitlement Hash",
- "type": "string"
- }
- },
- "required": [
- "provider",
- "protocol",
- "request_hash",
- "challenge_or_session_hash",
- "payment_proof_or_charge_hash",
- "settlement_or_entitlement_hash",
- "response_hash"
- ],
- "title": "PaymentProofEnvelopeInput",
- "type": "object"
- }
-}Input schema / properties / payment_proof / $refRemoved value: -"#/$defs/PaymentProofEnvelopeInput"Input schema / properties / payment_proof / propertiesAdded value: +{
+ "amount": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "challenge_or_session_hash": {
+ "type": "string"
+ },
+ "currency": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "expires_at": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "non_secret_refs": {
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+ },
+ "payment_proof_or_charge_hash": {
+ "type": "string"
+ },
+ "protocol": {
+ "type": "string"
+ },
+ "provider": {
+ "type": "string"
+ },
+ "replay_key": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "request_hash": {
+ "type": "string"
+ },
+ "response_hash": {
+ "type": "string"
+ },
+ "settlement_or_entitlement_hash": {
+ "type": "string"
+ }
+}Input schema / properties / payment_proof / requiredAdded value: +[
+ "provider",
+ "protocol",
+ "request_hash",
+ "challenge_or_session_hash",
+ "payment_proof_or_charge_hash",
+ "settlement_or_entitlement_hash",
+ "response_hash"
+]Input schema / properties / payment_proof / typeAdded value: +"object"Input schema / titleRemoved value: -"normalize_payment_proofArguments"proofrelay.plan_replay_rejection_test6 fields changedInput schema / $defsRemoved value: -{
- "ReplayObservation": {
- "description": "Optional observed first/replay responses for replay-test classification.",
- "properties": {
- "first_error": {
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ],
- "default": null,
- "description": "Error code from first redemption.",
- "title": "First Error"
- },
- "first_status": {
- "anyOf": [
- {
- "type": "integer"
- },
- {
- "type": "null"
- }
- ],
- "default": null,
- "description": "HTTP status of first redemption.",
- "title": "First Status"
- },
- "second_error": {
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ],
- "default": null,
- "description": "Error code from replay attempt.",
- "title": "Second Error"
- },
- "second_status": {
- "anyOf": [
- {
- "type": "integer"
- },
- {
- "type": "null"
- }
- ],
- "default": null,
- "description": "HTTP status of replay attempt.",
- "title": "Second Status"
- }
- },
- "title": "ReplayObservation",
- "type": "object"
- },
- "ReplayTestInput": {
- "description": "Replay rejection test target and optional observed responses.",
- "properties": {
- "bundle_hash": {
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ],
- "default": null,
- "description": "Bundle hash used in redemption.",
- "title": "Bundle Hash"
- },
- "entitlement_hash": {
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ],
- "default": null,
- "description": "Public-safe entitlement hash; never pass bearer tokens.",
- "title": "Entitlement Hash"
- },
- "observed": {
- "anyOf": [
- {
- "$ref": "#/$defs/ReplayObservation"
- },
- {
- "type": "null"
- }
- ],
- "default": null,
- "description": "Optional observed first and replay responses to classify."
- },
- "payment_protocol": {
- "default": "stripe_checkout_entitlement",
- "description": "Payment protocol whose replay behavior should be tested.",
- "enum": [
- "stripe_checkout_entitlement",
- "x402",
- "other"
- ],
- "title": "Payment Protocol",
- "type": "string"
- },
- "redeem_url": {
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ],
- "default": null,
- "description": "Paid verification endpoint.",
- "title": "Redeem Url"
- }
- },
- "title": "ReplayTestInput",
- "type": "object"
- }
-}Input schema / properties / replay_test / $defsAdded value: +{
+ "ReplayObservation": {
+ "properties": {
+ "first_error": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "first_status": {
+ "anyOf": [
+ {
+ "type": "integer"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "second_error": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "second_status": {
+ "anyOf": [
+ {
+ "type": "integer"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ }
+ },
+ "type": "object"
+ }
+}Input schema / properties / replay_test / $refRemoved value: -"#/$defs/ReplayTestInput"Input schema / properties / replay_test / propertiesAdded value: +{
+ "bundle_hash": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "entitlement_hash": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "observed": {
+ "anyOf": [
+ {
+ "$ref": "#/$defs/ReplayObservation"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "payment_protocol": {
+ "enum": [
+ "stripe_checkout_entitlement",
+ "x402",
+ "other"
+ ],
+ "type": "string"
+ },
+ "redeem_url": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ }
+}Input schema / properties / replay_test / typeAdded value: +"object"Input schema / titleRemoved value: -"plan_replay_rejection_testArguments"proofrelay.recommend_checkpoint6 fields changedInput schema / $defsRemoved value: -{
- "WorkflowContext": {
- "description": "Public-safe workflow context for checkpoint recommendation.",
- "properties": {
- "action_class": {
- "description": "Public-safe action category, such as paid_api_call, paid_mcp_call, material_action, artifact_delivery, or counterparty_handoff.",
- "examples": [
- "paid_mcp_call"
- ],
- "title": "Action Class",
- "type": "string"
- },
- "action_receipt_present": {
- "default": false,
- "description": "True when a portable agent action receipt already exists.",
- "title": "Action Receipt Present",
- "type": "boolean"
- },
- "artifact_delivery_expected": {
- "default": false,
- "description": "True when the workflow delivers an artifact to another party.",
- "title": "Artifact Delivery Expected",
- "type": "boolean"
- },
- "authority_envelope_present": {
- "description": "True when agent authority, policy, scope, limits, and TTL are recorded.",
- "title": "Authority Envelope Present",
- "type": "boolean"
- },
- "counterparty_reliance_expected": {
- "description": "True when another party is expected to rely on the result.",
- "title": "Counterparty Reliance Expected",
- "type": "boolean"
- },
- "dispute_or_audit_plausible": {
- "description": "True when refund, SLA, audit, or dispute replay may be needed.",
- "title": "Dispute Or Audit Plausible",
- "type": "boolean"
- },
- "dispute_replay_present": {
- "default": false,
- "description": "True when a replay package for audit or dispute already exists.",
- "title": "Dispute Replay Present",
- "type": "boolean"
- },
- "evidence_bundle_present": {
- "description": "True when a non-confidential evidence bundle is available.",
- "title": "Evidence Bundle Present",
- "type": "boolean"
- },
- "payment_context_present": {
- "description": "True when the workflow has a payment, entitlement, or charge context.",
- "title": "Payment Context Present",
- "type": "boolean"
- },
- "receiver_acknowledgement_present": {
- "default": false,
- "description": "True when the receiving party has accepted, replayed, or rejected.",
- "title": "Receiver Acknowledgement Present",
- "type": "boolean"
- },
- "reliance_tier": {
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ],
- "default": null,
- "description": "Optional reliance tier: low, standard, high, regulated, or critical.",
- "examples": [
- "high"
- ],
- "title": "Reliance Tier"
- },
- "verification_result_present": {
- "default": false,
- "description": "True when a prior verifier result is already available.",
- "title": "Verification Result Present",
- "type": "boolean"
- }
- },
- "required": [
- "action_class",
- "payment_context_present",
- "authority_envelope_present",
- "evidence_bundle_present",
- "counterparty_reliance_expected",
- "dispute_or_audit_plausible"
- ],
- "title": "WorkflowContext",
- "type": "object"
- }
-}Input schema / properties / workflow_context / $refRemoved value: -"#/$defs/WorkflowContext"Input schema / properties / workflow_context / propertiesAdded value: +{
+ "action_class": {
+ "type": "string"
+ },
+ "action_receipt_present": {
+ "type": "boolean"
+ },
+ "artifact_delivery_expected": {
+ "type": "boolean"
+ },
+ "authority_envelope_present": {
+ "type": "boolean"
+ },
+ "counterparty_reliance_expected": {
+ "type": "boolean"
+ },
+ "dispute_or_audit_plausible": {
+ "type": "boolean"
+ },
+ "dispute_replay_present": {
+ "type": "boolean"
+ },
+ "evidence_bundle_present": {
+ "type": "boolean"
+ },
+ "payment_context_present": {
+ "type": "boolean"
+ },
+ "receiver_acknowledgement_present": {
+ "type": "boolean"
+ },
+ "reliance_tier": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "verification_result_present": {
+ "type": "boolean"
+ }
+}Input schema / properties / workflow_context / requiredAdded value: +[
+ "action_class",
+ "payment_context_present",
+ "authority_envelope_present",
+ "evidence_bundle_present",
+ "counterparty_reliance_expected",
+ "dispute_or_audit_plausible"
+]Input schema / properties / workflow_context / typeAdded value: +"object"Input schema / titleRemoved value: -"recommend_checkpointArguments"proofrelay.review_vendor_risk_profile6 fields changedInput schema / $defsRemoved value: -{
- "VendorRiskProfileInput": {
- "description": "Public vendor risk profile metadata for review guidance.",
- "properties": {
- "control_refs": {
- "description": "Public-safe control references.",
- "items": {
- "type": "string"
- },
- "title": "Control Refs",
- "type": "array"
- },
- "data_boundary": {
- "default": "unknown",
- "description": "Highest declared data boundary.",
- "enum": [
- "none",
- "metadata",
- "pii",
- "unknown"
- ],
- "title": "Data Boundary",
- "type": "string"
- },
- "prior_incident_hash": {
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ],
- "default": null,
- "description": "Optional prior-incident disclosure hash.",
- "title": "Prior Incident Hash"
- },
- "requires_authentication": {
- "default": false,
- "description": "Auth is required.",
- "title": "Requires Authentication",
- "type": "boolean"
- },
- "requires_payment": {
- "default": false,
- "description": "Payment is required.",
- "title": "Requires Payment",
- "type": "boolean"
- },
- "security_docs_hash": {
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ],
- "default": null,
- "description": "Optional security documentation hash.",
- "title": "Security Docs Hash"
- },
- "stores_customer_data": {
- "default": false,
- "description": "Stores customer data.",
- "title": "Stores Customer Data",
- "type": "boolean"
- },
- "subprocessors_hash": {
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ],
- "default": null,
- "description": "Optional subprocessors disclosure hash.",
- "title": "Subprocessors Hash"
- },
- "terms_hash": {
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ],
- "default": null,
- "description": "Optional terms hash.",
- "title": "Terms Hash"
- },
- "vendor_name": {
- "description": "Public vendor or MCP server name.",
- "title": "Vendor Name",
- "type": "string"
- },
- "vendor_profile_hash": {
- "description": "SHA-256 vendor profile hash.",
- "title": "Vendor Profile Hash",
- "type": "string"
- }
- },
- "required": [
- "vendor_name",
- "vendor_profile_hash"
- ],
- "title": "VendorRiskProfileInput",
- "type": "object"
- }
-}Input schema / properties / vendor / $refRemoved value: -"#/$defs/VendorRiskProfileInput"Input schema / properties / vendor / propertiesAdded value: +{
+ "control_refs": {
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+ },
+ "data_boundary": {
+ "enum": [
+ "none",
+ "metadata",
+ "pii",
+ "unknown"
+ ],
+ "type": "string"
+ },
+ "prior_incident_hash": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "requires_authentication": {
+ "type": "boolean"
+ },
+ "requires_payment": {
+ "type": "boolean"
+ },
+ "security_docs_hash": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "stores_customer_data": {
+ "type": "boolean"
+ },
+ "subprocessors_hash": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "terms_hash": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "vendor_name": {
+ "type": "string"
+ },
+ "vendor_profile_hash": {
+ "type": "string"
+ }
+}Input schema / properties / vendor / requiredAdded value: +[
+ "vendor_name",
+ "vendor_profile_hash"
+]Input schema / properties / vendor / typeAdded value: +"object"Input schema / titleRemoved value: -"review_vendor_risk_profileArguments"proofrelay.review_wire_payoff_change6 fields changedInput schema / $defsRemoved value: -{
- "WirePayoffChangeInput": {
- "description": "Hash-only wire or payoff change evidence input.",
- "properties": {
- "approval_hashes": {
- "description": "Approval or escalation hashes.",
- "items": {
- "type": "string"
- },
- "title": "Approval Hashes",
- "type": "array"
- },
- "callback_evidence_hash": {
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ],
- "default": null,
- "description": "Optional callback or out-of-band verification hash.",
- "title": "Callback Evidence Hash"
- },
- "change_request_hash": {
- "description": "SHA-256 change request hash.",
- "title": "Change Request Hash",
- "type": "string"
- },
- "change_type": {
- "description": "Change category under review.",
- "enum": [
- "wire_instruction",
- "payoff_statement",
- "disbursement_instruction",
- "other"
- ],
- "title": "Change Type",
- "type": "string"
- },
- "new_instruction_hash": {
- "description": "SHA-256 new instruction hash.",
- "title": "New Instruction Hash",
- "type": "string"
- },
- "observed_red_flags": {
- "description": "Public-safe red flag reason codes.",
- "items": {
- "type": "string"
- },
- "title": "Observed Red Flags",
- "type": "array"
- },
- "original_instruction_hash": {
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ],
- "default": null,
- "description": "Optional original instruction hash.",
- "title": "Original Instruction Hash"
- },
- "payoff_statement_hash": {
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ],
- "default": null,
- "description": "Optional payoff statement hash.",
- "title": "Payoff Statement Hash"
- },
- "requester_hash": {
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ],
- "default": null,
- "description": "Optional requester hash.",
- "title": "Requester Hash"
- }
- },
- "required": [
- "change_type",
- "change_request_hash",
- "new_instruction_hash"
- ],
- "title": "WirePayoffChangeInput",
- "type": "object"
- }
-}Input schema / properties / wire_change / $refRemoved value: -"#/$defs/WirePayoffChangeInput"Input schema / properties / wire_change / propertiesAdded value: +{
+ "approval_hashes": {
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+ },
+ "callback_evidence_hash": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "change_request_hash": {
+ "type": "string"
+ },
+ "change_type": {
+ "enum": [
+ "wire_instruction",
+ "payoff_statement",
+ "disbursement_instruction",
+ "other"
+ ],
+ "type": "string"
+ },
+ "new_instruction_hash": {
+ "type": "string"
+ },
+ "observed_red_flags": {
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+ },
+ "original_instruction_hash": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "payoff_statement_hash": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "requester_hash": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ }
+}Input schema / properties / wire_change / requiredAdded value: +[
+ "change_type",
+ "change_request_hash",
+ "new_instruction_hash"
+]Input schema / properties / wire_change / typeAdded value: +"object"Input schema / titleRemoved value: -"review_wire_payoff_changeArguments"proofrelay.scan_mcp_risk5 fields changedInput schema / $defsRemoved value: -{
- "MCPRiskScanInput": {
- "description": "Public MCP descriptor or tool metadata for lightweight risk scanning.",
- "properties": {
- "declared_read_only": {
- "default": false,
- "description": "Whether the server claims read-only behavior.",
- "title": "Declared Read Only",
- "type": "boolean"
- },
- "payment_or_entitlement_required": {
- "default": false,
- "description": "Whether paid access is expected.",
- "title": "Payment Or Entitlement Required",
- "type": "boolean"
- },
- "requires_authentication": {
- "default": false,
- "description": "Whether the server requires user authentication.",
- "title": "Requires Authentication",
- "type": "boolean"
- },
- "server_name": {
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ],
- "default": null,
- "description": "Public MCP server name.",
- "title": "Server Name"
- },
- "tools": {
- "description": "Public tool descriptors, schemas, and descriptions only.",
- "items": {
- "additionalProperties": true,
- "type": "object"
- },
- "title": "Tools",
- "type": "array"
- }
- },
- "title": "MCPRiskScanInput",
- "type": "object"
- }
-}Input schema / properties / risk_scan / $refRemoved value: -"#/$defs/MCPRiskScanInput"Input schema / properties / risk_scan / propertiesAdded value: +{
+ "declared_read_only": {
+ "type": "boolean"
+ },
+ "payment_or_entitlement_required": {
+ "type": "boolean"
+ },
+ "requires_authentication": {
+ "type": "boolean"
+ },
+ "server_name": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "tools": {
+ "items": {
+ "additionalProperties": true,
+ "type": "object"
+ },
+ "type": "array"
+ }
+}Input schema / properties / risk_scan / typeAdded value: +"object"Input schema / titleRemoved value: -"scan_mcp_riskArguments"proofrelay.summarize_agent_action_log6 fields changedInput schema / $defsRemoved value: -{
- "AgentActionLogSummaryInput": {
- "description": "Hash-only agent action log summary input.",
- "properties": {
- "action_count": {
- "description": "Number of actions summarized.",
- "minimum": 0,
- "title": "Action Count",
- "type": "integer"
- },
- "action_type_counts": {
- "additionalProperties": {
- "type": "integer"
- },
- "description": "Public action type counts.",
- "title": "Action Type Counts",
- "type": "object"
- },
- "actor_hash": {
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ],
- "default": null,
- "description": "Optional actor hash.",
- "title": "Actor Hash"
- },
- "authority_hash": {
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ],
- "default": null,
- "description": "Optional authority hash.",
- "title": "Authority Hash"
- },
- "error_count": {
- "default": 0,
- "description": "Number of failed actions.",
- "minimum": 0,
- "title": "Error Count",
- "type": "integer"
- },
- "first_ts_ms": {
- "anyOf": [
- {
- "type": "integer"
- },
- {
- "type": "null"
- }
- ],
- "default": null,
- "description": "First action timestamp.",
- "title": "First Ts Ms"
- },
- "last_ts_ms": {
- "anyOf": [
- {
- "type": "integer"
- },
- {
- "type": "null"
- }
- ],
- "default": null,
- "description": "Last action timestamp.",
- "title": "Last Ts Ms"
- },
- "log_hash": {
- "description": "SHA-256 hash of the action log.",
- "title": "Log Hash",
- "type": "string"
- },
- "payment_context_hash": {
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ],
- "default": null,
- "description": "Optional payment context hash.",
- "title": "Payment Context Hash"
- },
- "session_hash": {
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ],
- "default": null,
- "description": "Optional session hash.",
- "title": "Session Hash"
- }
- },
- "required": [
- "log_hash",
- "action_count"
- ],
- "title": "AgentActionLogSummaryInput",
- "type": "object"
- }
-}Input schema / properties / action_log / $refRemoved value: -"#/$defs/AgentActionLogSummaryInput"Input schema / properties / action_log / propertiesAdded value: +{
+ "action_count": {
+ "minimum": 0,
+ "type": "integer"
+ },
+ "action_type_counts": {
+ "additionalProperties": {
+ "type": "integer"
+ },
+ "type": "object"
+ },
+ "actor_hash": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "authority_hash": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "error_count": {
+ "minimum": 0,
+ "type": "integer"
+ },
+ "first_ts_ms": {
+ "anyOf": [
+ {
+ "type": "integer"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "last_ts_ms": {
+ "anyOf": [
+ {
+ "type": "integer"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "log_hash": {
+ "type": "string"
+ },
+ "payment_context_hash": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "session_hash": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ }
+}Input schema / properties / action_log / requiredAdded value: +[
+ "log_hash",
+ "action_count"
+]Input schema / properties / action_log / typeAdded value: +"object"Input schema / titleRemoved value: -"summarize_agent_action_logArguments"proofrelay.verify_bundle19 fields changedInput schema / $defsRemoved value: -{
- "Bundle": {
- "description": "Non-confidential ProofRelay evidence bundle submitted for verification.",
- "properties": {
- "bundle_hash": {
- "description": "Hash commitment for the bundle.",
- "title": "Bundle Hash",
- "type": "string"
- },
- "count": {
- "description": "Number of receipt events in the bundle.",
- "title": "Count",
- "type": "integer"
- },
- "created_ts_ms": {
- "description": "Bundle creation timestamp in Unix milliseconds.",
- "title": "Created Ts Ms",
- "type": "integer"
- },
- "events": {
- "description": "Receipt events whose hashes and ordering are verified.",
- "items": {
- "$ref": "#/$defs/ReceiptEvent"
- },
- "title": "Events",
- "type": "array"
- },
- "receipt_ids": {
- "description": "Receipt identifiers included in deterministic order.",
- "items": {
- "type": "string"
- },
- "title": "Receipt Ids",
- "type": "array"
- },
- "service": {
- "description": "Service represented by the bundle.",
- "title": "Service",
- "type": "string"
- },
- "v": {
- "default": 1,
- "description": "Evidence bundle schema version.",
- "title": "V",
- "type": "integer"
- }
- },
- "required": [
- "bundle_hash",
- "created_ts_ms",
- "service",
- "count",
- "receipt_ids",
- "events"
- ],
- "title": "Bundle",
- "type": "object"
- },
- "EvidenceBundleV2": {
- "additionalProperties": false,
- "properties": {
- "bundle_hash": {
- "pattern": "^sha256:[0-9a-f]{64}$",
- "title": "Bundle Hash",
- "type": "string"
- },
- "canonicalization": {
- "const": "RFC8785-JCS",
- "default": "RFC8785-JCS",
- "title": "Canonicalization",
- "type": "string"
- },
- "created_at_ms": {
- "maximum": 9223372036854776000,
- "minimum": 0,
- "title": "Created At Ms",
- "type": "integer"
- },
- "event_count": {
- "maximum": 10000,
- "minimum": 1,
- "title": "Event Count",
- "type": "integer"
- },
- "events": {
- "items": {
- "$ref": "#/$defs/EvidenceEventV2"
- },
- "maxItems": 10000,
- "minItems": 1,
- "title": "Events",
- "type": "array"
- },
- "hash_algorithm": {
- "const": "SHA-256",
- "default": "SHA-256",
- "title": "Hash Algorithm",
- "type": "string"
- },
- "schema": {
- "const": "io.genesisre.proofrelay.evidence-bundle.v2",
- "default": "io.genesisre.proofrelay.evidence-bundle.v2",
- "title": "Schema",
- "type": "string"
- },
- "sequence_end": {
- "minimum": 1,
- "title": "Sequence End",
- "type": "integer"
- },
- "sequence_start": {
- "minimum": 1,
- "title": "Sequence Start",
- "type": "integer"
- },
- "service_id": {
- "maxLength": 128,
- "minLength": 1,
- "pattern": "^[a-z0-9](?:[a-z0-9._:-]*[a-z0-9])?$",
- "title": "Service Id",
- "type": "string"
- },
- "tenant_id": {
- "maxLength": 128,
- "minLength": 1,
- "pattern": "^[a-z0-9](?:[a-z0-9._:-]*[a-z0-9])?$",
- "title": "Tenant Id",
- "type": "string"
- }
- },
- "required": [
- "tenant_id",
- "service_id",
- "created_at_ms",
- "sequence_start",
- "sequence_end",
- "event_count",
- "events",
- "bundle_hash"
- ],
- "title": "EvidenceBundleV2",
- "type": "object"
- },
- "EvidenceEventV2": {
- "additionalProperties": false,
- "properties": {
- "canonicalization": {
- "const": "RFC8785-JCS",
- "default": "RFC8785-JCS",
- "title": "Canonicalization",
- "type": "string"
- },
- "event_hash": {
- "pattern": "^sha256:[0-9a-f]{64}$",
- "title": "Event Hash",
- "type": "string"
- },
- "event_id": {
- "maxLength": 128,
- "minLength": 1,
- "pattern": "^[a-z0-9](?:[a-z0-9._:-]*[a-z0-9])?$",
- "title": "Event Id",
- "type": "string"
- },
- "event_type": {
- "maxLength": 128,
- "minLength": 1,
- "pattern": "^[a-z0-9](?:[a-z0-9._:-]*[a-z0-9])?$",
- "title": "Event Type",
- "type": "string"
- },
- "evidence": {
- "maxProperties": 64,
- "minProperties": 1,
- "patternProperties": {
- "^[a-z][a-z0-9_]*$": {
- "pattern": "^sha256:[0-9a-f]{64}$",
- "type": "string"
- }
- },
- "propertyNames": {
- "maxLength": 64,
- "minLength": 1
- },
- "title": "Evidence",
- "type": "object"
- },
- "hash_algorithm": {
- "const": "SHA-256",
- "default": "SHA-256",
- "title": "Hash Algorithm",
- "type": "string"
- },
- "occurred_at_ms": {
- "maximum": 9223372036854776000,
- "minimum": 0,
- "title": "Occurred At Ms",
- "type": "integer"
- },
- "policy_digest": {
- "anyOf": [
- {
- "pattern": "^sha256:[0-9a-f]{64}$",
- "type": "string"
- },
- {
- "type": "null"
- }
- ],
- "default": null,
- "title": "Policy Digest"
- },
- "previous_event_hash": {
- "anyOf": [
- {
- "pattern": "^sha256:[0-9a-f]{64}$",
- "type": "string"
- },
- {
- "type": "null"
- }
- ],
- "default": null,
- "title": "Previous Event Hash"
- },
- "producer_signature": {
- "$ref": "#/$defs/ProducerSignatureV1"
- },
- "schema": {
- "const": "io.genesisre.proofrelay.evidence-event.v2",
- "default": "io.genesisre.proofrelay.evidence-event.v2",
- "title": "Schema",
- "type": "string"
- },
- "sequence": {
- "maximum": 9223372036854776000,
- "minimum": 1,
- "title": "Sequence",
- "type": "integer"
- },
- "service_id": {
- "maxLength": 128,
- "minLength": 1,
- "pattern": "^[a-z0-9](?:[a-z0-9._:-]*[a-z0-9])?$",
- "title": "Service Id",
- "type": "string"
- },
- "tenant_id": {
- "maxLength": 128,
- "minLength": 1,
- "pattern": "^[a-z0-9](?:[a-z0-9._:-]*[a-z0-9])?$",
- "title": "Tenant Id",
- "type": "string"
- }
- },
- "required": [
- "event_id",
- "tenant_id",
- "service_id",
- "sequence",
- "occurred_at_ms",
- "event_type",
- "evidence",
- "event_hash",
- "producer_signature"
- ],
- "title": "EvidenceEventV2",
- "type": "object"
- },
- "ProducerSignatureV1": {
- "additionalProperties": false,
- "properties": {
- "algorithm": {
- "enum": [
- "Ed25519",
- "ES256"
- ],
- "title": "Algorithm",
- "type": "string"
- },
- "key_id": {
- "maxLength": 128,
- "minLength": 1,
- "pattern": "^[a-z0-9](?:[a-z0-9._:-]*[a-z0-9])?$",
- "title": "Key Id",
- "type": "string"
- },
- "schema": {
- "const": "io.genesisre.proofrelay.producer-signature.v1",
- "default": "io.genesisre.proofrelay.producer-signature.v1",
- "title": "Schema",
- "type": "string"
- },
- "signature": {
- "maxLength": 256,
- "minLength": 43,
- "pattern": "^[A-Za-z0-9_-]+$",
- "title": "Signature",
- "type": "string"
- }
- },
- "required": [
- "algorithm",
- "key_id",
- "signature"
- ],
- "title": "ProducerSignatureV1",
- "type": "object"
- },
- "PublicVerificationKeyInput": {
- "description": "Caller-supplied public producer key for stateless V2 verification.",
- "properties": {
- "jwk": {
- "additionalProperties": true,
- "title": "Jwk",
- "type": "object"
- },
- "key_id": {
- "maxLength": 128,
- "minLength": 1,
- "title": "Key Id",
- "type": "string"
- },
- "service_id": {
- "maxLength": 128,
- "minLength": 1,
- "title": "Service Id",
- "type": "string"
- },
- "tenant_id": {
- "maxLength": 128,
- "minLength": 1,
- "title": "Tenant Id",
- "type": "string"
- }
- },
- "required": [
- "tenant_id",
- "service_id",
- "key_id",
- "jwk"
- ],
- "title": "PublicVerificationKeyInput",
- "type": "object"
- },
- "ReceiptEvent": {
- "description": "Non-confidential receipt event included in a ProofRelay bundle.",
- "properties": {
- "event_hash": {
- "description": "Hash commitment for this event.",
- "title": "Event Hash",
- "type": "string"
- },
- "event_type": {
- "description": "Public-safe event category.",
- "title": "Event Type",
- "type": "string"
- },
- "payload": {
- "additionalProperties": true,
- "description": "Minimized metadata and hashes only; never include secrets.",
- "title": "Payload",
- "type": "object"
- },
- "policy_digest": {
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ],
- "default": null,
- "description": "Hash or digest of the policy context, when available.",
- "title": "Policy Digest"
- },
- "prev_hash": {
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ],
- "default": null,
- "description": "Previous event hash for hash-chain continuity.",
- "title": "Prev Hash"
- },
- "receipt_id": {
- "description": "Stable receipt identifier.",
- "title": "Receipt Id",
- "type": "string"
- },
- "service": {
- "description": "Service or agent that emitted the event.",
- "title": "Service",
- "type": "string"
- },
- "sig": {
- "anyOf": [
- {
- "$ref": "#/$defs/ReceiptSignature"
- },
- {
- "type": "null"
- }
- ],
- "default": null,
- "description": "Optional event signature envelope."
- },
- "ts_ms": {
- "description": "Event timestamp in Unix milliseconds.",
- "title": "Ts Ms",
- "type": "integer"
- },
- "v": {
- "default": 1,
- "description": "Receipt schema version.",
- "title": "V",
- "type": "integer"
- }
- },
- "required": [
- "receipt_id",
- "ts_ms",
- "service",
- "event_type",
- "event_hash"
- ],
- "title": "ReceiptEvent",
- "type": "object"
- },
- "ReceiptSignature": {
- "description": "Signature envelope for a non-confidential ProofRelay receipt event.",
- "properties": {
- "alg": {
- "description": "Signature algorithm used for the event signature.",
- "examples": [
- "HMAC-SHA256"
- ],
- "title": "Alg",
- "type": "string"
- },
- "key_id": {
- "description": "Public-safe key identifier used by the verifier.",
- "examples": [
- "hmac:default"
- ],
- "title": "Key Id",
- "type": "string"
- },
- "sig": {
- "description": "Hex-encoded event signature.",
- "title": "Sig",
- "type": "string"
- }
- },
- "required": [
- "alg",
- "key_id",
- "sig"
- ],
- "title": "ReceiptSignature",
- "type": "object"
- }
-}Input schema / properties / bundle / anyOfRemoved value: -[
- {
- "$ref": "#/$defs/Bundle"
- },
- {
- "$ref": "#/$defs/EvidenceBundleV2"
- }
-]Input schema / properties / bundle / oneOfAdded value: +[
+ {
+ "$defs": {
+ "ReceiptEvent": {
+ "properties": {
+ "event_hash": {
+ "type": "string"
+ },
+ "event_type": {
+ "type": "string"
+ },
+ "payload": {
+ "additionalProperties": true,
+ "type": "object"
+ },
+ "policy_digest": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "prev_hash": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "receipt_id": {
+ "type": "string"
+ },
+ "service": {
+ "type": "string"
+ },
+ "sig": {
+ "anyOf": [
+ {
+ "$ref": "#/$defs/ReceiptSignature"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "ts_ms": {
+ "type": "integer"
+ },
+ "v": {
+ "type": "integer"
+ }
+ },
+ "required": [
+ "receipt_id",
+ "ts_ms",
+ "service",
+ "event_type",
+ "event_hash"
+ ],
+ "type": "object"
+ },
+ "ReceiptSignature": {
+ "properties": {
+ "alg": {
+ "type": "string"
+ },
+ "key_id": {
+ "type": "string"
+ },
+ "sig": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "alg",
+ "key_id",
+ "sig"
+ ],
+ "type": "object"
+ }
+ },
+ "properties": {
+ "bundle_hash": {
+ "type": "string"
+ },
+ "count": {
+ "type": "integer"
+ },
+ "created_ts_ms": {
+ "type": "integer"
+ },
+ "events": {
+ "items": {
+ "$ref": "#/$defs/ReceiptEvent"
+ },
+ "type": "array"
+ },
+ "receipt_ids": {
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+ },
+ "service": {
+ "type": "string"
+ },
+ "v": {
+ "type": "integer"
+ }
+ },
+ "required": [
+ "bundle_hash",
+ "created_ts_ms",
+ "service",
+ "count",
+ "receipt_ids",
+ "events"
+ ],
+ "type": "object"
+ },
+ {
+ "$defs": {
+ "EvidenceEventV2": {
+ "additionalProperties": false,
+ "properties": {
+ "canonicalization": {
+ "const": "RFC8785-JCS",
+ "type": "string"
+ },
+ "event_hash": {
+ "pattern": "^sha256:[0-9a-f]{64}$",
+ "type": "string"
+ },
+ "event_id": {
+ "maxLength": 128,
+ "minLength": 1,
+ "pattern": "^[a-z0-9](?:[a-z0-9._:-]*[a-z0-9])?$",
+ "type": "string"
+ },
+ "event_type": {
+ "maxLength": 128,
+ "minLength": 1,
+ "pattern": "^[a-z0-9](?:[a-z0-9._:-]*[a-z0-9])?$",
+ "type": "string"
+ },
+ "evidence": {
+ "maxProperties": 64,
+ "minProperties": 1,
+ "patternProperties": {
+ "^[a-z][a-z0-9_]*$": {
+ "pattern": "^sha256:[0-9a-f]{64}$",
+ "type": "string"
+ }
+ },
+ "propertyNames": {
+ "maxLength": 64,
+ "minLength": 1
+ },
+ "type": "object"
+ },
+ "hash_algorithm": {
+ "const": "SHA-256",
+ "type": "string"
+ },
+ "occurred_at_ms": {
+ "maximum": 9223372036854776000,
+ "minimum": 0,
+ "type": "integer"
+ },
+ "policy_digest": {
+ "anyOf": [
+ {
+ "pattern": "^sha256:[0-9a-f]{64}$",
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "previous_event_hash": {
+ "anyOf": [
+ {
+ "pattern": "^sha256:[0-9a-f]{64}$",
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "producer_signature": {
+ "$ref": "#/$defs/ProducerSignatureV1"
+ },
+ "schema": {
+ "const": "io.genesisre.proofrelay.evidence-event.v2",
+ "type": "string"
+ },
+ "sequence": {
+ "maximum": 9223372036854776000,
+ "minimum": 1,
+ "type": "integer"
+ },
+ "service_id": {
+ "maxLength": 128,
+ "minLength": 1,
+ "pattern": "^[a-z0-9](?:[a-z0-9._:-]*[a-z0-9])?$",
+ "type": "string"
+ },
+ "tenant_id": {
+ "maxLength": 128,
+ "minLength": 1,
+ "pattern": "^[a-z0-9](?:[a-z0-9._:-]*[a-z0-9])?$",
+ "type": "string"
+ }
+ },
+ "required": [
+ "event_id",
+ "tenant_id",
+ "service_id",
+ "sequence",
+ "occurred_at_ms",
+ "event_type",
+ "evidence",
+ "event_hash",
+ "producer_signature"
+ ],
+ "type": "object"
+ },
+ "ProducerSignatureV1": {
+ "additionalProperties": false,
+ "properties": {
+ "algorithm": {
+ "enum": [
+ "Ed25519",
+ "ES256"
+ ],
+ "type": "string"
+ },
+ "key_id": {
+ "maxLength": 128,
+ "minLength": 1,
+ "pattern": "^[a-z0-9](?:[a-z0-9._:-]*[a-z0-9])?$",
+ "type": "string"
+ },
+ "schema": {
+ "const": "io.genesisre.proofrelay.producer-signature.v1",
+ "type": "string"
+ },
+ "signature": {
+ "maxLength": 256,
+ "minLength": 43,
+ "pattern": "^[A-Za-z0-9_-]+$",
+ "type": "string"
+ }
+ },
+ "required": [
+ "algorithm",
+ "key_id",
+ "signature"
+ ],
+ "type": "object"
+ }
+ },
+ "additionalProperties": false,
+ "properties": {
+ "bundle_hash": {
+ "pattern": "^sha256:[0-9a-f]{64}$",
+ "type": "string"
+ },
+ "canonicalization": {
+ "const": "RFC8785-JCS",
+ "type": "string"
+ },
+ "created_at_ms": {
+ "maximum": 9223372036854776000,
+ "minimum": 0,
+ "type": "integer"
+ },
+ "event_count": {
+ "maximum": 10000,
+ "minimum": 1,
+ "type": "integer"
+ },
+ "events": {
+ "items": {
+ "$ref": "#/$defs/EvidenceEventV2"
+ },
+ "maxItems": 10000,
+ "minItems": 1,
+ "type": "array"
+ },
+ "hash_algorithm": {
+ "const": "SHA-256",
+ "type": "string"
+ },
+ "schema": {
+ "const": "io.genesisre.proofrelay.evidence-bundle.v2",
+ "type": "string"
+ },
+ "sequence_end": {
+ "minimum": 1,
+ "type": "integer"
+ },
+ "sequence_start": {
+ "minimum": 1,
+ "type": "integer"
+ },
+ "service_id": {
+ "maxLength": 128,
+ "minLength": 1,
+ "pattern": "^[a-z0-9](?:[a-z0-9._:-]*[a-z0-9])?$",
+ "type": "string"
+ },
+ "tenant_id": {
+ "maxLength": 128,
+ "minLength": 1,
+ "pattern": "^[a-z0-9](?:[a-z0-9._:-]*[a-z0-9])?$",
+ "type": "string"
+ }
+ },
+ "required": [
+ "tenant_id",
+ "service_id",
+ "created_at_ms",
+ "sequence_start",
+ "sequence_end",
+ "event_count",
+ "events",
+ "bundle_hash"
+ ],
+ "type": "object"
+ }
+]Input schema / properties / bundle / titleRemoved value: -"Bundle"Input schema / properties / public_keys / anyOfRemoved value: -[
- {
- "items": {
- "$ref": "#/$defs/PublicVerificationKeyInput"
- },
- "type": "array"
- },
- {
- "type": "null"
- }
-]Input schema / properties / public_keys / defaultRemoved value: -nullInput schema / properties / public_keys / itemsAdded value: +{
+ "properties": {
+ "jwk": {
+ "additionalProperties": true,
+ "type": "object"
+ },
+ "key_id": {
+ "maxLength": 128,
+ "minLength": 1,
+ "type": "string"
+ },
+ "service_id": {
+ "maxLength": 128,
+ "minLength": 1,
+ "type": "string"
+ },
+ "tenant_id": {
+ "maxLength": 128,
+ "minLength": 1,
+ "type": "string"
+ }
+ },
+ "required": [
+ "tenant_id",
+ "service_id",
+ "key_id",
+ "jwk"
+ ],
+ "type": "object"
+}Input schema / properties / public_keys / maxItemsAdded value: +128Input schema / properties / public_keys / titleRemoved value: -"Public Keys"Input schema / properties / public_keys / typeAdded value: +"array"Input schema / properties / require_chain / anyOfRemoved value: -[
- {
- "type": "boolean"
- },
- {
- "type": "null"
- }
-]Input schema / properties / require_chain / defaultRemoved value: -nullInput schema / properties / require_chain / titleRemoved value: -"Require Chain"Input schema / properties / require_chain / typeAdded value: +"boolean"Input schema / properties / require_signature / anyOfRemoved value: -[
- {
- "type": "boolean"
- },
- {
- "type": "null"
- }
-]Input schema / properties / require_signature / defaultRemoved value: -nullInput schema / properties / require_signature / titleRemoved value: -"Require Signature"Input schema / properties / require_signature / typeAdded value: +"boolean"Input schema / titleRemoved value: -"verify_submitted_bundleArguments"proofrelay.verify_signed_attestation6 fields changedInput schema / $defsRemoved value: -{
- "SignedAttestationVerificationInput": {
- "description": "Public-key verification input for V1 or V2 ProofRelay artifacts.",
- "properties": {
- "expected_issuer": {
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ],
- "default": null,
- "description": "Optional issuer/domain pin, for example genesisre.io.",
- "title": "Expected Issuer"
- },
- "expected_purpose": {
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ],
- "default": null,
- "description": "Optional purpose pin, for example proofrelay.conformance_badge.",
- "title": "Expected Purpose"
- },
- "now": {
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ],
- "default": null,
- "description": "Optional ISO-8601 timestamp for deterministic expiry checks.",
- "title": "Now"
- },
- "now_ms": {
- "anyOf": [
- {
- "minimum": 0,
- "type": "integer"
- },
- {
- "type": "null"
- }
- ],
- "default": null,
- "description": "Optional Unix timestamp in milliseconds for V2.",
- "title": "Now Ms"
- },
- "public_jwk": {
- "anyOf": [
- {
- "additionalProperties": true,
- "type": "object"
- },
- {
- "type": "null"
- }
- ],
- "default": null,
- "description": "Public P-256 JWK used to verify a V2 ES256 artifact.",
- "title": "Public Jwk"
- },
- "public_key_hex": {
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ],
- "default": null,
- "description": "Hex-encoded Ed25519 public verification key for V1.",
- "title": "Public Key Hex"
- },
- "signed_artifact": {
- "additionalProperties": true,
- "description": "Signed ProofRelay artifact containing payload and detached attestation.",
- "title": "Signed Artifact",
- "type": "object"
- }
- },
- "required": [
- "signed_artifact"
- ],
- "title": "SignedAttestationVerificationInput",
- "type": "object"
- }
-}Input schema / properties / verification / $refRemoved value: -"#/$defs/SignedAttestationVerificationInput"Input schema / properties / verification / propertiesAdded value: +{
+ "expected_issuer": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "expected_purpose": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "now": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "now_ms": {
+ "anyOf": [
+ {
+ "minimum": 0,
+ "type": "integer"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "public_jwk": {
+ "anyOf": [
+ {
+ "additionalProperties": true,
+ "type": "object"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "public_key_hex": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "signed_artifact": {
+ "additionalProperties": true,
+ "type": "object"
+ }
+}Input schema / properties / verification / requiredAdded value: +[
+ "signed_artifact"
+]Input schema / properties / verification / typeAdded value: +"object"Input schema / titleRemoved value: -"verify_signed_attestationArguments"proofrelay.wrap_mcp_tool_evidence6 fields changedInput schema / $defsRemoved value: -{
- "MCPToolEvidenceInput": {
- "description": "Hash-only MCP tool call evidence for portable ProofRelay wrapping.",
- "properties": {
- "authority_hash": {
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ],
- "default": null,
- "description": "Optional hash of authority, scope, or policy context.",
- "title": "Authority Hash"
- },
- "identity_reference_hash": {
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ],
- "default": null,
- "description": "Optional PREP-3 agent identity reference hash.",
- "title": "Identity Reference Hash"
- },
- "non_secret_refs": {
- "description": "Endpoint names, descriptor ids, or other non-secret references.",
- "items": {
- "type": "string"
- },
- "title": "Non Secret Refs",
- "type": "array"
- },
- "payment_context_hash": {
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ],
- "default": null,
- "description": "Optional hash returned by normalize_payment_proof.",
- "title": "Payment Context Hash"
- },
- "request_hash": {
- "description": "SHA-256 hash of the tool request.",
- "title": "Request Hash",
- "type": "string"
- },
- "response_hash": {
- "description": "SHA-256 hash of the tool response.",
- "title": "Response Hash",
- "type": "string"
- },
- "tool_call_id": {
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ],
- "default": null,
- "description": "Public-safe tool call id or correlation id.",
- "title": "Tool Call Id"
- },
- "tool_name": {
- "description": "MCP tool name being wrapped.",
- "title": "Tool Name",
- "type": "string"
- },
- "tool_schema_hash": {
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ],
- "default": null,
- "description": "Optional SHA-256 hash of the tool schema.",
- "title": "Tool Schema Hash"
- },
- "verifier_response_hash": {
- "anyOf": [
- {
- "type": "string"
- },
- {
- "type": "null"
- }
- ],
- "default": null,
- "description": "Optional hash of a downstream verifier response.",
- "title": "Verifier Response Hash"
- }
- },
- "required": [
- "tool_name",
- "request_hash",
- "response_hash"
- ],
- "title": "MCPToolEvidenceInput",
- "type": "object"
- }
-}Input schema / properties / tool_evidence / $refRemoved value: -"#/$defs/MCPToolEvidenceInput"Input schema / properties / tool_evidence / propertiesAdded value: +{
+ "authority_hash": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "identity_reference_hash": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "non_secret_refs": {
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+ },
+ "payment_context_hash": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "request_hash": {
+ "type": "string"
+ },
+ "response_hash": {
+ "type": "string"
+ },
+ "tool_call_id": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "tool_name": {
+ "type": "string"
+ },
+ "tool_schema_hash": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ },
+ "verifier_response_hash": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ]
+ }
+}Input schema / properties / tool_evidence / requiredAdded value: +[
+ "tool_name",
+ "request_hash",
+ "response_hash"
+]Input schema / properties / tool_evidence / typeAdded value: +"object"Input schema / titleRemoved value: -"wrap_mcp_tool_evidenceArguments"proofrelay.verify_bundle8 fields changedInput schema / $defs / EvidenceBundleV2Added value: +{
+ "additionalProperties": false,
+ "properties": {
+ "bundle_hash": {
+ "pattern": "^sha256:[0-9a-f]{64}$",
+ "title": "Bundle Hash",
+ "type": "string"
+ },
+ "canonicalization": {
+ "const": "RFC8785-JCS",
+ "default": "RFC8785-JCS",
+ "title": "Canonicalization",
+ "type": "string"
+ },
+ "created_at_ms": {
+ "maximum": 9223372036854776000,
+ "minimum": 0,
+ "title": "Created At Ms",
+ "type": "integer"
+ },
+ "event_count": {
+ "maximum": 10000,
+ "minimum": 1,
+ "title": "Event Count",
+ "type": "integer"
+ },
+ "events": {
+ "items": {
+ "$ref": "#/$defs/EvidenceEventV2"
+ },
+ "maxItems": 10000,
+ "minItems": 1,
+ "title": "Events",
+ "type": "array"
+ },
+ "hash_algorithm": {
+ "const": "SHA-256",
+ "default": "SHA-256",
+ "title": "Hash Algorithm",
+ "type": "string"
+ },
+ "schema": {
+ "const": "io.genesisre.proofrelay.evidence-bundle.v2",
+ "default": "io.genesisre.proofrelay.evidence-bundle.v2",
+ "title": "Schema",
+ "type": "string"
+ },
+ "sequence_end": {
+ "minimum": 1,
+ "title": "Sequence End",
+ "type": "integer"
+ },
+ "sequence_start": {
+ "minimum": 1,
+ "title": "Sequence Start",
+ "type": "integer"
+ },
+ "service_id": {
+ "maxLength": 128,
+ "minLength": 1,
+ "pattern": "^[a-z0-9](?:[a-z0-9._:-]*[a-z0-9])?$",
+ "title": "Service Id",
+ "type": "string"
+ },
+ "tenant_id": {
+ "maxLength": 128,
+ "minLength": 1,
+ "pattern": "^[a-z0-9](?:[a-z0-9._:-]*[a-z0-9])?$",
+ "title": "Tenant Id",
+ "type": "string"
+ }
+ },
+ "required": [
+ "tenant_id",
+ "service_id",
+ "created_at_ms",
+ "sequence_start",
+ "sequence_end",
+ "event_count",
+ "events",
+ "bundle_hash"
+ ],
+ "title": "EvidenceBundleV2",
+ "type": "object"
+}Input schema / $defs / EvidenceEventV2Added value: +{
+ "additionalProperties": false,
+ "properties": {
+ "canonicalization": {
+ "const": "RFC8785-JCS",
+ "default": "RFC8785-JCS",
+ "title": "Canonicalization",
+ "type": "string"
+ },
+ "event_hash": {
+ "pattern": "^sha256:[0-9a-f]{64}$",
+ "title": "Event Hash",
+ "type": "string"
+ },
+ "event_id": {
+ "maxLength": 128,
+ "minLength": 1,
+ "pattern": "^[a-z0-9](?:[a-z0-9._:-]*[a-z0-9])?$",
+ "title": "Event Id",
+ "type": "string"
+ },
+ "event_type": {
+ "maxLength": 128,
+ "minLength": 1,
+ "pattern": "^[a-z0-9](?:[a-z0-9._:-]*[a-z0-9])?$",
+ "title": "Event Type",
+ "type": "string"
+ },
+ "evidence": {
+ "maxProperties": 64,
+ "minProperties": 1,
+ "patternProperties": {
+ "^[a-z][a-z0-9_]*$": {
+ "pattern": "^sha256:[0-9a-f]{64}$",
+ "type": "string"
+ }
+ },
+ "propertyNames": {
+ "maxLength": 64,
+ "minLength": 1
+ },
+ "title": "Evidence",
+ "type": "object"
+ },
+ "hash_algorithm": {
+ "const": "SHA-256",
+ "default": "SHA-256",
+ "title": "Hash Algorithm",
+ "type": "string"
+ },
+ "occurred_at_ms": {
+ "maximum": 9223372036854776000,
+ "minimum": 0,
+ "title": "Occurred At Ms",
+ "type": "integer"
+ },
+ "policy_digest": {
+ "anyOf": [
+ {
+ "pattern": "^sha256:[0-9a-f]{64}$",
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ],
+ "default": null,
+ "title": "Policy Digest"
+ },
+ "previous_event_hash": {
+ "anyOf": [
+ {
+ "pattern": "^sha256:[0-9a-f]{64}$",
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ],
+ "default": null,
+ "title": "Previous Event Hash"
+ },
+ "producer_signature": {
+ "$ref": "#/$defs/ProducerSignatureV1"
+ },
+ "schema": {
+ "const": "io.genesisre.proofrelay.evidence-event.v2",
+ "default": "io.genesisre.proofrelay.evidence-event.v2",
+ "title": "Schema",
+ "type": "string"
+ },
+ "sequence": {
+ "maximum": 9223372036854776000,
+ "minimum": 1,
+ "title": "Sequence",
+ "type": "integer"
+ },
+ "service_id": {
+ "maxLength": 128,
+ "minLength": 1,
+ "pattern": "^[a-z0-9](?:[a-z0-9._:-]*[a-z0-9])?$",
+ "title": "Service Id",
+ "type": "string"
+ },
+ "tenant_id": {
+ "maxLength": 128,
+ "minLength": 1,
+ "pattern": "^[a-z0-9](?:[a-z0-9._:-]*[a-z0-9])?$",
+ "title": "Tenant Id",
+ "type": "string"
+ }
+ },
+ "required": [
+ "event_id",
+ "tenant_id",
+ "service_id",
+ "sequence",
+ "occurred_at_ms",
+ "event_type",
+ "evidence",
+ "event_hash",
+ "producer_signature"
+ ],
+ "title": "EvidenceEventV2",
+ "type": "object"
+}Input schema / $defs / ProducerSignatureV1Added value: +{
+ "additionalProperties": false,
+ "properties": {
+ "algorithm": {
+ "enum": [
+ "Ed25519",
+ "ES256"
+ ],
+ "title": "Algorithm",
+ "type": "string"
+ },
+ "key_id": {
+ "maxLength": 128,
+ "minLength": 1,
+ "pattern": "^[a-z0-9](?:[a-z0-9._:-]*[a-z0-9])?$",
+ "title": "Key Id",
+ "type": "string"
+ },
+ "schema": {
+ "const": "io.genesisre.proofrelay.producer-signature.v1",
+ "default": "io.genesisre.proofrelay.producer-signature.v1",
+ "title": "Schema",
+ "type": "string"
+ },
+ "signature": {
+ "maxLength": 256,
+ "minLength": 43,
+ "pattern": "^[A-Za-z0-9_-]+$",
+ "title": "Signature",
+ "type": "string"
+ }
+ },
+ "required": [
+ "algorithm",
+ "key_id",
+ "signature"
+ ],
+ "title": "ProducerSignatureV1",
+ "type": "object"
+}Input schema / $defs / PublicVerificationKeyInputAdded value: +{
+ "description": "Caller-supplied public producer key for stateless V2 verification.",
+ "properties": {
+ "jwk": {
+ "additionalProperties": true,
+ "title": "Jwk",
+ "type": "object"
+ },
+ "key_id": {
+ "maxLength": 128,
+ "minLength": 1,
+ "title": "Key Id",
+ "type": "string"
+ },
+ "service_id": {
+ "maxLength": 128,
+ "minLength": 1,
+ "title": "Service Id",
+ "type": "string"
+ },
+ "tenant_id": {
+ "maxLength": 128,
+ "minLength": 1,
+ "title": "Tenant Id",
+ "type": "string"
+ }
+ },
+ "required": [
+ "tenant_id",
+ "service_id",
+ "key_id",
+ "jwk"
+ ],
+ "title": "PublicVerificationKeyInput",
+ "type": "object"
+}Input schema / properties / bundle / $refRemoved value: -"#/$defs/Bundle"Input schema / properties / bundle / anyOfAdded value: +[
+ {
+ "$ref": "#/$defs/Bundle"
+ },
+ {
+ "$ref": "#/$defs/EvidenceBundleV2"
+ }
+]Input schema / properties / bundle / titleAdded value: +"Bundle"Input schema / properties / public_keysAdded value: +{
+ "anyOf": [
+ {
+ "items": {
+ "$ref": "#/$defs/PublicVerificationKeyInput"
+ },
+ "type": "array"
+ },
+ {
+ "type": "null"
+ }
+ ],
+ "default": null,
+ "title": "Public Keys"
+}proofrelay.verify_signed_attestation8 fields changedInput schema / $defs / SignedAttestationVerificationInput / descriptionPrevious value: -"Public-key verification input for signed ProofRelay artifacts."New value: +"Public-key verification input for V1 or V2 ProofRelay artifacts."Input schema / $defs / SignedAttestationVerificationInput / properties / now_msAdded value: +{
+ "anyOf": [
+ {
+ "minimum": 0,
+ "type": "integer"
+ },
+ {
+ "type": "null"
+ }
+ ],
+ "default": null,
+ "description": "Optional Unix timestamp in milliseconds for V2.",
+ "title": "Now Ms"
+}Input schema / $defs / SignedAttestationVerificationInput / properties / public_jwkAdded value: +{
+ "anyOf": [
+ {
+ "additionalProperties": true,
+ "type": "object"
+ },
+ {
+ "type": "null"
+ }
+ ],
+ "default": null,
+ "description": "Public P-256 JWK used to verify a V2 ES256 artifact.",
+ "title": "Public Jwk"
+}Input schema / $defs / SignedAttestationVerificationInput / properties / public_key_hex / anyOfAdded value: +[
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+]Input schema / $defs / SignedAttestationVerificationInput / properties / public_key_hex / defaultAdded value: +nullInput schema / $defs / SignedAttestationVerificationInput / properties / public_key_hex / descriptionPrevious value: -"Hex-encoded Ed25519 public verification key."New value: +"Hex-encoded Ed25519 public verification key for V1."Input schema / $defs / SignedAttestationVerificationInput / properties / public_key_hex / typeRemoved value: -"string"Input schema / $defs / SignedAttestationVerificationInput / requiredPrevious value: -[
- "signed_artifact",
- "public_key_hex"
-]New value: +[
+ "signed_artifact"
+]proofrelay.verify_bundle8 fields changedInput schema / $defs / EvidenceBundleV2Removed value: -{
- "additionalProperties": false,
- "properties": {
- "bundle_hash": {
- "pattern": "^sha256:[0-9a-f]{64}$",
- "title": "Bundle Hash",
- "type": "string"
- },
- "canonicalization": {
- "const": "RFC8785-JCS",
- "default": "RFC8785-JCS",
- "title": "Canonicalization",
- "type": "string"
- },
- "created_at_ms": {
- "maximum": 9223372036854776000,
- "minimum": 0,
- "title": "Created At Ms",
- "type": "integer"
- },
- "event_count": {
- "maximum": 10000,
- "minimum": 1,
- "title": "Event Count",
- "type": "integer"
- },
- "events": {
- "items": {
- "$ref": "#/$defs/EvidenceEventV2"
- },
- "maxItems": 10000,
- "minItems": 1,
- "title": "Events",
- "type": "array"
- },
- "hash_algorithm": {
- "const": "SHA-256",
- "default": "SHA-256",
- "title": "Hash Algorithm",
- "type": "string"
- },
- "schema": {
- "const": "io.genesisre.proofrelay.evidence-bundle.v2",
- "default": "io.genesisre.proofrelay.evidence-bundle.v2",
- "title": "Schema",
- "type": "string"
- },
- "sequence_end": {
- "minimum": 1,
- "title": "Sequence End",
- "type": "integer"
- },
- "sequence_start": {
- "minimum": 1,
- "title": "Sequence Start",
- "type": "integer"
- },
- "service_id": {
- "maxLength": 128,
- "minLength": 1,
- "pattern": "^[a-z0-9](?:[a-z0-9._:-]*[a-z0-9])?$",
- "title": "Service Id",
- "type": "string"
- },
- "tenant_id": {
- "maxLength": 128,
- "minLength": 1,
- "pattern": "^[a-z0-9](?:[a-z0-9._:-]*[a-z0-9])?$",
- "title": "Tenant Id",
- "type": "string"
- }
- },
- "required": [
- "tenant_id",
- "service_id",
- "created_at_ms",
- "sequence_start",
- "sequence_end",
- "event_count",
- "events",
- "bundle_hash"
- ],
- "title": "EvidenceBundleV2",
- "type": "object"
-}Input schema / $defs / EvidenceEventV2Removed value: -{
- "additionalProperties": false,
- "properties": {
- "canonicalization": {
- "const": "RFC8785-JCS",
- "default": "RFC8785-JCS",
- "title": "Canonicalization",
- "type": "string"
- },
- "event_hash": {
- "pattern": "^sha256:[0-9a-f]{64}$",
- "title": "Event Hash",
- "type": "string"
- },
- "event_id": {
- "maxLength": 128,
- "minLength": 1,
- "pattern": "^[a-z0-9](?:[a-z0-9._:-]*[a-z0-9])?$",
- "title": "Event Id",
- "type": "string"
- },
- "event_type": {
- "maxLength": 128,
- "minLength": 1,
- "pattern": "^[a-z0-9](?:[a-z0-9._:-]*[a-z0-9])?$",
- "title": "Event Type",
- "type": "string"
- },
- "evidence": {
- "maxProperties": 64,
- "minProperties": 1,
- "patternProperties": {
- "^[a-z][a-z0-9_]*$": {
- "pattern": "^sha256:[0-9a-f]{64}$",
- "type": "string"
- }
- },
- "propertyNames": {
- "maxLength": 64,
- "minLength": 1
- },
- "title": "Evidence",
- "type": "object"
- },
- "hash_algorithm": {
- "const": "SHA-256",
- "default": "SHA-256",
- "title": "Hash Algorithm",
- "type": "string"
- },
- "occurred_at_ms": {
- "maximum": 9223372036854776000,
- "minimum": 0,
- "title": "Occurred At Ms",
- "type": "integer"
- },
- "policy_digest": {
- "anyOf": [
- {
- "pattern": "^sha256:[0-9a-f]{64}$",
- "type": "string"
- },
- {
- "type": "null"
- }
- ],
- "default": null,
- "title": "Policy Digest"
- },
- "previous_event_hash": {
- "anyOf": [
- {
- "pattern": "^sha256:[0-9a-f]{64}$",
- "type": "string"
- },
- {
- "type": "null"
- }
- ],
- "default": null,
- "title": "Previous Event Hash"
- },
- "producer_signature": {
- "$ref": "#/$defs/ProducerSignatureV1"
- },
- "schema": {
- "const": "io.genesisre.proofrelay.evidence-event.v2",
- "default": "io.genesisre.proofrelay.evidence-event.v2",
- "title": "Schema",
- "type": "string"
- },
- "sequence": {
- "maximum": 9223372036854776000,
- "minimum": 1,
- "title": "Sequence",
- "type": "integer"
- },
- "service_id": {
- "maxLength": 128,
- "minLength": 1,
- "pattern": "^[a-z0-9](?:[a-z0-9._:-]*[a-z0-9])?$",
- "title": "Service Id",
- "type": "string"
- },
- "tenant_id": {
- "maxLength": 128,
- "minLength": 1,
- "pattern": "^[a-z0-9](?:[a-z0-9._:-]*[a-z0-9])?$",
- "title": "Tenant Id",
- "type": "string"
- }
- },
- "required": [
- "event_id",
- "tenant_id",
- "service_id",
- "sequence",
- "occurred_at_ms",
- "event_type",
- "evidence",
- "event_hash",
- "producer_signature"
- ],
- "title": "EvidenceEventV2",
- "type": "object"
-}Input schema / $defs / ProducerSignatureV1Removed value: -{
- "additionalProperties": false,
- "properties": {
- "algorithm": {
- "enum": [
- "Ed25519",
- "ES256"
- ],
- "title": "Algorithm",
- "type": "string"
- },
- "key_id": {
- "maxLength": 128,
- "minLength": 1,
- "pattern": "^[a-z0-9](?:[a-z0-9._:-]*[a-z0-9])?$",
- "title": "Key Id",
- "type": "string"
- },
- "schema": {
- "const": "io.genesisre.proofrelay.producer-signature.v1",
- "default": "io.genesisre.proofrelay.producer-signature.v1",
- "title": "Schema",
- "type": "string"
- },
- "signature": {
- "maxLength": 256,
- "minLength": 43,
- "pattern": "^[A-Za-z0-9_-]+$",
- "title": "Signature",
- "type": "string"
- }
- },
- "required": [
- "algorithm",
- "key_id",
- "signature"
- ],
- "title": "ProducerSignatureV1",
- "type": "object"
-}Input schema / $defs / PublicVerificationKeyInputRemoved value: -{
- "description": "Caller-supplied public producer key for stateless V2 verification.",
- "properties": {
- "jwk": {
- "additionalProperties": true,
- "title": "Jwk",
- "type": "object"
- },
- "key_id": {
- "maxLength": 128,
- "minLength": 1,
- "title": "Key Id",
- "type": "string"
- },
- "service_id": {
- "maxLength": 128,
- "minLength": 1,
- "title": "Service Id",
- "type": "string"
- },
- "tenant_id": {
- "maxLength": 128,
- "minLength": 1,
- "title": "Tenant Id",
- "type": "string"
- }
- },
- "required": [
- "tenant_id",
- "service_id",
- "key_id",
- "jwk"
- ],
- "title": "PublicVerificationKeyInput",
- "type": "object"
-}Input schema / properties / bundle / $refAdded value: +"#/$defs/Bundle"Input schema / properties / bundle / anyOfRemoved value: -[
- {
- "$ref": "#/$defs/Bundle"
- },
- {
- "$ref": "#/$defs/EvidenceBundleV2"
- }
-]Input schema / properties / bundle / titleRemoved value: -"Bundle"Input schema / properties / public_keysRemoved value: -{
- "anyOf": [
- {
- "items": {
- "$ref": "#/$defs/PublicVerificationKeyInput"
- },
- "type": "array"
- },
- {
- "type": "null"
- }
- ],
- "default": null,
- "title": "Public Keys"
-}proofrelay.verify_signed_attestation8 fields changedInput schema / $defs / SignedAttestationVerificationInput / descriptionPrevious value: -"Public-key verification input for V1 or V2 ProofRelay artifacts."New value: +"Public-key verification input for signed ProofRelay artifacts."Input schema / $defs / SignedAttestationVerificationInput / properties / now_msRemoved value: -{
- "anyOf": [
- {
- "minimum": 0,
- "type": "integer"
- },
- {
- "type": "null"
- }
- ],
- "default": null,
- "description": "Optional Unix timestamp in milliseconds for V2.",
- "title": "Now Ms"
-}Input schema / $defs / SignedAttestationVerificationInput / properties / public_jwkRemoved value: -{
- "anyOf": [
- {
- "additionalProperties": true,
- "type": "object"
- },
- {
- "type": "null"
- }
- ],
- "default": null,
- "description": "Public P-256 JWK used to verify a V2 ES256 artifact.",
- "title": "Public Jwk"
-}Input schema / $defs / SignedAttestationVerificationInput / properties / public_key_hex / anyOfRemoved value: -[
- {
- "type": "string"
- },
- {
- "type": "null"
- }
-]Input schema / $defs / SignedAttestationVerificationInput / properties / public_key_hex / defaultRemoved value: -nullInput schema / $defs / SignedAttestationVerificationInput / properties / public_key_hex / descriptionPrevious value: -"Hex-encoded Ed25519 public verification key for V1."New value: +"Hex-encoded Ed25519 public verification key."Input schema / $defs / SignedAttestationVerificationInput / properties / public_key_hex / typeAdded value: +"string"Input schema / $defs / SignedAttestationVerificationInput / requiredPrevious value: -[
- "signed_artifact"
-]New value: +[
+ "signed_artifact",
+ "public_key_hex"
+]proofrelay.verify_bundle8 fields changedInput schema / $defs / EvidenceBundleV2Added value: +{
+ "additionalProperties": false,
+ "properties": {
+ "bundle_hash": {
+ "pattern": "^sha256:[0-9a-f]{64}$",
+ "title": "Bundle Hash",
+ "type": "string"
+ },
+ "canonicalization": {
+ "const": "RFC8785-JCS",
+ "default": "RFC8785-JCS",
+ "title": "Canonicalization",
+ "type": "string"
+ },
+ "created_at_ms": {
+ "maximum": 9223372036854776000,
+ "minimum": 0,
+ "title": "Created At Ms",
+ "type": "integer"
+ },
+ "event_count": {
+ "maximum": 10000,
+ "minimum": 1,
+ "title": "Event Count",
+ "type": "integer"
+ },
+ "events": {
+ "items": {
+ "$ref": "#/$defs/EvidenceEventV2"
+ },
+ "maxItems": 10000,
+ "minItems": 1,
+ "title": "Events",
+ "type": "array"
+ },
+ "hash_algorithm": {
+ "const": "SHA-256",
+ "default": "SHA-256",
+ "title": "Hash Algorithm",
+ "type": "string"
+ },
+ "schema": {
+ "const": "io.genesisre.proofrelay.evidence-bundle.v2",
+ "default": "io.genesisre.proofrelay.evidence-bundle.v2",
+ "title": "Schema",
+ "type": "string"
+ },
+ "sequence_end": {
+ "minimum": 1,
+ "title": "Sequence End",
+ "type": "integer"
+ },
+ "sequence_start": {
+ "minimum": 1,
+ "title": "Sequence Start",
+ "type": "integer"
+ },
+ "service_id": {
+ "maxLength": 128,
+ "minLength": 1,
+ "pattern": "^[a-z0-9](?:[a-z0-9._:-]*[a-z0-9])?$",
+ "title": "Service Id",
+ "type": "string"
+ },
+ "tenant_id": {
+ "maxLength": 128,
+ "minLength": 1,
+ "pattern": "^[a-z0-9](?:[a-z0-9._:-]*[a-z0-9])?$",
+ "title": "Tenant Id",
+ "type": "string"
+ }
+ },
+ "required": [
+ "tenant_id",
+ "service_id",
+ "created_at_ms",
+ "sequence_start",
+ "sequence_end",
+ "event_count",
+ "events",
+ "bundle_hash"
+ ],
+ "title": "EvidenceBundleV2",
+ "type": "object"
+}Input schema / $defs / EvidenceEventV2Added value: +{
+ "additionalProperties": false,
+ "properties": {
+ "canonicalization": {
+ "const": "RFC8785-JCS",
+ "default": "RFC8785-JCS",
+ "title": "Canonicalization",
+ "type": "string"
+ },
+ "event_hash": {
+ "pattern": "^sha256:[0-9a-f]{64}$",
+ "title": "Event Hash",
+ "type": "string"
+ },
+ "event_id": {
+ "maxLength": 128,
+ "minLength": 1,
+ "pattern": "^[a-z0-9](?:[a-z0-9._:-]*[a-z0-9])?$",
+ "title": "Event Id",
+ "type": "string"
+ },
+ "event_type": {
+ "maxLength": 128,
+ "minLength": 1,
+ "pattern": "^[a-z0-9](?:[a-z0-9._:-]*[a-z0-9])?$",
+ "title": "Event Type",
+ "type": "string"
+ },
+ "evidence": {
+ "maxProperties": 64,
+ "minProperties": 1,
+ "patternProperties": {
+ "^[a-z][a-z0-9_]*$": {
+ "pattern": "^sha256:[0-9a-f]{64}$",
+ "type": "string"
+ }
+ },
+ "propertyNames": {
+ "maxLength": 64,
+ "minLength": 1
+ },
+ "title": "Evidence",
+ "type": "object"
+ },
+ "hash_algorithm": {
+ "const": "SHA-256",
+ "default": "SHA-256",
+ "title": "Hash Algorithm",
+ "type": "string"
+ },
+ "occurred_at_ms": {
+ "maximum": 9223372036854776000,
+ "minimum": 0,
+ "title": "Occurred At Ms",
+ "type": "integer"
+ },
+ "policy_digest": {
+ "anyOf": [
+ {
+ "pattern": "^sha256:[0-9a-f]{64}$",
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ],
+ "default": null,
+ "title": "Policy Digest"
+ },
+ "previous_event_hash": {
+ "anyOf": [
+ {
+ "pattern": "^sha256:[0-9a-f]{64}$",
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ],
+ "default": null,
+ "title": "Previous Event Hash"
+ },
+ "producer_signature": {
+ "$ref": "#/$defs/ProducerSignatureV1"
+ },
+ "schema": {
+ "const": "io.genesisre.proofrelay.evidence-event.v2",
+ "default": "io.genesisre.proofrelay.evidence-event.v2",
+ "title": "Schema",
+ "type": "string"
+ },
+ "sequence": {
+ "maximum": 9223372036854776000,
+ "minimum": 1,
+ "title": "Sequence",
+ "type": "integer"
+ },
+ "service_id": {
+ "maxLength": 128,
+ "minLength": 1,
+ "pattern": "^[a-z0-9](?:[a-z0-9._:-]*[a-z0-9])?$",
+ "title": "Service Id",
+ "type": "string"
+ },
+ "tenant_id": {
+ "maxLength": 128,
+ "minLength": 1,
+ "pattern": "^[a-z0-9](?:[a-z0-9._:-]*[a-z0-9])?$",
+ "title": "Tenant Id",
+ "type": "string"
+ }
+ },
+ "required": [
+ "event_id",
+ "tenant_id",
+ "service_id",
+ "sequence",
+ "occurred_at_ms",
+ "event_type",
+ "evidence",
+ "event_hash",
+ "producer_signature"
+ ],
+ "title": "EvidenceEventV2",
+ "type": "object"
+}Input schema / $defs / ProducerSignatureV1Added value: +{
+ "additionalProperties": false,
+ "properties": {
+ "algorithm": {
+ "enum": [
+ "Ed25519",
+ "ES256"
+ ],
+ "title": "Algorithm",
+ "type": "string"
+ },
+ "key_id": {
+ "maxLength": 128,
+ "minLength": 1,
+ "pattern": "^[a-z0-9](?:[a-z0-9._:-]*[a-z0-9])?$",
+ "title": "Key Id",
+ "type": "string"
+ },
+ "schema": {
+ "const": "io.genesisre.proofrelay.producer-signature.v1",
+ "default": "io.genesisre.proofrelay.producer-signature.v1",
+ "title": "Schema",
+ "type": "string"
+ },
+ "signature": {
+ "maxLength": 256,
+ "minLength": 43,
+ "pattern": "^[A-Za-z0-9_-]+$",
+ "title": "Signature",
+ "type": "string"
+ }
+ },
+ "required": [
+ "algorithm",
+ "key_id",
+ "signature"
+ ],
+ "title": "ProducerSignatureV1",
+ "type": "object"
+}Input schema / $defs / PublicVerificationKeyInputAdded value: +{
+ "description": "Caller-supplied public producer key for stateless V2 verification.",
+ "properties": {
+ "jwk": {
+ "additionalProperties": true,
+ "title": "Jwk",
+ "type": "object"
+ },
+ "key_id": {
+ "maxLength": 128,
+ "minLength": 1,
+ "title": "Key Id",
+ "type": "string"
+ },
+ "service_id": {
+ "maxLength": 128,
+ "minLength": 1,
+ "title": "Service Id",
+ "type": "string"
+ },
+ "tenant_id": {
+ "maxLength": 128,
+ "minLength": 1,
+ "title": "Tenant Id",
+ "type": "string"
+ }
+ },
+ "required": [
+ "tenant_id",
+ "service_id",
+ "key_id",
+ "jwk"
+ ],
+ "title": "PublicVerificationKeyInput",
+ "type": "object"
+}Input schema / properties / bundle / $refRemoved value: -"#/$defs/Bundle"Input schema / properties / bundle / anyOfAdded value: +[
+ {
+ "$ref": "#/$defs/Bundle"
+ },
+ {
+ "$ref": "#/$defs/EvidenceBundleV2"
+ }
+]Input schema / properties / bundle / titleAdded value: +"Bundle"Input schema / properties / public_keysAdded value: +{
+ "anyOf": [
+ {
+ "items": {
+ "$ref": "#/$defs/PublicVerificationKeyInput"
+ },
+ "type": "array"
+ },
+ {
+ "type": "null"
+ }
+ ],
+ "default": null,
+ "title": "Public Keys"
+}proofrelay.verify_signed_attestation8 fields changedInput schema / $defs / SignedAttestationVerificationInput / descriptionPrevious value: -"Public-key verification input for signed ProofRelay artifacts."New value: +"Public-key verification input for V1 or V2 ProofRelay artifacts."Input schema / $defs / SignedAttestationVerificationInput / properties / now_msAdded value: +{
+ "anyOf": [
+ {
+ "minimum": 0,
+ "type": "integer"
+ },
+ {
+ "type": "null"
+ }
+ ],
+ "default": null,
+ "description": "Optional Unix timestamp in milliseconds for V2.",
+ "title": "Now Ms"
+}Input schema / $defs / SignedAttestationVerificationInput / properties / public_jwkAdded value: +{
+ "anyOf": [
+ {
+ "additionalProperties": true,
+ "type": "object"
+ },
+ {
+ "type": "null"
+ }
+ ],
+ "default": null,
+ "description": "Public P-256 JWK used to verify a V2 ES256 artifact.",
+ "title": "Public Jwk"
+}Input schema / $defs / SignedAttestationVerificationInput / properties / public_key_hex / anyOfAdded value: +[
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+]Input schema / $defs / SignedAttestationVerificationInput / properties / public_key_hex / defaultAdded value: +nullInput schema / $defs / SignedAttestationVerificationInput / properties / public_key_hex / descriptionPrevious value: -"Hex-encoded Ed25519 public verification key."New value: +"Hex-encoded Ed25519 public verification key for V1."Input schema / $defs / SignedAttestationVerificationInput / properties / public_key_hex / typeRemoved value: -"string"Input schema / $defs / SignedAttestationVerificationInput / requiredPrevious value: -[
- "signed_artifact",
- "public_key_hex"
-]New value: +[
+ "signed_artifact"
+]proofrelay.adapt_agent_identity_evidenceproofrelay.adapt_x402_payment_proofproofrelay.build_audit_pack_manifestproofrelay.build_bundle_draftproofrelay.build_closing_proof_packproofrelay.build_human_approval_receiptproofrelay.build_registry_entryproofrelay.build_title_production_evidenceproofrelay.compute_readiness_signalproofrelay.describe_cli_sdk_helperproofrelay.describe_stripe_entitlement_flowproofrelay.generate_paid_tool_receiptproofrelay.get_verifier_statusproofrelay.issue_conformance_badgeproofrelay.map_lender_condition_evidenceproofrelay.map_openapi_operation_evidenceproofrelay.normalize_payment_proofproofrelay.plan_replay_rejection_testproofrelay.recommend_checkpointproofrelay.review_vendor_risk_profileproofrelay.review_wire_payoff_changeproofrelay.scan_mcp_riskproofrelay.summarize_agent_action_logproofrelay.verify_bundleproofrelay.verify_signed_attestationproofrelay.wrap_mcp_tool_evidenceFree, no-account verification of KeyHalve-sealed documents. Read-only; never receives keys.
Read-only Remote MCP for externally grounded AI agent trust receipts.
Read-only XRP Ledger MCP tools with proof-annotation envelopes and signed daily snapshots.
Read-only MCP server for The Quiet Protocol's engines, benchmarks, proof, and business data.
Add one secure layer between your agents and this server.
