@adcp/sdk 16.4.0 → 16.6.0

package/dist/lib/protocols/mcp-modern.mjs

@@ -3,6 +3,7 @@ import { dirname as __adcpDirname } from "node:path";
 import { createRequire as __adcpCreateRequire } from "node:module";
 const __dirname = __adcpDirname(__adcpFileURLToPath(import.meta.url));
 const require2 = __adcpCreateRequire(import.meta.url);
+import { mcpConnectionPartitionKey, shouldReuseMCPConnection } from "./mcp-connection-policy.mjs";
 import {
   Client,
   SdkError,
@@ -15,6 +16,7 @@ import { is401Error } from "../errors/index.mjs";
 import { withSpan, injectTraceHeaders } from "../observability/tracing.mjs";
 import {
   currentMCPConnectionScopeKey,
+  markMCPConnectionScopeInterrupted,
   isMCPConnectionScopeCacheKeyActive,
   registerMCPConnectionScopeCleanup,
   registerMCPConnectionScopePending
@@ -110,6 +112,8 @@ function connectionCacheKey(agentUrl, headers, signingCacheKey, authProvider, fe
   if (handleLegacy !== void 0) parts.push(`handle-legacy:${handleLegacy}`);
   if (allowPrivateIp !== void 0) parts.push(`allow-private-ip:${allowPrivateIp}`);
   parts.push(responseSizeCapCacheKey());
+  const partitionKey = mcpConnectionPartitionKey();
+  if (partitionKey) parts.push(`partition:${partitionKey}`);
   const scopeKey = currentMCPConnectionScopeKey();
   if (scopeKey) parts.push(scopeKey);
   return parts.join("::");
@@ -252,9 +256,15 @@ async function createNegotiatedClient(cacheKey, options, authHeaders, useCachedD
     getCapability: options.signingContext.getCapability,
     adcpVersion: options.signingContext.adcpVersion
   }) : diagnosticFetch;
+  const transportFetch = wrapFetchWithCapture(withPerRequestTraceHeaders(signedFetch));
+  let throttleRetryAfter;
   const transport = new StreamableHTTPClientTransport(new URL(options.agentUrl), {
     requestInit: { headers: splitConnectionHeaders(authHeaders).identity, redirect: "manual" },
-    fetch: wrapFetchWithCapture(withPerRequestTraceHeaders(signedFetch)),
+    fetch: async (input, init) => {
+      const response = await transportFetch(input, init);
+      throttleRetryAfter = response.status === 429 || response.status === 503 ? response.headers.get("retry-after") ?? void 0 : void 0;
+      return response;
+    },
     ...options.authProvider && {
       authProvider: options.authProvider
     }
@@ -279,7 +289,7 @@ async function createNegotiatedClient(cacheKey, options, authHeaders, useCachedD
     if (prior && !skipProbe) clientsUsingCachedDiscovery.add(client);
     if (!prior) {
       const discover = client.getDiscoverResult();
-      if (generation === connectionGeneration) {
+      if (generation === connectionGeneration && useCachedDiscovery) {
         if (client.getProtocolEra() === "modern" && discover) cacheModernDiscovery(cacheKey, discover);
         else modernDiscoveries.delete(cacheKey);
       }
@@ -297,8 +307,22 @@ async function createNegotiatedClient(cacheKey, options, authHeaders, useCachedD
     if (isNegotiationAuthFailure(error) && !skipProbe && presentedStaticCredential(authHeaders, options.authProvider)) {
       return createNegotiatedClient(cacheKey, options, authHeaders, useCachedDiscovery, true);
     }
-    throw error;
+    throw withRetryAfter(error, throttleRetryAfter);
+  }
+}
+function withRetryAfter(error, retryAfter) {
+  if (retryAfter === void 0 || !error || typeof error !== "object") return error;
+  const status = httpStatusOf(error);
+  if (status !== 429 && status !== 503) return error;
+  try {
+    Object.defineProperty(error, "retryAfter", { value: retryAfter, enumerable: false, configurable: true });
+  } catch {
   }
+  return error;
+}
+function retryAfterOf(error) {
+  const value = error && typeof error === "object" ? error.retryAfter : void 0;
+  return typeof value === "string" ? value : void 0;
 }
 async function getOrCreateModernConnection(cacheKey, options, authHeaders) {
   for (let attempt = 0; ; attempt++) {
@@ -318,12 +342,12 @@ function createSharedModernConnection(cacheKey, options, authHeaders) {
   const promise = createNegotiatedClient(cacheKey, options, authHeaders).then(async (client) => {
     if ((client.getProtocolEra() === "modern" || options.handleLegacy === true) && generation === connectionGeneration) {
       modernConnections.set(cacheKey, client);
-      registerMCPConnectionScopeCleanup("modern", cacheKey, async () => {
+      registerMCPConnectionScopeCleanup("modern", cacheKey, async (terminateSession) => {
         if (modernConnections.get(cacheKey) !== client) return;
         modernConnections.delete(cacheKey);
         legacyConnectionExpiresAt.delete(cacheKey);
         modernDiscoveries.delete(cacheKey);
-        await closeModernClient(client);
+        await closeModernClient(client, terminateSession);
       });
       if (client.getProtocolEra() === "legacy") {
         legacyConnectionExpiresAt.set(cacheKey, Date.now() + LEGACY_CLASSIFICATION_TTL_MS);
@@ -345,7 +369,10 @@ function createSharedModernConnection(cacheKey, options, authHeaders) {
   return promise;
 }
 async function retireFailedConnection(cacheKey, client, error) {
-  if (isAbortOrTimeoutError(error)) return;
+  if (isAbortOrTimeoutError(error)) {
+    markMCPConnectionScopeInterrupted();
+    return;
+  }
   if (modernConnections.get(cacheKey) === client) {
     modernConnections.delete(cacheKey);
     legacyConnectionExpiresAt.delete(cacheKey);
@@ -376,11 +403,11 @@ async function attemptModernCall(options, toolName, args) {
     options.allowPrivateIp
   );
   if (isKnownLegacy(cacheKey)) return { handled: false };
-  const oneShot = options.fetchFn !== void 0 && currentMCPConnectionScopeKey() === void 0;
+  const oneShot = !shouldReuseMCPConnection(options.fetchFn !== void 0);
   let client;
   let callSucceeded = false;
   try {
-    client = oneShot ? await createNegotiatedClient(cacheKey, options, authHeaders) : await getOrCreateModernConnection(cacheKey, options, authHeaders);
+    client = oneShot ? await createNegotiatedClient(cacheKey, options, authHeaders, false) : await getOrCreateModernConnection(cacheKey, options, authHeaders);
   } catch (error) {
     const status = httpStatusOf(error);
     if (status === 404 || status === 405) {
@@ -513,7 +540,8 @@ async function probeModernMCPConnection(agentUrl, authToken, customHeaders, opti
     options.handleLegacy,
     options.allowPrivateIp
   );
-  const scoped = currentMCPConnectionScopeKey() !== void 0;
+  const scoped = shouldReuseMCPConnection(options.fetchFn !== void 0);
+  if (isKnownLegacy(cacheKey)) return { connected: false };
   let client;
   return runWithMCPCallContext(
     callContextFor({ customHeaders, requestTimeoutMs: options.requestTimeoutMs }),
@@ -563,7 +591,7 @@ async function tryListModernMCPTools(agentUrl, authToken, customHeaders, options
     options.handleLegacy,
     options.allowPrivateIp
   );
-  const scoped = currentMCPConnectionScopeKey() !== void 0;
+  const scoped = shouldReuseMCPConnection(options.fetchFn !== void 0);
   if (scoped && isKnownLegacy(cacheKey)) return { handled: false };
   let client;
   const sharedClients = /* @__PURE__ */ new WeakSet();
@@ -598,7 +626,7 @@ async function tryListModernMCPTools(agentUrl, authToken, customHeaders, options
     async () => {
       try {
         client = await acquire(
-          () => scoped ? getOrCreateModernConnection(cacheKey, connectionOptions, authHeaders) : createNegotiatedClient(cacheKey, connectionOptions, authHeaders)
+          () => scoped ? getOrCreateModernConnection(cacheKey, connectionOptions, authHeaders) : createNegotiatedClient(cacheKey, connectionOptions, authHeaders, false)
         );
         return await listTools(client);
       } catch (error) {
@@ -653,6 +681,7 @@ async function closeModernMCPConnections() {
 export {
   closeModernMCPConnections,
   probeModernMCPConnection,
+  retryAfterOf,
   tryCallModernMCPTool,
   tryListModernMCPTools
 };

package/dist/lib/protocols/mcp-scope.d.mts

@@ -1,6 +1,8 @@
-type ScopeCleanup = () => Promise<void>;
+type ScopeCleanup = (terminateSession: boolean) => Promise<void>;
 /** Cache-key suffix for the current caller-owned MCP workflow. */
 export declare function currentMCPConnectionScopeKey(): string | undefined;
+/** Preserve seller work even when a higher layer handles a request timeout. */
+export declare function markMCPConnectionScopeInterrupted(): void;
 /** Whether an LRU entry belongs to a workflow that has not finished yet. */
 export declare function isMCPConnectionScopeCacheKeyActive(cacheKey: string): boolean;
 /** Register one idempotent cache-entry cleanup with the current workflow. */
@@ -20,6 +22,9 @@ export declare function closeCurrentMCPConnectionScope(): Promise<boolean>;
  * Per-call correlation headers, `AbortSignal`s and timeouts do not choose the
  * session. The scope terminates its sessions once, when `fn` settles; pass
  * `{ isolate: true }` to force a fresh scope even when called from inside one.
+ * Explicit workflows terminate sessions at exit even if an inner call returned
+ * submitted/working; the caller owns that lifetime. Implicit task scopes may
+ * close only their local clients when their final result remains nonterminal.
  *
  * @example
  * ```ts

package/dist/lib/protocols/mcp-scope.d.ts

@@ -1,6 +1,8 @@
-type ScopeCleanup = () => Promise<void>;
+type ScopeCleanup = (terminateSession: boolean) => Promise<void>;
 /** Cache-key suffix for the current caller-owned MCP workflow. */
 export declare function currentMCPConnectionScopeKey(): string | undefined;
+/** Preserve seller work even when a higher layer handles a request timeout. */
+export declare function markMCPConnectionScopeInterrupted(): void;
 /** Whether an LRU entry belongs to a workflow that has not finished yet. */
 export declare function isMCPConnectionScopeCacheKeyActive(cacheKey: string): boolean;
 /** Register one idempotent cache-entry cleanup with the current workflow. */
@@ -20,6 +22,9 @@ export declare function closeCurrentMCPConnectionScope(): Promise<boolean>;
  * Per-call correlation headers, `AbortSignal`s and timeouts do not choose the
  * session. The scope terminates its sessions once, when `fn` settles; pass
  * `{ isolate: true }` to force a fresh scope even when called from inside one.
+ * Explicit workflows terminate sessions at exit even if an inner call returned
+ * submitted/working; the caller owns that lifetime. Implicit task scopes may
+ * close only their local clients when their final result remains nonterminal.
  *
  * @example
  * ```ts

package/dist/lib/protocols/mcp-scope.js

@@ -21,18 +21,24 @@ __export(mcp_scope_exports, {
   closeCurrentMCPConnectionScope: () => closeCurrentMCPConnectionScope,
   currentMCPConnectionScopeKey: () => currentMCPConnectionScopeKey,
   isMCPConnectionScopeCacheKeyActive: () => isMCPConnectionScopeCacheKeyActive,
+  markMCPConnectionScopeInterrupted: () => markMCPConnectionScopeInterrupted,
   registerMCPConnectionScopeCleanup: () => registerMCPConnectionScopeCleanup,
   registerMCPConnectionScopePending: () => registerMCPConnectionScopePending,
   withMCPConnectionScope: () => withMCPConnectionScope
 });
 module.exports = __toCommonJS(mcp_scope_exports);
 var import_node_async_hooks = require("node:async_hooks");
+var import_abort = require('./abort.js');
 const scopeStorage = new import_node_async_hooks.AsyncLocalStorage();
 const activeScopeKeys = /* @__PURE__ */ new Set();
 let nextScopeId = 0;
 function currentMCPConnectionScopeKey() {
   return scopeStorage.getStore()?.cacheKey;
 }
+function markMCPConnectionScopeInterrupted() {
+  const scope = scopeStorage.getStore();
+  if (scope?.preserveOnInterruption) scope.interrupted = true;
+}
 function isMCPConnectionScopeCacheKeyActive(cacheKey) {
   const marker = cacheKey.lastIndexOf("::scope:");
   return marker >= 0 && activeScopeKeys.has(cacheKey.slice(marker + 2));
@@ -55,17 +61,32 @@ async function closeCurrentMCPConnectionScope() {
   }
   const cleanups = [...scope.cleanups.values()];
   scope.cleanups.clear();
-  await Promise.allSettled(cleanups.map((cleanup) => cleanup()));
+  await Promise.allSettled(
+    cleanups.map((cleanup) => cleanup(!scope.signal?.aborted && !scope.interrupted && !scope.preserveSession))
+  );
   return true;
 }
 async function withMCPConnectionScope(fn, options = {}) {
   if (scopeStorage.getStore() && options.isolate !== true) return fn();
   const id = ++nextScopeId;
-  const scope = { id, cacheKey: `scope:${id}`, pending: /* @__PURE__ */ new Set(), cleanups: /* @__PURE__ */ new Map() };
+  const scope = {
+    id,
+    cacheKey: `scope:${id}`,
+    pending: /* @__PURE__ */ new Set(),
+    cleanups: /* @__PURE__ */ new Map(),
+    signal: options.signal,
+    preserveOnInterruption: options.preserveOnInterruption,
+    preserveSessionOnResult: options.preserveSessionOnResult
+  };
   activeScopeKeys.add(scope.cacheKey);
   return scopeStorage.run(scope, async () => {
     try {
-      return await fn();
+      const result = await fn();
+      scope.preserveSession = scope.preserveSessionOnResult?.(result) === true;
+      return result;
+    } catch (error) {
+      if ((0, import_abort.isAbortOrTimeoutError)(error)) markMCPConnectionScopeInterrupted();
+      throw error;
     } finally {
       try {
         await closeCurrentMCPConnectionScope();
@@ -80,6 +101,7 @@ async function withMCPConnectionScope(fn, options = {}) {
   closeCurrentMCPConnectionScope,
   currentMCPConnectionScopeKey,
   isMCPConnectionScopeCacheKeyActive,
+  markMCPConnectionScopeInterrupted,
   registerMCPConnectionScopeCleanup,
   registerMCPConnectionScopePending,
   withMCPConnectionScope

package/dist/lib/protocols/mcp-scope.mjs

@@ -4,12 +4,17 @@ import { createRequire as __adcpCreateRequire } from "node:module";
 const __dirname = __adcpDirname(__adcpFileURLToPath(import.meta.url));
 const require2 = __adcpCreateRequire(import.meta.url);
 import { AsyncLocalStorage } from "node:async_hooks";
+import { isAbortOrTimeoutError } from "./abort.mjs";
 const scopeStorage = new AsyncLocalStorage();
 const activeScopeKeys = /* @__PURE__ */ new Set();
 let nextScopeId = 0;
 function currentMCPConnectionScopeKey() {
   return scopeStorage.getStore()?.cacheKey;
 }
+function markMCPConnectionScopeInterrupted() {
+  const scope = scopeStorage.getStore();
+  if (scope?.preserveOnInterruption) scope.interrupted = true;
+}
 function isMCPConnectionScopeCacheKeyActive(cacheKey) {
   const marker = cacheKey.lastIndexOf("::scope:");
   return marker >= 0 && activeScopeKeys.has(cacheKey.slice(marker + 2));
@@ -32,17 +37,32 @@ async function closeCurrentMCPConnectionScope() {
   }
   const cleanups = [...scope.cleanups.values()];
   scope.cleanups.clear();
-  await Promise.allSettled(cleanups.map((cleanup) => cleanup()));
+  await Promise.allSettled(
+    cleanups.map((cleanup) => cleanup(!scope.signal?.aborted && !scope.interrupted && !scope.preserveSession))
+  );
   return true;
 }
 async function withMCPConnectionScope(fn, options = {}) {
   if (scopeStorage.getStore() && options.isolate !== true) return fn();
   const id = ++nextScopeId;
-  const scope = { id, cacheKey: `scope:${id}`, pending: /* @__PURE__ */ new Set(), cleanups: /* @__PURE__ */ new Map() };
+  const scope = {
+    id,
+    cacheKey: `scope:${id}`,
+    pending: /* @__PURE__ */ new Set(),
+    cleanups: /* @__PURE__ */ new Map(),
+    signal: options.signal,
+    preserveOnInterruption: options.preserveOnInterruption,
+    preserveSessionOnResult: options.preserveSessionOnResult
+  };
   activeScopeKeys.add(scope.cacheKey);
   return scopeStorage.run(scope, async () => {
     try {
-      return await fn();
+      const result = await fn();
+      scope.preserveSession = scope.preserveSessionOnResult?.(result) === true;
+      return result;
+    } catch (error) {
+      if (isAbortOrTimeoutError(error)) markMCPConnectionScopeInterrupted();
+      throw error;
     } finally {
       try {
         await closeCurrentMCPConnectionScope();
@@ -56,6 +76,7 @@ export {
   closeCurrentMCPConnectionScope,
   currentMCPConnectionScopeKey,
   isMCPConnectionScopeCacheKeyActive,
+  markMCPConnectionScopeInterrupted,
   registerMCPConnectionScopeCleanup,
   registerMCPConnectionScopePending,
   withMCPConnectionScope

package/dist/lib/protocols/mcp-tasks.d.mts

@@ -1,3 +1,4 @@
+import { type MCPConnectionPolicy } from './mcp-connection-policy.mjs';
 /**
  * MCP Tasks protocol integration for async tool calls.
  *
@@ -13,8 +14,17 @@ import type { DebugLogEntry } from '../types/adcp.mjs';
 import type { TaskInfo } from '../core/ConversationTypes.mjs';
 import { type AgentSigningContext } from '../signing/client.mjs';
 import { type TransportActivityHandler } from './transportDiagnostics.mjs';
+/** Connection identity for URL/token native task follow-up calls. */
+export interface MCPTaskConnectionOptions extends MCPConnectionPolicy {
+    headers?: Record<string, string>;
+    signingContext?: AgentSigningContext;
+}
 interface MCPTaskProtocolOptions {
+    signingContext?: AgentSigningContext;
+    headers?: Record<string, string>;
     transport?: {
+        connectionPartition?: string;
+        connectionReuse?: 'process';
         maxResponseBytes?: number;
         trustedFetchFn?: typeof fetch;
         requestTimeoutMs?: number;
@@ -50,7 +60,7 @@ export declare function mapMCPTaskStatus(mcpStatus: string): string;
  * The stream is consumed with a timeout. If the task doesn't complete within the timeout,
  * returns a working-status response with the MCP task_id for follow-up polling.
  */
-export declare function callMCPToolWithTasks(agentUrl: string, toolName: string, args: Record<string, unknown>, authToken?: string, debugLogs?: DebugLogEntry[], customHeaders?: Record<string, string>, options?: {
+export declare function callMCPToolWithTasks(agentUrl: string, toolName: string, args: Record<string, unknown>, authToken?: string, debugLogs?: DebugLogEntry[], customHeaders?: Record<string, string>, options?: MCPConnectionPolicy & {
     workingTimeout?: number;
     signingContext?: AgentSigningContext;
     signal?: AbortSignal;
@@ -79,18 +89,17 @@ export declare function callMCPToolWithClient(mcpClient: MCPClient, toolName: st
  *
  * Task lifecycle methods (`tasks/get`, `tasks/result`, `tasks/list`,
  * `tasks/cancel`) are MCP protocol methods, not AdCP operations.
- * `extractAdcpOperation` returns `undefined` for them, so the signing fetch
- * passes them through unsigned regardless of whether an `AgentSigningContext`
- * is present in ALS. That matches the RFC 9421 signing profile, which only
- * covers AdCP tool calls (`tools/call` / `message/send`).
+ * The transport signing fetch evaluates them against the seller's separate
+ * `protocol_methods_*` lists (or the buyer's `always_sign_protocol_methods`),
+ * using exact JSON-RPC wire names rather than AdCP operation names.
  *
  * Re-throws auth errors (401) — only catches protocol capability errors.
  */
-export declare function getMCPTaskStatus(agentUrl: string, taskId: string, authToken?: string, debugLogs?: DebugLogEntry[], toolName?: string): Promise<TaskInfo>;
+export declare function getMCPTaskStatus(agentUrl: string, taskId: string, authToken?: string, debugLogs?: DebugLogEntry[], toolName?: string, options?: MCPTaskConnectionOptions): Promise<TaskInfo>;
 /**
  * Get task result via MCP Tasks protocol method (blocks until terminal).
  */
-export declare function getMCPTaskResult(agentUrl: string, taskId: string, authToken?: string, debugLogs?: DebugLogEntry[]): Promise<unknown>;
+export declare function getMCPTaskResult(agentUrl: string, taskId: string, authToken?: string, debugLogs?: DebugLogEntry[], options?: MCPTaskConnectionOptions): Promise<unknown>;
 /**
  * List tasks via MCP Tasks protocol method.
  */
@@ -98,5 +107,5 @@ export declare function listMCPTasks(agentUrl: string, authToken?: string, debug
 /**
  * Cancel a task via MCP Tasks protocol method.
  */
-export declare function cancelMCPTask(agentUrl: string, taskId: string, authToken?: string, debugLogs?: DebugLogEntry[]): Promise<void>;
+export declare function cancelMCPTask(agentUrl: string, taskId: string, authToken?: string, debugLogs?: DebugLogEntry[], options?: MCPTaskConnectionOptions): Promise<void>;
 export {};

package/dist/lib/protocols/mcp-tasks.d.ts

@@ -1,3 +1,4 @@
+import { type MCPConnectionPolicy } from './mcp-connection-policy';
 /**
  * MCP Tasks protocol integration for async tool calls.
  *
@@ -13,8 +14,17 @@ import type { DebugLogEntry } from '../types/adcp';
 import type { TaskInfo } from '../core/ConversationTypes';
 import { type AgentSigningContext } from '../signing/client';
 import { type TransportActivityHandler } from './transportDiagnostics';
+/** Connection identity for URL/token native task follow-up calls. */
+export interface MCPTaskConnectionOptions extends MCPConnectionPolicy {
+    headers?: Record<string, string>;
+    signingContext?: AgentSigningContext;
+}
 interface MCPTaskProtocolOptions {
+    signingContext?: AgentSigningContext;
+    headers?: Record<string, string>;
     transport?: {
+        connectionPartition?: string;
+        connectionReuse?: 'process';
         maxResponseBytes?: number;
         trustedFetchFn?: typeof fetch;
         requestTimeoutMs?: number;
@@ -50,7 +60,7 @@ export declare function mapMCPTaskStatus(mcpStatus: string): string;
  * The stream is consumed with a timeout. If the task doesn't complete within the timeout,
  * returns a working-status response with the MCP task_id for follow-up polling.
  */
-export declare function callMCPToolWithTasks(agentUrl: string, toolName: string, args: Record<string, unknown>, authToken?: string, debugLogs?: DebugLogEntry[], customHeaders?: Record<string, string>, options?: {
+export declare function callMCPToolWithTasks(agentUrl: string, toolName: string, args: Record<string, unknown>, authToken?: string, debugLogs?: DebugLogEntry[], customHeaders?: Record<string, string>, options?: MCPConnectionPolicy & {
     workingTimeout?: number;
     signingContext?: AgentSigningContext;
     signal?: AbortSignal;
@@ -79,18 +89,17 @@ export declare function callMCPToolWithClient(mcpClient: MCPClient, toolName: st
  *
  * Task lifecycle methods (`tasks/get`, `tasks/result`, `tasks/list`,
  * `tasks/cancel`) are MCP protocol methods, not AdCP operations.
- * `extractAdcpOperation` returns `undefined` for them, so the signing fetch
- * passes them through unsigned regardless of whether an `AgentSigningContext`
- * is present in ALS. That matches the RFC 9421 signing profile, which only
- * covers AdCP tool calls (`tools/call` / `message/send`).
+ * The transport signing fetch evaluates them against the seller's separate
+ * `protocol_methods_*` lists (or the buyer's `always_sign_protocol_methods`),
+ * using exact JSON-RPC wire names rather than AdCP operation names.
  *
  * Re-throws auth errors (401) — only catches protocol capability errors.
  */
-export declare function getMCPTaskStatus(agentUrl: string, taskId: string, authToken?: string, debugLogs?: DebugLogEntry[], toolName?: string): Promise<TaskInfo>;
+export declare function getMCPTaskStatus(agentUrl: string, taskId: string, authToken?: string, debugLogs?: DebugLogEntry[], toolName?: string, options?: MCPTaskConnectionOptions): Promise<TaskInfo>;
 /**
  * Get task result via MCP Tasks protocol method (blocks until terminal).
  */
-export declare function getMCPTaskResult(agentUrl: string, taskId: string, authToken?: string, debugLogs?: DebugLogEntry[]): Promise<unknown>;
+export declare function getMCPTaskResult(agentUrl: string, taskId: string, authToken?: string, debugLogs?: DebugLogEntry[], options?: MCPTaskConnectionOptions): Promise<unknown>;
 /**
  * List tasks via MCP Tasks protocol method.
  */
@@ -98,5 +107,5 @@ export declare function listMCPTasks(agentUrl: string, authToken?: string, debug
 /**
  * Cancel a task via MCP Tasks protocol method.
  */
-export declare function cancelMCPTask(agentUrl: string, taskId: string, authToken?: string, debugLogs?: DebugLogEntry[]): Promise<void>;
+export declare function cancelMCPTask(agentUrl: string, taskId: string, authToken?: string, debugLogs?: DebugLogEntry[], options?: MCPTaskConnectionOptions): Promise<void>;
 export {};

package/dist/lib/protocols/mcp-tasks.js

@@ -20,14 +20,20 @@ var mcp_tasks_exports = {};
 __export(mcp_tasks_exports, {
   callMCPToolWithClient: () => callMCPToolWithClient,
   callMCPToolWithTasks: () => callMCPToolWithTasks,
+  callMCPToolWithTasksInContext: () => callMCPToolWithTasksInContext,
   cancelMCPTask: () => cancelMCPTask,
+  cancelMCPTaskInContext: () => cancelMCPTaskInContext,
   getMCPTaskResult: () => getMCPTaskResult,
+  getMCPTaskResultInContext: () => getMCPTaskResultInContext,
   getMCPTaskStatus: () => getMCPTaskStatus,
+  getMCPTaskStatusInContext: () => getMCPTaskStatusInContext,
   listMCPTasks: () => listMCPTasks,
   mapMCPTaskStatus: () => mapMCPTaskStatus,
   serverSupportsTasks: () => serverSupportsTasks
 });
 module.exports = __toCommonJS(mcp_tasks_exports);
+var import_types = require("@modelcontextprotocol/sdk/types.js");
+var import_mcp_connection_policy = require('./mcp-connection-policy.js');
 var import_mcp = require('./mcp.js');
 var import_auth = require('../auth/index.js');
 var import_tracing = require('../observability/tracing.js');
@@ -90,6 +96,12 @@ function validateTaskId(taskId) {
   }
 }
 async function callMCPToolWithTasks(agentUrl, toolName, args, authToken, debugLogs = [], customHeaders, options) {
+  return (0, import_mcp_connection_policy.withMCPConnectionPolicy)(
+    options,
+    () => callMCPToolWithTasksInContext(agentUrl, toolName, args, authToken, debugLogs, customHeaders, options)
+  );
+}
+async function callMCPToolWithTasksInContext(agentUrl, toolName, args, authToken, debugLogs = [], customHeaders, options) {
   debugLogs.push({
     type: "info",
     message: `MCP: Auth configuration`,
@@ -253,7 +265,7 @@ async function callToolOnClient(client, toolName, args, debugLogs, workingTimeou
             try {
               const taskResult = await client.experimental.tasks.getTaskResult(
                 capturedTaskId,
-                void 0,
+                import_types.CallToolResultSchema,
                 requestOptions
               );
               const content = taskResult?.content;
@@ -318,9 +330,18 @@ async function callToolOnClient(client, toolName, args, debugLogs, workingTimeou
   }
   throw new Error(`MCP Tasks: callToolStream for ${toolName} ended without result or task`);
 }
-async function getMCPTaskStatus(agentUrl, taskId, authToken, debugLogs = [], toolName) {
+async function getMCPTaskStatus(agentUrl, taskId, authToken, debugLogs = [], toolName, options = {}) {
+  return (0, import_mcp_connection_policy.withMCPConnectionPolicy)(
+    options,
+    () => import_client.signingContextStorage.run(
+      options.signingContext,
+      () => getMCPTaskStatusInContext(agentUrl, taskId, authToken, debugLogs, toolName, options)
+    )
+  );
+}
+async function getMCPTaskStatusInContext(agentUrl, taskId, authToken, debugLogs = [], toolName, options = {}) {
   validateTaskId(taskId);
-  const authHeaders = buildAuthHeaders(authToken);
+  const authHeaders = buildAuthHeaders(authToken, options.headers);
   return (0, import_mcp.withCachedConnection)(agentUrl, authToken, authHeaders, debugLogs, `tasks/get:${taskId}`, async (client) => {
     const result = await client.experimental.tasks.getTask(taskId);
     debugLogs.push({
@@ -334,11 +355,20 @@ async function getMCPTaskStatus(agentUrl, taskId, authToken, debugLogs = [], too
     );
   });
 }
-async function getMCPTaskResult(agentUrl, taskId, authToken, debugLogs = []) {
+async function getMCPTaskResult(agentUrl, taskId, authToken, debugLogs = [], options = {}) {
+  return (0, import_mcp_connection_policy.withMCPConnectionPolicy)(
+    options,
+    () => import_client.signingContextStorage.run(
+      options.signingContext,
+      () => getMCPTaskResultInContext(agentUrl, taskId, authToken, debugLogs, options)
+    )
+  );
+}
+async function getMCPTaskResultInContext(agentUrl, taskId, authToken, debugLogs = [], options = {}) {
   validateTaskId(taskId);
-  const authHeaders = buildAuthHeaders(authToken);
+  const authHeaders = buildAuthHeaders(authToken, options.headers);
   return (0, import_mcp.withCachedConnection)(agentUrl, authToken, authHeaders, debugLogs, `tasks/result:${taskId}`, async (client) => {
-    const result = await client.experimental.tasks.getTaskResult(taskId);
+    const result = await client.experimental.tasks.getTaskResult(taskId, import_types.CallToolResultSchema);
     debugLogs.push({
       type: "success",
       message: `MCP Tasks: getTaskResult ${taskId} received`,
@@ -348,45 +378,60 @@ async function getMCPTaskResult(agentUrl, taskId, authToken, debugLogs = []) {
   });
 }
 async function listMCPTasks(agentUrl, authToken, debugLogs = [], options = {}) {
-  const authHeaders = buildAuthHeaders(authToken);
-  return (0, import_responseSizeLimit.withResponseSizeLimit)(
-    options.transport?.maxResponseBytes,
-    () => (0, import_transportDiagnostics.withTransportDiagnostics)(
-      {
-        agentId: options.transportActivityContext?.agentId ?? "unknown-agent",
-        protocol: "mcp",
-        tool: "tasks/list",
-        taskType: "tasks/list",
-        ...options.transportActivityContext,
-        onTransportActivity: options.onTransportActivity
-      },
-      () => (0, import_mcp.withCachedConnection)(
-        agentUrl,
-        authToken,
-        authHeaders,
-        debugLogs,
-        "tasks/list",
-        async (client) => {
-          const result = await client.experimental.tasks.listTasks();
-          debugLogs.push({
-            type: "info",
-            message: `MCP Tasks: listTasks returned ${result.tasks.length} tasks`,
-            timestamp: (/* @__PURE__ */ new Date()).toISOString()
-          });
-          return result.tasks.map((task) => mapMCPTaskToTaskInfo(task));
-        },
-        options.transport?.trustedFetchFn,
-        {
-          requestTimeoutMs: options.transport?.requestTimeoutMs,
-          allowPrivateIp: options.transport?.allowPrivateIp
-        }
+  const authHeaders = buildAuthHeaders(authToken, options.headers);
+  return (0, import_mcp_connection_policy.withMCPConnectionPolicy)(
+    options.transport,
+    () => import_client.signingContextStorage.run(
+      options.signingContext,
+      () => (0, import_responseSizeLimit.withResponseSizeLimit)(
+        options.transport?.maxResponseBytes,
+        () => (0, import_transportDiagnostics.withTransportDiagnostics)(
+          {
+            agentId: options.transportActivityContext?.agentId ?? "unknown-agent",
+            protocol: "mcp",
+            tool: "tasks/list",
+            taskType: "tasks/list",
+            ...options.transportActivityContext,
+            onTransportActivity: options.onTransportActivity
+          },
+          () => (0, import_mcp.withCachedConnection)(
+            agentUrl,
+            authToken,
+            authHeaders,
+            debugLogs,
+            "tasks/list",
+            async (client) => {
+              const result = await client.experimental.tasks.listTasks();
+              debugLogs.push({
+                type: "info",
+                message: `MCP Tasks: listTasks returned ${result.tasks.length} tasks`,
+                timestamp: (/* @__PURE__ */ new Date()).toISOString()
+              });
+              return result.tasks.map((task) => mapMCPTaskToTaskInfo(task));
+            },
+            options.transport?.trustedFetchFn,
+            {
+              requestTimeoutMs: options.transport?.requestTimeoutMs,
+              allowPrivateIp: options.transport?.allowPrivateIp
+            }
+          )
+        )
       )
     )
   );
 }
-async function cancelMCPTask(agentUrl, taskId, authToken, debugLogs = []) {
+async function cancelMCPTask(agentUrl, taskId, authToken, debugLogs = [], options = {}) {
+  return (0, import_mcp_connection_policy.withMCPConnectionPolicy)(
+    options,
+    () => import_client.signingContextStorage.run(
+      options.signingContext,
+      () => cancelMCPTaskInContext(agentUrl, taskId, authToken, debugLogs, options)
+    )
+  );
+}
+async function cancelMCPTaskInContext(agentUrl, taskId, authToken, debugLogs = [], options = {}) {
   validateTaskId(taskId);
-  const authHeaders = buildAuthHeaders(authToken);
+  const authHeaders = buildAuthHeaders(authToken, options.headers);
   await (0, import_mcp.withCachedConnection)(agentUrl, authToken, authHeaders, debugLogs, `tasks/cancel:${taskId}`, async (client) => {
     await client.experimental.tasks.cancelTask(taskId);
     debugLogs.push({
@@ -400,9 +445,13 @@ async function cancelMCPTask(agentUrl, taskId, authToken, debugLogs = []) {
 0 && (module.exports = {
   callMCPToolWithClient,
   callMCPToolWithTasks,
+  callMCPToolWithTasksInContext,
   cancelMCPTask,
+  cancelMCPTaskInContext,
   getMCPTaskResult,
+  getMCPTaskResultInContext,
   getMCPTaskStatus,
+  getMCPTaskStatusInContext,
   listMCPTasks,
   mapMCPTaskStatus,
   serverSupportsTasks