@adcp/sdk 15.0.0 → 15.2.0

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

@@ -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.mjs';
 import { type ReplayStore } from '../signing/replay.mjs';
 import { type RevocationStore } from '../signing/revocation.mjs';
 import type { VerifiedSigner, VerifierCapability } from '../signing/types.mjs';
+import { type OperationResolutionInput, type ResolvedOperation } from '../signing/operation-resolution.mjs';
 import { type AuthPrincipal, type Authenticator } from './auth.mjs';
 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.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,