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

package/dist/{chunk-BLSI67J6.cjs → chunk-H5XMKBBA.cjs}

@@ -1,6 +1,7 @@
 'use strict';
 
-var chunk4PRWNAXQ_cjs = require('./chunk-4PRWNAXQ.cjs');
+var chunkUOWLKFXK_cjs = require('./chunk-UOWLKFXK.cjs');
+var chunk7K7HZMP4_cjs = require('./chunk-7K7HZMP4.cjs');
 var react = require('react');
 var jsxRuntime = require('react/jsx-runtime');
 var z = require('zod');
@@ -176,6 +177,63 @@ function processStreamChunk(chunk, state) {
         toolCalls: parseToolCalls(chunk.toolCalls),
         requiresAction: true
       };
+    // Handle tool action events from server
+    case "action:start": {
+      const newResults = new Map(state.toolResults);
+      newResults.set(chunk.id, {
+        id: chunk.id,
+        name: chunk.name,
+        status: "executing"
+      });
+      return { ...state, toolResults: newResults };
+    }
+    case "action:args": {
+      const existing = state.toolResults.get(chunk.id);
+      if (existing) {
+        const newResults = new Map(state.toolResults);
+        try {
+          newResults.set(chunk.id, {
+            ...existing,
+            args: JSON.parse(chunk.args)
+          });
+        } catch {
+        }
+        return { ...state, toolResults: newResults };
+      }
+      return state;
+    }
+    case "action:end": {
+      const existing = state.toolResults.get(chunk.id);
+      const newResults = new Map(state.toolResults);
+      newResults.set(chunk.id, {
+        id: chunk.id,
+        name: chunk.name,
+        status: chunk.error ? "failed" : "completed",
+        args: existing?.args,
+        result: chunk.result,
+        error: chunk.error
+      });
+      return { ...state, toolResults: newResults };
+    }
+    case "tool:result": {
+      const existing = state.toolResults.get(chunk.id);
+      const newResults = new Map(state.toolResults);
+      newResults.set(chunk.id, {
+        id: chunk.id,
+        name: chunk.name,
+        status: chunk.result?.success ? "completed" : "failed",
+        args: existing?.args,
+        result: chunk.result,
+        error: chunk.result?.error
+      });
+      return { ...state, toolResults: newResults };
+    }
+    case "citation": {
+      return {
+        ...state,
+        citations: [...state.citations, ...chunk.citations]
+      };
+    }
     case "done":
       return {
         ...state,
@@ -214,6 +272,8 @@ function createStreamState(messageId) {
     content: "",
     thinking: "",
     toolCalls: [],
+    toolResults: /* @__PURE__ */ new Map(),
+    citations: [],
     requiresAction: false,
     finishReason: void 0
   };
@@ -241,13 +301,31 @@ function streamStateToMessage(state) {
       arguments: JSON.stringify(tc.args)
     }
   })) : void 0;
+  const toolExecutions = state.toolResults.size > 0 ? Array.from(state.toolResults.values()).map((tr) => ({
+    id: tr.id,
+    name: tr.name,
+    args: tr.args ?? {},
+    status: tr.status,
+    result: tr.result,
+    error: tr.error,
+    timestamp: Date.now()
+  })) : void 0;
+  const metadata = {};
+  if (toolExecutions) {
+    metadata.toolExecutions = toolExecutions;
+  }
+  if (state.citations && state.citations.length > 0) {
+    metadata.citations = state.citations;
+  }
   return {
     id: state.messageId,
     role: "assistant",
     content: state.content,
     thinking: state.thinking || void 0,
     toolCalls,
-    createdAt: /* @__PURE__ */ new Date()
+    createdAt: /* @__PURE__ */ new Date(),
+    // Store tool executions and citations in metadata for UI components
+    metadata: Object.keys(metadata).length > 0 ? metadata : void 0
   };
 }
 function createEmptyAssistantMessage(id) {
@@ -420,11 +498,21 @@ function buildToolResultContentForAI(result, tool, args) {
     case "full":
     default:
       if (aiContext) {
-        const { _aiResponseMode, _aiContext, _aiContent, ...dataOnly } = typedResult ?? {};
+        const {
+          _aiResponseMode,
+          _aiContext,
+          _aiContent,
+          _uiResources,
+          ...dataOnly
+        } = typedResult ?? {};
         return `${aiContext}
 
 Full data: ${JSON.stringify(dataOnly)}`;
       }
+      if (typedResult?._uiResources) {
+        const { _uiResources, ...dataOnly } = typedResult;
+        return JSON.stringify(dataOnly);
+      }
       return JSON.stringify(result);
   }
 }
@@ -2258,17 +2346,17 @@ function useAITools(options = {}) {
   const rememberedConsentRef = react.useRef(/* @__PURE__ */ new Set());
   react.useEffect(() => {
     if (!autoStart || !isEnabled) return;
-    if (consoleCapture && !chunk4PRWNAXQ_cjs.isConsoleCaptureActive()) {
-      chunk4PRWNAXQ_cjs.startConsoleCapture(consoleOptions);
+    if (consoleCapture && !chunkUOWLKFXK_cjs.isConsoleCaptureActive()) {
+      chunkUOWLKFXK_cjs.startConsoleCapture(consoleOptions);
       setActiveCaptures((prev) => ({ ...prev, console: true }));
     }
-    if (network && !chunk4PRWNAXQ_cjs.isNetworkCaptureActive()) {
-      chunk4PRWNAXQ_cjs.startNetworkCapture(networkOptions);
+    if (network && !chunkUOWLKFXK_cjs.isNetworkCaptureActive()) {
+      chunkUOWLKFXK_cjs.startNetworkCapture(networkOptions);
       setActiveCaptures((prev) => ({ ...prev, network: true }));
     }
     return () => {
-      chunk4PRWNAXQ_cjs.stopConsoleCapture();
-      chunk4PRWNAXQ_cjs.stopNetworkCapture();
+      chunkUOWLKFXK_cjs.stopConsoleCapture();
+      chunkUOWLKFXK_cjs.stopNetworkCapture();
     };
   }, [
     autoStart,
@@ -2283,12 +2371,12 @@ function useAITools(options = {}) {
       if (!screenshot) {
         throw new Error("Screenshot capture is not enabled");
       }
-      if (!chunk4PRWNAXQ_cjs.isScreenshotSupported()) {
+      if (!chunkUOWLKFXK_cjs.isScreenshotSupported()) {
         throw new Error(
           "Screenshot capture is not supported in this environment"
         );
       }
-      return chunk4PRWNAXQ_cjs.captureScreenshot({ ...screenshotOptions, ...opts });
+      return chunkUOWLKFXK_cjs.captureScreenshot({ ...screenshotOptions, ...opts });
     },
     [screenshot, screenshotOptions]
   );
@@ -2297,7 +2385,7 @@ function useAITools(options = {}) {
       if (!consoleCapture) {
         return { logs: [], totalCaptured: 0 };
       }
-      return chunk4PRWNAXQ_cjs.getConsoleLogs({ ...consoleOptions, ...opts });
+      return chunkUOWLKFXK_cjs.getConsoleLogs({ ...consoleOptions, ...opts });
     },
     [consoleCapture, consoleOptions]
   );
@@ -2306,7 +2394,7 @@ function useAITools(options = {}) {
       if (!network) {
         return { requests: [], totalCaptured: 0 };
       }
-      return chunk4PRWNAXQ_cjs.getNetworkRequests({ ...networkOptions, ...opts });
+      return chunkUOWLKFXK_cjs.getNetworkRequests({ ...networkOptions, ...opts });
     },
     [network, networkOptions]
   );
@@ -2399,23 +2487,23 @@ function useAITools(options = {}) {
     ]
   );
   const startCapturing = react.useCallback(() => {
-    if (consoleCapture && !chunk4PRWNAXQ_cjs.isConsoleCaptureActive()) {
-      chunk4PRWNAXQ_cjs.startConsoleCapture(consoleOptions);
+    if (consoleCapture && !chunkUOWLKFXK_cjs.isConsoleCaptureActive()) {
+      chunkUOWLKFXK_cjs.startConsoleCapture(consoleOptions);
       setActiveCaptures((prev) => ({ ...prev, console: true }));
     }
-    if (network && !chunk4PRWNAXQ_cjs.isNetworkCaptureActive()) {
-      chunk4PRWNAXQ_cjs.startNetworkCapture(networkOptions);
+    if (network && !chunkUOWLKFXK_cjs.isNetworkCaptureActive()) {
+      chunkUOWLKFXK_cjs.startNetworkCapture(networkOptions);
       setActiveCaptures((prev) => ({ ...prev, network: true }));
     }
   }, [consoleCapture, network, consoleOptions, networkOptions]);
   const stopCapturing = react.useCallback(() => {
-    chunk4PRWNAXQ_cjs.stopConsoleCapture();
-    chunk4PRWNAXQ_cjs.stopNetworkCapture();
+    chunkUOWLKFXK_cjs.stopConsoleCapture();
+    chunkUOWLKFXK_cjs.stopNetworkCapture();
     setActiveCaptures({ console: false, network: false });
   }, []);
   const clearCaptured = react.useCallback(() => {
-    chunk4PRWNAXQ_cjs.clearConsoleLogs();
-    chunk4PRWNAXQ_cjs.clearNetworkRequests();
+    chunkUOWLKFXK_cjs.clearConsoleLogs();
+    chunkUOWLKFXK_cjs.clearNetworkRequests();
   }, []);
   const formatForAI = react.useCallback((context) => {
     const parts = [];
@@ -2425,16 +2513,16 @@ function useAITools(options = {}) {
       );
     }
     if (context.consoleLogs && context.consoleLogs.logs.length > 0) {
-      parts.push(chunk4PRWNAXQ_cjs.formatLogsForAI(context.consoleLogs.logs));
+      parts.push(chunkUOWLKFXK_cjs.formatLogsForAI(context.consoleLogs.logs));
     }
     if (context.networkRequests && context.networkRequests.requests.length > 0) {
-      parts.push(chunk4PRWNAXQ_cjs.formatRequestsForAI(context.networkRequests.requests));
+      parts.push(chunkUOWLKFXK_cjs.formatRequestsForAI(context.networkRequests.requests));
     }
     return parts.length > 0 ? parts.join("\n\n---\n\n") : "No context captured.";
   }, []);
   const detectIntentFn = react.useCallback(
     (message) => {
-      const result = chunk4PRWNAXQ_cjs.detectIntent(message);
+      const result = chunkUOWLKFXK_cjs.detectIntent(message);
       result.suggestedTools = result.suggestedTools.filter((tool) => {
         if (tool === "screenshot") return screenshot;
         if (tool === "console") return consoleCapture;
@@ -2548,7 +2636,7 @@ function convertZodSchema(schema, _toolName) {
     }
   } catch {
   }
-  return chunk4PRWNAXQ_cjs.zodObjectToInputSchema(schema);
+  return chunkUOWLKFXK_cjs.zodObjectToInputSchema(schema);
 }
 function useToolWithSchema(config, dependencies = []) {
   const { registerTool, unregisterTool } = useCopilot();
@@ -2856,7 +2944,7 @@ function useAgent(options) {
         if (!response.ok) {
           throw new Error(`Agent error: ${response.status}`);
         }
-        for await (const event of chunk4PRWNAXQ_cjs.streamSSE(response)) {
+        for await (const event of chunkUOWLKFXK_cjs.streamSSE(response)) {
           handleAgentEvent(event);
         }
       } catch (err) {
@@ -3350,7 +3438,7 @@ function createReactThreadManagerState(initialThreads) {
 }
 
 // src/react/internal/ReactThreadManager.ts
-var _ReactThreadManager = class _ReactThreadManager extends chunk4PRWNAXQ_cjs.ThreadManager {
+var _ReactThreadManager = class _ReactThreadManager extends chunkUOWLKFXK_cjs.ThreadManager {
   constructor(config = {}, callbacks = {}) {
     const reactState = new ReactThreadManagerState();
     super({ ...config, state: reactState }, callbacks);
@@ -3493,7 +3581,6 @@ function useThreadManager(config) {
     if (!config.adapter) {
       return getInternalManager(config);
     }
-    console.log("[useThreadManager] Creating new manager with custom adapter");
     return createReactThreadManager(
       {
         adapter: config.adapter,
@@ -3625,6 +3712,309 @@ function useThreadManager(config) {
     hasPendingChanges
   };
 }
+function useMCPClient(config) {
+  const {
+    autoConnect = true,
+    onConnectionStateChange,
+    onToolsChange,
+    onElicitationRequest,
+    onError,
+    onNotification,
+    ...clientConfig
+  } = config;
+  const clientRef = react.useRef(null);
+  const mountedRef = react.useRef(true);
+  const [state, setState] = react.useState({
+    connectionState: "disconnected",
+    tools: []
+  });
+  const getClient = react.useCallback(() => {
+    if (!clientRef.current) {
+      clientRef.current = chunk7K7HZMP4_cjs.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 = react.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 = react.useCallback(async () => {
+    const client = clientRef.current;
+    if (client) {
+      await client.disconnect();
+      if (mountedRef.current) {
+        setState({
+          connectionState: "disconnected",
+          tools: []
+        });
+      }
+    }
+  }, []);
+  const callTool = react.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 = react.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;
+  }, []);
+  react.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 = react.useRef([]);
+  const mcpClient = useMCPClient(clientConfig);
+  const toolAdapter = react.useMemo(
+    () => new chunk7K7HZMP4_cjs.MCPToolAdapter(clientConfig.name),
+    [clientConfig.name]
+  );
+  const toolDefinitions = react.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
+  ]);
+  react.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,
+    onIntent,
+    onPrompt,
+    onNotify,
+    onLink,
+    requireConsent = { tool: false, link: true }
+  } = config;
+  const handleIntent = react.useCallback(
+    async (intent, context) => {
+      switch (intent.type) {
+        case "tool": {
+          if (requireConsent.tool) ;
+          await onToolCall?.(intent.name, intent.arguments, context);
+          break;
+        }
+        case "intent": {
+          await onIntent?.(intent.action, intent.data, context);
+          break;
+        }
+        case "prompt": {
+          onPrompt?.(intent.text, context);
+          break;
+        }
+        case "notify": {
+          onNotify?.(intent.message, intent.level, context);
+          break;
+        }
+        case "link": {
+          const shouldContinue = onLink?.(intent.url, intent.newTab, context);
+          if (shouldContinue === false) {
+            break;
+          }
+          if (requireConsent.link) {
+            const isSafeUrl = intent.url.startsWith("https://") || intent.url.startsWith("http://localhost");
+            if (!isSafeUrl) {
+              console.warn(
+                "[MCP-UI] Blocked potentially unsafe link:",
+                intent.url
+              );
+              break;
+            }
+          }
+          if (typeof window !== "undefined") {
+            if (intent.newTab !== false) {
+              window.open(intent.url, "_blank", "noopener,noreferrer");
+            } else {
+              window.location.href = intent.url;
+            }
+          }
+          break;
+        }
+        default: {
+          console.warn(
+            "[MCP-UI] Unknown intent type:",
+            intent.type
+          );
+        }
+      }
+    },
+    [onToolCall, onIntent, onPrompt, onNotify, onLink, requireConsent]
+  );
+  return react.useMemo(
+    () => ({
+      handleIntent
+    }),
+    [handleIntent]
+  );
+}
+function createMessageIntentHandler(sendMessage) {
+  return {
+    onIntent: async (action, data) => {
+      const dataStr = data ? ` with ${JSON.stringify(data)}` : "";
+      await sendMessage(`User action: ${action}${dataStr}`);
+    },
+    onPrompt: (text) => {
+      sendMessage(text);
+    },
+    onNotify: (message, level) => {
+      if (level === "error") {
+        sendMessage(`Error: ${message}`);
+      }
+    }
+  };
+}
+function createToolIntentHandler(callTool) {
+  return {
+    onToolCall: async (name, args) => {
+      await callTool(name, args);
+    }
+  };
+}
 
 // src/react/utils/permission-storage.ts
 var DEFAULT_KEY_PREFIX = "yourgpt-permissions";
@@ -3891,12 +4281,14 @@ exports.ReactChat = ReactChat;
 exports.ReactChatState = ReactChatState;
 exports.ReactThreadManager = ReactThreadManager;
 exports.ReactThreadManagerState = ReactThreadManagerState;
+exports.createMessageIntentHandler = createMessageIntentHandler;
 exports.createPermissionStorage = createPermissionStorage;
 exports.createReactChat = createReactChat;
 exports.createReactChatState = createReactChatState;
 exports.createReactThreadManager = createReactThreadManager;
 exports.createReactThreadManagerState = createReactThreadManagerState;
 exports.createSessionPermissionCache = createSessionPermissionCache;
+exports.createToolIntentHandler = createToolIntentHandler;
 exports.formatKnowledgeResultsForAI = formatKnowledgeResultsForAI;
 exports.initialAgentLoopState = initialAgentLoopState;
 exports.searchKnowledgeBase = searchKnowledgeBase;
@@ -3912,6 +4304,9 @@ exports.useCopilot = useCopilot;
 exports.useDevLogger = useDevLogger;
 exports.useFeatureSupport = useFeatureSupport;
 exports.useKnowledgeBase = useKnowledgeBase;
+exports.useMCPClient = useMCPClient;
+exports.useMCPTools = useMCPTools;
+exports.useMCPUIIntents = useMCPUIIntents;
 exports.useSuggestions = useSuggestions;
 exports.useSupportedMediaTypes = useSupportedMediaTypes;
 exports.useThreadManager = useThreadManager;
@@ -3920,5 +4315,5 @@ exports.useToolExecutor = useToolExecutor;
 exports.useToolWithSchema = useToolWithSchema;
 exports.useTools = useTools;
 exports.useToolsWithSchema = useToolsWithSchema;
-//# sourceMappingURL=chunk-BLSI67J6.cjs.map
-//# sourceMappingURL=chunk-BLSI67J6.cjs.map
+//# sourceMappingURL=chunk-H5XMKBBA.cjs.map
+//# sourceMappingURL=chunk-H5XMKBBA.cjs.map