@adcp/sdk 16.4.0 → 16.5.0

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

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

@@ -3,6 +3,8 @@ 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 { CallToolResultSchema } from "@modelcontextprotocol/sdk/types.js";
+import { withMCPConnectionPolicy } from "./mcp-connection-policy.mjs";
 import { withCachedConnection } from "./mcp.mjs";
 import { createMCPRequestHeaders } from "../auth/index.mjs";
 import { withSpan } from "../observability/tracing.mjs";
@@ -65,6 +67,12 @@ function validateTaskId(taskId) {
   }
 }
 async function callMCPToolWithTasks(agentUrl, toolName, args, authToken, debugLogs = [], customHeaders, options) {
+  return 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`,
@@ -228,7 +236,7 @@ async function callToolOnClient(client, toolName, args, debugLogs, workingTimeou
             try {
               const taskResult = await client.experimental.tasks.getTaskResult(
                 capturedTaskId,
-                void 0,
+                CallToolResultSchema,
                 requestOptions
               );
               const content = taskResult?.content;
@@ -293,9 +301,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 withMCPConnectionPolicy(
+    options,
+    () => 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 withCachedConnection(agentUrl, authToken, authHeaders, debugLogs, `tasks/get:${taskId}`, async (client) => {
     const result = await client.experimental.tasks.getTask(taskId);
     debugLogs.push({
@@ -309,11 +326,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 withMCPConnectionPolicy(
+    options,
+    () => 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 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, CallToolResultSchema);
     debugLogs.push({
       type: "success",
       message: `MCP Tasks: getTaskResult ${taskId} received`,
@@ -323,45 +349,60 @@ async function getMCPTaskResult(agentUrl, taskId, authToken, debugLogs = []) {
   });
 }
 async function listMCPTasks(agentUrl, authToken, debugLogs = [], options = {}) {
-  const authHeaders = buildAuthHeaders(authToken);
-  return withResponseSizeLimit(
-    options.transport?.maxResponseBytes,
-    () => withTransportDiagnostics(
-      {
-        agentId: options.transportActivityContext?.agentId ?? "unknown-agent",
-        protocol: "mcp",
-        tool: "tasks/list",
-        taskType: "tasks/list",
-        ...options.transportActivityContext,
-        onTransportActivity: options.onTransportActivity
-      },
-      () => 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 withMCPConnectionPolicy(
+    options.transport,
+    () => signingContextStorage.run(
+      options.signingContext,
+      () => withResponseSizeLimit(
+        options.transport?.maxResponseBytes,
+        () => withTransportDiagnostics(
+          {
+            agentId: options.transportActivityContext?.agentId ?? "unknown-agent",
+            protocol: "mcp",
+            tool: "tasks/list",
+            taskType: "tasks/list",
+            ...options.transportActivityContext,
+            onTransportActivity: options.onTransportActivity
+          },
+          () => 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 withMCPConnectionPolicy(
+    options,
+    () => 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 withCachedConnection(agentUrl, authToken, authHeaders, debugLogs, `tasks/cancel:${taskId}`, async (client) => {
     await client.experimental.tasks.cancelTask(taskId);
     debugLogs.push({
@@ -374,9 +415,13 @@ async function cancelMCPTask(agentUrl, taskId, authToken, debugLogs = []) {
 export {
   callMCPToolWithClient,
   callMCPToolWithTasks,
+  callMCPToolWithTasksInContext,
   cancelMCPTask,
+  cancelMCPTaskInContext,
   getMCPTaskResult,
+  getMCPTaskResultInContext,
   getMCPTaskStatus,
+  getMCPTaskStatusInContext,
   listMCPTasks,
   mapMCPTaskStatus,
   serverSupportsTasks

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

@@ -1,3 +1,4 @@
+import { type MCPConnectionPolicy } from './mcp-connection-policy.mjs';
 import { Client as MCPClient } from '@modelcontextprotocol/sdk/client/index.js';
 import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
 import { UnauthorizedError } from '@modelcontextprotocol/sdk/client/auth.js';
@@ -19,7 +20,7 @@ export declare function closeMCPConnections(): Promise<void>;
 /**
  * Options for MCP tool calls with OAuth support
  */
-export interface MCPCallOptions {
+export interface MCPCallOptions extends MCPConnectionPolicy {
     /** Agent URL */
     agentUrl: string;
     /** Tool name to call */
@@ -78,7 +79,7 @@ export declare function connectMCPWithFallback(url: URL, authHeaders: Record<str
     requestTimeoutMs?: number;
     allowPrivateIp?: boolean;
 }): Promise<MCPClient>;
-export declare function callMCPTool(agentUrl: string, toolName: string, args: Record<string, unknown>, authToken?: string, debugLogs?: DebugLogEntry[], customHeaders?: Record<string, string>, signingContext?: AgentSigningContext, transportFetch?: typeof fetch, requestOptions?: {
+export declare function callMCPTool(agentUrl: string, toolName: string, args: Record<string, unknown>, authToken?: string, debugLogs?: DebugLogEntry[], customHeaders?: Record<string, string>, signingContext?: AgentSigningContext, transportFetch?: typeof fetch, requestOptions?: MCPConnectionPolicy & {
     signal?: AbortSignal;
     requestTimeoutMs?: number;
     allowPrivateIp?: boolean;

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

@@ -1,3 +1,4 @@
+import { type MCPConnectionPolicy } from './mcp-connection-policy';
 import { Client as MCPClient } from '@modelcontextprotocol/sdk/client/index.js';
 import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
 import { UnauthorizedError } from '@modelcontextprotocol/sdk/client/auth.js';
@@ -19,7 +20,7 @@ export declare function closeMCPConnections(): Promise<void>;
 /**
  * Options for MCP tool calls with OAuth support
  */
-export interface MCPCallOptions {
+export interface MCPCallOptions extends MCPConnectionPolicy {
     /** Agent URL */
     agentUrl: string;
     /** Tool name to call */
@@ -78,7 +79,7 @@ export declare function connectMCPWithFallback(url: URL, authHeaders: Record<str
     requestTimeoutMs?: number;
     allowPrivateIp?: boolean;
 }): Promise<MCPClient>;
-export declare function callMCPTool(agentUrl: string, toolName: string, args: Record<string, unknown>, authToken?: string, debugLogs?: DebugLogEntry[], customHeaders?: Record<string, string>, signingContext?: AgentSigningContext, transportFetch?: typeof fetch, requestOptions?: {
+export declare function callMCPTool(agentUrl: string, toolName: string, args: Record<string, unknown>, authToken?: string, debugLogs?: DebugLogEntry[], customHeaders?: Record<string, string>, signingContext?: AgentSigningContext, transportFetch?: typeof fetch, requestOptions?: MCPConnectionPolicy & {
     signal?: AbortSignal;
     requestTimeoutMs?: number;
     allowPrivateIp?: boolean;

package/dist/lib/protocols/mcp.js

@@ -20,8 +20,10 @@ var mcp_exports = {};
 __export(mcp_exports, {
   UnauthorizedError: () => import_auth.UnauthorizedError,
   callMCPTool: () => callMCPTool,
+  callMCPToolInContext: () => callMCPToolInContext,
   callMCPToolRaw: () => callMCPToolRaw,
   callMCPToolWithOAuth: () => callMCPToolWithOAuth,
+  callMCPToolWithOAuthInContext: () => callMCPToolWithOAuthInContext,
   closeMCPConnections: () => closeMCPConnections,
   closeOAuthConnections: () => closeOAuthConnections,
   connectMCP: () => connectMCP,
@@ -30,6 +32,7 @@ __export(mcp_exports, {
   withScopedLegacyConnection: () => withScopedLegacyConnection
 });
 module.exports = __toCommonJS(mcp_exports);
+var import_mcp_connection_policy = require('./mcp-connection-policy.js');
 var import_client = require("@modelcontextprotocol/sdk/client/index.js");
 var import_streamableHttp = require("@modelcontextprotocol/sdk/client/streamableHttp.js");
 var import_sse = require("@modelcontextprotocol/sdk/client/sse.js");
@@ -90,6 +93,8 @@ function connectionCacheKey(agentUrl, authToken, signingCacheKey, authHeaders, t
   if (transportFetch) parts.push(`fetch:${getTransportFetchFnDisambiguator(transportFetch)}`);
   if (allowPrivateIp !== void 0) parts.push(`allow-private-ip:${allowPrivateIp}`);
   parts.push((0, import_responseSizeLimit.responseSizeCapCacheKey)());
+  const partitionKey = (0, import_mcp_connection_policy.mcpConnectionPartitionKey)();
+  if (partitionKey) parts.push(`partition:${partitionKey}`);
   const scopeKey = (0, import_mcp_scope.currentMCPConnectionScopeKey)();
   if (scopeKey) parts.push(scopeKey);
   return parts.join("::");
@@ -243,6 +248,8 @@ function oauthConnectionCacheKey(agentUrl, authProvider, signingCacheKey, custom
   if (headersKey) parts.push(`headers:${headersKey}`);
   if (fetchFn) parts.push(`fetch:${getTransportFetchFnDisambiguator(fetchFn)}`);
   if (allowPrivateIp !== void 0) parts.push(`allow-private-ip:${allowPrivateIp}`);
+  const partitionKey = (0, import_mcp_connection_policy.mcpConnectionPartitionKey)();
+  if (partitionKey) parts.push(`partition:${partitionKey}`);
   const scopeKey = (0, import_mcp_scope.currentMCPConnectionScopeKey)();
   if (scopeKey) parts.push(scopeKey);
   return parts.join("::");
@@ -297,15 +304,17 @@ async function withCachedOAuthConnection(options, label, fn) {
 }
 async function withCachedOAuthConnectionImpl(options, label, fn) {
   const guardedConnection = options.fetchFn !== void 0;
-  if (guardedConnection && (0, import_mcp_scope.currentMCPConnectionScopeKey)() === void 0) {
+  if (!(0, import_mcp_connection_policy.shouldReuseMCPConnection)(guardedConnection)) {
     const { client } = await connectMCP(options);
-    let succeeded = false;
+    let terminateSession = true;
     try {
       const result = await (0, import_mcp_call_context.runCallPhase)(options.signal, () => fn(client));
-      succeeded = true;
       return result;
+    } catch (error) {
+      terminateSession = !(0, import_abort.isAbortOrTimeoutError)(error);
+      throw error;
     } finally {
-      await closeMCPClient(client, succeeded).catch(() => {
+      await closeMCPClient(client, terminateSession).catch(() => {
       });
     }
   }
@@ -351,19 +360,21 @@ async function withCachedConnectionImpl(agentUrl, authToken, authHeaders, debugL
   const signingContext = import_client2.signingContextStorage.getStore();
   const baseUrl = new URL(agentUrl);
   const guardedConnection = transportFetch !== void 0;
-  if (guardedConnection && (0, import_mcp_scope.currentMCPConnectionScopeKey)() === void 0) {
+  if (!(0, import_mcp_connection_policy.shouldReuseMCPConnection)(guardedConnection)) {
     const client = await connectMCPWithFallback(baseUrl, authHeaders, debugLogs, label, transportFetch, requestOptions);
-    let succeeded = false;
+    let terminateSession = true;
     try {
       const result = await (0, import_abort.withAbortSignal)(
         [requestOptions.signal],
         void 0,
         () => (0, import_mcp_call_context.runCallPhase)(requestOptions.signal, () => fn(client))
       );
-      succeeded = true;
       return result;
+    } catch (error) {
+      terminateSession = !(0, import_abort.isAbortOrTimeoutError)(error);
+      throw error;
     } finally {
-      await closeMCPClient(client, succeeded).catch(() => {
+      await closeMCPClient(client, terminateSession).catch(() => {
       });
     }
   }
@@ -413,7 +424,7 @@ async function withCachedConnectionImpl(agentUrl, authToken, authHeaders, debugL
   }
 }
 async function withScopedLegacyConnection(options, label, fn) {
-  if ((0, import_mcp_scope.currentMCPConnectionScopeKey)() === void 0) return void 0;
+  if (!(0, import_mcp_connection_policy.shouldReuseMCPConnection)(options.fetchFn !== void 0)) return void 0;
   const debugLogs = options.debugLogs ?? [];
   if (options.authProvider) {
     return {
@@ -619,6 +630,22 @@ async function connectMCPWithFallbackImpl(url, authHeaders, debugLogs = [], labe
   }
 }
 async function callMCPTool(agentUrl, toolName, args, authToken, debugLogs = [], customHeaders, signingContext, transportFetch, requestOptions) {
+  return (0, import_mcp_connection_policy.withMCPConnectionPolicy)(
+    requestOptions,
+    () => callMCPToolInContext(
+      agentUrl,
+      toolName,
+      args,
+      authToken,
+      debugLogs,
+      customHeaders,
+      signingContext,
+      transportFetch,
+      requestOptions
+    )
+  );
+}
+async function callMCPToolInContext(agentUrl, toolName, args, authToken, debugLogs = [], customHeaders, signingContext, transportFetch, requestOptions) {
   debugLogs.push({
     type: "info",
     message: `MCP: Auth configuration`,
@@ -844,6 +871,9 @@ async function connectMCP(options) {
   }
 }
 async function callMCPToolWithOAuth(options) {
+  return (0, import_mcp_connection_policy.withMCPConnectionPolicy)(options, () => callMCPToolWithOAuthInContext(options));
+}
+async function callMCPToolWithOAuthInContext(options) {
   const {
     agentUrl,
     toolName,
@@ -864,11 +894,21 @@ async function callMCPToolWithOAuth(options) {
     ...resolvedRequestTimeoutMs !== void 0 && { timeout: resolvedRequestTimeoutMs }
   };
   if (!authProvider) {
-    return callMCPTool(agentUrl, toolName, args, authToken, debugLogs, customHeaders, signingContext, fetchFn, {
-      signal,
-      requestTimeoutMs,
-      allowPrivateIp
-    });
+    return callMCPToolInContext(
+      agentUrl,
+      toolName,
+      args,
+      authToken,
+      debugLogs,
+      customHeaders,
+      signingContext,
+      fetchFn,
+      {
+        signal,
+        requestTimeoutMs,
+        allowPrivateIp
+      }
+    );
   }
   const modernAttempt = await (0, import_mcp_modern.tryCallModernMCPTool)(agentUrl, toolName, args, void 0, debugLogs, customHeaders, {
     authProvider,
@@ -883,6 +923,7 @@ async function callMCPToolWithOAuth(options) {
     debugLogs.push({
       type: modernAttempt.response?.isError ? "error" : "success",
       message: `MCP: Tool ${toolName} response received`,
+      response: modernAttempt.response,
       timestamp: (/* @__PURE__ */ new Date()).toISOString()
     });
     return modernAttempt.response;
@@ -910,6 +951,7 @@ async function callMCPToolWithOAuth(options) {
       debugLogs.push({
         type: response2?.isError ? "error" : "success",
         message: `MCP: Tool ${toolName} response received`,
+        response: response2,
         timestamp: (/* @__PURE__ */ new Date()).toISOString()
       });
       return response2;
@@ -921,8 +963,10 @@ async function callMCPToolWithOAuth(options) {
 0 && (module.exports = {
   UnauthorizedError,
   callMCPTool,
+  callMCPToolInContext,
   callMCPToolRaw,
   callMCPToolWithOAuth,
+  callMCPToolWithOAuthInContext,
   closeMCPConnections,
   closeOAuthConnections,
   connectMCP,