@yourgpt/copilot-sdk 1.4.31 → 1.4.33

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

@@ -1,6 +1,6 @@
 'use strict';
 
-var chunkCVKN4H62_cjs = require('./chunk-CVKN4H62.cjs');
+var chunk4PRWNAXQ_cjs = require('./chunk-4PRWNAXQ.cjs');
 var react = require('react');
 var jsxRuntime = require('react/jsx-runtime');
 var z = require('zod');
@@ -438,7 +438,7 @@ var AbstractChat = class {
      * Dynamic context from useAIContext hook
      */
     this.dynamicContext = "";
-    this.isDisposed = false;
+    this._isDisposed = false;
     this.config = {
       runtimeUrl: init.runtimeUrl,
       llm: init.llm,
@@ -906,18 +906,35 @@ ${this.dynamicContext}`.trim() : this.config.systemPrompt,
   isAsyncIterable(value) {
     return value !== null && typeof value === "object" && Symbol.asyncIterator in value;
   }
+  /**
+   * Whether this instance has been disposed
+   */
+  get disposed() {
+    return this._isDisposed;
+  }
   /**
    * Dispose and cleanup
+   * Note: Event handlers are NOT cleared to support React StrictMode revive()
    */
   dispose() {
-    if (this.isDisposed) {
+    if (this._isDisposed) {
       this.debug("dispose() called but already disposed - ignoring");
       return;
     }
-    this.debug("dispose() - clearing event handlers");
-    this.isDisposed = true;
+    this.debug("dispose() - stopping active requests");
+    this._isDisposed = true;
     this.stop();
-    this.eventHandlers.clear();
+  }
+  /**
+   * Revive a disposed instance (for React StrictMode compatibility)
+   * This allows reusing an instance after dispose() was called
+   */
+  revive() {
+    if (!this._isDisposed) {
+      return;
+    }
+    this.debug("revive() - restoring disposed instance");
+    this._isDisposed = false;
   }
 };
 
@@ -932,10 +949,18 @@ var AbstractAgentLoop = class {
     this._isCancelled = false;
     // Cancellation support
     this.abortController = null;
-    // Registered tools
+    // Registered tools with reference counting for React StrictMode compatibility
+    // Tools are never fully removed during a session - only marked as inactive
     this.registeredTools = /* @__PURE__ */ new Map();
     // Pending approvals - resolve with approval result including extraData
     this.pendingApprovals = /* @__PURE__ */ new Map();
+    // ============================================
+    // Cleanup
+    // ============================================
+    /**
+     * Dispose of resources
+     */
+    this._isDisposed = false;
     this.config = config;
     this.callbacks = callbacks;
     this._maxIterations = config.maxIterations ?? 20;
@@ -985,7 +1010,7 @@ var AbstractAgentLoop = class {
     );
   }
   get tools() {
-    return Array.from(this.registeredTools.values());
+    return Array.from(this.registeredTools.values()).filter((entry) => entry.active).map((entry) => entry.tool);
   }
   // ============================================
   // Private setters with callbacks
@@ -1019,22 +1044,42 @@ var AbstractAgentLoop = class {
   // Tool Registration
   // ============================================
   /**
-   * Register a tool
+   * Register a tool (reference counted for React StrictMode compatibility)
+   * Tools are never fully removed - ref counting ensures StrictMode works correctly
    */
   registerTool(tool) {
-    this.registeredTools.set(tool.name, tool);
+    const existing = this.registeredTools.get(tool.name);
+    if (existing) {
+      existing.tool = tool;
+      existing.refCount++;
+      existing.active = true;
+    } else {
+      this.registeredTools.set(tool.name, {
+        tool,
+        refCount: 1,
+        active: true
+      });
+    }
   }
   /**
-   * Unregister a tool
+   * Unregister a tool (reference counted for React StrictMode compatibility)
+   * Tool is only marked inactive when refCount reaches 0, never deleted
    */
   unregisterTool(name) {
-    this.registeredTools.delete(name);
+    const entry = this.registeredTools.get(name);
+    if (entry) {
+      entry.refCount = Math.max(0, entry.refCount - 1);
+      if (entry.refCount === 0) {
+        entry.active = false;
+      }
+    }
   }
   /**
-   * Get a registered tool
+   * Get a registered tool (returns active tools, or inactive if forExecution=true)
    */
   getTool(name) {
-    return this.registeredTools.get(name);
+    const entry = this.registeredTools.get(name);
+    return entry?.tool;
   }
   // ============================================
   // Tool Execution
@@ -1076,7 +1121,7 @@ var AbstractAgentLoop = class {
    * Execute a single tool
    */
   async executeSingleTool(toolCall) {
-    const tool = this.registeredTools.get(toolCall.name);
+    const tool = this.getTool(toolCall.name);
     const execution = {
       id: toolCall.id,
       toolCallId: toolCall.id,
@@ -1287,20 +1332,39 @@ var AbstractAgentLoop = class {
   updateCallbacks(callbacks) {
     this.callbacks = { ...this.callbacks, ...callbacks };
   }
-  // ============================================
-  // Cleanup
-  // ============================================
   /**
-   * Dispose of resources
+   * Whether this instance has been disposed
+   */
+  get disposed() {
+    return this._isDisposed;
+  }
+  /**
+   * Dispose and cleanup
+   * Note: Tools are NOT cleared to support React StrictMode revive()
    */
   dispose() {
+    if (this._isDisposed) {
+      return;
+    }
+    this._isDisposed = true;
     for (const [_id, pending] of this.pendingApprovals) {
       pending.resolve({ approved: false });
     }
     this.pendingApprovals.clear();
-    this.registeredTools.clear();
     this._toolExecutions = [];
   }
+  /**
+   * Revive a disposed instance (for React StrictMode compatibility)
+   * Tools are preserved across dispose/revive cycle
+   */
+  revive() {
+    if (!this._isDisposed) {
+      return;
+    }
+    this._isDisposed = false;
+    this._isCancelled = false;
+    this._maxIterationsReached = false;
+  }
 };
 
 // src/chat/ChatWithTools.ts
@@ -1352,13 +1416,11 @@ var ChatWithTools = class {
   wireEvents() {
     this.debug("Wiring up toolCalls event handler");
     this.chat.on("toolCalls", async (event) => {
-      this.debug("\u{1F3AF} toolCalls event handler FIRED", event);
       const toolCalls = event.toolCalls;
       if (!toolCalls?.length) {
-        this.debug("No tool calls in event");
         return;
       }
-      this.debug("Tool calls received:", toolCalls);
+      this.debug("Tool calls received:", toolCalls.length);
       const toolCallInfos = toolCalls.map((tc) => {
         const tcAny = tc;
         const name = tcAny.function?.name ?? tcAny.name ?? "";
@@ -1563,6 +1625,21 @@ var ChatWithTools = class {
   // ============================================
   // Cleanup
   // ============================================
+  /**
+   * Whether this instance has been disposed
+   */
+  get disposed() {
+    return this.chat.disposed;
+  }
+  /**
+   * Revive a disposed instance (for React StrictMode compatibility)
+   * This allows reusing an instance after dispose() was called,
+   * preserving registered tools and state
+   */
+  revive() {
+    this.chat.revive();
+    this.agentLoop.revive();
+  }
   /**
    * Dispose and cleanup
    */
@@ -1694,6 +1771,12 @@ var ReactChatState = class {
   dispose() {
     this.subscribers.clear();
   }
+  /**
+   * Revive after dispose (for React StrictMode compatibility)
+   * Subscribers will be re-added automatically via useSyncExternalStore
+   */
+  revive() {
+  }
 };
 function createReactChatState(initialMessages) {
   return new ReactChatState(initialMessages);
@@ -1719,6 +1802,13 @@ var ReactChatWithTools = class extends ChatWithTools {
     super.dispose();
     this.reactState.dispose();
   }
+  /**
+   * Revive a disposed instance (for React StrictMode compatibility)
+   */
+  revive() {
+    super.revive();
+    this.reactState.revive();
+  }
 };
 
 // src/react/utils/context-tree.ts
@@ -1830,6 +1920,10 @@ function CopilotProvider({
   }, [toolsConfig]);
   const [toolExecutions, setToolExecutions] = react.useState([]);
   const chatRef = react.useRef(null);
+  if (chatRef.current !== null && chatRef.current.disposed) {
+    chatRef.current.revive();
+    debugLog("Revived disposed instance (React StrictMode)");
+  }
   if (chatRef.current === null) {
     const uiInitialMessages = initialMessages?.map(
       (m) => ({
@@ -2164,17 +2258,17 @@ function useAITools(options = {}) {
   const rememberedConsentRef = react.useRef(/* @__PURE__ */ new Set());
   react.useEffect(() => {
     if (!autoStart || !isEnabled) return;
-    if (consoleCapture && !chunkCVKN4H62_cjs.isConsoleCaptureActive()) {
-      chunkCVKN4H62_cjs.startConsoleCapture(consoleOptions);
+    if (consoleCapture && !chunk4PRWNAXQ_cjs.isConsoleCaptureActive()) {
+      chunk4PRWNAXQ_cjs.startConsoleCapture(consoleOptions);
       setActiveCaptures((prev) => ({ ...prev, console: true }));
     }
-    if (network && !chunkCVKN4H62_cjs.isNetworkCaptureActive()) {
-      chunkCVKN4H62_cjs.startNetworkCapture(networkOptions);
+    if (network && !chunk4PRWNAXQ_cjs.isNetworkCaptureActive()) {
+      chunk4PRWNAXQ_cjs.startNetworkCapture(networkOptions);
       setActiveCaptures((prev) => ({ ...prev, network: true }));
     }
     return () => {
-      chunkCVKN4H62_cjs.stopConsoleCapture();
-      chunkCVKN4H62_cjs.stopNetworkCapture();
+      chunk4PRWNAXQ_cjs.stopConsoleCapture();
+      chunk4PRWNAXQ_cjs.stopNetworkCapture();
     };
   }, [
     autoStart,
@@ -2189,12 +2283,12 @@ function useAITools(options = {}) {
       if (!screenshot) {
         throw new Error("Screenshot capture is not enabled");
       }
-      if (!chunkCVKN4H62_cjs.isScreenshotSupported()) {
+      if (!chunk4PRWNAXQ_cjs.isScreenshotSupported()) {
         throw new Error(
           "Screenshot capture is not supported in this environment"
         );
       }
-      return chunkCVKN4H62_cjs.captureScreenshot({ ...screenshotOptions, ...opts });
+      return chunk4PRWNAXQ_cjs.captureScreenshot({ ...screenshotOptions, ...opts });
     },
     [screenshot, screenshotOptions]
   );
@@ -2203,7 +2297,7 @@ function useAITools(options = {}) {
       if (!consoleCapture) {
         return { logs: [], totalCaptured: 0 };
       }
-      return chunkCVKN4H62_cjs.getConsoleLogs({ ...consoleOptions, ...opts });
+      return chunk4PRWNAXQ_cjs.getConsoleLogs({ ...consoleOptions, ...opts });
     },
     [consoleCapture, consoleOptions]
   );
@@ -2212,7 +2306,7 @@ function useAITools(options = {}) {
       if (!network) {
         return { requests: [], totalCaptured: 0 };
       }
-      return chunkCVKN4H62_cjs.getNetworkRequests({ ...networkOptions, ...opts });
+      return chunk4PRWNAXQ_cjs.getNetworkRequests({ ...networkOptions, ...opts });
     },
     [network, networkOptions]
   );
@@ -2305,23 +2399,23 @@ function useAITools(options = {}) {
     ]
   );
   const startCapturing = react.useCallback(() => {
-    if (consoleCapture && !chunkCVKN4H62_cjs.isConsoleCaptureActive()) {
-      chunkCVKN4H62_cjs.startConsoleCapture(consoleOptions);
+    if (consoleCapture && !chunk4PRWNAXQ_cjs.isConsoleCaptureActive()) {
+      chunk4PRWNAXQ_cjs.startConsoleCapture(consoleOptions);
       setActiveCaptures((prev) => ({ ...prev, console: true }));
     }
-    if (network && !chunkCVKN4H62_cjs.isNetworkCaptureActive()) {
-      chunkCVKN4H62_cjs.startNetworkCapture(networkOptions);
+    if (network && !chunk4PRWNAXQ_cjs.isNetworkCaptureActive()) {
+      chunk4PRWNAXQ_cjs.startNetworkCapture(networkOptions);
       setActiveCaptures((prev) => ({ ...prev, network: true }));
     }
   }, [consoleCapture, network, consoleOptions, networkOptions]);
   const stopCapturing = react.useCallback(() => {
-    chunkCVKN4H62_cjs.stopConsoleCapture();
-    chunkCVKN4H62_cjs.stopNetworkCapture();
+    chunk4PRWNAXQ_cjs.stopConsoleCapture();
+    chunk4PRWNAXQ_cjs.stopNetworkCapture();
     setActiveCaptures({ console: false, network: false });
   }, []);
   const clearCaptured = react.useCallback(() => {
-    chunkCVKN4H62_cjs.clearConsoleLogs();
-    chunkCVKN4H62_cjs.clearNetworkRequests();
+    chunk4PRWNAXQ_cjs.clearConsoleLogs();
+    chunk4PRWNAXQ_cjs.clearNetworkRequests();
   }, []);
   const formatForAI = react.useCallback((context) => {
     const parts = [];
@@ -2331,16 +2425,16 @@ function useAITools(options = {}) {
       );
     }
     if (context.consoleLogs && context.consoleLogs.logs.length > 0) {
-      parts.push(chunkCVKN4H62_cjs.formatLogsForAI(context.consoleLogs.logs));
+      parts.push(chunk4PRWNAXQ_cjs.formatLogsForAI(context.consoleLogs.logs));
     }
     if (context.networkRequests && context.networkRequests.requests.length > 0) {
-      parts.push(chunkCVKN4H62_cjs.formatRequestsForAI(context.networkRequests.requests));
+      parts.push(chunk4PRWNAXQ_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 = chunkCVKN4H62_cjs.detectIntent(message);
+      const result = chunk4PRWNAXQ_cjs.detectIntent(message);
       result.suggestedTools = result.suggestedTools.filter((tool) => {
         if (tool === "screenshot") return screenshot;
         if (tool === "console") return consoleCapture;
@@ -2437,16 +2531,6 @@ function useTools(tools) {
     };
   }, [toolsKey]);
 }
-var CopilotContext2 = react.createContext(null);
-function useCopilotContext() {
-  const context = react.useContext(CopilotContext2);
-  if (!context) {
-    throw new Error("useCopilotContext must be used within a CopilotProvider");
-  }
-  return context;
-}
-
-// src/react/hooks/useToolWithSchema.ts
 function convertZodSchema(schema, _toolName) {
   try {
     const zodWithJsonSchema = z__namespace;
@@ -2464,10 +2548,10 @@ function convertZodSchema(schema, _toolName) {
     }
   } catch {
   }
-  return chunkCVKN4H62_cjs.zodObjectToInputSchema(schema);
+  return chunk4PRWNAXQ_cjs.zodObjectToInputSchema(schema);
 }
 function useToolWithSchema(config, dependencies = []) {
-  const { registerTool, unregisterTool } = useCopilotContext();
+  const { registerTool, unregisterTool } = useCopilot();
   const configRef = react.useRef(config);
   configRef.current = config;
   const inputSchema = react.useMemo(() => {
@@ -2503,7 +2587,7 @@ function useToolWithSchema(config, dependencies = []) {
   }, [config.name, inputSchema, ...dependencies]);
 }
 function useToolsWithSchema(tools, dependencies = []) {
-  const { registerTool, unregisterTool } = useCopilotContext();
+  const { registerTool, unregisterTool } = useCopilot();
   const toolsRef = react.useRef(tools);
   toolsRef.current = tools;
   react.useEffect(() => {
@@ -2545,6 +2629,16 @@ function useToolsWithSchema(tools, dependencies = []) {
     };
   }, [tools.map((t) => t.name).join(","), ...dependencies]);
 }
+var CopilotContext2 = react.createContext(null);
+function useCopilotContext() {
+  const context = react.useContext(CopilotContext2);
+  if (!context) {
+    throw new Error("useCopilotContext must be used within a CopilotProvider");
+  }
+  return context;
+}
+
+// src/react/hooks/useToolExecutor.ts
 function useToolExecutor() {
   const {
     registeredTools,
@@ -2762,7 +2856,7 @@ function useAgent(options) {
         if (!response.ok) {
           throw new Error(`Agent error: ${response.status}`);
         }
-        for await (const event of chunkCVKN4H62_cjs.streamSSE(response)) {
+        for await (const event of chunk4PRWNAXQ_cjs.streamSSE(response)) {
           handleAgentEvent(event);
         }
       } catch (err) {
@@ -2885,7 +2979,7 @@ function formatKnowledgeResultsForAI(results) {
 
 // src/react/hooks/useKnowledgeBase.ts
 function useKnowledgeBase(config) {
-  const { registerTool, unregisterTool } = useCopilotContext();
+  const { registerTool, unregisterTool } = useCopilot();
   const configRef = react.useRef(config);
   configRef.current = config;
   const handleSearch = react.useCallback(
@@ -3256,7 +3350,7 @@ function createReactThreadManagerState(initialThreads) {
 }
 
 // src/react/internal/ReactThreadManager.ts
-var _ReactThreadManager = class _ReactThreadManager extends chunkCVKN4H62_cjs.ThreadManager {
+var _ReactThreadManager = class _ReactThreadManager extends chunk4PRWNAXQ_cjs.ThreadManager {
   constructor(config = {}, callbacks = {}) {
     const reactState = new ReactThreadManagerState();
     super({ ...config, state: reactState }, callbacks);
@@ -3689,6 +3783,13 @@ var ReactChat = class extends AbstractChat {
     super.dispose();
     this.reactState.dispose();
   }
+  /**
+   * Revive a disposed instance (for React StrictMode compatibility)
+   */
+  revive() {
+    super.revive();
+    this.reactState.revive();
+  }
 };
 function createReactChat(config) {
   return new ReactChat(config);
@@ -3696,6 +3797,9 @@ function createReactChat(config) {
 function useChat(config) {
   const chatRef = react.useRef(null);
   const [input, setInput] = react.useState("");
+  if (chatRef.current !== null && chatRef.current.disposed) {
+    chatRef.current.revive();
+  }
   if (chatRef.current === null) {
     chatRef.current = createReactChat({
       runtimeUrl: config.runtimeUrl,
@@ -3816,5 +3920,5 @@ exports.useToolExecutor = useToolExecutor;
 exports.useToolWithSchema = useToolWithSchema;
 exports.useTools = useTools;
 exports.useToolsWithSchema = useToolsWithSchema;
-//# sourceMappingURL=chunk-FCWLHNLI.cjs.map
-//# sourceMappingURL=chunk-FCWLHNLI.cjs.map
+//# sourceMappingURL=chunk-BLSI67J6.cjs.map
+//# sourceMappingURL=chunk-BLSI67J6.cjs.map