@adcp/sdk 15.0.0 → 15.2.0

package/dist/lib/server/a2a-adapter.js

@@ -28,7 +28,10 @@ var import_sdk = require("@a2a-js/sdk");
 var import_v0_3 = require("@a2a-js/sdk/compat/v0_3");
 var import_node_crypto = require("node:crypto");
 var import_redact_secrets = require('../utils/redact-secrets.js');
+var import_operation_resolution = require('../signing/operation-resolution.js');
 var import_adcp_server = require('./adcp-server.js');
+var import_create_adcp_server = require('./create-adcp-server.js');
+var import_auth = require('./auth.js');
 class RedactingA2ATaskStore {
   constructor(delegate) {
     this.delegate = delegate;
@@ -44,7 +47,7 @@ class RedactingA2ATaskStore {
     return this.delegate.list(params, context);
   }
 }
-function buildAuthenticatedUser(authInfo) {
+function buildAuthenticatedUser(authInfo, gate) {
   const clientId = authInfo.clientId;
   return {
     get isAuthenticated() {
@@ -53,23 +56,29 @@ function buildAuthenticatedUser(authInfo) {
     get userName() {
       return clientId;
     },
-    adcpAuthInfo: authInfo
+    adcpAuthInfo: authInfo,
+    ...gate && { adcpGate: gate }
   };
 }
-function buildAnonymousUser() {
+function buildAnonymousUser(gate) {
   return {
     get isAuthenticated() {
       return false;
     },
     get userName() {
       return "anonymous";
-    }
+    },
+    ...gate && { adcpGate: gate }
   };
 }
 function getAdcpAuthInfo(context) {
   const user = context?.user;
   return user?.adcpAuthInfo;
 }
+function getGateState(context) {
+  const user = context?.user;
+  return user?.adcpGate;
+}
 function extractInvocation(message, allowLegacyParameters = false) {
   if (!Array.isArray(message.parts) || message.parts.length === 0) {
     throw new A2AInvocationError("Message must carry at least one part with a `data` kind.");
@@ -106,6 +115,15 @@ function extractInvocation(message, allowLegacyParameters = false) {
   }
   return { skill, input };
 }
+function operationTaskWasCreatedFor(task) {
+  const first = task.history?.[0];
+  if (!first) return void 0;
+  try {
+    return extractInvocation(first, true).skill;
+  } catch {
+    return void 0;
+  }
+}
 class A2AInvocationError extends Error {
   constructor(message) {
     super(message);
@@ -177,6 +195,28 @@ class AdcpA2AAgentExecutor {
         });
         return;
       }
+      const gate = getGateState(requestContext.context);
+      if (gate && gate.operation !== invocation.skill) {
+        this.logger.error("A2A adapter: dispatcher operation differs from the signature gate", {
+          gateOperation: gate.operation === void 0 ? void 0 : JSON.stringify(gate.operation.slice(0, 64)),
+          requestedToolName: JSON.stringify(invocation.skill.slice(0, 64))
+        });
+        this.emitFailure(eventBus, taskId, contextId, {
+          reason: "INVALID_REQUEST",
+          message: "The request does not resolve to a single AdCP operation."
+        });
+        return;
+      }
+      if (requestContext.task) {
+        const createdFor = operationTaskWasCreatedFor(requestContext.task);
+        if (createdFor !== invocation.skill) {
+          this.emitFailure(eventBus, taskId, contextId, {
+            reason: "INVALID_REQUEST",
+            message: "A task continuation must use the operation the task was created for."
+          });
+          return;
+        }
+      }
       let response;
       const toolNames = a2aSkillToServerToolNames(invocation.skill);
       let invokedToolName;
@@ -577,6 +617,157 @@ function validateAgentCard(card) {
     );
   }
 }
+const MAX_GATED_BODY_BYTES = 100 * 1024;
+class BodyTooLargeError extends Error {
+}
+function captureRawBody(req, _res, buf) {
+  req.rawBody = buf.toString("utf8");
+}
+function resolveSignatureGate(options) {
+  const symbols = options.server;
+  const attached = symbols[import_create_adcp_server.ADCP_PRE_TRANSPORT];
+  const gate = options.preTransport ?? (typeof attached === "function" ? attached : void 0);
+  if (gate) return gate;
+  const state = symbols[import_create_adcp_server.ADCP_SIGNED_REQUESTS_STATE];
+  if ((state?.specialismClaimed || state?.capabilitySupported) && !options.allowUnenforcedSignedRequests) {
+    throw new Error(
+      "createA2AAdapter: the server advertises request signing (`signed-requests` / `request_signing.supported`) but no signature verifier is wired for A2A, so `required_for` would not be enforced over A2A. Configure `createAdcpServer({ signedRequests })`, pass the same verifier as `preTransport`, or set `allowUnenforcedSignedRequests: true` if a gateway in front of this adapter enforces it."
+    );
+  }
+  return void 0;
+}
+class InvalidRequestTargetError extends Error {
+}
+function signedRequestTargetUrl(req, agentUrl, override) {
+  if (override) return new URL(override(req));
+  const raw = req.originalUrl || req.url;
+  if (!raw.startsWith("/") || raw.startsWith("//")) throw new InvalidRequestTargetError();
+  const requested = new URL(raw, "http://placeholder.invalid");
+  return new URL(requested.pathname + requested.search, new URL(agentUrl).origin);
+}
+function createSignatureGate(opts) {
+  const { gate, next: sdkHandler, gateStates, targetUrl, logger } = opts;
+  const reject = (res, code, message) => {
+    res.status(401).set("WWW-Authenticate", `Signature error="${code}"`).json({ error: code, message });
+  };
+  const run = async (req, res) => {
+    const gated = req;
+    if (gated.rawBody === void 0) {
+      const encoding = req.headers["content-encoding"];
+      if (encoding !== void 0 && encoding.trim().toLowerCase() !== "identity") {
+        res.status(415).json({
+          jsonrpc: "2.0",
+          id: null,
+          error: { code: -32600, message: "Content-Encoding is not supported on a signed-requests endpoint." }
+        });
+        return false;
+      }
+      try {
+        const body = await readBody(req);
+        if (body !== void 0) {
+          gated.rawBody = body;
+          try {
+            gated.body = JSON.parse(body);
+            gated._body = true;
+          } catch {
+          }
+        }
+      } catch (err) {
+        if (!(err instanceof BodyTooLargeError)) throw err;
+        res.status(413).json({ jsonrpc: "2.0", id: null, error: { code: -32600, message: "Request body too large." } });
+        return false;
+      }
+    }
+    const captured = gated.rawBody;
+    const rawBody = typeof captured === "string" ? captured : captured?.toString("utf8");
+    if (rawBody === void 0) {
+      logger.error(
+        "A2A adapter: the raw request body is unavailable, so the signature gate cannot verify it. Mount the adapter ahead of any body parser, or capture the bytes with `express.json({ verify: adapter.rawBodyVerify })`."
+      );
+      res.status(500).json({ error: "raw_body_unavailable" });
+      return false;
+    }
+    gated.rawBody = rawBody;
+    let target;
+    try {
+      target = targetUrl(req);
+    } catch (err) {
+      if (!(err instanceof InvalidRequestTargetError)) throw err;
+      res.status(400).json({ jsonrpc: "2.0", id: null, error: { code: -32600, message: "Invalid request target." } });
+      return false;
+    }
+    const targetPath = target.pathname + target.search;
+    const input = { rawBody, method: req.method, url: targetPath };
+    const operation = (0, import_operation_resolution.resolveRequestOperation)(input);
+    if ((0, import_operation_resolution.isUnresolvableOperation)(operation)) {
+      logger.error("A2A adapter: request body does not resolve to one operation", {
+        reason: (0, import_operation_resolution.describeUnresolvable)(input) ?? "unknown"
+      });
+      reject(res, "request_body_malformed", "Request body does not resolve to exactly one AdCP operation");
+      return false;
+    }
+    const originalUrl = req.url;
+    const stamped = req;
+    const previousContext = stamped[import_auth.ADCP_SERVE_REQUEST_CONTEXT];
+    stamped[import_auth.ADCP_SERVE_REQUEST_CONTEXT] = { host: target.host.toLowerCase(), publicUrl: target.origin };
+    req.url = targetPath;
+    const slots = req;
+    const previousAuth = slots.auth;
+    const previousSigner = slots.verifiedSigner;
+    slots.auth = void 0;
+    slots.verifiedSigner = void 0;
+    let handled;
+    let signedAuth;
+    try {
+      handled = await gate(req, res);
+      if (slots.verifiedSigner !== void 0) signedAuth = slots.auth;
+    } finally {
+      req.url = originalUrl;
+      stamped[import_auth.ADCP_SERVE_REQUEST_CONTEXT] = previousContext;
+      slots.auth = previousAuth;
+      slots.verifiedSigner = previousSigner;
+    }
+    if (handled || res.headersSent) return false;
+    gated.body = JSON.parse(rawBody);
+    gated._body = true;
+    gateStates.set(req, { operation, ...signedAuth && { signedAuth } });
+    return true;
+  };
+  return (req, res, next) => {
+    if (req.method !== "POST") {
+      sdkHandler(req, res, next);
+      return;
+    }
+    run(req, res).then(
+      (proceed) => {
+        if (proceed) sdkHandler(req, res, next);
+      },
+      (err) => {
+        logger.error("A2A adapter: signature gate failed", { error: err?.name || "Error" });
+        if (!res.headersSent) res.status(500).json({ error: "verifier_error" });
+      }
+    );
+  };
+}
+function readBody(req) {
+  if (req.readableEnded || req.complete && !req.readable) return Promise.resolve(void 0);
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    let size = 0;
+    req.on("data", (chunk) => {
+      size += chunk.length;
+      if (size > MAX_GATED_BODY_BYTES) {
+        req.removeAllListeners("data");
+        req.resume();
+        reject(new BodyTooLargeError());
+        return;
+      }
+      chunks.push(chunk);
+    });
+    req.on("end", () => resolve(Buffer.concat(chunks).toString("utf8")));
+    req.on("error", reject);
+  });
+}
 const DEFAULT_LOGGER = {
   debug: (m, d) => console.debug(m, d ?? ""),
   info: (m, d) => console.info(m, d ?? ""),
@@ -587,6 +778,16 @@ function createA2AAdapter(options) {
   const logger = options.logger ?? DEFAULT_LOGGER;
   const legacyCompat = { enabled: options.legacyCompat?.enabled !== false };
   const card = buildAgentCard(options.server, options.agentCard, legacyCompat);
+  const signatureGate = resolveSignatureGate(options);
+  if (signatureGate && !options.signedRequestsUrl) {
+    try {
+      new URL(card.supportedInterfaces[0].url);
+    } catch {
+      throw new Error(
+        "createA2AAdapter: request signing needs an absolute `agentCard.url` (the URL buyers sign), or a `signedRequestsUrl` callback that returns it."
+      );
+    }
+  }
   const handlerCard = structuredClone(card);
   if (handlerCard.capabilities?.extensions) {
     handlerCard.capabilities.extensions = handlerCard.capabilities.extensions.map(
@@ -603,15 +804,36 @@ function createA2AAdapter(options) {
   const executor = new AdcpA2AAgentExecutor(options.server, logger);
   const eventBusManager = new import_server.DefaultExecutionEventBusManager();
   const requestHandler = new import_server.DefaultRequestHandler(handlerCard, taskStore, executor, eventBusManager);
+  const gateStates = /* @__PURE__ */ new WeakMap();
   const userBuilder = async (req) => {
-    if (!options.authenticate) return buildAnonymousUser();
+    const gate = gateStates.get(req);
+    const signed = gate?.signedAuth;
+    if (!options.authenticate) {
+      return signed ? buildAuthenticatedUser(signed, gate) : buildAnonymousUser(gate);
+    }
     const authInfo = await options.authenticate(req);
     if (authInfo == null) {
       throw new Error("A2A authentication failed");
     }
-    return buildAuthenticatedUser(authInfo);
+    if (signed) {
+      if (authInfo.clientId !== signed.clientId) {
+        logger.error(
+          `A2A adapter: \`authenticate\` returned a principal that differs from the verified signer (${signed.clientId}). Map the signer in \`authenticate\` (read \`req.verifiedSigner\`) or use makePrincipal.`
+        );
+        throw new Error("A2A authentication failed");
+      }
+      return buildAuthenticatedUser({ ...authInfo, extra: { ...authInfo.extra, ...signed.extra } }, gate);
+    }
+    return buildAuthenticatedUser(authInfo, gate);
   };
-  const jsonRpc = (0, import_express.jsonRpcHandler)({ requestHandler, userBuilder, legacyCompat });
+  const sdkJsonRpc = (0, import_express.jsonRpcHandler)({ requestHandler, userBuilder, legacyCompat });
+  const jsonRpc = signatureGate ? createSignatureGate({
+    gate: signatureGate,
+    next: sdkJsonRpc,
+    gateStates,
+    targetUrl: (req) => signedRequestTargetUrl(req, card.supportedInterfaces[0].url, options.signedRequestsUrl),
+    logger
+  }) : sdkJsonRpc;
   const nativeAgentCardMiddleware = (0, import_express.agentCardHandler)({ agentCardProvider: async () => card });
   const legacyAgentCardMiddleware = (0, import_express.agentCardHandler)({ agentCardProvider: async () => handlerCard, legacyCompat });
   const agentCardMiddleware = (req, res, next) => {
@@ -643,6 +865,7 @@ function createA2AAdapter(options) {
     async getAgentCard() {
       return card;
     },
+    rawBodyVerify: captureRawBody,
     mount
   };
 }

package/dist/lib/server/a2a-adapter.mjs

@@ -9,12 +9,22 @@ import { AgentCard, Role, TaskState } from "@a2a-js/sdk";
 import { duplicateInterfacesForLegacy } from "@a2a-js/sdk/compat/v0_3";
 import { randomUUID } from "node:crypto";
 import { redactSecrets } from "../utils/redact-secrets.mjs";
+import {
+  describeUnresolvable,
+  resolveRequestOperation,
+  isUnresolvableOperation
+} from "../signing/operation-resolution.mjs";
 import {
   getSdkServer,
   isToolAvailableForVersion,
   listRegisteredToolNames,
   resolveDiscoveryVersion
 } from "./adcp-server.mjs";
+import {
+  ADCP_PRE_TRANSPORT,
+  ADCP_SIGNED_REQUESTS_STATE
+} from "./create-adcp-server.mjs";
+import { ADCP_SERVE_REQUEST_CONTEXT } from "./auth.mjs";
 class RedactingA2ATaskStore {
   constructor(delegate) {
     this.delegate = delegate;
@@ -30,7 +40,7 @@ class RedactingA2ATaskStore {
     return this.delegate.list(params, context);
   }
 }
-function buildAuthenticatedUser(authInfo) {
+function buildAuthenticatedUser(authInfo, gate) {
   const clientId = authInfo.clientId;
   return {
     get isAuthenticated() {
@@ -39,23 +49,29 @@ function buildAuthenticatedUser(authInfo) {
     get userName() {
       return clientId;
     },
-    adcpAuthInfo: authInfo
+    adcpAuthInfo: authInfo,
+    ...gate && { adcpGate: gate }
   };
 }
-function buildAnonymousUser() {
+function buildAnonymousUser(gate) {
   return {
     get isAuthenticated() {
       return false;
     },
     get userName() {
       return "anonymous";
-    }
+    },
+    ...gate && { adcpGate: gate }
   };
 }
 function getAdcpAuthInfo(context) {
   const user = context?.user;
   return user?.adcpAuthInfo;
 }
+function getGateState(context) {
+  const user = context?.user;
+  return user?.adcpGate;
+}
 function extractInvocation(message, allowLegacyParameters = false) {
   if (!Array.isArray(message.parts) || message.parts.length === 0) {
     throw new A2AInvocationError("Message must carry at least one part with a `data` kind.");
@@ -92,6 +108,15 @@ function extractInvocation(message, allowLegacyParameters = false) {
   }
   return { skill, input };
 }
+function operationTaskWasCreatedFor(task) {
+  const first = task.history?.[0];
+  if (!first) return void 0;
+  try {
+    return extractInvocation(first, true).skill;
+  } catch {
+    return void 0;
+  }
+}
 class A2AInvocationError extends Error {
   constructor(message) {
     super(message);
@@ -163,6 +188,28 @@ class AdcpA2AAgentExecutor {
         });
         return;
       }
+      const gate = getGateState(requestContext.context);
+      if (gate && gate.operation !== invocation.skill) {
+        this.logger.error("A2A adapter: dispatcher operation differs from the signature gate", {
+          gateOperation: gate.operation === void 0 ? void 0 : JSON.stringify(gate.operation.slice(0, 64)),
+          requestedToolName: JSON.stringify(invocation.skill.slice(0, 64))
+        });
+        this.emitFailure(eventBus, taskId, contextId, {
+          reason: "INVALID_REQUEST",
+          message: "The request does not resolve to a single AdCP operation."
+        });
+        return;
+      }
+      if (requestContext.task) {
+        const createdFor = operationTaskWasCreatedFor(requestContext.task);
+        if (createdFor !== invocation.skill) {
+          this.emitFailure(eventBus, taskId, contextId, {
+            reason: "INVALID_REQUEST",
+            message: "A task continuation must use the operation the task was created for."
+          });
+          return;
+        }
+      }
       let response;
       const toolNames = a2aSkillToServerToolNames(invocation.skill);
       let invokedToolName;
@@ -563,6 +610,157 @@ function validateAgentCard(card) {
     );
   }
 }
+const MAX_GATED_BODY_BYTES = 100 * 1024;
+class BodyTooLargeError extends Error {
+}
+function captureRawBody(req, _res, buf) {
+  req.rawBody = buf.toString("utf8");
+}
+function resolveSignatureGate(options) {
+  const symbols = options.server;
+  const attached = symbols[ADCP_PRE_TRANSPORT];
+  const gate = options.preTransport ?? (typeof attached === "function" ? attached : void 0);
+  if (gate) return gate;
+  const state = symbols[ADCP_SIGNED_REQUESTS_STATE];
+  if ((state?.specialismClaimed || state?.capabilitySupported) && !options.allowUnenforcedSignedRequests) {
+    throw new Error(
+      "createA2AAdapter: the server advertises request signing (`signed-requests` / `request_signing.supported`) but no signature verifier is wired for A2A, so `required_for` would not be enforced over A2A. Configure `createAdcpServer({ signedRequests })`, pass the same verifier as `preTransport`, or set `allowUnenforcedSignedRequests: true` if a gateway in front of this adapter enforces it."
+    );
+  }
+  return void 0;
+}
+class InvalidRequestTargetError extends Error {
+}
+function signedRequestTargetUrl(req, agentUrl, override) {
+  if (override) return new URL(override(req));
+  const raw = req.originalUrl || req.url;
+  if (!raw.startsWith("/") || raw.startsWith("//")) throw new InvalidRequestTargetError();
+  const requested = new URL(raw, "http://placeholder.invalid");
+  return new URL(requested.pathname + requested.search, new URL(agentUrl).origin);
+}
+function createSignatureGate(opts) {
+  const { gate, next: sdkHandler, gateStates, targetUrl, logger } = opts;
+  const reject = (res, code, message) => {
+    res.status(401).set("WWW-Authenticate", `Signature error="${code}"`).json({ error: code, message });
+  };
+  const run = async (req, res) => {
+    const gated = req;
+    if (gated.rawBody === void 0) {
+      const encoding = req.headers["content-encoding"];
+      if (encoding !== void 0 && encoding.trim().toLowerCase() !== "identity") {
+        res.status(415).json({
+          jsonrpc: "2.0",
+          id: null,
+          error: { code: -32600, message: "Content-Encoding is not supported on a signed-requests endpoint." }
+        });
+        return false;
+      }
+      try {
+        const body = await readBody(req);
+        if (body !== void 0) {
+          gated.rawBody = body;
+          try {
+            gated.body = JSON.parse(body);
+            gated._body = true;
+          } catch {
+          }
+        }
+      } catch (err) {
+        if (!(err instanceof BodyTooLargeError)) throw err;
+        res.status(413).json({ jsonrpc: "2.0", id: null, error: { code: -32600, message: "Request body too large." } });
+        return false;
+      }
+    }
+    const captured = gated.rawBody;
+    const rawBody = typeof captured === "string" ? captured : captured?.toString("utf8");
+    if (rawBody === void 0) {
+      logger.error(
+        "A2A adapter: the raw request body is unavailable, so the signature gate cannot verify it. Mount the adapter ahead of any body parser, or capture the bytes with `express.json({ verify: adapter.rawBodyVerify })`."
+      );
+      res.status(500).json({ error: "raw_body_unavailable" });
+      return false;
+    }
+    gated.rawBody = rawBody;
+    let target;
+    try {
+      target = targetUrl(req);
+    } catch (err) {
+      if (!(err instanceof InvalidRequestTargetError)) throw err;
+      res.status(400).json({ jsonrpc: "2.0", id: null, error: { code: -32600, message: "Invalid request target." } });
+      return false;
+    }
+    const targetPath = target.pathname + target.search;
+    const input = { rawBody, method: req.method, url: targetPath };
+    const operation = resolveRequestOperation(input);
+    if (isUnresolvableOperation(operation)) {
+      logger.error("A2A adapter: request body does not resolve to one operation", {
+        reason: describeUnresolvable(input) ?? "unknown"
+      });
+      reject(res, "request_body_malformed", "Request body does not resolve to exactly one AdCP operation");
+      return false;
+    }
+    const originalUrl = req.url;
+    const stamped = req;
+    const previousContext = stamped[ADCP_SERVE_REQUEST_CONTEXT];
+    stamped[ADCP_SERVE_REQUEST_CONTEXT] = { host: target.host.toLowerCase(), publicUrl: target.origin };
+    req.url = targetPath;
+    const slots = req;
+    const previousAuth = slots.auth;
+    const previousSigner = slots.verifiedSigner;
+    slots.auth = void 0;
+    slots.verifiedSigner = void 0;
+    let handled;
+    let signedAuth;
+    try {
+      handled = await gate(req, res);
+      if (slots.verifiedSigner !== void 0) signedAuth = slots.auth;
+    } finally {
+      req.url = originalUrl;
+      stamped[ADCP_SERVE_REQUEST_CONTEXT] = previousContext;
+      slots.auth = previousAuth;
+      slots.verifiedSigner = previousSigner;
+    }
+    if (handled || res.headersSent) return false;
+    gated.body = JSON.parse(rawBody);
+    gated._body = true;
+    gateStates.set(req, { operation, ...signedAuth && { signedAuth } });
+    return true;
+  };
+  return (req, res, next) => {
+    if (req.method !== "POST") {
+      sdkHandler(req, res, next);
+      return;
+    }
+    run(req, res).then(
+      (proceed) => {
+        if (proceed) sdkHandler(req, res, next);
+      },
+      (err) => {
+        logger.error("A2A adapter: signature gate failed", { error: err?.name || "Error" });
+        if (!res.headersSent) res.status(500).json({ error: "verifier_error" });
+      }
+    );
+  };
+}
+function readBody(req) {
+  if (req.readableEnded || req.complete && !req.readable) return Promise.resolve(void 0);
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    let size = 0;
+    req.on("data", (chunk) => {
+      size += chunk.length;
+      if (size > MAX_GATED_BODY_BYTES) {
+        req.removeAllListeners("data");
+        req.resume();
+        reject(new BodyTooLargeError());
+        return;
+      }
+      chunks.push(chunk);
+    });
+    req.on("end", () => resolve(Buffer.concat(chunks).toString("utf8")));
+    req.on("error", reject);
+  });
+}
 const DEFAULT_LOGGER = {
   debug: (m, d) => console.debug(m, d ?? ""),
   info: (m, d) => console.info(m, d ?? ""),
@@ -573,6 +771,16 @@ function createA2AAdapter(options) {
   const logger = options.logger ?? DEFAULT_LOGGER;
   const legacyCompat = { enabled: options.legacyCompat?.enabled !== false };
   const card = buildAgentCard(options.server, options.agentCard, legacyCompat);
+  const signatureGate = resolveSignatureGate(options);
+  if (signatureGate && !options.signedRequestsUrl) {
+    try {
+      new URL(card.supportedInterfaces[0].url);
+    } catch {
+      throw new Error(
+        "createA2AAdapter: request signing needs an absolute `agentCard.url` (the URL buyers sign), or a `signedRequestsUrl` callback that returns it."
+      );
+    }
+  }
   const handlerCard = structuredClone(card);
   if (handlerCard.capabilities?.extensions) {
     handlerCard.capabilities.extensions = handlerCard.capabilities.extensions.map(
@@ -589,15 +797,36 @@ function createA2AAdapter(options) {
   const executor = new AdcpA2AAgentExecutor(options.server, logger);
   const eventBusManager = new DefaultExecutionEventBusManager();
   const requestHandler = new DefaultRequestHandler(handlerCard, taskStore, executor, eventBusManager);
+  const gateStates = /* @__PURE__ */ new WeakMap();
   const userBuilder = async (req) => {
-    if (!options.authenticate) return buildAnonymousUser();
+    const gate = gateStates.get(req);
+    const signed = gate?.signedAuth;
+    if (!options.authenticate) {
+      return signed ? buildAuthenticatedUser(signed, gate) : buildAnonymousUser(gate);
+    }
     const authInfo = await options.authenticate(req);
     if (authInfo == null) {
       throw new Error("A2A authentication failed");
     }
-    return buildAuthenticatedUser(authInfo);
+    if (signed) {
+      if (authInfo.clientId !== signed.clientId) {
+        logger.error(
+          `A2A adapter: \`authenticate\` returned a principal that differs from the verified signer (${signed.clientId}). Map the signer in \`authenticate\` (read \`req.verifiedSigner\`) or use makePrincipal.`
+        );
+        throw new Error("A2A authentication failed");
+      }
+      return buildAuthenticatedUser({ ...authInfo, extra: { ...authInfo.extra, ...signed.extra } }, gate);
+    }
+    return buildAuthenticatedUser(authInfo, gate);
   };
-  const jsonRpc = jsonRpcHandler({ requestHandler, userBuilder, legacyCompat });
+  const sdkJsonRpc = jsonRpcHandler({ requestHandler, userBuilder, legacyCompat });
+  const jsonRpc = signatureGate ? createSignatureGate({
+    gate: signatureGate,
+    next: sdkJsonRpc,
+    gateStates,
+    targetUrl: (req) => signedRequestTargetUrl(req, card.supportedInterfaces[0].url, options.signedRequestsUrl),
+    logger
+  }) : sdkJsonRpc;
   const nativeAgentCardMiddleware = agentCardHandler({ agentCardProvider: async () => card });
   const legacyAgentCardMiddleware = agentCardHandler({ agentCardProvider: async () => handlerCard, legacyCompat });
   const agentCardMiddleware = (req, res, next) => {
@@ -629,6 +858,7 @@ function createA2AAdapter(options) {
     async getAgentCard() {
       return card;
     },
+    rawBodyVerify: captureRawBody,
     mount
   };
 }