@adcp/sdk 15.0.0 → 15.2.0

package/dist/lib/signing/operation-resolution.mjs

@@ -0,0 +1,125 @@
+import { parseStrictJson, StrictJsonError } from "./agent-resolver/strict-json.mjs";
+const UNRESOLVABLE_OPERATION = /* @__PURE__ */ Symbol.for("@adcp/client.signing.unresolvableOperation");
+function isUnresolvableOperation(value) {
+  return value === UNRESOLVABLE_OPERATION;
+}
+const A2A_MESSAGE_METHODS = /* @__PURE__ */ new Set([
+  "SendMessage",
+  "SendStreamingMessage",
+  "message/send",
+  "message/stream"
+]);
+const CONTENT_MEMBERS = ["text", "data", "raw", "url", "file"];
+const FILE_MEMBERS = /* @__PURE__ */ new Set(["raw", "url", "file"]);
+const HTTP_JSON_MESSAGE_PATH = /(?:^|\/)message:(?:send|stream)$/;
+const ENVELOPE_MEMBERS = ["method", "params"];
+const TOOLS_CALL_PARAMS_MEMBERS = ["name"];
+const CARRIER_MEMBERS = ["message"];
+const MESSAGE_MEMBERS = ["parts", "taskId"];
+const PART_MEMBERS = [...CONTENT_MEMBERS, "kind"];
+const DATA_MEMBERS = ["skill"];
+function resolveRequestOperationDetailed(input) {
+  if (input.method !== void 0 && input.method.toUpperCase() !== "POST") return { kind: "none" };
+  const raw = typeof input.rawBody === "string" ? input.rawBody : input.rawBody?.toString("utf8");
+  if (raw === void 0 || raw.trim() === "") return unresolvable("request body is empty");
+  if (raw.charCodeAt(0) === 65279) return unresolvable("body starts with a byte order mark");
+  let body;
+  try {
+    body = parseStrictJson(raw);
+  } catch (err) {
+    return unresolvable(err instanceof StrictJsonError ? `body is not strict JSON (${err.code})` : "body is not JSON");
+  }
+  if (!isPlainObject(body)) {
+    return unresolvable(Array.isArray(body) ? "JSON-RPC batches are not supported" : "body is not a JSON object");
+  }
+  if (isHttpJsonMessagePath(input.url)) {
+    return resolveMessageCarrier(body);
+  }
+  if (hasCaseVariantMember(body, ENVELOPE_MEMBERS)) return unresolvable("case variant of an envelope member");
+  const method = body.method;
+  if (method === void 0 && isJsonRpcResponse(body)) {
+    return { kind: "none" };
+  }
+  if (typeof method !== "string") return unresolvable("JSON-RPC request has no string method");
+  if (method === "tools/call") {
+    const params = body.params;
+    if (!isPlainObject(params)) return unresolvable("tools/call params is not an object");
+    if (hasCaseVariantMember(params, TOOLS_CALL_PARAMS_MEMBERS)) return unresolvable("case variant of a params member");
+    const name = params.name;
+    if (typeof name !== "string" || name.length === 0) return unresolvable("tools/call params.name is not a string");
+    return { kind: "operation", operation: name };
+  }
+  if (A2A_MESSAGE_METHODS.has(method)) {
+    const params = body.params;
+    if (!isPlainObject(params)) return unresolvable("message method params is not an object");
+    return resolveMessageCarrier(params);
+  }
+  return { kind: "none" };
+}
+function resolveRequestOperation(input) {
+  const resolution = resolveRequestOperationDetailed(input);
+  if (resolution.kind === "operation") return resolution.operation;
+  return resolution.kind === "none" ? void 0 : UNRESOLVABLE_OPERATION;
+}
+function describeUnresolvable(input) {
+  const resolution = resolveRequestOperationDetailed(input);
+  return resolution.kind === "unresolvable" ? resolution.reason : void 0;
+}
+function resolveMessageCarrier(container) {
+  if (hasCaseVariantMember(container, CARRIER_MEMBERS)) return unresolvable("case variant of the message member");
+  const message = container.message;
+  if (!isPlainObject(message)) return unresolvable("request carries no message object");
+  if (hasCaseVariantMember(message, MESSAGE_MEMBERS)) return unresolvable("case variant of a message member");
+  const parts = message.parts;
+  if (!Array.isArray(parts)) return unresolvable("message.parts is not an array");
+  let invocation;
+  for (const part of parts) {
+    if (!isPlainObject(part)) return unresolvable("a Part is not an object");
+    if (hasCaseVariantMember(part, PART_MEMBERS)) return unresolvable("case variant of a Part member");
+    const present = CONTENT_MEMBERS.filter((member2) => Object.prototype.hasOwnProperty.call(part, member2));
+    if (present.length !== 1) return unresolvable("a Part must carry exactly one content member");
+    const member = present[0];
+    if (FILE_MEMBERS.has(member)) return unresolvable("FileParts are not allowed on an AdCP invocation");
+    const kind = part.kind;
+    if (kind !== void 0 && kind !== member) return unresolvable("a Part kind disagrees with its content member");
+    if (member === "data") {
+      if (invocation !== void 0) return unresolvable("message carries more than one DataPart");
+      if (!isPlainObject(part.data)) return unresolvable("DataPart data is not an object");
+      invocation = part.data;
+    }
+  }
+  if (invocation === void 0) return unresolvable("message carries no DataPart");
+  if (hasCaseVariantMember(invocation, DATA_MEMBERS)) return unresolvable("case variant of skill");
+  const skill = invocation.skill;
+  if (typeof skill !== "string" || skill.length === 0) return unresolvable("DataPart skill is not a non-empty string");
+  return { kind: "operation", operation: skill };
+}
+function isJsonRpcResponse(body) {
+  const has = (key) => Object.prototype.hasOwnProperty.call(body, key);
+  return (has("result") || has("error")) && !has("params");
+}
+function unresolvable(reason) {
+  return { kind: "unresolvable", reason };
+}
+function isHttpJsonMessagePath(url) {
+  if (!url) return false;
+  const queryStart = url.search(/[?#]/);
+  return HTTP_JSON_MESSAGE_PATH.test(queryStart === -1 ? url : url.slice(0, queryStart));
+}
+function isPlainObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function hasCaseVariantMember(obj, recognized) {
+  return Object.keys(obj).some((key) => {
+    const lowered = key.toLowerCase();
+    return recognized.some((name) => name.toLowerCase() === lowered && name !== key);
+  });
+}
+export {
+  A2A_MESSAGE_METHODS,
+  UNRESOLVABLE_OPERATION,
+  describeUnresolvable,
+  isUnresolvableOperation,
+  resolveRequestOperation,
+  resolveRequestOperationDetailed
+};

package/dist/lib/signing/postgres-replay-store.d.mts

@@ -24,7 +24,7 @@
  *   capability: { ... },
  *   jwks,
  *   replayStore,                                        // <-- shared across instances
- *   resolveOperation: mcpToolNameResolver,
+ *   resolveOperation: adcpOperationResolver,
  * }));
  *
  * // Schedule the sweeper somewhere (cron, app timer, pg_cron, etc.):

package/dist/lib/signing/postgres-replay-store.d.ts

@@ -24,7 +24,7 @@
  *   capability: { ... },
  *   jwks,
  *   replayStore,                                        // <-- shared across instances
- *   resolveOperation: mcpToolNameResolver,
+ *   resolveOperation: adcpOperationResolver,
  * }));
  *
  * // Schedule the sweeper somewhere (cron, app timer, pg_cron, etc.):

package/dist/lib/signing/redis-replay-store.d.mts

@@ -74,7 +74,7 @@
  *   capability: { ... },
  *   jwks,
  *   replayStore,           // <-- shared across instances
- *   resolveOperation: mcpToolNameResolver,
+ *   resolveOperation: adcpOperationResolver,
  * }));
  * ```
  */

package/dist/lib/signing/redis-replay-store.d.ts

@@ -74,7 +74,7 @@
  *   capability: { ... },
  *   jwks,
  *   replayStore,           // <-- shared across instances
- *   resolveOperation: mcpToolNameResolver,
+ *   resolveOperation: adcpOperationResolver,
  * }));
  * ```
  */

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

@@ -25,6 +25,7 @@ export { InMemoryRevocationStore, type RevocationStore } from './revocation.mjs'
 export { HttpsRevocationStore, type HttpsRevocationStoreOptions } from './revocation-https.mjs';
 export { ALLOWED_ALGS, CLOCK_SKEW_TOLERANCE_SECONDS, MANDATORY_COMPONENTS, MAX_SIGNATURE_WINDOW_SECONDS, REQUEST_SIGNING_TAG, RESPONSE_MANDATORY_COMPONENTS, RESPONSE_SIGNING_TAG, type AdcpJsonWebKey, type ContentDigestPolicy, type RevocationSnapshot, type VerifiedSigner, type VerifierCapability, type VerifyResult, } from './types.mjs';
 export { verifyRequestSignature, type VerifyRequestOptions } from './verifier.mjs';
+export { isUnresolvableOperation, resolveRequestOperation, UNRESOLVABLE_OPERATION, type OperationResolutionInput, type ResolvedOperation, type UnresolvableOperation, } from './operation-resolution.mjs';
 export { createWebhookVerifier, isWebhookLoopbackHost, verifyWebhookSignature, WEBHOOK_MANDATORY_COMPONENTS, WEBHOOK_SIGNING_TAG, type CreateWebhookVerifierOptions, type VerifyWebhookOptions, type VerifyWebhookResult, type WebhookRequestLike, } from './webhook-verifier.mjs';
 export { createExpressVerifier, type ExpressLike, type ExpressMiddlewareOptions } from './middleware.mjs';
 export { finalizeResponseSignature, prepareResponseSignature, signResponse, type PreparedResponseSignature, type SignedResponse, type SignResponseOptions, } from './signer.mjs';

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

@@ -25,6 +25,7 @@ export { InMemoryRevocationStore, type RevocationStore } from './revocation';
 export { HttpsRevocationStore, type HttpsRevocationStoreOptions } from './revocation-https';
 export { ALLOWED_ALGS, CLOCK_SKEW_TOLERANCE_SECONDS, MANDATORY_COMPONENTS, MAX_SIGNATURE_WINDOW_SECONDS, REQUEST_SIGNING_TAG, RESPONSE_MANDATORY_COMPONENTS, RESPONSE_SIGNING_TAG, type AdcpJsonWebKey, type ContentDigestPolicy, type RevocationSnapshot, type VerifiedSigner, type VerifierCapability, type VerifyResult, } from './types';
 export { verifyRequestSignature, type VerifyRequestOptions } from './verifier';
+export { isUnresolvableOperation, resolveRequestOperation, UNRESOLVABLE_OPERATION, type OperationResolutionInput, type ResolvedOperation, type UnresolvableOperation, } from './operation-resolution';
 export { createWebhookVerifier, isWebhookLoopbackHost, verifyWebhookSignature, WEBHOOK_MANDATORY_COMPONENTS, WEBHOOK_SIGNING_TAG, type CreateWebhookVerifierOptions, type VerifyWebhookOptions, type VerifyWebhookResult, type WebhookRequestLike, } from './webhook-verifier';
 export { createExpressVerifier, type ExpressLike, type ExpressMiddlewareOptions } from './middleware';
 export { finalizeResponseSignature, prepareResponseSignature, signResponse, type PreparedResponseSignature, type SignedResponse, type SignResponseOptions, } from './signer';

package/dist/lib/signing/server.js

@@ -41,6 +41,7 @@ __export(server_exports, {
   ResolvedAgentJwksResolver: () => import_agent_resolver.ResolvedAgentJwksResolver,
   ResponseSignatureError: () => import_errors.ResponseSignatureError,
   StaticJwksResolver: () => import_jwks.StaticJwksResolver,
+  UNRESOLVABLE_OPERATION: () => import_operation_resolution.UNRESOLVABLE_OPERATION,
   WEBHOOK_MANDATORY_COMPONENTS: () => import_webhook_verifier.WEBHOOK_MANDATORY_COMPONENTS,
   WEBHOOK_SIGNING_TAG: () => import_webhook_verifier.WEBHOOK_SIGNING_TAG,
   WebhookSignatureError: () => import_errors.WebhookSignatureError,
@@ -61,6 +62,7 @@ __export(server_exports, {
   getAgentJwks: () => import_agent_resolver.getAgentJwks,
   getHeaderValue: () => import_canonicalize.getHeaderValue,
   getReplayStoreMigration: () => import_postgres_replay_store.getReplayStoreMigration,
+  isUnresolvableOperation: () => import_operation_resolution.isUnresolvableOperation,
   isWebhookLoopbackHost: () => import_webhook_verifier.isWebhookLoopbackHost,
   jwkToPublicKey: () => import_crypto.jwkToPublicKey,
   parseContentDigest: () => import_content_digest.parseContentDigest,
@@ -73,6 +75,7 @@ __export(server_exports, {
   requestContextFromFetch: () => import_request_context.requestContextFromFetch,
   requestContextFromLambda: () => import_request_context.requestContextFromLambda,
   resolveAgent: () => import_agent_resolver.resolveAgent,
+  resolveRequestOperation: () => import_operation_resolution.resolveRequestOperation,
   signResponse: () => import_signer.signResponse,
   signResponseAsync: () => import_signer_async.signResponseAsync,
   sweepExpiredReplays: () => import_postgres_replay_store.sweepExpiredReplays,
@@ -97,6 +100,7 @@ var import_revocation = require('./revocation.js');
 var import_revocation_https = require('./revocation-https.js');
 var import_types = require('./types.js');
 var import_verifier = require('./verifier.js');
+var import_operation_resolution = require('./operation-resolution.js');
 var import_webhook_verifier = require('./webhook-verifier.js');
 var import_middleware = require('./middleware.js');
 var import_signer = require('./signer.js');
@@ -127,6 +131,7 @@ var import_agent_resolver = require('./agent-resolver/index.js');
   ResolvedAgentJwksResolver,
   ResponseSignatureError,
   StaticJwksResolver,
+  UNRESOLVABLE_OPERATION,
   WEBHOOK_MANDATORY_COMPONENTS,
   WEBHOOK_SIGNING_TAG,
   WebhookSignatureError,
@@ -147,6 +152,7 @@ var import_agent_resolver = require('./agent-resolver/index.js');
   getAgentJwks,
   getHeaderValue,
   getReplayStoreMigration,
+  isUnresolvableOperation,
   isWebhookLoopbackHost,
   jwkToPublicKey,
   parseContentDigest,
@@ -159,6 +165,7 @@ var import_agent_resolver = require('./agent-resolver/index.js');
   requestContextFromFetch,
   requestContextFromLambda,
   resolveAgent,
+  resolveRequestOperation,
   signResponse,
   signResponseAsync,
   sweepExpiredReplays,

package/dist/lib/signing/server.mjs

@@ -52,6 +52,11 @@ import {
   RESPONSE_SIGNING_TAG
 } from "./types.mjs";
 import { verifyRequestSignature } from "./verifier.mjs";
+import {
+  isUnresolvableOperation,
+  resolveRequestOperation,
+  UNRESOLVABLE_OPERATION
+} from "./operation-resolution.mjs";
 import {
   createWebhookVerifier,
   isWebhookLoopbackHost,
@@ -101,6 +106,7 @@ export {
   ResolvedAgentJwksResolver,
   ResponseSignatureError,
   StaticJwksResolver,
+  UNRESOLVABLE_OPERATION,
   WEBHOOK_MANDATORY_COMPONENTS,
   WEBHOOK_SIGNING_TAG,
   WebhookSignatureError,
@@ -121,6 +127,7 @@ export {
   getAgentJwks,
   getHeaderValue,
   getReplayStoreMigration,
+  isUnresolvableOperation,
   isWebhookLoopbackHost,
   jwkToPublicKey,
   parseContentDigest,
@@ -133,6 +140,7 @@ export {
   requestContextFromFetch,
   requestContextFromLambda,
   resolveAgent,
+  resolveRequestOperation,
   signResponse,
   signResponseAsync,
   sweepExpiredReplays,

package/dist/lib/signing/verifier.d.mts

@@ -1,4 +1,6 @@
 import { type RequestLike } from './canonicalize.mjs';
+import { RequestSignatureError } from './errors.mjs';
+import { type UnresolvableOperation } from './operation-resolution.mjs';
 import type { JwksResolver } from './jwks.mjs';
 import type { ReplayStore } from './replay.mjs';
 import type { RevocationStore } from './revocation.mjs';
@@ -15,8 +17,13 @@ export interface VerifyRequestOptions {
      * the verifier treats the operation as "not in any required_for list" and
      * returns an unsigned result rather than rejecting — callers in
      * always-verify mode (where every request is signed) can leave this blank.
+     *
+     * Pass {@link UNRESOLVABLE_OPERATION} when the request body does not resolve
+     * to exactly one operation (see `resolveRequestOperation`). The verifier
+     * then rejects with `request_body_malformed` before it looks at any
+     * signature header or capability list, whether or not the request is signed.
      */
-    operation?: string;
+    operation?: string | UnresolvableOperation;
     /**
      * Trusted endpoint release pin; never inferred from request payload data.
      * A 3.2+ pin parses `Signature` and `Content-Digest` strictly as RFC 8941
@@ -31,3 +38,31 @@ export interface VerifyRequestOptions {
     agentUrlForKeyid?: (keyid: string) => string | undefined;
 }
 export declare function verifyRequestSignature(request: RequestLike, options: VerifyRequestOptions): Promise<VerifyResult>;
+/** The `request_body_malformed` rejection for a body that resolves to no single operation. */
+export declare function unresolvableOperationError(): RequestSignatureError;
+/**
+ * Throw `request_signature_required` when an UNSIGNED request must be signed:
+ * its resolved operation is in `capability.required_for`, or its JSON-RPC
+ * method is in `capability.protocol_methods_required_for`, or it carries
+ * webhook authentication. Returns normally when none applies.
+ *
+ * "Unsigned" is the caller's contract: no `Signature` / `Signature-Input`
+ * header. The checks do not consult any fallback credential; a caller that
+ * lets a configured fallback authenticator satisfy `required_for` (the
+ * presence-gated composer) runs the pieces separately.
+ */
+export declare function assertUnsignedRequestAllowed(body: string | undefined, operation: string | undefined, capability: Pick<VerifierCapability, 'required_for' | 'protocol_methods_required_for'>): void;
+/** `required_for` half of {@link assertUnsignedRequestAllowed}. */
+export declare function assertUnsignedOperationNotRequired(operation: string | undefined, capability: Pick<VerifierCapability, 'required_for'>): void;
+/** `protocol_methods_required_for` half of {@link assertUnsignedRequestAllowed}. */
+export declare function assertUnsignedProtocolMethodNotRequired(body: string | undefined, capability: Pick<VerifierCapability, 'protocol_methods_required_for'>): void;
+/**
+ * Payload-driven elevation: any request carrying webhook receiver credentials
+ * (task, reporting, artifact, or revocation callbacks) MUST be RFC 9421
+ * signed, regardless of whether the operation appears in `required_for`
+ * (#webhook-security downgrade-resistance). A bearer-only channel would
+ * otherwise let an attacker who captured a token register or update webhook
+ * credentials and redirect callbacks to a hostile URL. Unlike `required_for`,
+ * a valid fallback credential does not satisfy this.
+ */
+export declare function assertUnsignedWebhookAuthenticationAbsent(body: string | undefined): void;

package/dist/lib/signing/verifier.d.ts

@@ -1,4 +1,6 @@
 import { type RequestLike } from './canonicalize';
+import { RequestSignatureError } from './errors';
+import { type UnresolvableOperation } from './operation-resolution';
 import type { JwksResolver } from './jwks';
 import type { ReplayStore } from './replay';
 import type { RevocationStore } from './revocation';
@@ -15,8 +17,13 @@ export interface VerifyRequestOptions {
      * the verifier treats the operation as "not in any required_for list" and
      * returns an unsigned result rather than rejecting — callers in
      * always-verify mode (where every request is signed) can leave this blank.
+     *
+     * Pass {@link UNRESOLVABLE_OPERATION} when the request body does not resolve
+     * to exactly one operation (see `resolveRequestOperation`). The verifier
+     * then rejects with `request_body_malformed` before it looks at any
+     * signature header or capability list, whether or not the request is signed.
      */
-    operation?: string;
+    operation?: string | UnresolvableOperation;
     /**
      * Trusted endpoint release pin; never inferred from request payload data.
      * A 3.2+ pin parses `Signature` and `Content-Digest` strictly as RFC 8941
@@ -31,3 +38,31 @@ export interface VerifyRequestOptions {
     agentUrlForKeyid?: (keyid: string) => string | undefined;
 }
 export declare function verifyRequestSignature(request: RequestLike, options: VerifyRequestOptions): Promise<VerifyResult>;
+/** The `request_body_malformed` rejection for a body that resolves to no single operation. */
+export declare function unresolvableOperationError(): RequestSignatureError;
+/**
+ * Throw `request_signature_required` when an UNSIGNED request must be signed:
+ * its resolved operation is in `capability.required_for`, or its JSON-RPC
+ * method is in `capability.protocol_methods_required_for`, or it carries
+ * webhook authentication. Returns normally when none applies.
+ *
+ * "Unsigned" is the caller's contract: no `Signature` / `Signature-Input`
+ * header. The checks do not consult any fallback credential; a caller that
+ * lets a configured fallback authenticator satisfy `required_for` (the
+ * presence-gated composer) runs the pieces separately.
+ */
+export declare function assertUnsignedRequestAllowed(body: string | undefined, operation: string | undefined, capability: Pick<VerifierCapability, 'required_for' | 'protocol_methods_required_for'>): void;
+/** `required_for` half of {@link assertUnsignedRequestAllowed}. */
+export declare function assertUnsignedOperationNotRequired(operation: string | undefined, capability: Pick<VerifierCapability, 'required_for'>): void;
+/** `protocol_methods_required_for` half of {@link assertUnsignedRequestAllowed}. */
+export declare function assertUnsignedProtocolMethodNotRequired(body: string | undefined, capability: Pick<VerifierCapability, 'protocol_methods_required_for'>): void;
+/**
+ * Payload-driven elevation: any request carrying webhook receiver credentials
+ * (task, reporting, artifact, or revocation callbacks) MUST be RFC 9421
+ * signed, regardless of whether the operation appears in `required_for`
+ * (#webhook-security downgrade-resistance). A bearer-only channel would
+ * otherwise let an attacker who captured a token register or update webhook
+ * credentials and redirect callbacks to a hostile URL. Unlike `required_for`,
+ * a valid fallback credential does not satisfy this.
+ */
+export declare function assertUnsignedWebhookAuthenticationAbsent(body: string | undefined): void;

package/dist/lib/signing/verifier.js

@@ -18,6 +18,11 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var verifier_exports = {};
 __export(verifier_exports, {
+  assertUnsignedOperationNotRequired: () => assertUnsignedOperationNotRequired,
+  assertUnsignedProtocolMethodNotRequired: () => assertUnsignedProtocolMethodNotRequired,
+  assertUnsignedRequestAllowed: () => assertUnsignedRequestAllowed,
+  assertUnsignedWebhookAuthenticationAbsent: () => assertUnsignedWebhookAuthenticationAbsent,
+  unresolvableOperationError: () => unresolvableOperationError,
   verifyRequestSignature: () => verifyRequestSignature
 });
 module.exports = __toCommonJS(verifier_exports);
@@ -29,6 +34,7 @@ var import_errors2 = require('./agent-resolver/errors.js');
 var import_strict_json = require('./agent-resolver/strict-json.js');
 var import_parser = require('./parser.js');
 var import_crypto = require('./crypto.js');
+var import_operation_resolution = require('./operation-resolution.js');
 var import_webhook_auth_detection = require('./webhook-auth-detection.js');
 var import_types = require('./types.js');
 async function verifyRequestSignature(request, options) {
@@ -37,39 +43,10 @@ async function verifyRequestSignature(request, options) {
   const pinnedBinaryEncoding = options.adcpVersion !== void 0 ? (0, import_content_digest.requestSigningEncodingForVersion)(options.adcpVersion) : void 0;
   const sigInputHeader = (0, import_canonicalize.getHeaderValue)(request.headers, "Signature-Input");
   const sigHeader = (0, import_canonicalize.getHeaderValue)(request.headers, "Signature");
+  if ((0, import_operation_resolution.isUnresolvableOperation)(options.operation)) throw unresolvableOperationError();
+  const operation = options.operation;
   if (!sigInputHeader && !sigHeader) {
-    const operation = options.operation;
-    if (operation && options.capability.required_for.includes(operation)) {
-      throw new import_errors.RequestSignatureError(
-        "request_signature_required",
-        0,
-        `Operation "${operation}" requires a signed request`
-      );
-    }
-    const protocolMethodsRequiredFor = options.capability.protocol_methods_required_for ?? [];
-    if (protocolMethodsRequiredFor.length > 0 && exceedsUnsignedBodyInspectionCap(request.body)) {
-      throw new import_errors.RequestSignatureError(
-        "request_signature_required",
-        0,
-        "Unsigned request body exceeds the protocol method inspection cap while protocol methods require signing"
-      );
-    }
-    const protocolMethods = jsonRpcProtocolMethods(request.body);
-    const requiredProtocolMethod = protocolMethods.find((method) => protocolMethodsRequiredFor.includes(method));
-    if (requiredProtocolMethod) {
-      throw new import_errors.RequestSignatureError(
-        "request_signature_required",
-        0,
-        `Protocol method "${requiredProtocolMethod}" requires a signed request`
-      );
-    }
-    if (carriesWebhookAuthentication(request)) {
-      throw new import_errors.RequestSignatureError(
-        "request_signature_required",
-        0,
-        "Requests carrying webhook authentication must be RFC 9421 signed"
-      );
-    }
+    assertUnsignedRequestAllowed(request.body, operation, options.capability);
     return { status: "unsigned", verified_at: now };
   }
   if (!sigInputHeader || !sigHeader) {
@@ -292,6 +269,57 @@ function signatureEncodingCandidates(pinned, digestPolicy) {
   if (pinned === "rfc8941-base64" || digestPolicy !== "either") return [pinned];
   return ["legacy-base64url", "rfc8941-base64"];
 }
+function unresolvableOperationError() {
+  return new import_errors.RequestSignatureError(
+    "request_body_malformed",
+    0,
+    "Request body does not resolve to exactly one AdCP operation"
+  );
+}
+function assertUnsignedRequestAllowed(body, operation, capability) {
+  assertUnsignedOperationNotRequired(operation, capability);
+  assertUnsignedProtocolMethodNotRequired(body, capability);
+  assertUnsignedWebhookAuthenticationAbsent(body);
+}
+function assertUnsignedOperationNotRequired(operation, capability) {
+  if (operation && capability.required_for.includes(operation)) {
+    throw new import_errors.RequestSignatureError(
+      "request_signature_required",
+      0,
+      `Operation "${operation}" requires a signed request`
+    );
+  }
+}
+function assertUnsignedProtocolMethodNotRequired(body, capability) {
+  const protocolMethodsRequiredFor = capability.protocol_methods_required_for ?? [];
+  if (protocolMethodsRequiredFor.length === 0) return;
+  if (exceedsUnsignedBodyInspectionCap(body)) {
+    throw new import_errors.RequestSignatureError(
+      "request_signature_required",
+      0,
+      "Unsigned request body exceeds the protocol method inspection cap while protocol methods require signing"
+    );
+  }
+  const requiredProtocolMethod = jsonRpcProtocolMethods(body).find(
+    (method) => protocolMethodsRequiredFor.includes(method)
+  );
+  if (requiredProtocolMethod) {
+    throw new import_errors.RequestSignatureError(
+      "request_signature_required",
+      0,
+      `Protocol method "${requiredProtocolMethod}" requires a signed request`
+    );
+  }
+}
+function assertUnsignedWebhookAuthenticationAbsent(body) {
+  if (carriesWebhookAuthentication(body)) {
+    throw new import_errors.RequestSignatureError(
+      "request_signature_required",
+      0,
+      "Requests carrying webhook authentication must be RFC 9421 signed"
+    );
+  }
+}
 function contentDigestEncodingCandidates(pinned) {
   if (pinned === "rfc8941-base64") return [pinned];
   return ["rfc8941-base64", "legacy-base64url"];
@@ -498,8 +526,7 @@ const MAX_UNSIGNED_BODY_INSPECTION_BYTES = 1048576;
 function exceedsUnsignedBodyInspectionCap(body) {
   return typeof body === "string" && body.length > MAX_UNSIGNED_BODY_INSPECTION_BYTES;
 }
-function carriesWebhookAuthentication(request) {
-  const body = request.body;
+function carriesWebhookAuthentication(body) {
   if (!body) return false;
   if (exceedsUnsignedBodyInspectionCap(body)) return true;
   let parsed;
@@ -546,5 +573,10 @@ function validateCoveredComponents(components, capability, request) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  assertUnsignedOperationNotRequired,
+  assertUnsignedProtocolMethodNotRequired,
+  assertUnsignedRequestAllowed,
+  assertUnsignedWebhookAuthenticationAbsent,
+  unresolvableOperationError,
   verifyRequestSignature
 });

package/dist/lib/signing/verifier.mjs

@@ -16,6 +16,7 @@ import { AgentResolverError } from "./agent-resolver/errors.mjs";
 import { parseStrictJson, StrictJsonError } from "./agent-resolver/strict-json.mjs";
 import { parseSignature, parseSignatureInput } from "./parser.mjs";
 import { jwkToPublicKey, verifySignature } from "./crypto.mjs";
+import { isUnresolvableOperation } from "./operation-resolution.mjs";
 import { containsWebhookAuthentication, WEBHOOK_AUTH_TRAVERSAL_DEPTH } from "./webhook-auth-detection.mjs";
 import {
   ALLOWED_ALGS,
@@ -30,39 +31,10 @@ async function verifyRequestSignature(request, options) {
   const pinnedBinaryEncoding = options.adcpVersion !== void 0 ? requestSigningEncodingForVersion(options.adcpVersion) : void 0;
   const sigInputHeader = getHeaderValue(request.headers, "Signature-Input");
   const sigHeader = getHeaderValue(request.headers, "Signature");
+  if (isUnresolvableOperation(options.operation)) throw unresolvableOperationError();
+  const operation = options.operation;
   if (!sigInputHeader && !sigHeader) {
-    const operation = options.operation;
-    if (operation && options.capability.required_for.includes(operation)) {
-      throw new RequestSignatureError(
-        "request_signature_required",
-        0,
-        `Operation "${operation}" requires a signed request`
-      );
-    }
-    const protocolMethodsRequiredFor = options.capability.protocol_methods_required_for ?? [];
-    if (protocolMethodsRequiredFor.length > 0 && exceedsUnsignedBodyInspectionCap(request.body)) {
-      throw new RequestSignatureError(
-        "request_signature_required",
-        0,
-        "Unsigned request body exceeds the protocol method inspection cap while protocol methods require signing"
-      );
-    }
-    const protocolMethods = jsonRpcProtocolMethods(request.body);
-    const requiredProtocolMethod = protocolMethods.find((method) => protocolMethodsRequiredFor.includes(method));
-    if (requiredProtocolMethod) {
-      throw new RequestSignatureError(
-        "request_signature_required",
-        0,
-        `Protocol method "${requiredProtocolMethod}" requires a signed request`
-      );
-    }
-    if (carriesWebhookAuthentication(request)) {
-      throw new RequestSignatureError(
-        "request_signature_required",
-        0,
-        "Requests carrying webhook authentication must be RFC 9421 signed"
-      );
-    }
+    assertUnsignedRequestAllowed(request.body, operation, options.capability);
     return { status: "unsigned", verified_at: now };
   }
   if (!sigInputHeader || !sigHeader) {
@@ -285,6 +257,57 @@ function signatureEncodingCandidates(pinned, digestPolicy) {
   if (pinned === "rfc8941-base64" || digestPolicy !== "either") return [pinned];
   return ["legacy-base64url", "rfc8941-base64"];
 }
+function unresolvableOperationError() {
+  return new RequestSignatureError(
+    "request_body_malformed",
+    0,
+    "Request body does not resolve to exactly one AdCP operation"
+  );
+}
+function assertUnsignedRequestAllowed(body, operation, capability) {
+  assertUnsignedOperationNotRequired(operation, capability);
+  assertUnsignedProtocolMethodNotRequired(body, capability);
+  assertUnsignedWebhookAuthenticationAbsent(body);
+}
+function assertUnsignedOperationNotRequired(operation, capability) {
+  if (operation && capability.required_for.includes(operation)) {
+    throw new RequestSignatureError(
+      "request_signature_required",
+      0,
+      `Operation "${operation}" requires a signed request`
+    );
+  }
+}
+function assertUnsignedProtocolMethodNotRequired(body, capability) {
+  const protocolMethodsRequiredFor = capability.protocol_methods_required_for ?? [];
+  if (protocolMethodsRequiredFor.length === 0) return;
+  if (exceedsUnsignedBodyInspectionCap(body)) {
+    throw new RequestSignatureError(
+      "request_signature_required",
+      0,
+      "Unsigned request body exceeds the protocol method inspection cap while protocol methods require signing"
+    );
+  }
+  const requiredProtocolMethod = jsonRpcProtocolMethods(body).find(
+    (method) => protocolMethodsRequiredFor.includes(method)
+  );
+  if (requiredProtocolMethod) {
+    throw new RequestSignatureError(
+      "request_signature_required",
+      0,
+      `Protocol method "${requiredProtocolMethod}" requires a signed request`
+    );
+  }
+}
+function assertUnsignedWebhookAuthenticationAbsent(body) {
+  if (carriesWebhookAuthentication(body)) {
+    throw new RequestSignatureError(
+      "request_signature_required",
+      0,
+      "Requests carrying webhook authentication must be RFC 9421 signed"
+    );
+  }
+}
 function contentDigestEncodingCandidates(pinned) {
   if (pinned === "rfc8941-base64") return [pinned];
   return ["rfc8941-base64", "legacy-base64url"];
@@ -491,8 +514,7 @@ const MAX_UNSIGNED_BODY_INSPECTION_BYTES = 1048576;
 function exceedsUnsignedBodyInspectionCap(body) {
   return typeof body === "string" && body.length > MAX_UNSIGNED_BODY_INSPECTION_BYTES;
 }
-function carriesWebhookAuthentication(request) {
-  const body = request.body;
+function carriesWebhookAuthentication(body) {
   if (!body) return false;
   if (exceedsUnsignedBodyInspectionCap(body)) return true;
   let parsed;
@@ -538,5 +560,10 @@ function validateCoveredComponents(components, capability, request) {
   }
 }
 export {
+  assertUnsignedOperationNotRequired,
+  assertUnsignedProtocolMethodNotRequired,
+  assertUnsignedRequestAllowed,
+  assertUnsignedWebhookAuthenticationAbsent,
+  unresolvableOperationError,
   verifyRequestSignature
 };