@yourgpt/copilot-sdk 2.0.2-beta.2 → 2.1.0

package/dist/{chunk-IXFV6AW6.js → chunk-3SP6V22Y.js}

@@ -1,7 +1,7 @@
-import { ThreadManager, isConsoleCaptureActive, startConsoleCapture, isNetworkCaptureActive, startNetworkCapture, stopConsoleCapture, stopNetworkCapture, isScreenshotSupported, captureScreenshot, getConsoleLogs, getNetworkRequests, clearConsoleLogs, clearNetworkRequests, formatLogsForAI, formatRequestsForAI, detectIntent, streamSSE, zodObjectToInputSchema } from './chunk-7XFFRV7D.js';
-import { createMCPClient, MCPToolAdapter } from './chunk-BH7MNDWW.js';
-import { createContext, useContext, useCallback, useEffect, useState, useRef, useSyncExternalStore, useMemo } from 'react';
-import { jsx } from 'react/jsx-runtime';
+import { ThreadManager, isConsoleCaptureActive, startConsoleCapture, isNetworkCaptureActive, startNetworkCapture, stopConsoleCapture, stopNetworkCapture, isScreenshotSupported, captureScreenshot, getConsoleLogs, getNetworkRequests, clearConsoleLogs, clearNetworkRequests, formatLogsForAI, formatRequestsForAI, detectIntent, streamSSE, zodObjectToInputSchema } from './chunk-7PJ4GAJR.js';
+import { createMCPClient, MCPToolAdapter } from './chunk-EWVQWTNV.js';
+import { createContext, useRef, useState, useCallback, useEffect, useMemo, useContext, useSyncExternalStore } from 'react';
+import { jsxs, jsx } from 'react/jsx-runtime';
 import * as z from 'zod';
 
 // src/chat/types/tool.ts
@@ -1948,6 +1948,238 @@ function printTree(tree) {
   });
   return output.trim();
 }
+function useMCPClient(config) {
+  const {
+    autoConnect = true,
+    onConnectionStateChange,
+    onToolsChange,
+    onElicitationRequest,
+    onError,
+    onNotification,
+    ...clientConfig
+  } = config;
+  const clientRef = useRef(null);
+  const mountedRef = useRef(true);
+  const [state, setState] = useState({
+    connectionState: "disconnected",
+    tools: []
+  });
+  const getClient = useCallback(() => {
+    if (!clientRef.current) {
+      clientRef.current = createMCPClient(clientConfig, {
+        onConnectionStateChange: (newState) => {
+          if (mountedRef.current) {
+            setState((prev) => ({ ...prev, connectionState: newState }));
+            onConnectionStateChange?.(newState);
+          }
+        },
+        onToolsChange: (tools) => {
+          if (mountedRef.current) {
+            setState((prev) => ({ ...prev, tools }));
+            onToolsChange?.(tools);
+          }
+        },
+        onElicitationRequest,
+        onError: (error) => {
+          if (mountedRef.current) {
+            setState((prev) => ({ ...prev, error: error.message }));
+            onError?.(error);
+          }
+        },
+        onNotification
+      });
+    }
+    return clientRef.current;
+  }, [
+    clientConfig,
+    onConnectionStateChange,
+    onToolsChange,
+    onElicitationRequest,
+    onError,
+    onNotification
+  ]);
+  const connect = useCallback(async () => {
+    const client = getClient();
+    try {
+      setState((prev) => ({
+        ...prev,
+        connectionState: "connecting",
+        error: void 0
+      }));
+      await client.connect();
+      if (mountedRef.current) {
+        const clientState = client.getState();
+        setState({
+          connectionState: "connected",
+          tools: clientState.tools,
+          serverInfo: clientState.serverInfo,
+          serverCapabilities: clientState.serverCapabilities,
+          lastActivity: Date.now()
+        });
+      }
+    } catch (error) {
+      if (mountedRef.current) {
+        const errorMessage = error instanceof Error ? error.message : "Connection failed";
+        setState((prev) => ({
+          ...prev,
+          connectionState: "error",
+          error: errorMessage
+        }));
+      }
+      throw error;
+    }
+  }, [getClient]);
+  const disconnect = useCallback(async () => {
+    const client = clientRef.current;
+    if (client) {
+      await client.disconnect();
+      if (mountedRef.current) {
+        setState({
+          connectionState: "disconnected",
+          tools: []
+        });
+      }
+    }
+  }, []);
+  const callTool = useCallback(
+    async (name, args) => {
+      const client = clientRef.current;
+      if (!client || !client.isConnected()) {
+        throw new Error("MCP client not connected");
+      }
+      const result = await client.callTool(name, args);
+      if (mountedRef.current) {
+        setState((prev) => ({ ...prev, lastActivity: Date.now() }));
+      }
+      return result;
+    },
+    []
+  );
+  const refreshTools = useCallback(async () => {
+    const client = clientRef.current;
+    if (!client || !client.isConnected()) {
+      throw new Error("MCP client not connected");
+    }
+    const tools = await client.refreshTools();
+    if (mountedRef.current) {
+      setState((prev) => ({ ...prev, tools, lastActivity: Date.now() }));
+    }
+    return tools;
+  }, []);
+  useEffect(() => {
+    mountedRef.current = true;
+    if (autoConnect) {
+      connect().catch(() => {
+      });
+    }
+    return () => {
+      mountedRef.current = false;
+      const client = clientRef.current;
+      if (client) {
+        client.disconnect().catch(() => {
+        });
+        clientRef.current = null;
+      }
+    };
+  }, []);
+  const isConnected = state.connectionState === "connected";
+  const isLoading = state.connectionState === "connecting";
+  return {
+    state,
+    connect,
+    disconnect,
+    callTool,
+    refreshTools,
+    isConnected,
+    isLoading
+  };
+}
+
+// src/react/hooks/useMCPTools.ts
+function useMCPTools(config) {
+  const {
+    prefixToolNames = true,
+    autoRegister = true,
+    hidden = false,
+    source = "mcp",
+    ...clientConfig
+  } = config;
+  const { registerTool, unregisterTool } = useCopilot();
+  const registeredToolsRef = useRef([]);
+  const mcpClient = useMCPClient(clientConfig);
+  const toolAdapter = useMemo(
+    () => new MCPToolAdapter(clientConfig.name),
+    [clientConfig.name]
+  );
+  const toolDefinitions = useMemo(() => {
+    if (!mcpClient.isConnected || mcpClient.state.tools.length === 0) {
+      return [];
+    }
+    return mcpClient.state.tools.map(
+      (tool) => toolAdapter.toToolDefinition(tool, {
+        prefix: prefixToolNames,
+        asServerTool: true,
+        // MCP tools execute remotely
+        callTool: mcpClient.callTool,
+        hidden,
+        // Hide from chat UI
+        source
+        // Tool source for UI differentiation
+      })
+    );
+  }, [
+    mcpClient.isConnected,
+    mcpClient.state.tools,
+    mcpClient.callTool,
+    toolAdapter,
+    prefixToolNames,
+    hidden,
+    source
+  ]);
+  useEffect(() => {
+    if (!autoRegister) {
+      return;
+    }
+    for (const toolName of registeredToolsRef.current) {
+      unregisterTool(toolName);
+    }
+    registeredToolsRef.current = [];
+    if (mcpClient.isConnected && toolDefinitions.length > 0) {
+      for (const tool of toolDefinitions) {
+        registerTool(tool);
+        registeredToolsRef.current.push(tool.name);
+      }
+    }
+    return () => {
+      for (const toolName of registeredToolsRef.current) {
+        unregisterTool(toolName);
+      }
+      registeredToolsRef.current = [];
+    };
+  }, [
+    autoRegister,
+    mcpClient.isConnected,
+    toolDefinitions,
+    registerTool,
+    unregisterTool
+  ]);
+  return {
+    ...mcpClient,
+    toolDefinitions
+  };
+}
+function MCPConnection({ config }) {
+  useMCPTools({
+    name: config.name,
+    transport: config.transport,
+    url: config.url,
+    headers: config.headers,
+    autoConnect: true,
+    prefixToolNames: config.prefixToolNames ?? true,
+    timeout: config.timeout
+  });
+  return null;
+}
 var CopilotContext = createContext(null);
 function useCopilot() {
   const context = useContext(CopilotContext);
@@ -1969,7 +2201,8 @@ function CopilotProvider({
   headers,
   debug = false,
   maxIterations,
-  maxIterationsMessage
+  maxIterationsMessage,
+  mcpServers
 }) {
   const debugLog = useCallback(
     (...args) => {
@@ -2229,7 +2462,10 @@ function CopilotProvider({
       toolsConfig
     ]
   );
-  return /* @__PURE__ */ jsx(CopilotContext.Provider, { value: contextValue, children });
+  return /* @__PURE__ */ jsxs(CopilotContext.Provider, { value: contextValue, children: [
+    mcpServers?.map((config) => /* @__PURE__ */ jsx(MCPConnection, { config }, config.name)),
+    children
+  ] });
 }
 function useAIActions(actions) {
   const { registerAction, unregisterAction } = useCopilot();
@@ -2562,7 +2798,8 @@ function useTool(config, dependencies = []) {
       render: config.render,
       available: config.available ?? true,
       needsApproval: config.needsApproval,
-      approvalMessage: config.approvalMessage
+      approvalMessage: config.approvalMessage,
+      hidden: config.hidden
     };
     registerTool(tool);
     return () => {
@@ -3690,216 +3927,6 @@ function useThreadManager(config) {
     hasPendingChanges
   };
 }
-function useMCPClient(config) {
-  const {
-    autoConnect = true,
-    onConnectionStateChange,
-    onToolsChange,
-    onElicitationRequest,
-    onError,
-    onNotification,
-    ...clientConfig
-  } = config;
-  const clientRef = useRef(null);
-  const mountedRef = useRef(true);
-  const [state, setState] = useState({
-    connectionState: "disconnected",
-    tools: []
-  });
-  const getClient = useCallback(() => {
-    if (!clientRef.current) {
-      clientRef.current = createMCPClient(clientConfig, {
-        onConnectionStateChange: (newState) => {
-          if (mountedRef.current) {
-            setState((prev) => ({ ...prev, connectionState: newState }));
-            onConnectionStateChange?.(newState);
-          }
-        },
-        onToolsChange: (tools) => {
-          if (mountedRef.current) {
-            setState((prev) => ({ ...prev, tools }));
-            onToolsChange?.(tools);
-          }
-        },
-        onElicitationRequest,
-        onError: (error) => {
-          if (mountedRef.current) {
-            setState((prev) => ({ ...prev, error: error.message }));
-            onError?.(error);
-          }
-        },
-        onNotification
-      });
-    }
-    return clientRef.current;
-  }, [
-    clientConfig,
-    onConnectionStateChange,
-    onToolsChange,
-    onElicitationRequest,
-    onError,
-    onNotification
-  ]);
-  const connect = useCallback(async () => {
-    const client = getClient();
-    try {
-      setState((prev) => ({
-        ...prev,
-        connectionState: "connecting",
-        error: void 0
-      }));
-      await client.connect();
-      if (mountedRef.current) {
-        const clientState = client.getState();
-        setState({
-          connectionState: "connected",
-          tools: clientState.tools,
-          serverInfo: clientState.serverInfo,
-          serverCapabilities: clientState.serverCapabilities,
-          lastActivity: Date.now()
-        });
-      }
-    } catch (error) {
-      if (mountedRef.current) {
-        const errorMessage = error instanceof Error ? error.message : "Connection failed";
-        setState((prev) => ({
-          ...prev,
-          connectionState: "error",
-          error: errorMessage
-        }));
-      }
-      throw error;
-    }
-  }, [getClient]);
-  const disconnect = useCallback(async () => {
-    const client = clientRef.current;
-    if (client) {
-      await client.disconnect();
-      if (mountedRef.current) {
-        setState({
-          connectionState: "disconnected",
-          tools: []
-        });
-      }
-    }
-  }, []);
-  const callTool = useCallback(
-    async (name, args) => {
-      const client = clientRef.current;
-      if (!client || !client.isConnected()) {
-        throw new Error("MCP client not connected");
-      }
-      const result = await client.callTool(name, args);
-      if (mountedRef.current) {
-        setState((prev) => ({ ...prev, lastActivity: Date.now() }));
-      }
-      return result;
-    },
-    []
-  );
-  const refreshTools = useCallback(async () => {
-    const client = clientRef.current;
-    if (!client || !client.isConnected()) {
-      throw new Error("MCP client not connected");
-    }
-    const tools = await client.refreshTools();
-    if (mountedRef.current) {
-      setState((prev) => ({ ...prev, tools, lastActivity: Date.now() }));
-    }
-    return tools;
-  }, []);
-  useEffect(() => {
-    mountedRef.current = true;
-    if (autoConnect) {
-      connect().catch(() => {
-      });
-    }
-    return () => {
-      mountedRef.current = false;
-      const client = clientRef.current;
-      if (client) {
-        client.disconnect().catch(() => {
-        });
-        clientRef.current = null;
-      }
-    };
-  }, []);
-  const isConnected = state.connectionState === "connected";
-  const isLoading = state.connectionState === "connecting";
-  return {
-    state,
-    connect,
-    disconnect,
-    callTool,
-    refreshTools,
-    isConnected,
-    isLoading
-  };
-}
-function useMCPTools(config) {
-  const {
-    prefixToolNames = true,
-    autoRegister = true,
-    ...clientConfig
-  } = config;
-  const { registerTool, unregisterTool } = useCopilot();
-  const registeredToolsRef = useRef([]);
-  const mcpClient = useMCPClient(clientConfig);
-  const toolAdapter = useMemo(
-    () => new MCPToolAdapter(clientConfig.name),
-    [clientConfig.name]
-  );
-  const toolDefinitions = useMemo(() => {
-    if (!mcpClient.isConnected || mcpClient.state.tools.length === 0) {
-      return [];
-    }
-    return mcpClient.state.tools.map(
-      (tool) => toolAdapter.toToolDefinition(tool, {
-        prefix: prefixToolNames,
-        asServerTool: true,
-        // MCP tools execute remotely
-        callTool: mcpClient.callTool
-      })
-    );
-  }, [
-    mcpClient.isConnected,
-    mcpClient.state.tools,
-    mcpClient.callTool,
-    toolAdapter,
-    prefixToolNames
-  ]);
-  useEffect(() => {
-    if (!autoRegister) {
-      return;
-    }
-    for (const toolName of registeredToolsRef.current) {
-      unregisterTool(toolName);
-    }
-    registeredToolsRef.current = [];
-    if (mcpClient.isConnected && toolDefinitions.length > 0) {
-      for (const tool of toolDefinitions) {
-        registerTool(tool);
-        registeredToolsRef.current.push(tool.name);
-      }
-    }
-    return () => {
-      for (const toolName of registeredToolsRef.current) {
-        unregisterTool(toolName);
-      }
-      registeredToolsRef.current = [];
-    };
-  }, [
-    autoRegister,
-    mcpClient.isConnected,
-    toolDefinitions,
-    registerTool,
-    unregisterTool
-  ]);
-  return {
-    ...mcpClient,
-    toolDefinitions
-  };
-}
 function useMCPUIIntents(config = {}) {
   const {
     onToolCall,
@@ -4253,5 +4280,5 @@ function useChat(config) {
 }
 
 export { AbstractAgentLoop, AbstractChat, CopilotProvider, ReactChat, ReactChatState, ReactThreadManager, ReactThreadManagerState, createMessageIntentHandler, createPermissionStorage, createReactChat, createReactChatState, createReactThreadManager, createReactThreadManagerState, createSessionPermissionCache, createToolIntentHandler, formatKnowledgeResultsForAI, initialAgentLoopState, searchKnowledgeBase, useAIAction, useAIActions, useAIContext, useAIContexts, useAITools, useAgent, useCapabilities, useChat, useCopilot, useDevLogger, useFeatureSupport, useKnowledgeBase, useMCPClient, useMCPTools, useMCPUIIntents, useSuggestions, useSupportedMediaTypes, useThreadManager, useTool, useToolExecutor, useToolWithSchema, useTools, useToolsWithSchema };
-//# sourceMappingURL=chunk-IXFV6AW6.js.map
-//# sourceMappingURL=chunk-IXFV6AW6.js.map
+//# sourceMappingURL=chunk-3SP6V22Y.js.map
+//# sourceMappingURL=chunk-3SP6V22Y.js.map