@copilotkit/runtime 1.56.5-canary.1777972218 → 1.57.0

package/src/agent/index.ts

@@ -1,6 +1,8 @@
-import type {
+import {
+  AbstractAgent,
   BaseEvent,
   RunAgentInput,
+  EventType,
   Message,
   ReasoningEndEvent,
   ReasoningMessageContentEvent,
@@ -18,9 +20,9 @@ import type {
   StateSnapshotEvent,
   StateDeltaEvent,
 } from "@ag-ui/client";
-import { AbstractAgent, EventType } from "@ag-ui/client";
 import type { AgentCapabilities } from "@ag-ui/core";
-import type {
+import {
+  streamText,
   LanguageModel,
   ModelMessage,
   AssistantModelMessage,
@@ -32,31 +34,29 @@ import type {
   TextPart,
   ImagePart,
   FilePart,
+  tool as createVercelAISDKTool,
   ToolChoice,
   ToolSet,
+  stepCountIs,
 } from "ai";
-import { streamText, tool as createVercelAISDKTool, stepCountIs } from "ai";
-import { createMCPClient } from "@ai-sdk/mcp";
-import type { MCPClient } from "@ai-sdk/mcp";
+import { experimental_createMCPClient as createMCPClient } from "@ai-sdk/mcp";
 import { Observable } from "rxjs";
 import { createOpenAI } from "@ai-sdk/openai";
 import { createAnthropic } from "@ai-sdk/anthropic";
 import { createGoogleGenerativeAI } from "@ai-sdk/google";
 import { createVertex } from "@ai-sdk/google-vertex";
-import { logger, safeParseToolArgs } from "@copilotkit/shared";
+import { safeParseToolArgs } from "@copilotkit/shared";
 import { z } from "zod";
 import type { StandardSchemaV1, InferSchemaOutput } from "@copilotkit/shared";
 import { schemaToJsonSchema } from "@copilotkit/shared";
 import { jsonSchema as aiJsonSchema } from "ai";
 import { convertAISDKStream } from "./converters/aisdk";
 import { convertTanStackStream } from "./converters/tanstack";
-import type { StreamableHTTPClientTransportOptions } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
 import {
-  CopilotKitMCPTransport,
-  MCPHeaderResolverError,
-  type MCPRequestContext,
-  type MCPRuntimeUser,
-} from "./mcp-transport";
+  StreamableHTTPClientTransport,
+  StreamableHTTPClientTransportOptions,
+} from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
 import { randomUUID } from "@copilotkit/shared";
 
 /**
@@ -113,114 +113,58 @@ export type BuiltInAgentModel =
  */
 export type ModelSpecifier = string | LanguageModel;
 
-// MCPRequestContext and MCPHeaderResolverError now live in mcp-transport.ts.
-// Re-export so existing imports of these symbols from agent/index continue to
-// work.
-export { MCPHeaderResolverError, type MCPRequestContext };
-
 /**
- * MCP Client configuration for HTTP transport.
+ * MCP Client configuration for HTTP transport
  */
 export interface MCPClientConfigHTTP {
-  /** Type of MCP client */
-  type: "http";
-  /** URL of the MCP server */
-  url: string;
   /**
-   * Optional transport options for the underlying
-   * `StreamableHTTPClientTransport`. Pre-existing escape hatch for advanced
-   * use cases (custom `fetch`, `requestInit`, OAuth `authProvider`, etc.).
+   * Type of MCP client
    */
-  options?: StreamableHTTPClientTransportOptions;
+  type: "http";
   /**
-   * Static HTTP headers, merged into every outbound request to this server.
-   * For per-call values, use {@link MCPClientConfigHTTP.getHeaders} instead.
+   * URL of the MCP server
    */
-  headers?: Record<string, string>;
+  url: string;
   /**
-   * Per-call header resolver. Invoked on **every** outbound HTTP request to
-   * this server (initialize, tools/list, tools/call, SSE reconnects). The
-   * returned headers are merged on top of `headers` and any
-   * `options.requestInit.headers`, so a resolver can override either.
-   *
-   * Throwing from the resolver causes the agent run to emit `RUN_ERROR`
-   * carrying a {@link MCPHeaderResolverError}.
+   * Optional transport options for HTTP client
    */
-  getHeaders?: (
-    ctx: MCPRequestContext,
-  ) => Record<string, string> | Promise<Record<string, string>>;
-  /** If true, the server is skipped at run-start when `agent.user` is unset. */
-  requiresUser?: boolean;
+  options?: StreamableHTTPClientTransportOptions;
 }
 
 /**
- * MCP Client configuration for SSE transport.
+ * MCP Client configuration for SSE transport
  */
 export interface MCPClientConfigSSE {
-  /** Type of MCP client */
+  /**
+   * Type of MCP client
+   */
   type: "sse";
-  /** URL of the MCP server */
+  /**
+   * URL of the MCP server
+   */
   url: string;
-  /** Optional HTTP headers (e.g., for authentication). */
+  /**
+   * Optional HTTP headers (e.g., for authentication)
+   */
   headers?: Record<string, string>;
 }
 
 /**
- * MCP Client configuration.
+ * MCP Client configuration
  */
 export type MCPClientConfig = MCPClientConfigHTTP | MCPClientConfigSSE;
 
 /**
- * A user-managed MCP client that provides tools to the agent. Structural
- * alias for `@ai-sdk/mcp`'s `MCPClient.tools` slice — pass any value built by
- * `createMCPClient()` directly, or supply a custom `{ tools(): ... }` object
- * for tests/caching layers.
- *
- * Unlike `mcpServers`, the agent does NOT create or close these clients. The
- * user controls the full lifecycle.
- */
-export type MCPClientProvider = Pick<MCPClient, "tools">;
-
-/**
- * Open an MCP client for the given server config.
+ * A user-managed MCP client that provides tools to the agent.
+ * The user is responsible for creating, configuring, and closing the client.
+ * Compatible with the return type of @ai-sdk/mcp's createMCPClient().
  *
- * - HTTP always goes through {@link CopilotKitMCPTransport} (preserves the
- *   pre-existing `options` escape hatch and adds per-call `getHeaders`
- *   resolution).
- * - SSE goes through `@ai-sdk/mcp`'s `createMCPClient`, whose built-in
- *   `SseMCPTransport` correctly applies static `headers` on every outbound
- *   request.
+ * Unlike mcpServers, the agent does NOT create or close these clients.
+ * This allows persistent connections, custom auth, and tool caching.
  */
-async function openMcpClient(
-  config: MCPClientConfig,
-  context: {
-    requestHeaders: Record<string, string>;
-    input: RunAgentInput;
-    user?: MCPRuntimeUser;
-  },
-): Promise<MCPClient> {
-  if (config.type === "http") {
-    const transport = new CopilotKitMCPTransport({
-      url: config.url,
-      headers: config.headers,
-      getHeaders: config.getHeaders,
-      options: config.options,
-      requestHeaders: context.requestHeaders,
-      input: context.input,
-      user: context.user,
-    });
-    return createMCPClient({ transport });
-  }
-
-  // SSE: hand to Vercel's transport. Static `headers` are applied via the
-  // SseMCPTransport's common-header pipeline.
-  return createMCPClient({
-    transport: {
-      type: "sse",
-      url: config.url,
-      headers: config.headers,
-    },
-  });
+export interface MCPClientProvider {
+  /** Return tools to be merged into the agent's tool set. */
+  tools(): Promise<ToolSet>;
 }
 
 /**
@@ -907,21 +851,6 @@ function isFactoryConfig(
 
 export class BuiltInAgent extends AbstractAgent {
   private abortController?: AbortController;
-  /**
-   * Headers populated per-request by the runtime's
-   * `extractForwardableHeaders` (the incoming request's `Authorization` +
-   * every `x-*` header, lower-cased). Available to MCP header resolvers via
-   * {@link MCPRequestContext.requestHeaders}; kept here as a plain field so
-   * the runtime's `configureAgentForRequest` feature-detect activates.
-   */
-  public headers: Record<string, string> = {};
-  /**
-   * End-user identity for the current request, populated by the runtime by
-   * invoking `identifyUser(request)` (Intelligence mode). Surfaced to MCP
-   * header resolvers via {@link MCPRequestContext.user}; remains undefined
-   * for runs that aren't going through a runtime with `identifyUser` set.
-   */
-  public user?: { id: string; name: string };
 
   constructor(private config: BuiltInAgentConfiguration) {
     super();
@@ -1175,7 +1104,7 @@ export class BuiltInAgent extends AbstractAgent {
       }
 
       // Set up MCP clients if configured and process the stream
-      const mcpClients: MCPClient[] = [];
+      const mcpClients: Array<{ close: () => Promise<void> }> = [];
 
       (async () => {
         let terminalEventEmitted = false;
@@ -1260,39 +1189,33 @@ export class BuiltInAgent extends AbstractAgent {
 
           // Initialize MCP clients and get their tools
           if (this.config.mcpServers && this.config.mcpServers.length > 0) {
-            // Snapshot the agent's per-run state (forwarded headers + user)
-            // once at run-start. Resolvers see this immutable snapshot for the
-            // lifetime of the run, including any reconnections fired after the
-            // initial run completes.
-            const requestHeaders: Record<string, string> = { ...this.headers };
-            const user = this.user ? { ...this.user } : undefined;
-
             for (const serverConfig of this.config.mcpServers) {
-              if (
-                serverConfig.type === "http" &&
-                serverConfig.requiresUser &&
-                !user
-              ) {
-                logger.warn(
-                  { url: serverConfig.url },
-                  "Skipping MCP server: requiresUser is set but no user is resolved for this run",
+              let transport;
+
+              if (serverConfig.type === "http") {
+                const url = new URL(serverConfig.url);
+                transport = new StreamableHTTPClientTransport(
+                  url,
+                  serverConfig.options,
+                );
+              } else if (serverConfig.type === "sse") {
+                transport = new SSEClientTransport(
+                  new URL(serverConfig.url),
+                  serverConfig.headers,
                 );
-                continue;
               }
 
-              const mcpClient = await openMcpClient(serverConfig, {
-                requestHeaders,
-                input,
-                user,
-              });
-              mcpClients.push(mcpClient);
+              if (transport) {
+                const mcpClient = await createMCPClient({ transport });
+                mcpClients.push(mcpClient);
 
-              // Get tools from this MCP server and merge with existing tools
-              const mcpTools = await mcpClient.tools();
-              streamTextParams.tools = {
-                ...streamTextParams.tools,
-                ...mcpTools,
-              } as ToolSet;
+                // Get tools from this MCP server and merge with existing tools
+                const mcpTools = await mcpClient.tools();
+                streamTextParams.tools = {
+                  ...streamTextParams.tools,
+                  ...mcpTools,
+                } as ToolSet;
+              }
             }
           }
 

package/src/v2/runtime/handlers/intelligence/run.ts

@@ -80,15 +80,6 @@ export async function handleIntelligenceRun({
   }
   const userId = user.id;
 
-  // Surface the resolved user on the agent so MCP header resolvers (and any
-  // other per-run consumer) can read it via context. Snapshotted by the
-  // BuiltInAgent at run-start; runs that don't go through this Intelligence
-  // path leave `agent.user` undefined.
-  (agent as unknown as { user?: { id: string; name: string } }).user = {
-    id: user.id,
-    name: user.name,
-  };
-
   try {
     const { thread, created } = await runtime.intelligence.getOrCreateThread({
       threadId: input.threadId,

package/src/v2/runtime/handlers/shared/agent-utils.ts

@@ -13,7 +13,6 @@ import { logger } from "@copilotkit/shared";
 type MiddlewareCapableAgent = AbstractAgent & {
   use?: (middleware: unknown) => void;
   headers?: Record<string, string>;
-  user?: { id: string; name: string };
 };
 
 export interface RunAgentParameters {

package/src/v2/runtime/index.ts

@@ -19,11 +19,6 @@ export {
   type UpdateThreadRequest,
 } from "./intelligence-platform";
 
-// Re-export `@ai-sdk/mcp` stable types so consumers don't need to depend on
-// it directly to type their MCP wiring. `MCPClient` is the value users pass
-// into `mcpClients`; `MCPTransport` is the contract for custom transports.
-export type { MCPClient, MCPTransport } from "@ai-sdk/mcp";
-
 // Export framework-agnostic fetch handler
 export { createCopilotRuntimeHandler } from "./core/fetch-handler";
 export type {

package/src/v2/runtime/intelligence-platform/client.ts

@@ -1,12 +1,4 @@
 import { logger } from "@copilotkit/shared";
-import type { MCPClientConfigHTTP } from "../../../agent";
-
-// Header name carrying the per-call end-user identity that the CopilotKit
-// Intelligence `/mcp` endpoint requires. Encapsulated inside the helper so
-// users of `intelligence.toMCPServer()` never need to know the wire-level
-// header name — they configure `identifyUser` once on the runtime and the
-// helper does the rest.
-const INTELLIGENCE_USER_ID_HEADER = "x-cpki-user-id";
 
 /**
  * Error thrown when an Intelligence platform HTTP request returns a non-2xx
@@ -382,66 +374,6 @@ export class CopilotKitIntelligence {
     return this.#apiKey;
   }
 
-  /**
-   * Build an MCP-server config pre-wired for this Intelligence platform
-   * connection. Drop the result into a `BuiltInAgent`'s `mcpServers` to give
-   * the agent access to Intel's bash + thread tools with both auth axes
-   * correctly populated:
-   *
-   * - `Authorization: Bearer <apiKey>` is stamped on every outbound request
-   *   from this Intelligence client's project key.
-   * - `X-Cpki-User-Id` is read fresh per call from the agent's resolved user,
-   *   which is populated by the runtime's `identifyUser` callback. The
-   *   helper does not surface the header name to user code.
-   *
-   * @example
-   * ```ts
-   * const intelligence = new CopilotKitIntelligence({
-   *   apiUrl: "https://api.copilotkit.ai",
-   *   wsUrl:  "wss://api.copilotkit.ai",
-   *   apiKey: process.env.INTELLIGENCE_API_KEY!,
-   * });
-   *
-   * const runtime = new CopilotRuntime({
-   *   intelligence,
-   *   identifyUser: (request) => resolveUserFromSession(request),
-   *   agents: {
-   *     myAgent: new BuiltInAgent({
-   *       model: "openai/gpt-4o",
-   *       mcpServers: [intelligence.toMCPServer()],
-   *     }),
-   *   },
-   * });
-   * ```
-   *
-   * The resolver throws if no user is present — typically the runtime is
-   * misconfigured (no `identifyUser`) or `identifyUser` returned an invalid
-   * id. Silent fallthrough to an empty user-id would collapse every browser
-   * session for this project into one shared bash sandbox, which is the
-   * very isolation guarantee the per-call header exists to enforce.
-   */
-  toMCPServer(): MCPClientConfigHTTP {
-    const apiKey = this.#apiKey;
-    const url = `${this.#apiUrl}/mcp`;
-    return {
-      type: "http",
-      url,
-      headers: { Authorization: `Bearer ${apiKey}` },
-      requiresUser: true,
-      getHeaders: ({ user }) => {
-        const userId = user?.id?.trim();
-        if (!userId) {
-          throw new Error(
-            "CopilotKitIntelligence.toMCPServer(): no user resolved for this run. " +
-              "Configure `identifyUser` on the CopilotRuntime so the agent " +
-              "knows which end-user each MCP call is on behalf of.",
-          );
-        }
-        return { [INTELLIGENCE_USER_ID_HEADER]: userId };
-      },
-    };
-  }
-
   async #request<T>(method: string, path: string, body?: unknown): Promise<T> {
     const url = `${this.#apiUrl}${path}`;
 

package/dist/agent/mcp-transport.cjs

@@ -1,94 +0,0 @@
-require("reflect-metadata");
-const require_runtime = require('../_virtual/_rolldown/runtime.cjs');
-let _modelcontextprotocol_sdk_client_streamableHttp_js = require("@modelcontextprotocol/sdk/client/streamableHttp.js");
-
-//#region src/agent/mcp-transport.ts
-/**
-* Thrown when an MCP {@link MCPClientConfigHTTP.getHeaders} resolver throws.
-* Wraps the underlying error so `RUN_ERROR` carries clear attribution instead
-* of a generic transport failure. The original error is preserved on the
-* standard ES2022 `Error.cause` chain.
-*/
-var MCPHeaderResolverError = class extends Error {
-	constructor(message, cause) {
-		super(message, { cause });
-		this.name = "MCPHeaderResolverError";
-	}
-};
-/**
-* MCP transport for CopilotKit's BuiltInAgent that adds per-call header
-* resolution on top of the standard Streamable HTTP transport.
-*
-* Implements `@ai-sdk/mcp`'s {@link MCPTransport} interface so it can be
-* passed straight to `createMCPClient({ transport })`. Internally delegates
-* to `@modelcontextprotocol/sdk`'s `StreamableHTTPClientTransport` with a
-* wrapped `fetch` that runs the static-header + per-call resolver pipeline
-* before each outbound request.
-*/
-var CopilotKitMCPTransport = class {
-	constructor(options) {
-		const transportOptions = {
-			...options.options,
-			fetch: buildWrappedFetch(options)
-		};
-		this.inner = new _modelcontextprotocol_sdk_client_streamableHttp_js.StreamableHTTPClientTransport(new URL(options.url), transportOptions);
-	}
-	get onclose() {
-		return this.inner.onclose;
-	}
-	set onclose(handler) {
-		this.inner.onclose = handler;
-	}
-	get onerror() {
-		return this.inner.onerror;
-	}
-	set onerror(handler) {
-		this.inner.onerror = handler;
-	}
-	get onmessage() {
-		return this.inner.onmessage;
-	}
-	set onmessage(handler) {
-		this.inner.onmessage = handler;
-	}
-	start() {
-		return this.inner.start();
-	}
-	send(message) {
-		return this.inner.send(message);
-	}
-	close() {
-		return this.inner.close();
-	}
-};
-function buildWrappedFetch(options) {
-	const { headers: staticHeaders, getHeaders, requestHeaders, input, url: mcpServerUrl, user, options: transportOptions } = options;
-	const baseFetch = transportOptions?.fetch ?? globalThis.fetch;
-	return async (fetchUrl, init) => {
-		const merged = new Headers(init?.headers);
-		if (staticHeaders) for (const [key, value] of Object.entries(staticHeaders)) merged.set(key, value);
-		if (getHeaders) {
-			let resolved;
-			try {
-				resolved = await getHeaders({
-					requestHeaders,
-					input,
-					mcpServerUrl,
-					user
-				});
-			} catch (err) {
-				throw new MCPHeaderResolverError(`MCP header resolver for ${mcpServerUrl} threw: ${err instanceof Error ? err.message : String(err)}`, err);
-			}
-			for (const [key, value] of Object.entries(resolved)) merged.set(key, value);
-		}
-		return baseFetch(fetchUrl, {
-			...init,
-			headers: merged
-		});
-	};
-}
-
-//#endregion
-exports.CopilotKitMCPTransport = CopilotKitMCPTransport;
-exports.MCPHeaderResolverError = MCPHeaderResolverError;
-//# sourceMappingURL=mcp-transport.cjs.map

package/dist/agent/mcp-transport.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"mcp-transport.cjs","names":["StreamableHTTPClientTransport"],"sources":["../../src/agent/mcp-transport.ts"],"sourcesContent":["import type { RunAgentInput } from \"@ag-ui/client\";\nimport type { JSONRPCMessage, MCPTransport } from \"@ai-sdk/mcp\";\nimport { StreamableHTTPClientTransport } from \"@modelcontextprotocol/sdk/client/streamableHttp.js\";\nimport type { StreamableHTTPClientTransportOptions } from \"@modelcontextprotocol/sdk/client/streamableHttp.js\";\nimport type { FetchLike } from \"@modelcontextprotocol/sdk/shared/transport.js\";\n\n/**\n * The end-user identity resolved by the runtime's `identifyUser` callback for\n * the current request. Surfaced on {@link MCPRequestContext} so MCP header\n * resolvers can read it without re-doing auth work.\n */\nexport interface MCPRuntimeUser {\n  id: string;\n  name: string;\n}\n\n/**\n * Context handed to {@link MCPClientConfigHTTP.getHeaders} on every outbound\n * MCP HTTP request. The resolver is invoked fresh per request — initialize,\n * tools/list, tools/call, and reconnects — so values it depends on are never\n * cached across calls.\n */\nexport interface MCPRequestContext {\n  /**\n   * Headers forwarded onto the agent for this run. Populated by the runtime's\n   * `extractForwardableHeaders` (`authorization` + every `x-*` header from the\n   * incoming HTTP request). Keys are lower-cased.\n   */\n  requestHeaders: Record<string, string>;\n  /** The {@link RunAgentInput} the agent is currently running. */\n  input: RunAgentInput;\n  /** URL of the MCP server this request is going to. */\n  mcpServerUrl: string;\n  /**\n   * The end-user identity for this run, resolved by the runtime's\n   * `identifyUser` callback (only populated when the agent is run via a\n   * `CopilotRuntime` configured with `identifyUser`). Snapshotted at\n   * run-start.\n   */\n  user?: MCPRuntimeUser;\n}\n\n/**\n * Thrown when an MCP {@link MCPClientConfigHTTP.getHeaders} resolver throws.\n * Wraps the underlying error so `RUN_ERROR` carries clear attribution instead\n * of a generic transport failure. The original error is preserved on the\n * standard ES2022 `Error.cause` chain.\n */\nexport class MCPHeaderResolverError extends Error {\n  constructor(message: string, cause: unknown) {\n    super(message, { cause });\n    this.name = \"MCPHeaderResolverError\";\n  }\n}\n\nexport interface CopilotKitMCPTransportOptions {\n  /** URL of the MCP server. */\n  url: string;\n  /** Static HTTP headers, merged into every outbound request. */\n  headers?: Record<string, string>;\n  /**\n   * Per-call header resolver. Invoked on **every** outbound HTTP request to\n   * this server (initialize, tools/list, tools/call, reconnects). Returned\n   * headers are merged on top of `headers`, so a resolver can override either.\n   */\n  getHeaders?: (\n    ctx: MCPRequestContext,\n  ) => Record<string, string> | Promise<Record<string, string>>;\n  /**\n   * Pre-existing escape hatch: low-level options for the underlying\n   * `StreamableHTTPClientTransport`. Forwarded as-is, except `fetch` is\n   * wrapped so static `headers` and `getHeaders` resolution still apply.\n   */\n  options?: StreamableHTTPClientTransportOptions;\n  /** Snapshot of the agent's per-run forwarded headers, captured at run-start. */\n  requestHeaders: Record<string, string>;\n  /** RunAgentInput for the current run, exposed to the resolver via context. */\n  input: RunAgentInput;\n  /** Per-run end-user identity from the runtime's `identifyUser`, if set. */\n  user?: MCPRuntimeUser;\n}\n\n/**\n * MCP transport for CopilotKit's BuiltInAgent that adds per-call header\n * resolution on top of the standard Streamable HTTP transport.\n *\n * Implements `@ai-sdk/mcp`'s {@link MCPTransport} interface so it can be\n * passed straight to `createMCPClient({ transport })`. Internally delegates\n * to `@modelcontextprotocol/sdk`'s `StreamableHTTPClientTransport` with a\n * wrapped `fetch` that runs the static-header + per-call resolver pipeline\n * before each outbound request.\n */\nexport class CopilotKitMCPTransport implements MCPTransport {\n  private readonly inner: StreamableHTTPClientTransport;\n\n  constructor(options: CopilotKitMCPTransportOptions) {\n    const transportOptions: StreamableHTTPClientTransportOptions = {\n      ...options.options,\n      fetch: buildWrappedFetch(options),\n    };\n    this.inner = new StreamableHTTPClientTransport(\n      new URL(options.url),\n      transportOptions,\n    );\n  }\n\n  get onclose(): (() => void) | undefined {\n    return this.inner.onclose;\n  }\n  set onclose(handler: (() => void) | undefined) {\n    this.inner.onclose = handler;\n  }\n\n  get onerror(): ((error: Error) => void) | undefined {\n    return this.inner.onerror;\n  }\n  set onerror(handler: ((error: Error) => void) | undefined) {\n    this.inner.onerror = handler;\n  }\n\n  get onmessage(): ((message: JSONRPCMessage) => void) | undefined {\n    return this.inner.onmessage as\n      | ((message: JSONRPCMessage) => void)\n      | undefined;\n  }\n  set onmessage(handler: ((message: JSONRPCMessage) => void) | undefined) {\n    this.inner.onmessage = handler as\n      | ((message: JSONRPCMessage) => void)\n      | undefined;\n  }\n\n  start(): Promise<void> {\n    return this.inner.start();\n  }\n\n  send(message: JSONRPCMessage): Promise<void> {\n    return this.inner.send(message as Parameters<typeof this.inner.send>[0]);\n  }\n\n  close(): Promise<void> {\n    return this.inner.close();\n  }\n}\n\nfunction buildWrappedFetch(options: CopilotKitMCPTransportOptions): FetchLike {\n  const {\n    headers: staticHeaders,\n    getHeaders,\n    requestHeaders,\n    input,\n    url: mcpServerUrl,\n    user,\n    options: transportOptions,\n  } = options;\n  const baseFetch: FetchLike = transportOptions?.fetch ?? globalThis.fetch;\n\n  return async (fetchUrl, init) => {\n    // SDK passes a Headers instance via init.headers — start fresh from it so\n    // we don't mutate the SDK's object, then layer headers on top via .set()\n    // (last write wins).\n    const merged = new Headers(init?.headers);\n    if (staticHeaders) {\n      for (const [key, value] of Object.entries(staticHeaders)) {\n        merged.set(key, value);\n      }\n    }\n    if (getHeaders) {\n      let resolved: Record<string, string>;\n      try {\n        resolved = await getHeaders({\n          requestHeaders,\n          input,\n          mcpServerUrl,\n          user,\n        });\n      } catch (err) {\n        throw new MCPHeaderResolverError(\n          `MCP header resolver for ${mcpServerUrl} threw: ${\n            err instanceof Error ? err.message : String(err)\n          }`,\n          err,\n        );\n      }\n      for (const [key, value] of Object.entries(resolved)) {\n        merged.set(key, value);\n      }\n    }\n    return baseFetch(fetchUrl, { ...init, headers: merged });\n  };\n}\n"],"mappings":";;;;;;;;;;;AAgDA,IAAa,yBAAb,cAA4C,MAAM;CAChD,YAAY,SAAiB,OAAgB;AAC3C,QAAM,SAAS,EAAE,OAAO,CAAC;AACzB,OAAK,OAAO;;;;;;;;;;;;;AAyChB,IAAa,yBAAb,MAA4D;CAG1D,YAAY,SAAwC;EAClD,MAAM,mBAAyD;GAC7D,GAAG,QAAQ;GACX,OAAO,kBAAkB,QAAQ;GAClC;AACD,OAAK,QAAQ,IAAIA,iFACf,IAAI,IAAI,QAAQ,IAAI,EACpB,iBACD;;CAGH,IAAI,UAAoC;AACtC,SAAO,KAAK,MAAM;;CAEpB,IAAI,QAAQ,SAAmC;AAC7C,OAAK,MAAM,UAAU;;CAGvB,IAAI,UAAgD;AAClD,SAAO,KAAK,MAAM;;CAEpB,IAAI,QAAQ,SAA+C;AACzD,OAAK,MAAM,UAAU;;CAGvB,IAAI,YAA6D;AAC/D,SAAO,KAAK,MAAM;;CAIpB,IAAI,UAAU,SAA0D;AACtE,OAAK,MAAM,YAAY;;CAKzB,QAAuB;AACrB,SAAO,KAAK,MAAM,OAAO;;CAG3B,KAAK,SAAwC;AAC3C,SAAO,KAAK,MAAM,KAAK,QAAiD;;CAG1E,QAAuB;AACrB,SAAO,KAAK,MAAM,OAAO;;;AAI7B,SAAS,kBAAkB,SAAmD;CAC5E,MAAM,EACJ,SAAS,eACT,YACA,gBACA,OACA,KAAK,cACL,MACA,SAAS,qBACP;CACJ,MAAM,YAAuB,kBAAkB,SAAS,WAAW;AAEnE,QAAO,OAAO,UAAU,SAAS;EAI/B,MAAM,SAAS,IAAI,QAAQ,MAAM,QAAQ;AACzC,MAAI,cACF,MAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,cAAc,CACtD,QAAO,IAAI,KAAK,MAAM;AAG1B,MAAI,YAAY;GACd,IAAI;AACJ,OAAI;AACF,eAAW,MAAM,WAAW;KAC1B;KACA;KACA;KACA;KACD,CAAC;YACK,KAAK;AACZ,UAAM,IAAI,uBACR,2BAA2B,aAAa,UACtC,eAAe,QAAQ,IAAI,UAAU,OAAO,IAAI,IAElD,IACD;;AAEH,QAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,SAAS,CACjD,QAAO,IAAI,KAAK,MAAM;;AAG1B,SAAO,UAAU,UAAU;GAAE,GAAG;GAAM,SAAS;GAAQ,CAAC"}

package/dist/agent/mcp-transport.d.cts

@@ -1,51 +0,0 @@
-
-import { RunAgentInput } from "@ag-ui/client";
-import { StreamableHTTPClientTransportOptions } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
-
-//#region src/agent/mcp-transport.d.ts
-/**
- * The end-user identity resolved by the runtime's `identifyUser` callback for
- * the current request. Surfaced on {@link MCPRequestContext} so MCP header
- * resolvers can read it without re-doing auth work.
- */
-interface MCPRuntimeUser {
-  id: string;
-  name: string;
-}
-/**
- * Context handed to {@link MCPClientConfigHTTP.getHeaders} on every outbound
- * MCP HTTP request. The resolver is invoked fresh per request — initialize,
- * tools/list, tools/call, and reconnects — so values it depends on are never
- * cached across calls.
- */
-interface MCPRequestContext {
-  /**
-   * Headers forwarded onto the agent for this run. Populated by the runtime's
-   * `extractForwardableHeaders` (`authorization` + every `x-*` header from the
-   * incoming HTTP request). Keys are lower-cased.
-   */
-  requestHeaders: Record<string, string>;
-  /** The {@link RunAgentInput} the agent is currently running. */
-  input: RunAgentInput;
-  /** URL of the MCP server this request is going to. */
-  mcpServerUrl: string;
-  /**
-   * The end-user identity for this run, resolved by the runtime's
-   * `identifyUser` callback (only populated when the agent is run via a
-   * `CopilotRuntime` configured with `identifyUser`). Snapshotted at
-   * run-start.
-   */
-  user?: MCPRuntimeUser;
-}
-/**
- * Thrown when an MCP {@link MCPClientConfigHTTP.getHeaders} resolver throws.
- * Wraps the underlying error so `RUN_ERROR` carries clear attribution instead
- * of a generic transport failure. The original error is preserved on the
- * standard ES2022 `Error.cause` chain.
- */
-declare class MCPHeaderResolverError extends Error {
-  constructor(message: string, cause: unknown);
-}
-//#endregion
-export { MCPHeaderResolverError, MCPRequestContext };
-//# sourceMappingURL=mcp-transport.d.cts.map

package/dist/agent/mcp-transport.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"mcp-transport.d.cts","names":[],"sources":["../../src/agent/mcp-transport.ts"],"mappings":";;;;;;AAWA;;;;UAAiB,cAAA;EACf,EAAA;EACA,IAAA;AAAA;;;;;;;UASe,iBAAA;EAQf;;;;;EAFA,cAAA,EAAgB,MAAA;EAWK;EATrB,KAAA,EAAO,aAAA;EAkB2B;EAhBlC,YAAA;EAgB+C;;;;;;EAT/C,IAAA,GAAO,cAAA;AAAA;;;;;;;cASI,sBAAA,SAA+B,KAAA;cAC9B,OAAA,UAAiB,KAAA;AAAA"}

package/dist/agent/mcp-transport.d.mts

@@ -1,52 +0,0 @@
-import "reflect-metadata";
-import { RunAgentInput } from "@ag-ui/client";
-import "@ai-sdk/mcp";
-import { StreamableHTTPClientTransportOptions } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
-
-//#region src/agent/mcp-transport.d.ts
-/**
- * The end-user identity resolved by the runtime's `identifyUser` callback for
- * the current request. Surfaced on {@link MCPRequestContext} so MCP header
- * resolvers can read it without re-doing auth work.
- */
-interface MCPRuntimeUser {
-  id: string;
-  name: string;
-}
-/**
- * Context handed to {@link MCPClientConfigHTTP.getHeaders} on every outbound
- * MCP HTTP request. The resolver is invoked fresh per request — initialize,
- * tools/list, tools/call, and reconnects — so values it depends on are never
- * cached across calls.
- */
-interface MCPRequestContext {
-  /**
-   * Headers forwarded onto the agent for this run. Populated by the runtime's
-   * `extractForwardableHeaders` (`authorization` + every `x-*` header from the
-   * incoming HTTP request). Keys are lower-cased.
-   */
-  requestHeaders: Record<string, string>;
-  /** The {@link RunAgentInput} the agent is currently running. */
-  input: RunAgentInput;
-  /** URL of the MCP server this request is going to. */
-  mcpServerUrl: string;
-  /**
-   * The end-user identity for this run, resolved by the runtime's
-   * `identifyUser` callback (only populated when the agent is run via a
-   * `CopilotRuntime` configured with `identifyUser`). Snapshotted at
-   * run-start.
-   */
-  user?: MCPRuntimeUser;
-}
-/**
- * Thrown when an MCP {@link MCPClientConfigHTTP.getHeaders} resolver throws.
- * Wraps the underlying error so `RUN_ERROR` carries clear attribution instead
- * of a generic transport failure. The original error is preserved on the
- * standard ES2022 `Error.cause` chain.
- */
-declare class MCPHeaderResolverError extends Error {
-  constructor(message: string, cause: unknown);
-}
-//#endregion
-export { MCPHeaderResolverError, MCPRequestContext };
-//# sourceMappingURL=mcp-transport.d.mts.map

package/dist/agent/mcp-transport.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"mcp-transport.d.mts","names":[],"sources":["../../src/agent/mcp-transport.ts"],"mappings":";;;;;;;;AAWA;;;UAAiB,cAAA;EACf,EAAA;EACA,IAAA;AAAA;;;;;;;UASe,iBAAA;EAMC;;;;;EAAhB,cAAA,EAAgB,MAAA;EAWK;EATrB,KAAA,EAAO,aAAA;EAkBI;EAhBX,YAAA;;;;;;;EAOA,IAAA,GAAO,cAAA;AAAA;;;;;;;cASI,sBAAA,SAA+B,KAAA;cAC9B,OAAA,UAAiB,KAAA;AAAA"}