@adcp/sdk 15.0.0 → 15.2.1

package/dist/lib/testing/storyboard/request-signing/a2a-operation-resolution.mjs

@@ -0,0 +1,276 @@
+import { buildPositiveRequest } from "./builder.mjs";
+import { probeSignedRequest } from "./probe.mjs";
+import { resolveA2aDispatchTarget, resolveA2aHttpJsonEndpoint } from "./a2a-dispatch.mjs";
+import {
+  A2A_VECTORS_UNAVAILABLE_MESSAGE,
+  loadA2aOperationResolutionVectors
+} from "./vector-loader.mjs";
+const A2A_UNAVAILABLE_ROW_ID = "a2a/operation-resolution-vectors";
+const ALTERNATE_ACCEPTED_CODES = {
+  "a2a/negative/023-batch-body": ["request_signature_required"]
+};
+function emptyTiers() {
+  return {
+    "contradiction-resolution": { passed: 0, failed: 0, skipped: 0, failed_vectors: [] },
+    hardening: { passed: 0, failed: 0, skipped: 0, failed_vectors: [] }
+  };
+}
+async function gradeA2aOperationResolution(agentUrl, keys, contract, options) {
+  if (options.onlyVectors && !options.onlyVectors.some((id) => id.startsWith("a2a/"))) return void 0;
+  const loaded = loadA2aOperationResolutionVectors(options);
+  const tiers = emptyTiers();
+  if (loaded.source === "none") {
+    return {
+      positive: [],
+      negative: [
+        {
+          vector_id: A2A_UNAVAILABLE_ROW_ID,
+          kind: "negative",
+          passed: true,
+          skipped: true,
+          skip_reason: "a2a_vectors_unavailable",
+          diagnostic: A2A_VECTORS_UNAVAILABLE_MESSAGE,
+          http_status: 0,
+          probe_duration_ms: 0
+        }
+      ],
+      summary: {
+        vectors_available: false,
+        source: "none",
+        message: A2A_VECTORS_UNAVAILABLE_MESSAGE,
+        tiers
+      }
+    };
+  }
+  const dispatchOptions = {
+    allowPrivateIp: options.allowPrivateIp === true,
+    ...options.timeoutMs !== void 0 ? { timeoutMs: options.timeoutMs } : {},
+    ...options.cardFetch ? { cardFetch: options.cardFetch } : {}
+  };
+  const probeOptions = {
+    allowPrivateIp: options.allowPrivateIp === true,
+    timeoutMs: options.timeoutMs
+  };
+  let jsonRpcEndpoint;
+  const jsonRpc = () => jsonRpcEndpoint ??= resolveA2aDispatchTarget(agentUrl, dispatchOptions).then((target) => target.endpoint);
+  let httpJsonEndpoint;
+  const httpJson = () => httpJsonEndpoint ??= resolveA2aHttpJsonEndpoint(agentUrl, dispatchOptions);
+  const requiredFor = options.agentCapability?.required_for ?? options.agentRequiredFor;
+  const protocolMethodsRequiredFor = options.agentCapability !== void 0 ? options.agentCapability.protocol_methods_required_for ?? [] : options.agentProtocolMethodsRequiredFor;
+  const contentDigestPolicy = options.agentCapability?.covers_content_digest ?? options.agentContentDigestPolicy;
+  const results = [];
+  const grade = async (vector) => {
+    const skip = preflightSkip(vector, {
+      options,
+      contract,
+      requiredFor,
+      protocolMethodsRequiredFor,
+      contentDigestPolicy
+    });
+    if (skip) return skip;
+    let url;
+    if (isHttpJsonBinding(vector)) {
+      const base = await httpJson();
+      if (!base) {
+        return skipped(
+          vector,
+          "transport_ungradable",
+          `Vector ${vector.id} grades the A2A HTTP+JSON binding (POST \u2026/message:send), but the agent card declares no HTTP+JSON interface. An agent that does not serve that binding cannot be bypassed through it.`
+        );
+      }
+      url = `${base.replace(/\/+$/, "")}/${lastPathSegment(vector.request.url)}`;
+    } else {
+      url = await jsonRpc();
+    }
+    const request = buildRequest(vector, url, keys);
+    const probe = await probeSignedRequest(request, probeOptions);
+    return vector.kind === "positive" ? gradePositive(vector, probe) : gradeNegative(vector, probe);
+  };
+  for (const vector of [...loaded.positive, ...loaded.negative]) {
+    const result = await grade(vector);
+    results.push(result);
+    const tier = tiers[vector.tier];
+    if (result.skipped) tier.skipped++;
+    else if (result.passed) tier.passed++;
+    else {
+      tier.failed++;
+      tier.failed_vectors.push(vector.id);
+    }
+  }
+  return {
+    positive: results.filter((r) => r.kind === "positive"),
+    negative: results.filter((r) => r.kind === "negative"),
+    summary: {
+      vectors_available: true,
+      source: loaded.source,
+      ...loaded.sourceDir ? { source_dir: loaded.sourceDir } : {},
+      tiers
+    }
+  };
+}
+function skipped(vector, skip_reason, diagnostic) {
+  return {
+    vector_id: vector.id,
+    kind: vector.kind,
+    tier: vector.tier,
+    passed: true,
+    // skipped is not failed; overall pass/fail excludes skipped
+    skipped: true,
+    skip_reason,
+    ...vector.kind === "negative" && vector.expected_outcome.error_code ? { expected_error_code: vector.expected_outcome.error_code } : {},
+    ...diagnostic ? { diagnostic } : {},
+    http_status: 0,
+    probe_duration_ms: 0
+  };
+}
+function preflightSkip(vector, ctx) {
+  const { options } = ctx;
+  if (options.onlyVectors && !options.onlyVectors.includes(vector.id)) {
+    return skipped(vector, "not_in_only_vectors");
+  }
+  if (options.skipVectors?.includes(vector.id)) return skipped(vector, "operator_skip");
+  const mismatch = capabilityMismatch(vector, ctx.requiredFor, ctx.protocolMethodsRequiredFor);
+  if (mismatch) return skipped(vector, "capability_profile_mismatch", mismatch);
+  if (vector.kind === "positive" && isSigned(vector) && ctx.contentDigestPolicy === "forbidden") {
+    return skipped(
+      vector,
+      "capability_profile_mismatch",
+      `Vector ${vector.id} is signed with content-digest covered, but the agent declares covers_content_digest='forbidden'.`
+    );
+  }
+  if (vector.kind === "positive" && vector.expected_outcome.status === "verified" && !options.allowLiveSideEffects && ctx.contract?.endpoint_scope !== "sandbox") {
+    return skipped(
+      vector,
+      "live_side_effect_opt_in_required",
+      `Vector ${vector.id} sends a validly signed ${vector.expected_outcome.resolved_operation ?? "operation"} request the agent will accept and run. Pass allowLiveSideEffects: true (or point the grader at an endpoint whose signed-requests-runner contract declares endpoint_scope: sandbox) to run it.`
+    );
+  }
+  return void 0;
+}
+function capabilityMismatch(vector, requiredFor, protocolMethodsRequiredFor) {
+  if (vector.kind === "negative") {
+    if (vector.expected_outcome.error_code !== "request_signature_required") return void 0;
+    const methods = vector.verifier_capability.protocol_methods_required_for ?? [];
+    if (methods.length > 0) {
+      if (!protocolMethodsRequiredFor) return void 0;
+      const missing = methods.filter((m) => !protocolMethodsRequiredFor.includes(m));
+      return missing.length === 0 ? void 0 : `Vector asserts protocol_methods_required_for includes [${missing.join(", ")}] but the agent declares [${protocolMethodsRequiredFor.join(", ")}]. Add the method to request_signing.protocol_methods_required_for to grade it.`;
+    }
+    const operation2 = vector.expected_outcome.resolved_operation;
+    if (!requiredFor || typeof operation2 !== "string" || requiredFor.includes(operation2)) return void 0;
+    return `Vector asserts ${operation2} is in required_for but the agent declares required_for [${requiredFor.join(", ")}]. The vector tests a rejection path the agent has not opted into; add the operation to request_signing.required_for to grade it.`;
+  }
+  if (vector.expected_outcome.status !== "unsigned") return void 0;
+  const operation = vector.expected_outcome.resolved_operation;
+  if (requiredFor && typeof operation === "string" && requiredFor.includes(operation)) {
+    return `Vector asserts ${operation} needs no signature, but the agent declares it in required_for.`;
+  }
+  const method = jsonRpcMethodOf(vector.request.body);
+  if (protocolMethodsRequiredFor && method !== void 0 && protocolMethodsRequiredFor.includes(method)) {
+    return `Vector asserts an unsigned ${method} is accepted, but the agent declares ${method} in protocol_methods_required_for.`;
+  }
+  return void 0;
+}
+function hasHeader(headers, name) {
+  return Object.keys(headers).some((key) => key.toLowerCase() === name);
+}
+function isSigned(vector) {
+  return hasHeader(vector.request.headers, "signature-input");
+}
+function isHttpJsonBinding(vector) {
+  try {
+    return /(?:^|\/)message:(?:send|stream)$/.test(new URL(vector.request.url).pathname);
+  } catch {
+    return false;
+  }
+}
+function lastPathSegment(url) {
+  return new URL(url).pathname.split("/").filter(Boolean).pop() ?? "";
+}
+function jsonRpcMethodOf(body) {
+  if (!body) return void 0;
+  try {
+    const parsed = JSON.parse(body);
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      const method = parsed.method;
+      return typeof method === "string" ? method : void 0;
+    }
+  } catch {
+  }
+  return void 0;
+}
+function buildRequest(vector, url, keys) {
+  const request = { ...vector.request, url, headers: { ...vector.request.headers } };
+  if (!isSigned(vector)) return request;
+  const asPositive = {
+    kind: "positive",
+    id: vector.id,
+    name: vector.name,
+    signing_profile_version: vector.signing_profile_version,
+    reference_now: vector.reference_now,
+    request,
+    verifier_capability: vector.verifier_capability,
+    jwks_ref: vector.jwks_ref
+  };
+  return buildPositiveRequest(asPositive, keys, { transport: "raw" });
+}
+function isSignatureChallenge(probe) {
+  if (probe.status !== 401) return false;
+  if (probe.wwwAuthenticateErrorCode !== void 0) return true;
+  return /(?:^|,)\s*Signature\b/i.test(probe.headers["www-authenticate"] ?? "");
+}
+function gradePositive(vector, probe) {
+  const rejected = isSignatureChallenge(probe);
+  const passed = !probe.error && !rejected;
+  let diagnostic;
+  if (probe.error) diagnostic = `probe error: ${probe.error}`;
+  else if (rejected) {
+    const code = probe.wwwAuthenticateErrorCode ?? "(none)";
+    diagnostic = vector.expected_outcome.status === "verified" ? `expected the signed request to be accepted past the signature layer, got 401 with error="${code}". Check the grader test key is registered with the agent. Vector: ${vector.name}` : `expected no signature rejection (the resolved operation does not require one), got 401 with error="${code}". Vector: ${vector.name}`;
+  }
+  return {
+    vector_id: vector.id,
+    kind: "positive",
+    tier: vector.tier,
+    passed,
+    http_status: probe.status,
+    probe_url: probe.url,
+    ...probe.wwwAuthenticateErrorCode ? { actual_error_code: probe.wwwAuthenticateErrorCode } : {},
+    ...diagnostic ? { diagnostic } : {},
+    ...probe.error !== void 0 && { transport_error: true },
+    probe_duration_ms: probe.duration_ms
+  };
+}
+function gradeNegative(vector, probe) {
+  const expected = vector.expected_error_code;
+  const accepted = [expected, ...ALTERNATE_ACCEPTED_CODES[vector.id] ?? []];
+  const actual = probe.wwwAuthenticateErrorCode;
+  const passed = !probe.error && probe.status === 401 && actual !== void 0 && accepted.includes(actual);
+  let diagnostic;
+  if (!passed) {
+    const wanted = accepted.map((code) => `"${code}"`).join(" or ");
+    if (probe.error) diagnostic = `probe error: ${probe.error}`;
+    else if (probe.status !== 401) {
+      diagnostic = `expected 401 with error=${wanted}, got ${probe.status}. The request reached the agent's dispatcher: the verifier did not resolve the operation from the A2A DataPart skill (GHSA-frxv-c96c-4vqw). Vector: ${vector.name}`;
+    } else {
+      diagnostic = `expected error=${wanted}, got error="${actual ?? "(none)"}". Vector: ${vector.name}`;
+    }
+  }
+  return {
+    vector_id: vector.id,
+    kind: "negative",
+    tier: vector.tier,
+    passed,
+    http_status: probe.status,
+    probe_url: probe.url,
+    expected_error_code: expected,
+    ...actual ? { actual_error_code: actual } : {},
+    ...diagnostic ? { diagnostic } : {},
+    ...probe.error !== void 0 && { transport_error: true },
+    probe_duration_ms: probe.duration_ms
+  };
+}
+export {
+  A2A_UNAVAILABLE_ROW_ID,
+  gradeA2aOperationResolution
+};

package/dist/lib/testing/storyboard/request-signing/grader.d.mts

@@ -1,5 +1,6 @@
 import { type LoadVectorsOptions } from './vector-loader.mjs';
-import type { NegativeVector, PositiveVector, VerifierCapabilityFixture } from './types.mjs';
+import { type A2aOperationResolutionSummary } from './a2a-operation-resolution.mjs';
+import type { A2aVectorTier, NegativeVector, PositiveVector, VerifierCapabilityFixture } from './types.mjs';
 export interface GradeOptions extends LoadVectorsOptions {
     /** Grade only authored 3.2 profile vectors. Omit for the legacy root corpus. */
     signingProfileVersion?: '3.2';
@@ -94,6 +95,16 @@ export interface GradeOptions extends LoadVectorsOptions {
      * shadow-posture agent). Has no effect when `agentCapability` is provided.
      */
     agentRequiredFor?: readonly string[];
+    /**
+     * The agent's advertised `request_signing.protocol_methods_required_for`
+     * (JSON-RPC method names such as `SendMessage` or `tasks/cancel`). Only the
+     * A2A operation-resolution vectors consult it: negative/007 (an unsigned
+     * `SendMessage` rejected because the method itself is required) skips when
+     * the agent does not declare `SendMessage`, and unsigned positives skip when
+     * the agent requires their method. Has no effect when `agentCapability` is
+     * provided (its own `protocol_methods_required_for` governs).
+     */
+    agentProtocolMethodsRequiredFor?: readonly string[];
     /**
      * Transport shape the agent speaks. `'mcp'` (default) wraps each
      * vector body in a JSON-RPC `tools/call` envelope and POSTs to the MCP
@@ -101,6 +112,11 @@ export interface GradeOptions extends LoadVectorsOptions {
      * sits as transport-layer middleware ahead of MCP dispatch.
      *
      * See adcontextprotocol/adcp-client#612 for the MCP-mode rationale.
+     *
+     * `'a2a'` additionally grades the A2A operation-resolution vectors
+     * (adcp#7945): `required_for` must be enforced against the operation named
+     * by the invocation DataPart's `skill`, not the JSON-RPC method. See
+     * `a2a-operation-resolution.ts`. Vector ids are prefixed `a2a/`.
      */
     transport?: 'raw' | 'mcp' | 'a2a';
     /** Trusted Agent Card fetch seam for A2A tests and custom runtimes. */
@@ -167,6 +183,12 @@ export interface VectorGradeResult {
     /** For negatives: the error code the spec says we should see. */
     expected_error_code?: string;
     http_status: number;
+    /**
+     * A2A operation-resolution vectors only: `contradiction-resolution` is MUST
+     * for a 3.2 verifier; `hardening` is SHOULD in 3.2.x and MUST from 3.3.
+     * Hardening failures still count as failures; the tier tells you which kind.
+     */
+    tier?: A2aVectorTier;
     /** Actual endpoint probed when it differs from the configured agent URL (notably A2A card routing). */
     probe_url?: string;
     diagnostic?: string;
@@ -205,6 +227,14 @@ export interface GradeReport {
     contract_loaded: boolean;
     positive: VectorGradeResult[];
     negative: VectorGradeResult[];
+    /**
+     * Present only on `transport: 'a2a'` runs. Per-tier tally of the A2A
+     * operation-resolution vectors, or `vectors_available: false` (with the
+     * reason) when the compliance bundle carries none, so an absent corpus is
+     * never mistaken for a clean pass. The vector rows themselves are in
+     * `positive` / `negative` under `a2a/` ids.
+     */
+    a2a_operation_resolution?: A2aOperationResolutionSummary;
     passed: boolean;
     passed_count: number;
     failed_count: number;

package/dist/lib/testing/storyboard/request-signing/grader.d.ts

@@ -1,5 +1,6 @@
 import { type LoadVectorsOptions } from './vector-loader';
-import type { NegativeVector, PositiveVector, VerifierCapabilityFixture } from './types';
+import { type A2aOperationResolutionSummary } from './a2a-operation-resolution';
+import type { A2aVectorTier, NegativeVector, PositiveVector, VerifierCapabilityFixture } from './types';
 export interface GradeOptions extends LoadVectorsOptions {
     /** Grade only authored 3.2 profile vectors. Omit for the legacy root corpus. */
     signingProfileVersion?: '3.2';
@@ -94,6 +95,16 @@ export interface GradeOptions extends LoadVectorsOptions {
      * shadow-posture agent). Has no effect when `agentCapability` is provided.
      */
     agentRequiredFor?: readonly string[];
+    /**
+     * The agent's advertised `request_signing.protocol_methods_required_for`
+     * (JSON-RPC method names such as `SendMessage` or `tasks/cancel`). Only the
+     * A2A operation-resolution vectors consult it: negative/007 (an unsigned
+     * `SendMessage` rejected because the method itself is required) skips when
+     * the agent does not declare `SendMessage`, and unsigned positives skip when
+     * the agent requires their method. Has no effect when `agentCapability` is
+     * provided (its own `protocol_methods_required_for` governs).
+     */
+    agentProtocolMethodsRequiredFor?: readonly string[];
     /**
      * Transport shape the agent speaks. `'mcp'` (default) wraps each
      * vector body in a JSON-RPC `tools/call` envelope and POSTs to the MCP
@@ -101,6 +112,11 @@ export interface GradeOptions extends LoadVectorsOptions {
      * sits as transport-layer middleware ahead of MCP dispatch.
      *
      * See adcontextprotocol/adcp-client#612 for the MCP-mode rationale.
+     *
+     * `'a2a'` additionally grades the A2A operation-resolution vectors
+     * (adcp#7945): `required_for` must be enforced against the operation named
+     * by the invocation DataPart's `skill`, not the JSON-RPC method. See
+     * `a2a-operation-resolution.ts`. Vector ids are prefixed `a2a/`.
      */
     transport?: 'raw' | 'mcp' | 'a2a';
     /** Trusted Agent Card fetch seam for A2A tests and custom runtimes. */
@@ -167,6 +183,12 @@ export interface VectorGradeResult {
     /** For negatives: the error code the spec says we should see. */
     expected_error_code?: string;
     http_status: number;
+    /**
+     * A2A operation-resolution vectors only: `contradiction-resolution` is MUST
+     * for a 3.2 verifier; `hardening` is SHOULD in 3.2.x and MUST from 3.3.
+     * Hardening failures still count as failures; the tier tells you which kind.
+     */
+    tier?: A2aVectorTier;
     /** Actual endpoint probed when it differs from the configured agent URL (notably A2A card routing). */
     probe_url?: string;
     diagnostic?: string;
@@ -205,6 +227,14 @@ export interface GradeReport {
     contract_loaded: boolean;
     positive: VectorGradeResult[];
     negative: VectorGradeResult[];
+    /**
+     * Present only on `transport: 'a2a'` runs. Per-tier tally of the A2A
+     * operation-resolution vectors, or `vectors_available: false` (with the
+     * reason) when the compliance bundle carries none, so an absent corpus is
+     * never mistaken for a clean pass. The vector rows themselves are in
+     * `positive` / `negative` under `a2a/` ids.
+     */
+    a2a_operation_resolution?: A2aOperationResolutionSummary;
     passed: boolean;
     passed_count: number;
     failed_count: number;

package/dist/lib/testing/storyboard/request-signing/grader.js

@@ -32,6 +32,7 @@ var import_probe = require('./probe.js');
 var import_vector_loader = require('./vector-loader.js');
 var import_a2a_dispatch = require('./a2a-dispatch.js');
 var import_test_kit = require('./test-kit.js');
+var import_a2a_operation_resolution = require('./a2a-operation-resolution.js');
 var import_signing = require('../../../signing/index.js');
 var import_parser = require('../../../signing/parser.js');
 async function gradeRequestSigning(agentUrl, options = {}) {
@@ -88,6 +89,15 @@ async function gradeRequestSigning(agentUrl, options = {}) {
       withA2aProbeUrl(await gradeNegative(vector, loaded, contract, probeOpts, buildOpts, options), buildOpts)
     );
   }
+  let a2aSummary;
+  if (transport === "a2a") {
+    const a2a = await (0, import_a2a_operation_resolution.gradeA2aOperationResolution)(agentUrl, loaded.keys, contract, options);
+    if (a2a) {
+      positive.push(...a2a.positive);
+      negative.push(...a2a.negative);
+      a2aSummary = a2a.summary;
+    }
+  }
   const all = [...positive, ...negative];
   const passed_count = all.filter((r) => r.passed && !r.skipped).length;
   const skipped_count = all.filter((r) => r.skipped).length;
@@ -103,6 +113,7 @@ async function gradeRequestSigning(agentUrl, options = {}) {
     contract_loaded: Boolean(contract),
     positive,
     negative,
+    ...a2aSummary ? { a2a_operation_resolution: a2aSummary } : {},
     passed,
     passed_count,
     failed_count,

package/dist/lib/testing/storyboard/request-signing/grader.mjs

@@ -4,6 +4,7 @@ import { initializeMcpSession, probeSignedRequest } from "./probe.mjs";
 import { loadRequestSigningVectors, selectRequestSigningVectors } from "./vector-loader.mjs";
 import { captureA2aRequest, operationFromVectorUrl } from "./a2a-dispatch.mjs";
 import { loadSignedRequestsRunnerContract } from "./test-kit.mjs";
+import { gradeA2aOperationResolution } from "./a2a-operation-resolution.mjs";
 import {
   InMemoryReplayStore,
   InMemoryRevocationStore,
@@ -67,6 +68,15 @@ async function gradeRequestSigning(agentUrl, options = {}) {
       withA2aProbeUrl(await gradeNegative(vector, loaded, contract, probeOpts, buildOpts, options), buildOpts)
     );
   }
+  let a2aSummary;
+  if (transport === "a2a") {
+    const a2a = await gradeA2aOperationResolution(agentUrl, loaded.keys, contract, options);
+    if (a2a) {
+      positive.push(...a2a.positive);
+      negative.push(...a2a.negative);
+      a2aSummary = a2a.summary;
+    }
+  }
   const all = [...positive, ...negative];
   const passed_count = all.filter((r) => r.passed && !r.skipped).length;
   const skipped_count = all.filter((r) => r.skipped).length;
@@ -82,6 +92,7 @@ async function gradeRequestSigning(agentUrl, options = {}) {
     contract_loaded: Boolean(contract),
     positive,
     negative,
+    ...a2aSummary ? { a2a_operation_resolution: a2aSummary } : {},
     passed,
     passed_count,
     failed_count,

package/dist/lib/testing/storyboard/request-signing/index.d.mts

@@ -27,12 +27,13 @@
  * `StoryboardRunOptions.request_signing` on the runner options.
  */
 export { gradeRequestSigning, gradeOneVector, type GradeOptions, type GradeReport, type VectorGradeResult, } from './grader.mjs';
+export { A2A_UNAVAILABLE_ROW_ID, type A2aOperationResolutionSummary, type A2aTierSummary, } from './a2a-operation-resolution.mjs';
 export { synthesizeRequestSigningSteps, parseRequestSigningStepId, REQUEST_SIGNING_PROBE_TASK, POSITIVE_STEP_PREFIX, NEGATIVE_STEP_PREFIX, type SynthesizeOptions, } from './synthesize.mjs';
 export { probeRequestSigningVector } from './probe-dispatch.mjs';
-export type { NegativeVector, PositiveVector, TestKeypair, TestKeyset, VectorRequest, VerifierCapabilityFixture, Vector, ContractId, } from './types.mjs';
-export { CONTRACT_IDS } from './types.mjs';
-export { loadRequestSigningVectors, findKey, type LoadVectorsOptions, type LoadedVectors } from './vector-loader.mjs';
+export type { NegativeVector, PositiveVector, TestKeypair, TestKeyset, VectorRequest, VerifierCapabilityFixture, Vector, ContractId, A2aExpectedOutcome, A2aNegativeVector, A2aPositiveVector, A2aVector, A2aVectorTier, } from './types.mjs';
+export { CONTRACT_IDS, A2A_VECTOR_TIERS } from './types.mjs';
+export { loadRequestSigningVectors, loadA2aOperationResolutionVectors, findKey, A2A_VECTORS_UNAVAILABLE_MESSAGE, A2A_VECTORS_DIR_ENV, type A2aVectorSource, type LoadVectorsOptions, type LoadedA2aVectors, type LoadedVectors, } from './vector-loader.mjs';
 export { buildPositiveRequest, buildNegativeRequest, listSupportedNegativeVectors, type BuildOptions, type SignedHttpRequest, } from './builder.mjs';
-export { captureA2aRequest, resolveA2aDispatchTarget, operationFromVectorUrl, type A2aCall, type A2aDispatchOptions, type CapturedA2aRequest, } from './a2a-dispatch.mjs';
+export { captureA2aRequest, resolveA2aDispatchTarget, resolveA2aHttpJsonEndpoint, operationFromVectorUrl, type A2aCall, type A2aDispatchOptions, type CapturedA2aRequest, } from './a2a-dispatch.mjs';
 export { loadSignedRequestsRunnerContract, type LoadTestKitOptions, type RateAbuseContract, type ReplayWindowContract, type RevocationContract, type RunnerSigningKey, type SignedRequestsRunnerContract, } from './test-kit.mjs';
 export { probeSignedRequest, initializeMcpSession, attachMcpSessionHeader, extractSignatureErrorCode, type ProbeOptions, type ProbeResult, } from './probe.mjs';

package/dist/lib/testing/storyboard/request-signing/index.d.ts

@@ -27,12 +27,13 @@
  * `StoryboardRunOptions.request_signing` on the runner options.
  */
 export { gradeRequestSigning, gradeOneVector, type GradeOptions, type GradeReport, type VectorGradeResult, } from './grader';
+export { A2A_UNAVAILABLE_ROW_ID, type A2aOperationResolutionSummary, type A2aTierSummary, } from './a2a-operation-resolution';
 export { synthesizeRequestSigningSteps, parseRequestSigningStepId, REQUEST_SIGNING_PROBE_TASK, POSITIVE_STEP_PREFIX, NEGATIVE_STEP_PREFIX, type SynthesizeOptions, } from './synthesize';
 export { probeRequestSigningVector } from './probe-dispatch';
-export type { NegativeVector, PositiveVector, TestKeypair, TestKeyset, VectorRequest, VerifierCapabilityFixture, Vector, ContractId, } from './types';
-export { CONTRACT_IDS } from './types';
-export { loadRequestSigningVectors, findKey, type LoadVectorsOptions, type LoadedVectors } from './vector-loader';
+export type { NegativeVector, PositiveVector, TestKeypair, TestKeyset, VectorRequest, VerifierCapabilityFixture, Vector, ContractId, A2aExpectedOutcome, A2aNegativeVector, A2aPositiveVector, A2aVector, A2aVectorTier, } from './types';
+export { CONTRACT_IDS, A2A_VECTOR_TIERS } from './types';
+export { loadRequestSigningVectors, loadA2aOperationResolutionVectors, findKey, A2A_VECTORS_UNAVAILABLE_MESSAGE, A2A_VECTORS_DIR_ENV, type A2aVectorSource, type LoadVectorsOptions, type LoadedA2aVectors, type LoadedVectors, } from './vector-loader';
 export { buildPositiveRequest, buildNegativeRequest, listSupportedNegativeVectors, type BuildOptions, type SignedHttpRequest, } from './builder';
-export { captureA2aRequest, resolveA2aDispatchTarget, operationFromVectorUrl, type A2aCall, type A2aDispatchOptions, type CapturedA2aRequest, } from './a2a-dispatch';
+export { captureA2aRequest, resolveA2aDispatchTarget, resolveA2aHttpJsonEndpoint, operationFromVectorUrl, type A2aCall, type A2aDispatchOptions, type CapturedA2aRequest, } from './a2a-dispatch';
 export { loadSignedRequestsRunnerContract, type LoadTestKitOptions, type RateAbuseContract, type ReplayWindowContract, type RevocationContract, type RunnerSigningKey, type SignedRequestsRunnerContract, } from './test-kit';
 export { probeSignedRequest, initializeMcpSession, attachMcpSessionHeader, extractSignatureErrorCode, type ProbeOptions, type ProbeResult, } from './probe';

package/dist/lib/testing/storyboard/request-signing/index.js

@@ -18,6 +18,10 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var request_signing_exports = {};
 __export(request_signing_exports, {
+  A2A_UNAVAILABLE_ROW_ID: () => import_a2a_operation_resolution.A2A_UNAVAILABLE_ROW_ID,
+  A2A_VECTORS_DIR_ENV: () => import_vector_loader.A2A_VECTORS_DIR_ENV,
+  A2A_VECTORS_UNAVAILABLE_MESSAGE: () => import_vector_loader.A2A_VECTORS_UNAVAILABLE_MESSAGE,
+  A2A_VECTOR_TIERS: () => import_types.A2A_VECTOR_TIERS,
   CONTRACT_IDS: () => import_types.CONTRACT_IDS,
   NEGATIVE_STEP_PREFIX: () => import_synthesize.NEGATIVE_STEP_PREFIX,
   POSITIVE_STEP_PREFIX: () => import_synthesize.POSITIVE_STEP_PREFIX,
@@ -32,6 +36,7 @@ __export(request_signing_exports, {
   gradeRequestSigning: () => import_grader.gradeRequestSigning,
   initializeMcpSession: () => import_probe.initializeMcpSession,
   listSupportedNegativeVectors: () => import_builder.listSupportedNegativeVectors,
+  loadA2aOperationResolutionVectors: () => import_vector_loader.loadA2aOperationResolutionVectors,
   loadRequestSigningVectors: () => import_vector_loader.loadRequestSigningVectors,
   loadSignedRequestsRunnerContract: () => import_test_kit.loadSignedRequestsRunnerContract,
   operationFromVectorUrl: () => import_a2a_dispatch.operationFromVectorUrl,
@@ -39,10 +44,12 @@ __export(request_signing_exports, {
   probeRequestSigningVector: () => import_probe_dispatch.probeRequestSigningVector,
   probeSignedRequest: () => import_probe.probeSignedRequest,
   resolveA2aDispatchTarget: () => import_a2a_dispatch.resolveA2aDispatchTarget,
+  resolveA2aHttpJsonEndpoint: () => import_a2a_dispatch.resolveA2aHttpJsonEndpoint,
   synthesizeRequestSigningSteps: () => import_synthesize.synthesizeRequestSigningSteps
 });
 module.exports = __toCommonJS(request_signing_exports);
 var import_grader = require('./grader.js');
+var import_a2a_operation_resolution = require('./a2a-operation-resolution.js');
 var import_synthesize = require('./synthesize.js');
 var import_probe_dispatch = require('./probe-dispatch.js');
 var import_types = require('./types.js');
@@ -53,6 +60,10 @@ var import_test_kit = require('./test-kit.js');
 var import_probe = require('./probe.js');
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  A2A_UNAVAILABLE_ROW_ID,
+  A2A_VECTORS_DIR_ENV,
+  A2A_VECTORS_UNAVAILABLE_MESSAGE,
+  A2A_VECTOR_TIERS,
   CONTRACT_IDS,
   NEGATIVE_STEP_PREFIX,
   POSITIVE_STEP_PREFIX,
@@ -67,6 +78,7 @@ var import_probe = require('./probe.js');
   gradeRequestSigning,
   initializeMcpSession,
   listSupportedNegativeVectors,
+  loadA2aOperationResolutionVectors,
   loadRequestSigningVectors,
   loadSignedRequestsRunnerContract,
   operationFromVectorUrl,
@@ -74,5 +86,6 @@ var import_probe = require('./probe.js');
   probeRequestSigningVector,
   probeSignedRequest,
   resolveA2aDispatchTarget,
+  resolveA2aHttpJsonEndpoint,
   synthesizeRequestSigningSteps
 });

package/dist/lib/testing/storyboard/request-signing/index.mjs

@@ -2,6 +2,9 @@ import {
   gradeRequestSigning,
   gradeOneVector
 } from "./grader.mjs";
+import {
+  A2A_UNAVAILABLE_ROW_ID
+} from "./a2a-operation-resolution.mjs";
 import {
   synthesizeRequestSigningSteps,
   parseRequestSigningStepId,
@@ -10,8 +13,14 @@ import {
   NEGATIVE_STEP_PREFIX
 } from "./synthesize.mjs";
 import { probeRequestSigningVector } from "./probe-dispatch.mjs";
-import { CONTRACT_IDS } from "./types.mjs";
-import { loadRequestSigningVectors, findKey } from "./vector-loader.mjs";
+import { CONTRACT_IDS, A2A_VECTOR_TIERS } from "./types.mjs";
+import {
+  loadRequestSigningVectors,
+  loadA2aOperationResolutionVectors,
+  findKey,
+  A2A_VECTORS_UNAVAILABLE_MESSAGE,
+  A2A_VECTORS_DIR_ENV
+} from "./vector-loader.mjs";
 import {
   buildPositiveRequest,
   buildNegativeRequest,
@@ -20,6 +29,7 @@ import {
 import {
   captureA2aRequest,
   resolveA2aDispatchTarget,
+  resolveA2aHttpJsonEndpoint,
   operationFromVectorUrl
 } from "./a2a-dispatch.mjs";
 import {
@@ -32,6 +42,10 @@ import {
   extractSignatureErrorCode
 } from "./probe.mjs";
 export {
+  A2A_UNAVAILABLE_ROW_ID,
+  A2A_VECTORS_DIR_ENV,
+  A2A_VECTORS_UNAVAILABLE_MESSAGE,
+  A2A_VECTOR_TIERS,
   CONTRACT_IDS,
   NEGATIVE_STEP_PREFIX,
   POSITIVE_STEP_PREFIX,
@@ -46,6 +60,7 @@ export {
   gradeRequestSigning,
   initializeMcpSession,
   listSupportedNegativeVectors,
+  loadA2aOperationResolutionVectors,
   loadRequestSigningVectors,
   loadSignedRequestsRunnerContract,
   operationFromVectorUrl,
@@ -53,5 +68,6 @@ export {
   probeRequestSigningVector,
   probeSignedRequest,
   resolveA2aDispatchTarget,
+  resolveA2aHttpJsonEndpoint,
   synthesizeRequestSigningSteps
 };