@adcp/sdk 15.0.0 → 15.2.1

package/dist/lib/server/auth-signature.d.ts

@@ -19,7 +19,7 @@
  *   verifyApiKey,
  *   anyOf,
  *   verifySignatureAsAuthenticator,
- *   mcpToolNameResolver,
+ *   adcpOperationResolver,
  * } from '@adcp/sdk/server';
  *
  * serve(createAgent, {
@@ -28,7 +28,7 @@
  *     verifySignatureAsAuthenticator({
  *       jwks, replayStore, revocationStore,
  *       capability: { supported: true, required_for: [], covers_content_digest: 'either' },
- *       resolveOperation: mcpToolNameResolver,
+ *       resolveOperation: adcpOperationResolver,
  *     }),
  *   ),
  * });
@@ -42,6 +42,7 @@ import type { JwksResolver } from '../signing/jwks';
 import { type ReplayStore } from '../signing/replay';
 import { type RevocationStore } from '../signing/revocation';
 import type { VerifiedSigner, VerifierCapability } from '../signing/types';
+import { type OperationResolutionInput, type ResolvedOperation } from '../signing/operation-resolution';
 import { type AuthPrincipal, type Authenticator } from './auth';
 export interface VerifySignatureAsAuthenticatorOptions {
     /** Verifier capability block. `required_for` is not enforced here — unsigned
@@ -82,17 +83,22 @@ export interface VerifySignatureAsAuthenticatorOptions {
      * before this runs. Same semantics as
      * `ExpressMiddlewareOptions.resolveOperation` on {@link createExpressVerifier}.
      *
+     * Pass {@link adcpOperationResolver}: it resolves MCP `tools/call` and A2A
+     * `SendMessage` / `message/send` requests, and reports a body that does not
+     * resolve to exactly one operation as unresolvable, which the verifier
+     * rejects with `request_body_malformed`.
+     *
      * SECURITY: a resolver that always returns `undefined` disables
-     * `capability.required_for` enforcement for this authenticator. Since the
-     * bypass here is intentional (this adapter is for composition with other
-     * authenticators — see the module docstring), the fall-through still
-     * happens when the resolver returns `undefined`, so `required_for`
-     * enforcement should live in a separate `preTransport`-mounted verifier
-     * when composition is active.
+     * `capability.required_for` enforcement for this authenticator. This adapter
+     * is for composition with other authenticators (see the module docstring),
+     * so unsigned requests fall through to the next authenticator regardless;
+     * `required_for` enforcement on the unsigned path belongs to
+     * {@link requireSignatureWhenPresent}, which fails closed on an
+     * unresolvable body.
      */
     resolveOperation: (req: IncomingMessage & {
         rawBody?: string;
-    }) => string | undefined;
+    }) => ResolvedOperation;
     /**
      * Override how the request's full URL is reconstructed. Use when the
      * server sits behind a TLS-terminating or path-rewriting load balancer
@@ -202,21 +208,37 @@ export interface RequireSignatureWhenPresentOptions {
      */
     requiredFor?: readonly string[];
     /**
-     * Extract the AdCP operation name (or any identifier that can be
-     * matched against `requiredFor`) from the incoming request.
+     * JSON-RPC protocol methods (e.g. `CancelTask`, `tasks/cancel`) that MUST be
+     * signed, matching `capability.protocol_methods_required_for`. Matched
+     * against the JSON-RPC `method` only, never against the resolved operation.
+     * Like {@link requiredFor}, a valid fallback credential satisfies it.
+     */
+    protocolMethodsRequiredFor?: readonly string[];
+    /**
+     * Resolve the AdCP operation a request carries. Defaults to
+     * {@link adcpOperationResolver}, which understands MCP `tools/call` and A2A
+     * `SendMessage` / `SendStreamingMessage` / `message/send` / `message/stream`.
      *
-     * For MCP agents, pass the exported {@link mcpToolNameResolver} — it
-     * implements the standard `tools/call` → `params.name` parse. For A2A
-     * agents (or other non-JSON-RPC envelopes), supply a bespoke resolver.
+     * A resolver may return:
+     * - an operation name, matched against {@link requiredFor};
+     * - `undefined` for a request that carries no AdCP operation (discovery
+     *   probes, `tasks/*`) — the request is not subject to {@link requiredFor};
+     * - {@link UNRESOLVABLE_OPERATION} for a body that does not resolve to
+     *   exactly one operation. The gate rejects it with `request_body_malformed`
+     *   before it looks at any signature header or credential, whether or not
+     *   the request is signed. An ambiguous body is never treated as "an
+     *   operation that is not in `requiredFor`".
      *
-     * When `requiredFor` is set but `resolveOperation` is omitted OR
-     * returns `undefined`, the pre-check is skipped — better to let the
-     * downstream handler produce a precise `INVALID_REQUEST` than to
-     * reject every unsigned call as signature-required.
+     * Omitting this option no longer disables the pre-check: a gate with
+     * `requiredFor` set and no resolver used to skip enforcement for every
+     * request. The default resolver is used instead. `requiredFor` and the
+     * resolver are only as good as each other — a resolver that returns
+     * `undefined` for A2A messages (such as {@link mcpToolNameResolver}) leaves
+     * `requiredFor` unenforced over A2A.
      */
     resolveOperation?: (req: IncomingMessage & {
         rawBody?: string;
-    }) => string | undefined;
+    }) => ResolvedOperation;
 }
 /**
  * Compose a signature authenticator with a fallback under presence-gated
@@ -252,10 +274,12 @@ export interface RequireAuthenticatedOrSignedOptions {
      * declaration in `capabilities.request_signing.required_for`.
      */
     requiredFor?: readonly string[];
+    /** See {@link RequireSignatureWhenPresentOptions.protocolMethodsRequiredFor}. */
+    protocolMethodsRequiredFor?: readonly string[];
     /** See {@link RequireSignatureWhenPresentOptions.resolveOperation}. */
     resolveOperation?: (req: IncomingMessage & {
         rawBody?: string;
-    }) => string | undefined;
+    }) => ResolvedOperation;
 }
 /**
  * Bundled composition of {@link requireSignatureWhenPresent} with an
@@ -279,7 +303,7 @@ export interface RequireAuthenticatedOrSignedOptions {
  *   anyOf,
  *   verifySignatureAsAuthenticator,
  *   requireAuthenticatedOrSigned,
- *   mcpToolNameResolver,
+ *   adcpOperationResolver,
  *   MUTATING_TASKS,
  * } from '@adcp/sdk/server';
  *
@@ -287,43 +311,57 @@ export interface RequireAuthenticatedOrSignedOptions {
  *   authenticate: requireAuthenticatedOrSigned({
  *     signature: verifySignatureAsAuthenticator({
  *       jwks, replayStore, revocationStore, capability,
- *       resolveOperation: mcpToolNameResolver,
+ *       resolveOperation: adcpOperationResolver,
  *     }),
  *     fallback: anyOf(verifyApiKey({ keys }), verifyBearer({ jwksUri, issuer, audience })),
  *     requiredFor: [...MUTATING_TASKS],
- *     resolveOperation: mcpToolNameResolver,
+ *     resolveOperation: adcpOperationResolver,
  *   }),
  * });
  * ```
  */
 export declare function requireAuthenticatedOrSigned(options: RequireAuthenticatedOrSignedOptions): Authenticator;
 /**
- * Default `resolveOperation` for MCP agents. Parses the buffered JSON-RPC
- * body on `req.rawBody` and returns `params.name` when `method === 'tools/call'`.
- * Returns `undefined` for non-`tools/call` methods, a missing body, or
- * malformed JSON — the same "skip the pre-check and let the handler produce
- * a precise error" semantics every other `resolveOperation` in the SDK
- * uses.
+ * Resolve the AdCP operation a request carries, for MCP and A2A alike
+ * (adcp#7945, "Operation resolution over A2A"). Pass it as `resolveOperation`
+ * on {@link verifySignatureAsAuthenticator}, {@link requireSignatureWhenPresent},
+ * {@link requireAuthenticatedOrSigned}, or `createExpressVerifier` from
+ * `@adcp/sdk/signing`; it is the default for the composers.
  *
- * Pass directly as `resolveOperation` on {@link verifySignatureAsAuthenticator},
- * {@link requireSignatureWhenPresent}, {@link requireAuthenticatedOrSigned},
- * or `createExpressVerifier` from `@adcp/sdk/signing`:
+ * | Request                                                                 | Result                         |
+ * |-------------------------------------------------------------------------|--------------------------------|
+ * | MCP `tools/call`                                                        | `params.name`                  |
+ * | A2A `SendMessage`, `SendStreamingMessage`, `message/send`, `message/stream` | `skill` of the sole DataPart |
+ * | any other JSON-RPC method (`tasks/*`, `CancelTask`, `initialize`, …)    | `undefined` (no operation)     |
+ * | non-`POST` request                                                      | `undefined`                    |
+ * | anything ambiguous                                                      | {@link UNRESOLVABLE_OPERATION} |
  *
- * ```ts
- * serve(createAgent, {
- *   authenticate: requireAuthenticatedOrSigned({
- *     signature: verifySignatureAsAuthenticator({
- *       jwks, replayStore, revocationStore, capability,
- *       resolveOperation: mcpToolNameResolver,
- *     }),
- *     fallback: anyOf(verifyApiKey({ keys }), verifyBearer({ jwksUri, issuer, audience })),
- *     requiredFor: [...MUTATING_TASKS],
- *     resolveOperation: mcpToolNameResolver,
- *   }),
- * });
- * ```
+ * Ambiguous means: an empty or non-JSON body on a `POST`, a JSON-RPC batch or
+ * non-object body, a missing `method`, duplicate object keys (compared after
+ * JSON string decoding), a case variant of a recognized member name (`Skill`,
+ * `Parts`), zero or more than one DataPart, a FilePart (`raw`, `url`, `file`),
+ * a Part with other than one content member or a `kind` that disagrees with
+ * it, `data` that is not an object, or a `skill` / `params.name` that is not a
+ * non-empty string. Matching is exact and case-sensitive.
+ *
+ * The consumers reject {@link UNRESOLVABLE_OPERATION} with
+ * `request_body_malformed`, never as "an operation that is not in
+ * `required_for`". `req.rawBody` must hold the exact bytes the client sent.
+ */
+export declare function adcpOperationResolver(req: OperationResolutionInput | (IncomingMessage & {
+    rawBody?: string | Buffer;
+})): ResolvedOperation;
+/**
+ * Resolver for MCP agents. Parses the buffered JSON-RPC body on `req.rawBody`
+ * and returns `params.name` when `method === 'tools/call'`; returns
+ * `undefined` for every other method, a missing body, or malformed JSON.
  *
- * A2A agents use a different envelope — write a bespoke resolver there.
+ * **MCP only, and lenient.** It does not understand A2A: an A2A
+ * `SendMessage` resolves to `undefined`, so a `requiredFor` list guarded by
+ * this resolver is NOT enforced over A2A. It also treats an ambiguous body as
+ * "no operation". Prefer {@link adcpOperationResolver}, which resolves A2A and
+ * reports ambiguity as {@link UNRESOLVABLE_OPERATION}. Kept for callers that
+ * pin the previous behavior.
  */
 export declare function mcpToolNameResolver(req: {
     rawBody?: string;

package/dist/lib/server/auth-signature.js

@@ -18,6 +18,7 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var auth_signature_exports = {};
 __export(auth_signature_exports, {
+  adcpOperationResolver: () => adcpOperationResolver,
   mcpToolNameResolver: () => mcpToolNameResolver,
   principalForVerifiedSigner: () => principalForVerifiedSigner,
   requireAuthenticatedOrSigned: () => requireAuthenticatedOrSigned,
@@ -28,6 +29,7 @@ module.exports = __toCommonJS(auth_signature_exports);
 var import_errors = require('../signing/errors.js');
 var import_replay = require('../signing/replay.js');
 var import_revocation = require('../signing/revocation.js');
+var import_operation_resolution = require('../signing/operation-resolution.js');
 var import_verifier = require('../signing/verifier.js');
 var import_buyer_agent = require('./decisioning/buyer-agent.js');
 var import_auth = require('./auth.js');
@@ -112,8 +114,18 @@ function principalForVerifiedSigner(signer, makePrincipal) {
 }
 function requireSignatureWhenPresent(signatureAuth, fallbackAuth, options = {}) {
   const requiredFor = new Set(options.requiredFor ?? []);
-  const resolveOperation = options.resolveOperation;
+  const unsignedCapability = {
+    required_for: [...requiredFor],
+    ...options.protocolMethodsRequiredFor ? { protocol_methods_required_for: [...options.protocolMethodsRequiredFor] } : {}
+  };
+  const resolveOperation = options.resolveOperation ?? (requiredFor.size > 0 || unsignedCapability.protocol_methods_required_for ? adcpOperationResolver : void 0);
   const combined = async (req) => {
+    const request = req;
+    const operation = resolveOperation?.(request);
+    if ((0, import_operation_resolution.isUnresolvableOperation)(operation)) {
+      logUnresolvable(request);
+      throw signatureAuthError((0, import_verifier.unresolvableOperationError)());
+    }
     if (hasSignatureHeader(req)) {
       const result = await signatureAuth(req);
       if (result === null) {
@@ -121,6 +133,12 @@ function requireSignatureWhenPresent(signatureAuth, fallbackAuth, options = {})
       }
       return result;
     }
+    const body = bodyText(request);
+    try {
+      (0, import_verifier.assertUnsignedWebhookAuthenticationAbsent)(body);
+    } catch (err) {
+      throw asSignatureAuthError(err);
+    }
     let fallbackResult = null;
     let fallbackError;
     let fallbackThrew = false;
@@ -131,23 +149,16 @@ function requireSignatureWhenPresent(signatureAuth, fallbackAuth, options = {})
       fallbackError = err;
     }
     if (fallbackResult !== null) return fallbackResult;
-    if (requiredFor.size > 0 && resolveOperation) {
-      const operation = resolveOperation(req);
-      if (operation && requiredFor.has(operation)) {
-        throw new import_auth.AuthError(`Signature required for ${operation}.`, {
-          cause: new import_errors.RequestSignatureError(
-            "request_signature_required",
-            0,
-            `Operation ${operation} requires an RFC 9421 request signature when no other credentials are presented.`
-          )
-        });
-      }
+    try {
+      (0, import_verifier.assertUnsignedOperationNotRequired)(operation, unsignedCapability);
+      (0, import_verifier.assertUnsignedProtocolMethodNotRequired)(body, unsignedCapability);
+    } catch (err) {
+      throw asSignatureAuthError(err);
     }
     if (fallbackThrew) throw fallbackError;
     return null;
   };
-  const anyChildNeedsRawBody = (0, import_auth.authenticatorNeedsRawBody)(signatureAuth) || (0, import_auth.authenticatorNeedsRawBody)(fallbackAuth);
-  if (anyChildNeedsRawBody || resolveOperation) {
+  if (resolveOperation || (0, import_auth.authenticatorNeedsRawBody)(signatureAuth) || (0, import_auth.authenticatorNeedsRawBody)(fallbackAuth)) {
     (0, import_auth.tagAuthenticatorNeedsRawBody)(combined);
   }
   (0, import_auth.tagAuthenticatorPresenceGated)(combined);
@@ -156,9 +167,13 @@ function requireSignatureWhenPresent(signatureAuth, fallbackAuth, options = {})
 function requireAuthenticatedOrSigned(options) {
   return requireSignatureWhenPresent(options.signature, options.fallback, {
     requiredFor: options.requiredFor,
+    protocolMethodsRequiredFor: options.protocolMethodsRequiredFor,
     resolveOperation: options.resolveOperation
   });
 }
+function adcpOperationResolver(req) {
+  return (0, import_operation_resolution.resolveRequestOperation)(operationInput(req));
+}
 function mcpToolNameResolver(req) {
   const raw = req.rawBody;
   if (!raw) return void 0;
@@ -171,6 +186,24 @@ function mcpToolNameResolver(req) {
     return void 0;
   }
 }
+function operationInput(req) {
+  const candidate = req;
+  return { rawBody: candidate.rawBody, method: candidate.method, url: candidate.url };
+}
+function bodyText(req) {
+  const raw = req.rawBody;
+  return typeof raw === "string" ? raw : raw?.toString("utf8");
+}
+function signatureAuthError(err) {
+  return new import_auth.AuthError(`Signature rejected (${err.code}).`, { cause: err });
+}
+function asSignatureAuthError(err) {
+  return err instanceof import_errors.RequestSignatureError ? signatureAuthError(err) : err;
+}
+function logUnresolvable(req) {
+  const reason = (0, import_operation_resolution.describeUnresolvable)(operationInput(req));
+  console.error(`[adcp/auth] request body does not resolve to one operation: ${reason ?? "unknown"}`);
+}
 const SAFE_KEYID = /^[A-Za-z0-9._-]{1,256}$/;
 function hasSignatureHeader(req) {
   return nonEmptyHeader(req.headers["signature-input"]) || nonEmptyHeader(req.headers["signature"]);
@@ -204,6 +237,7 @@ function firstHeader(value) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  adcpOperationResolver,
   mcpToolNameResolver,
   principalForVerifiedSigner,
   requireAuthenticatedOrSigned,

package/dist/lib/server/auth-signature.mjs

@@ -1,7 +1,18 @@
 import { RequestSignatureError } from "../signing/errors.mjs";
 import { InMemoryReplayStore } from "../signing/replay.mjs";
 import { InMemoryRevocationStore } from "../signing/revocation.mjs";
-import { verifyRequestSignature } from "../signing/verifier.mjs";
+import {
+  isUnresolvableOperation,
+  resolveRequestOperation,
+  describeUnresolvable
+} from "../signing/operation-resolution.mjs";
+import {
+  assertUnsignedOperationNotRequired,
+  assertUnsignedProtocolMethodNotRequired,
+  assertUnsignedWebhookAuthenticationAbsent,
+  unresolvableOperationError,
+  verifyRequestSignature
+} from "../signing/verifier.mjs";
 import { markVerifiedHttpSig } from "./decisioning/buyer-agent.mjs";
 import {
   AuthError,
@@ -91,8 +102,18 @@ function principalForVerifiedSigner(signer, makePrincipal) {
 }
 function requireSignatureWhenPresent(signatureAuth, fallbackAuth, options = {}) {
   const requiredFor = new Set(options.requiredFor ?? []);
-  const resolveOperation = options.resolveOperation;
+  const unsignedCapability = {
+    required_for: [...requiredFor],
+    ...options.protocolMethodsRequiredFor ? { protocol_methods_required_for: [...options.protocolMethodsRequiredFor] } : {}
+  };
+  const resolveOperation = options.resolveOperation ?? (requiredFor.size > 0 || unsignedCapability.protocol_methods_required_for ? adcpOperationResolver : void 0);
   const combined = async (req) => {
+    const request = req;
+    const operation = resolveOperation?.(request);
+    if (isUnresolvableOperation(operation)) {
+      logUnresolvable(request);
+      throw signatureAuthError(unresolvableOperationError());
+    }
     if (hasSignatureHeader(req)) {
       const result = await signatureAuth(req);
       if (result === null) {
@@ -100,6 +121,12 @@ function requireSignatureWhenPresent(signatureAuth, fallbackAuth, options = {})
       }
       return result;
     }
+    const body = bodyText(request);
+    try {
+      assertUnsignedWebhookAuthenticationAbsent(body);
+    } catch (err) {
+      throw asSignatureAuthError(err);
+    }
     let fallbackResult = null;
     let fallbackError;
     let fallbackThrew = false;
@@ -110,23 +137,16 @@ function requireSignatureWhenPresent(signatureAuth, fallbackAuth, options = {})
       fallbackError = err;
     }
     if (fallbackResult !== null) return fallbackResult;
-    if (requiredFor.size > 0 && resolveOperation) {
-      const operation = resolveOperation(req);
-      if (operation && requiredFor.has(operation)) {
-        throw new AuthError(`Signature required for ${operation}.`, {
-          cause: new RequestSignatureError(
-            "request_signature_required",
-            0,
-            `Operation ${operation} requires an RFC 9421 request signature when no other credentials are presented.`
-          )
-        });
-      }
+    try {
+      assertUnsignedOperationNotRequired(operation, unsignedCapability);
+      assertUnsignedProtocolMethodNotRequired(body, unsignedCapability);
+    } catch (err) {
+      throw asSignatureAuthError(err);
     }
     if (fallbackThrew) throw fallbackError;
     return null;
   };
-  const anyChildNeedsRawBody = authenticatorNeedsRawBody(signatureAuth) || authenticatorNeedsRawBody(fallbackAuth);
-  if (anyChildNeedsRawBody || resolveOperation) {
+  if (resolveOperation || authenticatorNeedsRawBody(signatureAuth) || authenticatorNeedsRawBody(fallbackAuth)) {
     tagAuthenticatorNeedsRawBody(combined);
   }
   tagAuthenticatorPresenceGated(combined);
@@ -135,9 +155,13 @@ function requireSignatureWhenPresent(signatureAuth, fallbackAuth, options = {})
 function requireAuthenticatedOrSigned(options) {
   return requireSignatureWhenPresent(options.signature, options.fallback, {
     requiredFor: options.requiredFor,
+    protocolMethodsRequiredFor: options.protocolMethodsRequiredFor,
     resolveOperation: options.resolveOperation
   });
 }
+function adcpOperationResolver(req) {
+  return resolveRequestOperation(operationInput(req));
+}
 function mcpToolNameResolver(req) {
   const raw = req.rawBody;
   if (!raw) return void 0;
@@ -150,6 +174,24 @@ function mcpToolNameResolver(req) {
     return void 0;
   }
 }
+function operationInput(req) {
+  const candidate = req;
+  return { rawBody: candidate.rawBody, method: candidate.method, url: candidate.url };
+}
+function bodyText(req) {
+  const raw = req.rawBody;
+  return typeof raw === "string" ? raw : raw?.toString("utf8");
+}
+function signatureAuthError(err) {
+  return new AuthError(`Signature rejected (${err.code}).`, { cause: err });
+}
+function asSignatureAuthError(err) {
+  return err instanceof RequestSignatureError ? signatureAuthError(err) : err;
+}
+function logUnresolvable(req) {
+  const reason = describeUnresolvable(operationInput(req));
+  console.error(`[adcp/auth] request body does not resolve to one operation: ${reason ?? "unknown"}`);
+}
 const SAFE_KEYID = /^[A-Za-z0-9._-]{1,256}$/;
 function hasSignatureHeader(req) {
   return nonEmptyHeader(req.headers["signature-input"]) || nonEmptyHeader(req.headers["signature"]);
@@ -182,6 +224,7 @@ function firstHeader(value) {
   return void 0;
 }
 export {
+  adcpOperationResolver,
   mcpToolNameResolver,
   principalForVerifiedSigner,
   requireAuthenticatedOrSigned,

package/dist/lib/server/create-adcp-server.js

@@ -69,6 +69,7 @@ var import_diagnostic_limits = require('../validation/diagnostic-limits.js');
 var import_idempotency2 = require('./idempotency/index.js');
 var import_webhook_emitter = require('./webhook-emitter.js');
 var import_middleware = require('../signing/middleware.js');
+var import_operation_resolution = require('../signing/operation-resolution.js');
 var import_account_mode = require('./account-mode.js');
 var import_test_controller_bridge = require('./test-controller-bridge.js');
 var import_version2 = require('../version.js');
@@ -1431,22 +1432,10 @@ function buildSignedRequestsPreTransport(signedRequests, effectiveRequestSigning
     revocationStore: signedRequests.revocationStore,
     adcpVersion,
     ...signedRequests.agentUrlForKeyid ? { agentUrlForKeyid: signedRequests.agentUrlForKeyid } : {},
-    resolveOperation: (req) => {
-      const raw = req.rawBody;
-      if (!raw) return void 0;
-      try {
-        const parsed = JSON.parse(raw);
-        const messages = Array.isArray(parsed) ? parsed : [parsed];
-        const operations = messages.flatMap((message) => {
-          if (message == null || typeof message !== "object") return [];
-          const candidate = message;
-          return candidate.method === "tools/call" && typeof candidate.params?.name === "string" ? [candidate.params.name] : [];
-        });
-        return operations.find((operation) => requiredFor.includes(operation)) ?? operations[0];
-      } catch {
-      }
-      return void 0;
-    }
+    // One resolver for MCP `tools/call` and A2A message methods; a body that
+    // does not resolve to exactly one operation is rejected by the verifier
+    // (`request_body_malformed`), never treated as "not in required_for".
+    resolveOperation: (req) => (0, import_operation_resolution.resolveRequestOperation)({ rawBody: req.rawBody, method: req.method, url: req.url })
   });
   return async function adcpPreTransport(req, res) {
     const serveContext = (0, import_auth.getServeRequestContext)(req);

package/dist/lib/server/create-adcp-server.mjs

@@ -104,6 +104,7 @@ import {
   createWebhookEmitter
 } from "./webhook-emitter.mjs";
 import { createExpressVerifier } from "../signing/middleware.mjs";
+import { resolveRequestOperation } from "../signing/operation-resolution.mjs";
 import { isSandboxOrMockAccount } from "./account-mode.mjs";
 import {
   isSandboxRequest as isSandboxRequestForSeeding,
@@ -1503,22 +1504,10 @@ function buildSignedRequestsPreTransport(signedRequests, effectiveRequestSigning
     revocationStore: signedRequests.revocationStore,
     adcpVersion,
     ...signedRequests.agentUrlForKeyid ? { agentUrlForKeyid: signedRequests.agentUrlForKeyid } : {},
-    resolveOperation: (req) => {
-      const raw = req.rawBody;
-      if (!raw) return void 0;
-      try {
-        const parsed = JSON.parse(raw);
-        const messages = Array.isArray(parsed) ? parsed : [parsed];
-        const operations = messages.flatMap((message) => {
-          if (message == null || typeof message !== "object") return [];
-          const candidate = message;
-          return candidate.method === "tools/call" && typeof candidate.params?.name === "string" ? [candidate.params.name] : [];
-        });
-        return operations.find((operation) => requiredFor.includes(operation)) ?? operations[0];
-      } catch {
-      }
-      return void 0;
-    }
+    // One resolver for MCP `tools/call` and A2A message methods; a body that
+    // does not resolve to exactly one operation is rejected by the verifier
+    // (`request_body_malformed`), never treated as "not in required_for".
+    resolveOperation: (req) => resolveRequestOperation({ rawBody: req.rawBody, method: req.method, url: req.url })
   });
   return async function adcpPreTransport(req, res) {
     const serveContext = getServeRequestContext(req);

package/dist/lib/server/index.d.mts

@@ -49,7 +49,7 @@ export { verifyApiKey, verifyBearer, anyOf, extractBearerToken, respondUnauthori
 export type { Authenticator, AuthPrincipal, AuthResult, VerifyApiKeyOptions, VerifyBearerOptions, RespondUnauthorizedOptions, ServeRequestContext, } from './auth.mjs';
 export { verifyIntrospection } from './auth-introspection.mjs';
 export type { VerifyIntrospectionOptions, IntrospectionCacheOptions, IntrospectionResponse, } from './auth-introspection.mjs';
-export { verifySignatureAsAuthenticator, requireSignatureWhenPresent, requireAuthenticatedOrSigned, mcpToolNameResolver, } from './auth-signature.mjs';
+export { verifySignatureAsAuthenticator, requireSignatureWhenPresent, requireAuthenticatedOrSigned, mcpToolNameResolver, adcpOperationResolver, } from './auth-signature.mjs';
 export type { VerifySignatureAsAuthenticatorOptions, RequireSignatureWhenPresentOptions, RequireAuthenticatedOrSignedOptions, } from './auth-signature.mjs';
 export { InMemoryStateStore, StateError, PatchConflictError, DEFAULT_MAX_DOCUMENT_BYTES, SESSION_KEY_FIELD, createSessionedStore, scopedStore, patchWithRetry, isPutIfMatchConflict, validateCollection, validateId, validatePayloadSize, validateWrite, } from './state-store.mjs';
 export type { AdcpStateStore, InMemoryStateStoreOptions, ListOptions, ListResult, PatchWithRetryOptions, PutIfMatchResult, StateErrorCode, VersionedDocument, } from './state-store.mjs';

package/dist/lib/server/index.d.ts

@@ -49,7 +49,7 @@ export { verifyApiKey, verifyBearer, anyOf, extractBearerToken, respondUnauthori
 export type { Authenticator, AuthPrincipal, AuthResult, VerifyApiKeyOptions, VerifyBearerOptions, RespondUnauthorizedOptions, ServeRequestContext, } from './auth';
 export { verifyIntrospection } from './auth-introspection';
 export type { VerifyIntrospectionOptions, IntrospectionCacheOptions, IntrospectionResponse, } from './auth-introspection';
-export { verifySignatureAsAuthenticator, requireSignatureWhenPresent, requireAuthenticatedOrSigned, mcpToolNameResolver, } from './auth-signature';
+export { verifySignatureAsAuthenticator, requireSignatureWhenPresent, requireAuthenticatedOrSigned, mcpToolNameResolver, adcpOperationResolver, } from './auth-signature';
 export type { VerifySignatureAsAuthenticatorOptions, RequireSignatureWhenPresentOptions, RequireAuthenticatedOrSignedOptions, } from './auth-signature';
 export { InMemoryStateStore, StateError, PatchConflictError, DEFAULT_MAX_DOCUMENT_BYTES, SESSION_KEY_FIELD, createSessionedStore, scopedStore, patchWithRetry, isPutIfMatchConflict, validateCollection, validateId, validatePayloadSize, validateWrite, } from './state-store';
 export type { AdcpStateStore, InMemoryStateStoreOptions, ListOptions, ListResult, PatchWithRetryOptions, PutIfMatchResult, StateErrorCode, VersionedDocument, } from './state-store';

package/dist/lib/server/index.js

@@ -87,6 +87,7 @@ __export(server_exports, {
   WebhookAuthenticationResolutionError: () => import_webhook_delivery.WebhookAuthenticationResolutionError,
   WebhookDeliveryTerminalError: () => import_webhook_delivery.WebhookDeliveryTerminalError,
   adcpError: () => import_errors.adcpError,
+  adcpOperationResolver: () => import_auth_signature.adcpOperationResolver,
   anyOf: () => import_auth.anyOf,
   applyTargetingInput: () => import_targeting_input.applyTargetingInput,
   assertCreativeTransition: () => import_state_machine.assertCreativeTransition,
@@ -415,6 +416,7 @@ var import_media_buy_action_resolver = require('./media-buy-action-resolver.js')
   WebhookAuthenticationResolutionError,
   WebhookDeliveryTerminalError,
   adcpError,
+  adcpOperationResolver,
   anyOf,
   applyTargetingInput,
   assertCreativeTransition,

package/dist/lib/server/index.mjs

@@ -119,7 +119,8 @@ import {
   verifySignatureAsAuthenticator,
   requireSignatureWhenPresent,
   requireAuthenticatedOrSigned,
-  mcpToolNameResolver
+  mcpToolNameResolver,
+  adcpOperationResolver
 } from "./auth-signature.mjs";
 import {
   InMemoryStateStore,
@@ -363,6 +364,7 @@ export {
   WebhookAuthenticationResolutionError,
   WebhookDeliveryTerminalError,
   adcpError,
+  adcpOperationResolver,
   anyOf,
   applyTargetingInput,
   assertCreativeTransition,