@yourgpt/copilot-sdk 2.0.0 → 2.0.2-beta.1

package/dist/{chunk-CJ7UWN2Y.js → chunk-3YKHVLNP.js}

@@ -1,4 +1,5 @@
-import { ThreadManager, isConsoleCaptureActive, startConsoleCapture, isNetworkCaptureActive, startNetworkCapture, stopConsoleCapture, stopNetworkCapture, isScreenshotSupported, captureScreenshot, getConsoleLogs, getNetworkRequests, clearConsoleLogs, clearNetworkRequests, formatLogsForAI, formatRequestsForAI, detectIntent, streamSSE, zodObjectToInputSchema } from './chunk-JM7PB2LP.js';
+import { ThreadManager, isConsoleCaptureActive, startConsoleCapture, isNetworkCaptureActive, startNetworkCapture, stopConsoleCapture, stopNetworkCapture, isScreenshotSupported, captureScreenshot, getConsoleLogs, getNetworkRequests, clearConsoleLogs, clearNetworkRequests, formatLogsForAI, formatRequestsForAI, detectIntent, streamSSE, zodObjectToInputSchema } from './chunk-Z7PHGSJT.js';
+import { createMCPClient, MCPToolAdapter } from './chunk-4WWWMNUA.js';
 import { createContext, useContext, useCallback, useEffect, useState, useRef, useSyncExternalStore, useMemo } from 'react';
 import { jsx } from 'react/jsx-runtime';
 import * as z from 'zod';
@@ -154,6 +155,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,
@@ -192,6 +250,8 @@ function createStreamState(messageId) {
     content: "",
     thinking: "",
     toolCalls: [],
+    toolResults: /* @__PURE__ */ new Map(),
+    citations: [],
     requiresAction: false,
     finishReason: void 0
   };
@@ -219,13 +279,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) {
@@ -398,11 +476,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);
   }
 }
@@ -3471,7 +3559,6 @@ function useThreadManager(config) {
     if (!config.adapter) {
       return getInternalManager(config);
     }
-    console.log("[useThreadManager] Creating new manager with custom adapter");
     return createReactThreadManager(
       {
         adapter: config.adapter,
@@ -3603,6 +3690,309 @@ 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,
+    onIntent,
+    onPrompt,
+    onNotify,
+    onLink,
+    requireConsent = { tool: false, link: true }
+  } = config;
+  const handleIntent = 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 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";
@@ -3862,6 +4252,6 @@ function useChat(config) {
   };
 }
 
-export { AbstractAgentLoop, AbstractChat, CopilotProvider, ReactChat, ReactChatState, ReactThreadManager, ReactThreadManagerState, createPermissionStorage, createReactChat, createReactChatState, createReactThreadManager, createReactThreadManagerState, createSessionPermissionCache, formatKnowledgeResultsForAI, initialAgentLoopState, searchKnowledgeBase, useAIAction, useAIActions, useAIContext, useAIContexts, useAITools, useAgent, useCapabilities, useChat, useCopilot, useDevLogger, useFeatureSupport, useKnowledgeBase, useSuggestions, useSupportedMediaTypes, useThreadManager, useTool, useToolExecutor, useToolWithSchema, useTools, useToolsWithSchema };
-//# sourceMappingURL=chunk-CJ7UWN2Y.js.map
-//# sourceMappingURL=chunk-CJ7UWN2Y.js.map
+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-3YKHVLNP.js.map
+//# sourceMappingURL=chunk-3YKHVLNP.js.map