@tambo-ai/react 0.58.1 → 0.60.0

package/dist/mcp/tambo-mcp-provider.d.ts

@@ -1,5 +1,5 @@
 import React, { FC } from "react";
-import { MCPClient, MCPTransport } from "./mcp-client";
+import { MCPClient, MCPElicitationHandler, MCPHandlers, MCPSamplingHandler, MCPTransport } from "./mcp-client";
 /**
  * Extracts error message from MCP tool result content.
  * Handles both array and string content formats.
@@ -7,27 +7,79 @@ import { MCPClient, MCPTransport } from "./mcp-client";
  * @returns The extracted error message as a string
  */
 export declare function extractErrorMessage(content: unknown): string;
+/**
+ * User-provided configuration for an MCP server.
+ */
 export interface McpServerInfo {
+    /** Optional name for the MCP server */
     name?: string;
+    /** The URL of the MCP server to connect to */
     url: string;
+    /** Optional description of the MCP server */
     description?: string;
+    /** The transport type to use (SSE or HTTP). Defaults to SSE for string URLs */
     transport?: MCPTransport;
+    /** Optional custom headers to include in requests */
     customHeaders?: Record<string, string>;
+    /**
+     * Optional handlers for elicitation and sampling requests from the server.
+     * Note: These callbacks should be stable (e.g., wrapped in useCallback or defined outside the component)
+     * to avoid constant re-registration of the MCP server on every render.
+     */
+    handlers?: Partial<MCPHandlers>;
+}
+/**
+ * Normalized server information with a stable derived key.
+ */
+interface McpServerConfig extends McpServerInfo {
+    /**
+     * Stable identity for this server derived from its URL/transport/headers.
+     * Present for all server states (connected or failed).
+     */
+    key: string;
 }
-export interface ConnectedMcpServer extends McpServerInfo {
+/**
+ * Connected MCP server with an active client.
+ */
+export interface ConnectedMcpServer extends McpServerConfig {
     client: MCPClient;
 }
-export interface FailedMcpServer extends McpServerInfo {
+/**
+ * Failed MCP server with a connection error.
+ */
+export interface FailedMcpServer extends McpServerConfig {
     client?: never;
     connectionError: Error;
 }
+/**
+ * An active or failed MCP server, with access to the MCP client.
+ */
 export type McpServer = ConnectedMcpServer | FailedMcpServer;
+/**
+ * Provider-level MCP handlers that receive the McpServerInfo as context in addition to the request.
+ * These handlers are applied to all MCP servers unless overridden by per-server handlers.
+ *
+ * Handlers receive three parameters:
+ * 1. request - The MCP request
+ * 2. extra - RequestHandlerExtra containing AbortSignal and other metadata
+ * 3. serverInfo - Configuration of the MCP server that triggered this request
+ */
+export interface ProviderMCPHandlers {
+    elicitation?: (request: Parameters<MCPElicitationHandler>[0], extra: Parameters<MCPElicitationHandler>[1], serverInfo: McpServerConfig) => ReturnType<MCPElicitationHandler>;
+    sampling?: (request: Parameters<MCPSamplingHandler>[0], extra: Parameters<MCPSamplingHandler>[1], serverInfo: McpServerConfig) => ReturnType<MCPSamplingHandler>;
+}
 /**
  * This provider is used to register tools from MCP servers.
- * @returns the wrapped children
+ * It automatically includes an internal Tambo MCP server when an MCP access token is available.
+ * @param props - The provider props
+ * @param props.mcpServers - Array of MCP server configurations
+ * @param props.handlers - Optional handlers applied to all MCP servers unless overridden per-server
+ * @param props.children - The children to wrap
+ * @returns The TamboMcpProvider component
  */
 export declare const TamboMcpProvider: FC<{
     mcpServers: (McpServerInfo | string)[];
+    handlers?: ProviderMCPHandlers;
     children: React.ReactNode;
 }>;
 /**
@@ -54,4 +106,34 @@ export declare const TamboMcpProvider: FC<{
  * @returns The MCP servers
  */
 export declare const useTamboMcpServers: () => McpServer[];
+/**
+ * Hook to access elicitation context from TamboMcpProvider.
+ * This provides access to the current elicitation request and methods to respond to it.
+ *
+ * The elicitation state is automatically managed by TamboMcpProvider when MCP servers
+ * request user input through the elicitation protocol.
+ * @returns The elicitation context with current request and response handlers
+ * @example
+ * ```tsx
+ * function ElicitationUI() {
+ *   const { elicitation, resolveElicitation } = useTamboElicitationContext();
+ *
+ *   if (!elicitation) return null;
+ *
+ *   return (
+ *     <div>
+ *       <p>{elicitation.message}</p>
+ *       <button onClick={() => resolveElicitation?.({ action: "accept", content: {} })}>
+ *         Accept
+ *       </button>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+export declare const useTamboElicitationContext: () => {
+    elicitation: import("./elicitation").TamboElicitationRequest | null;
+    resolveElicitation: ((response: import("./elicitation").TamboElicitationResponse) => void) | null;
+};
+export {};
 //# sourceMappingURL=tambo-mcp-provider.d.ts.map

package/dist/mcp/tambo-mcp-provider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tambo-mcp-provider.d.ts","sourceRoot":"","sources":["../../src/mcp/tambo-mcp-provider.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,EAEZ,EAAE,EAIH,MAAM,OAAO,CAAC;AAIf,OAAO,EAAE,SAAS,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAEvD;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,CAsB5D;AAED,MAAM,WAAW,aAAa;IAC5B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,SAAS,CAAC,EAAE,YAAY,CAAC;IACzB,aAAa,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACxC;AAED,MAAM,WAAW,kBAAmB,SAAQ,aAAa;IACvD,MAAM,EAAE,SAAS,CAAC;CACnB;AAED,MAAM,WAAW,eAAgB,SAAQ,aAAa;IACpD,MAAM,CAAC,EAAE,KAAK,CAAC;IACf,eAAe,EAAE,KAAK,CAAC;CACxB;AAED,MAAM,MAAM,SAAS,GAAG,kBAAkB,GAAG,eAAe,CAAC;AAG7D;;;GAGG;AACH,eAAO,MAAM,gBAAgB,EAAE,EAAE,CAAC;IAChC,UAAU,EAAE,CAAC,aAAa,GAAG,MAAM,CAAC,EAAE,CAAC;IACvC,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC;CAC3B,CAgJA,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,kBAAkB,mBAE9B,CAAC"}
+{"version":3,"file":"tambo-mcp-provider.d.ts","sourceRoot":"","sources":["../../src/mcp/tambo-mcp-provider.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAEZ,EAAE,EAMH,MAAM,OAAO,CAAC;AAMf,OAAO,EACL,SAAS,EACT,qBAAqB,EACrB,WAAW,EACX,kBAAkB,EAClB,YAAY,EACb,MAAM,cAAc,CAAC;AAEtB;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,CAoB5D;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,uCAAuC;IACvC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,8CAA8C;IAC9C,GAAG,EAAE,MAAM,CAAC;IACZ,6CAA6C;IAC7C,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,+EAA+E;IAC/E,SAAS,CAAC,EAAE,YAAY,CAAC;IACzB,qDAAqD;IACrD,aAAa,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACvC;;;;OAIG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC,WAAW,CAAC,CAAC;CACjC;AAED;;GAEG;AACH,UAAU,eAAgB,SAAQ,aAAa;IAC7C;;;OAGG;IACH,GAAG,EAAE,MAAM,CAAC;CACb;AAED;;GAEG;AACH,MAAM,WAAW,kBAAmB,SAAQ,eAAe;IACzD,MAAM,EAAE,SAAS,CAAC;CACnB;AAED;;GAEG;AACH,MAAM,WAAW,eAAgB,SAAQ,eAAe;IACtD,MAAM,CAAC,EAAE,KAAK,CAAC;IACf,eAAe,EAAE,KAAK,CAAC;CACxB;AAED;;GAEG;AACH,MAAM,MAAM,SAAS,GAAG,kBAAkB,GAAG,eAAe,CAAC;AAE7D;;;;;;;;GAQG;AACH,MAAM,WAAW,mBAAmB;IAClC,WAAW,CAAC,EAAE,CACZ,OAAO,EAAE,UAAU,CAAC,qBAAqB,CAAC,CAAC,CAAC,CAAC,EAC7C,KAAK,EAAE,UAAU,CAAC,qBAAqB,CAAC,CAAC,CAAC,CAAC,EAC3C,UAAU,EAAE,eAAe,KACxB,UAAU,CAAC,qBAAqB,CAAC,CAAC;IACvC,QAAQ,CAAC,EAAE,CACT,OAAO,EAAE,UAAU,CAAC,kBAAkB,CAAC,CAAC,CAAC,CAAC,EAC1C,KAAK,EAAE,UAAU,CAAC,kBAAkB,CAAC,CAAC,CAAC,CAAC,EACxC,UAAU,EAAE,eAAe,KACxB,UAAU,CAAC,kBAAkB,CAAC,CAAC;CACrC;AAkBD;;;;;;;;GAQG;AACH,eAAO,MAAM,gBAAgB,EAAE,EAAE,CAAC;IAChC,UAAU,EAAE,CAAC,aAAa,GAAG,MAAM,CAAC,EAAE,CAAC;IACvC,QAAQ,CAAC,EAAE,mBAAmB,CAAC;IAC/B,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC;CAC3B,CA2RA,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,kBAAkB,mBAE9B,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,0BAA0B;;;CAMtC,CAAC"}

package/dist/mcp/tambo-mcp-provider.js

@@ -33,12 +33,13 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.useTamboMcpServers = exports.TamboMcpProvider = void 0;
+exports.useTamboElicitationContext = exports.useTamboMcpServers = exports.TamboMcpProvider = void 0;
 exports.extractErrorMessage = extractErrorMessage;
-const fast_equals_1 = require("fast-equals");
 const react_1 = __importStar(require("react"));
+const tambo_mcp_token_provider_1 = require("../providers/tambo-mcp-token-provider");
 const tambo_registry_provider_1 = require("../providers/tambo-registry-provider");
 const content_parts_1 = require("../util/content-parts");
+const elicitation_1 = require("./elicitation");
 const mcp_client_1 = require("./mcp-client");
 /**
  * Extracts error message from MCP tool result content.
@@ -52,7 +53,7 @@ function extractErrorMessage(content) {
     }
     if (Array.isArray(content)) {
         const textItems = content
-            .filter((item) => item && item.type === "text" && typeof item.text === "string")
+            .filter((item) => item?.type === "text" && typeof item.text === "string")
             .map((item) => item.text);
         return textItems.length > 0
             ? textItems.join(" ")
@@ -63,120 +64,236 @@ function extractErrorMessage(content) {
     }
     return `${content}`;
 }
-const McpProviderContext = (0, react_1.createContext)([]);
+const McpProviderContext = (0, react_1.createContext)({
+    servers: [],
+    elicitation: null,
+    resolveElicitation: null,
+});
+// Constant for the internal Tambo MCP server name
+const TAMBO_INTERNAL_MCP_SERVER_NAME = "__tambo_internal_mcp_server__";
 /**
  * This provider is used to register tools from MCP servers.
- * @returns the wrapped children
+ * It automatically includes an internal Tambo MCP server when an MCP access token is available.
+ * @param props - The provider props
+ * @param props.mcpServers - Array of MCP server configurations
+ * @param props.handlers - Optional handlers applied to all MCP servers unless overridden per-server
+ * @param props.children - The children to wrap
+ * @returns The TamboMcpProvider component
  */
-const TamboMcpProvider = ({ mcpServers, children }) => {
+const TamboMcpProvider = ({ mcpServers, handlers, children }) => {
     const { registerTool } = (0, tambo_registry_provider_1.useTamboRegistry)();
+    const { mcpAccessToken, tamboBaseUrl } = (0, tambo_mcp_token_provider_1.useTamboMcpToken)();
+    const providerSamplingHandler = handlers?.sampling;
+    // Elicitation state and default handler
+    const { elicitation, resolveElicitation, defaultElicitationHandler } = (0, elicitation_1.useElicitation)();
+    // Use provided handler or fall back to default
+    const providerElicitationHandler = handlers?.elicitation ?? defaultElicitationHandler;
+    // Stable reference to track active clients by server key
+    const clientMapRef = (0, react_1.useRef)(new Map());
+    // Track tool ownership to prevent duplicate registrations across servers
+    // toolOwnerRef: tool name -> server key; keyToToolsRef: server key -> set of tool names
+    const toolOwnerRef = (0, react_1.useRef)(new Map());
+    const keyToToolsRef = (0, react_1.useRef)(new Map());
+    // State for exposing connected servers to consumers
     const [connectedMcpServers, setConnectedMcpServers] = (0, react_1.useState)([]);
-    (0, react_1.useEffect)(() => {
-        if (!mcpServers) {
-            return;
+    // Stable map of current server configurations keyed by server key
+    const currentServersMap = (0, react_1.useMemo)(() => {
+        const servers = [...mcpServers];
+        // Add internal Tambo MCP server if we have an access token and a base URL
+        if (mcpAccessToken && tamboBaseUrl) {
+            const base = new URL(tamboBaseUrl);
+            base.pathname = `${base.pathname.replace(/\/+$/, "")}/mcp`;
+            const tamboMcpUrl = base.toString();
+            servers.push({
+                name: TAMBO_INTERNAL_MCP_SERVER_NAME,
+                url: tamboMcpUrl,
+                transport: mcp_client_1.MCPTransport.HTTP,
+                customHeaders: {
+                    Authorization: `Bearer ${mcpAccessToken}`,
+                },
+            });
         }
-        async function registerMcpServers(mcpServerInfos) {
-            // Maps tool names to the MCP client that registered them
-            const mcpServerMap = new Map();
-            setConnectedMcpServers((prev) => 
-            // remove any servers that are not in the new list
-            prev.filter((s) => mcpServerInfos.some((mcpServerInfo) => equalsMcpServer(s, mcpServerInfo))));
-            // initialize the MCP clients, converting McpServerInfo -> McpServer
-            const mcpServers = await Promise.allSettled(mcpServerInfos.map(async (mcpServerInfo) => {
+        // Create a map of server key -> server info for efficient lookups
+        const serverMap = new Map();
+        servers.forEach((server) => {
+            const serverInfo = normalizeServerInfo(server);
+            // Store without cloning to avoid unnecessary allocation
+            serverMap.set(serverInfo.key, serverInfo);
+        });
+        return serverMap;
+    }, [mcpServers, mcpAccessToken, tamboBaseUrl]);
+    // Main effect: manage client lifecycle (create/remove)
+    (0, react_1.useEffect)(() => {
+        const clientMap = clientMapRef.current;
+        const currentKeys = new Set(currentServersMap.keys());
+        const existingKeys = new Set(clientMap.keys());
+        // 1. Remove clients that are no longer in the current server list
+        const keysToRemove = Array.from(existingKeys).filter((key) => !currentKeys.has(key));
+        keysToRemove.forEach((key) => {
+            const server = clientMap.get(key);
+            if (server?.client) {
                 try {
-                    const client = await mcp_client_1.MCPClient.create(mcpServerInfo.url, mcpServerInfo.transport, mcpServerInfo.customHeaders, undefined, // no oauth support yet
-                    undefined);
-                    const connectedMcpServer = {
-                        ...mcpServerInfo,
-                        client: client,
+                    server.client.close();
+                }
+                catch (error) {
+                    // Avoid logging sensitive data embedded in the key (headers)
+                    const url = server.url ?? "(unknown url)";
+                    console.error(`Error closing MCP client for ${url}:`, error);
+                }
+            }
+            // Release tool ownership for this server
+            const owned = keyToToolsRef.current.get(key);
+            if (owned) {
+                for (const name of owned)
+                    toolOwnerRef.current.delete(name);
+                keyToToolsRef.current.delete(key);
+            }
+            clientMap.delete(key);
+        });
+        // 2. Add new clients for servers that don't exist yet
+        const keysToAdd = Array.from(currentKeys).filter((key) => !existingKeys.has(key));
+        if (keysToAdd.length > 0) {
+            // Async initialization of new clients
+            Promise.allSettled(keysToAdd.map(async (key) => {
+                const serverInfo = currentServersMap.get(key);
+                try {
+                    // Build effective handlers (per-server overrides provider)
+                    const effectiveHandlers = {};
+                    if (serverInfo.handlers?.elicitation) {
+                        effectiveHandlers.elicitation = serverInfo.handlers.elicitation;
+                    }
+                    else if (providerElicitationHandler) {
+                        effectiveHandlers.elicitation = async (request, extra) => await providerElicitationHandler(request, extra, serverInfo);
+                    }
+                    if (serverInfo.handlers?.sampling) {
+                        effectiveHandlers.sampling = serverInfo.handlers.sampling;
+                    }
+                    else if (providerSamplingHandler) {
+                        effectiveHandlers.sampling = async (request, extra) => await providerSamplingHandler(request, extra, serverInfo);
+                    }
+                    const client = await mcp_client_1.MCPClient.create(serverInfo.url, serverInfo.transport, serverInfo.customHeaders, undefined, undefined, effectiveHandlers);
+                    const connectedServer = {
+                        ...serverInfo,
+                        client,
                     };
-                    // note because the promises may resolve in any order, the resulting
-                    // array may not be in the same order as the input array
-                    setConnectedMcpServers((prev) => [
-                        // replace the server if it already exists
-                        ...prev.filter((s) => !equalsMcpServer(s, mcpServerInfo)),
-                        connectedMcpServer,
-                    ]);
-                    return connectedMcpServer;
+                    clientMap.set(key, connectedServer);
+                    setConnectedMcpServers(Array.from(clientMap.values()));
+                    // Register tools from this server (deduplicated by ownership)
+                    try {
+                        const tools = await client.listTools();
+                        tools.forEach((tool) => {
+                            // Skip if another server already owns this tool
+                            const currentOwner = toolOwnerRef.current.get(tool.name);
+                            if (currentOwner && currentOwner !== key) {
+                                return;
+                            }
+                            // Record ownership for this server key
+                            if (!currentOwner) {
+                                toolOwnerRef.current.set(tool.name, key);
+                                if (!keyToToolsRef.current.has(key)) {
+                                    keyToToolsRef.current.set(key, new Set());
+                                }
+                                keyToToolsRef.current.get(key).add(tool.name);
+                            }
+                            registerTool({
+                                description: tool.description ?? "",
+                                name: tool.name,
+                                tool: async (args = {}) => {
+                                    const server = clientMap.get(key);
+                                    if (!server?.client) {
+                                        throw new Error(`MCP server for tool ${tool.name} is not connected`);
+                                    }
+                                    const result = await server.client.callTool(tool.name, args);
+                                    if (result.isError) {
+                                        const errorMessage = extractErrorMessage(result.content);
+                                        throw new Error(errorMessage);
+                                    }
+                                    return result.content;
+                                },
+                                toolSchema: tool.inputSchema,
+                                transformToContent: (content) => {
+                                    if ((0, content_parts_1.isContentPartArray)(content)) {
+                                        return content;
+                                    }
+                                    return [{ type: "text", text: (0, content_parts_1.toText)(content) }];
+                                },
+                            });
+                        });
+                    }
+                    catch (error) {
+                        console.error(`Failed to register tools from MCP server ${serverInfo.url}:`, error);
+                    }
                 }
                 catch (error) {
-                    const failedMcpServer = {
-                        ...mcpServerInfo,
+                    const failedServer = {
+                        ...serverInfo,
                         connectionError: error,
                     };
-                    // note because the promises may resolve in any order, the resulting
-                    // array may not be in the same order as the input array
-                    setConnectedMcpServers((prev) => [
-                        // replace the server if it already exists
-                        ...prev.filter((s) => !equalsMcpServer(s, mcpServerInfo)),
-                        failedMcpServer,
-                    ]);
-                    return failedMcpServer;
+                    clientMap.set(key, failedServer);
+                    setConnectedMcpServers(Array.from(clientMap.values()));
+                    console.error(`Failed to connect to MCP server ${serverInfo.url}:`, error);
                 }
             }));
-            // note do not rely on the state
-            const connectedMcpServers = mcpServers
-                .filter((result) => result.status === "fulfilled")
-                .map((result) => result.value);
-            // Now create a map of tool name to MCP client
-            const serverToolLists = connectedMcpServers.map(async (mcpServer) => {
-                const tools = (await mcpServer.client?.listTools()) ?? [];
-                tools.forEach((tool) => {
-                    mcpServerMap.set(tool.name, mcpServer);
-                });
-                return tools;
-            });
-            const toolResults = await Promise.allSettled(serverToolLists);
-            // Just log the failed tools, we can't do anything about them
-            const failedTools = toolResults.filter((result) => result.status === "rejected");
-            if (failedTools.length > 0) {
-                console.error("Failed to register tools from MCP servers:", failedTools.map((result) => result.reason));
+        }
+        // Update state after removals (additions update state asynchronously above)
+        if (keysToRemove.length > 0) {
+            setConnectedMcpServers(Array.from(clientMap.values()));
+        }
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [currentServersMap, registerTool]);
+    // Update handlers when they change (without recreating clients)
+    (0, react_1.useEffect)(() => {
+        const clientMap = clientMapRef.current;
+        clientMap.forEach((server, key) => {
+            if (!server.client) {
+                return; // Skip failed servers
+            }
+            const serverInfo = currentServersMap.get(key);
+            if (!serverInfo) {
+                return; // Server was removed, handled by main effect
             }
-            // Register the successful tools
-            const allTools = toolResults
-                .filter((result) => result.status === "fulfilled")
-                .map((result) => result.value)
-                .flat();
-            allTools.forEach((tool) => {
-                registerTool({
-                    description: tool.description ?? "",
-                    name: tool.name,
-                    tool: async (args) => {
-                        const mcpServer = mcpServerMap.get(tool.name);
-                        if (!mcpServer) {
-                            // should never happen
-                            throw new Error(`MCP server for tool ${tool.name} not found`);
-                        }
-                        if (!mcpServer.client) {
-                            // this can't actually happen because the tool can't be registered if the server is not connected
-                            throw new Error(`MCP server for tool ${tool.name} is not connected`);
-                        }
-                        const result = await mcpServer.client.callTool(tool.name, args);
-                        if (result.isError) {
-                            const errorMessage = extractErrorMessage(result.content);
-                            throw new Error(errorMessage);
-                        }
-                        return result.content;
-                    },
-                    toolSchema: tool.inputSchema,
-                    transformToContent: (content) => {
-                        // MCP tools can return content in various formats; pass through arrays of content parts
-                        // unchanged, otherwise stringify into a text content part.
-                        if ((0, content_parts_1.isContentPartArray)(content)) {
-                            return content;
-                        }
-                        return [{ type: "text", text: (0, content_parts_1.toText)(content) }];
-                    },
-                });
+            // Determine effective handlers
+            const effectiveElicitationHandler = serverInfo.handlers?.elicitation ??
+                (providerElicitationHandler
+                    ? async (request, extra) => await providerElicitationHandler(request, extra, serverInfo)
+                    : undefined);
+            const effectiveSamplingHandler = serverInfo.handlers?.sampling ??
+                (providerSamplingHandler
+                    ? async (request, extra) => await providerSamplingHandler(request, extra, serverInfo)
+                    : undefined);
+            // Update handlers unconditionally (allows removal by passing undefined)
+            server.client.updateElicitationHandler?.(effectiveElicitationHandler);
+            server.client.updateSamplingHandler?.(effectiveSamplingHandler);
+        });
+    }, [currentServersMap, providerElicitationHandler, providerSamplingHandler]);
+    // Cleanup on unmount: close all clients
+    (0, react_1.useEffect)(() => {
+        const clientMap = clientMapRef.current;
+        const ownerMapAtMount = toolOwnerRef.current;
+        const keyToToolsAtMount = keyToToolsRef.current;
+        return () => {
+            clientMap.forEach((server, _key) => {
+                if (server.client) {
+                    try {
+                        server.client.close();
+                    }
+                    catch (error) {
+                        const url = server.url ?? "(unknown url)";
+                        console.error(`Error closing MCP client on unmount for ${url}:`, error);
+                    }
+                }
             });
-        }
-        // normalize the server infos
-        const mcpServerInfos = mcpServers.map((mcpServer) => typeof mcpServer === "string"
-            ? { url: mcpServer, transport: mcp_client_1.MCPTransport.SSE }
-            : mcpServer);
-        registerMcpServers(mcpServerInfos);
-    }, [mcpServers, registerTool]);
-    return (react_1.default.createElement(McpProviderContext.Provider, { value: connectedMcpServers }, children));
+            clientMap.clear();
+            ownerMapAtMount.clear();
+            keyToToolsAtMount.clear();
+        };
+    }, []);
+    const contextValue = (0, react_1.useMemo)(() => ({
+        servers: connectedMcpServers,
+        elicitation,
+        resolveElicitation,
+    }), [connectedMcpServers, elicitation, resolveElicitation]);
+    return (react_1.default.createElement(McpProviderContext.Provider, { value: contextValue }, children));
 };
 exports.TamboMcpProvider = TamboMcpProvider;
 /**
@@ -203,12 +320,64 @@ exports.TamboMcpProvider = TamboMcpProvider;
  * @returns The MCP servers
  */
 const useTamboMcpServers = () => {
-    return (0, react_1.useContext)(McpProviderContext);
+    return (0, react_1.useContext)(McpProviderContext).servers;
 };
 exports.useTamboMcpServers = useTamboMcpServers;
-function equalsMcpServer(s, mcpServerInfo) {
-    return (s.url === mcpServerInfo.url &&
-        s.transport === mcpServerInfo.transport &&
-        (0, fast_equals_1.deepEqual)(s.customHeaders, mcpServerInfo.customHeaders));
+/**
+ * Hook to access elicitation context from TamboMcpProvider.
+ * This provides access to the current elicitation request and methods to respond to it.
+ *
+ * The elicitation state is automatically managed by TamboMcpProvider when MCP servers
+ * request user input through the elicitation protocol.
+ * @returns The elicitation context with current request and response handlers
+ * @example
+ * ```tsx
+ * function ElicitationUI() {
+ *   const { elicitation, resolveElicitation } = useTamboElicitationContext();
+ *
+ *   if (!elicitation) return null;
+ *
+ *   return (
+ *     <div>
+ *       <p>{elicitation.message}</p>
+ *       <button onClick={() => resolveElicitation?.({ action: "accept", content: {} })}>
+ *         Accept
+ *       </button>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+const useTamboElicitationContext = () => {
+    const context = (0, react_1.useContext)(McpProviderContext);
+    return {
+        elicitation: context.elicitation,
+        resolveElicitation: context.resolveElicitation,
+    };
+};
+exports.useTamboElicitationContext = useTamboElicitationContext;
+/**
+ * Creates a stable identifier for an MCP server based on its connection properties.
+ * Two servers with the same URL, transport, and headers will have the same key.
+ * @returns A stable string key identifying the server
+ */
+function getServerKey(serverInfo) {
+    const headerStr = serverInfo.customHeaders
+        ? JSON.stringify(Object.entries(serverInfo.customHeaders)
+            .map(([k, v]) => [k.toLowerCase(), v])
+            .sort(([a], [b]) => a.localeCompare(b)))
+        : "";
+    return `${serverInfo.url}|${serverInfo.transport ?? mcp_client_1.MCPTransport.SSE}|${headerStr}`;
+}
+/**
+ * Normalizes a server definition (string or object) into a McpServerInfo.
+ * @returns The normalized McpServerInfo object
+ */
+function normalizeServerInfo(server) {
+    const s = typeof server === "string"
+        ? { url: server, transport: mcp_client_1.MCPTransport.SSE }
+        : server;
+    const key = getServerKey(s);
+    return { ...s, key };
 }
 //# sourceMappingURL=tambo-mcp-provider.js.map