@yourgpt/copilot-sdk 2.1.1 → 2.1.3

package/dist/{chunk-5UMM5VYB.cjs → chunk-R6LKHKAI.cjs}

@@ -1,6 +1,6 @@
 'use strict';
 
-var chunk33JSFVGH_cjs = require('./chunk-33JSFVGH.cjs');
+var chunkWQSK3Z4K_cjs = require('./chunk-WQSK3Z4K.cjs');
 var chunkJGPDQDY4_cjs = require('./chunk-JGPDQDY4.cjs');
 var react = require('react');
 var jsxRuntime = require('react/jsx-runtime');
@@ -183,7 +183,8 @@ function processStreamChunk(chunk, state) {
       newResults.set(chunk.id, {
         id: chunk.id,
         name: chunk.name,
-        status: "executing"
+        status: "executing",
+        hidden: chunk.hidden
       });
       return { ...state, toolResults: newResults };
     }
@@ -383,17 +384,11 @@ var HttpTransport = class {
     this.abortController = new AbortController();
     this.streaming = true;
     try {
-      console.log(
-        "[HttpTransport] Config headers type:",
-        typeof this.config.headers
-      );
-      console.log("[HttpTransport] Config headers:", this.config.headers);
       const resolved = await resolveValues({
         url: this.config.url,
         headers: this.config.headers ?? {},
         configBody: this.config.body ?? {}
       });
-      console.log("[HttpTransport] Resolved headers:", resolved.headers);
       const response = await fetch(resolved.url, {
         method: "POST",
         headers: {
@@ -549,16 +544,16 @@ var HttpTransport = class {
 };
 
 // src/chat/classes/AbstractChat.ts
-function buildToolResultContentForAI(result, tool, args) {
+function buildToolResultContentForAI(result, tool2, args) {
   if (typeof result === "string") return result;
   const typedResult = result;
-  const responseMode = typedResult?._aiResponseMode ?? tool?.aiResponseMode ?? "full";
+  const responseMode = typedResult?._aiResponseMode ?? tool2?.aiResponseMode ?? "full";
   if (typedResult?._aiContent) {
     return JSON.stringify(typedResult._aiContent);
   }
   let aiContext = typedResult?._aiContext;
-  if (!aiContext && tool?.aiContext) {
-    aiContext = typeof tool.aiContext === "function" ? tool.aiContext(typedResult, args ?? {}) : tool.aiContext;
+  if (!aiContext && tool2?.aiContext) {
+    aiContext = typeof tool2.aiContext === "function" ? tool2.aiContext(typedResult, args ?? {}) : tool2.aiContext;
   }
   switch (responseMode) {
     case "none":
@@ -914,10 +909,10 @@ var AbstractChat = class {
    * Build the request payload
    */
   buildRequest() {
-    const tools = this.config.tools?.filter((tool) => tool.available !== false).map((tool) => ({
-      name: tool.name,
-      description: tool.description,
-      inputSchema: tool.inputSchema
+    const tools = this.config.tools?.filter((tool2) => tool2.available !== false).map((tool2) => ({
+      name: tool2.name,
+      description: tool2.description,
+      inputSchema: tool2.inputSchema
     }));
     const toolCallMap = /* @__PURE__ */ new Map();
     for (const msg of this.state.messages) {
@@ -934,11 +929,11 @@ var AbstractChat = class {
     }
     const toolDefMap = /* @__PURE__ */ new Map();
     if (this.config.tools) {
-      for (const tool of this.config.tools) {
-        toolDefMap.set(tool.name, {
-          name: tool.name,
-          aiResponseMode: tool.aiResponseMode,
-          aiContext: tool.aiContext
+      for (const tool2 of this.config.tools) {
+        toolDefMap.set(tool2.name, {
+          name: tool2.name,
+          aiResponseMode: tool2.aiResponseMode,
+          aiContext: tool2.aiContext
         });
       }
     }
@@ -1010,7 +1005,70 @@ ${this.dynamicContext}`.trim() : this.config.systemPrompt,
         this.handleError(error);
         return;
       }
+      if (chunk.type === "message:end" && this.streamState?.content) {
+        this.debug("message:end mid-stream - finalizing current turn");
+        const turnMessage = streamStateToMessage(this.streamState);
+        const toolCallsHidden = {};
+        for (const [id, result] of this.streamState.toolResults) {
+          if (result.hidden !== void 0) {
+            toolCallsHidden[id] = result.hidden;
+          }
+        }
+        if (turnMessage.toolCalls?.length && Object.keys(toolCallsHidden).length > 0) {
+          turnMessage.metadata = {
+            ...turnMessage.metadata,
+            toolCallsHidden
+          };
+        }
+        this.state.updateMessageById(
+          this.streamState.messageId,
+          () => turnMessage
+        );
+        this.callbacks.onMessageFinish?.(turnMessage);
+        this.streamState = null;
+        continue;
+      }
+      if (chunk.type === "message:start" && this.streamState === null) {
+        this.debug("message:start after mid-stream end - creating new message");
+        const newMessage = createEmptyAssistantMessage();
+        this.state.pushMessage(newMessage);
+        this.streamState = createStreamState(newMessage.id);
+        this.callbacks.onMessageStart?.(newMessage.id);
+        continue;
+      }
+      if (!this.streamState) {
+        this.debug("warning", "streamState is null, skipping chunk");
+        continue;
+      }
       this.streamState = processStreamChunk(chunk, this.streamState);
+      if (chunk.type === "action:start") {
+        this.callbacks.onServerToolStart?.({
+          id: chunk.id,
+          name: chunk.name,
+          hidden: chunk.hidden
+        });
+      } else if (chunk.type === "action:args") {
+        let args = {};
+        try {
+          args = JSON.parse(chunk.args);
+        } catch {
+        }
+        const existingResult = this.streamState?.toolResults.get(chunk.id);
+        if (existingResult) {
+          this.callbacks.onServerToolArgs?.({
+            id: chunk.id,
+            name: existingResult.name,
+            args
+          });
+        }
+      } else if (chunk.type === "action:end") {
+        this.callbacks.onServerToolEnd?.({
+          id: chunk.id,
+          name: chunk.name,
+          result: chunk.result,
+          error: chunk.error
+        });
+      }
       const updatedMessage = streamStateToMessage(this.streamState);
       this.state.updateMessageById(
         this.streamState.messageId,
@@ -1026,19 +1084,68 @@ ${this.dynamicContext}`.trim() : this.config.systemPrompt,
       }
       if (isStreamDone(chunk)) {
         this.debug("streamDone", { chunk });
+        if (chunk.type === "done" && chunk.messages?.length) {
+          this.debug("processDoneMessages", {
+            count: chunk.messages.length
+          });
+          const toolCallsHidden = {};
+          if (this.streamState?.toolResults) {
+            for (const [id, result] of this.streamState.toolResults) {
+              if (result.hidden !== void 0) {
+                toolCallsHidden[id] = result.hidden;
+              }
+            }
+          }
+          for (const msg of chunk.messages) {
+            if (msg.role === "assistant") {
+              continue;
+            }
+            let metadata;
+            if (msg.role === "assistant" && msg.tool_calls?.length && Object.keys(toolCallsHidden).length > 0) {
+              metadata = { toolCallsHidden };
+            }
+            const message = {
+              id: generateMessageId(),
+              role: msg.role,
+              content: msg.content ?? "",
+              toolCalls: msg.tool_calls,
+              toolCallId: msg.tool_call_id,
+              createdAt: /* @__PURE__ */ new Date(),
+              metadata
+            };
+            this.state.pushMessage(message);
+          }
+        }
         break;
       }
     }
     this.debug("handleStreamResponse", `Processed ${chunkCount} chunks`);
-    const finalMessage = streamStateToMessage(this.streamState);
-    this.state.updateMessageById(
-      this.streamState.messageId,
-      () => finalMessage
-    );
-    if (!finalMessage.content && (!finalMessage.toolCalls || finalMessage.toolCalls.length === 0)) {
-      this.debug("warning", "Empty response - no content and no tool calls");
+    if (!this.streamState) {
+      this.debug("streamState already finalized via message:end");
+    } else {
+      const toolCallsHidden = {};
+      if (this.streamState.toolResults) {
+        for (const [id, result] of this.streamState.toolResults) {
+          if (result.hidden !== void 0) {
+            toolCallsHidden[id] = result.hidden;
+          }
+        }
+      }
+      const finalMessage = streamStateToMessage(this.streamState);
+      if (finalMessage.toolCalls?.length && Object.keys(toolCallsHidden).length > 0) {
+        finalMessage.metadata = {
+          ...finalMessage.metadata,
+          toolCallsHidden
+        };
+      }
+      this.state.updateMessageById(
+        this.streamState.messageId,
+        () => finalMessage
+      );
+      if (!finalMessage.content && (!finalMessage.toolCalls || finalMessage.toolCalls.length === 0)) {
+        this.debug("warning", "Empty response - no content and no tool calls");
+      }
     }
-    this.callbacks.onMessageFinish?.(finalMessage);
     this.callbacks.onMessagesChange?.(this.state.messages);
     if (!toolCallsEmitted) {
       this.state.status = "ready";
@@ -1052,13 +1159,37 @@ ${this.dynamicContext}`.trim() : this.config.systemPrompt,
    * Handle JSON (non-streaming) response
    */
   handleJsonResponse(response) {
+    const toolCallHiddenMap = /* @__PURE__ */ new Map();
+    if (response.toolCalls) {
+      for (const tc of response.toolCalls) {
+        if (tc.hidden !== void 0) {
+          toolCallHiddenMap.set(tc.id, tc.hidden);
+        }
+      }
+    }
     for (const msg of response.messages ?? []) {
+      let metadata;
+      if (msg.role === "assistant" && msg.tool_calls && toolCallHiddenMap.size > 0) {
+        const toolCallsHidden = {};
+        for (const tc of msg.tool_calls) {
+          const hidden = toolCallHiddenMap.get(tc.id);
+          if (hidden !== void 0) {
+            toolCallsHidden[tc.id] = hidden;
+          }
+        }
+        if (Object.keys(toolCallsHidden).length > 0) {
+          metadata = { toolCallsHidden };
+        }
+      }
       const message = {
         id: generateMessageId(),
         role: msg.role,
         content: msg.content ?? "",
         toolCalls: msg.tool_calls,
-        createdAt: /* @__PURE__ */ new Date()
+        // CRITICAL: Preserve toolCallId for tool messages (fixes Anthropic API errors)
+        toolCallId: msg.tool_call_id,
+        createdAt: /* @__PURE__ */ new Date(),
+        metadata
       };
       this.state.pushMessage(message);
     }
@@ -1159,8 +1290,8 @@ var AbstractAgentLoop = class {
     this._maxIterations = config.maxIterations ?? 20;
     this._maxExecutionHistory = config.maxExecutionHistory ?? 100;
     if (config.tools) {
-      for (const tool of config.tools) {
-        this.registerTool(tool);
+      for (const tool2 of config.tools) {
+        this.registerTool(tool2);
       }
     }
   }
@@ -1219,6 +1350,12 @@ var AbstractAgentLoop = class {
     this._isProcessing = processing;
   }
   addToolExecution(execution) {
+    const existingIndex = this._toolExecutions.findIndex(
+      (e) => e.id === execution.id
+    );
+    if (existingIndex !== -1) {
+      return;
+    }
     this._toolExecutions = [...this._toolExecutions, execution];
     if (this._toolExecutions.length > this._maxExecutionHistory) {
       this._toolExecutions = this._toolExecutions.slice(
@@ -1227,6 +1364,9 @@ var AbstractAgentLoop = class {
     }
     this.callbacks.onExecutionsChange?.(this._toolExecutions);
   }
+  /**
+   * Update a tool execution with partial data
+   */
   updateToolExecution(id, update) {
     this._toolExecutions = this._toolExecutions.map(
       (exec) => exec.id === id ? { ...exec, ...update } : exec
@@ -1240,15 +1380,15 @@ var AbstractAgentLoop = class {
    * Register a tool (reference counted for React StrictMode compatibility)
    * Tools are never fully removed - ref counting ensures StrictMode works correctly
    */
-  registerTool(tool) {
-    const existing = this.registeredTools.get(tool.name);
+  registerTool(tool2) {
+    const existing = this.registeredTools.get(tool2.name);
     if (existing) {
-      existing.tool = tool;
+      existing.tool = tool2;
       existing.refCount++;
       existing.active = true;
     } else {
-      this.registeredTools.set(tool.name, {
-        tool,
+      this.registeredTools.set(tool2.name, {
+        tool: tool2,
         refCount: 1,
         active: true
       });
@@ -1314,7 +1454,7 @@ var AbstractAgentLoop = class {
    * Execute a single tool
    */
   async executeSingleTool(toolCall) {
-    const tool = this.getTool(toolCall.name);
+    const tool2 = this.getTool(toolCall.name);
     const execution = {
       id: toolCall.id,
       toolCallId: toolCall.id,
@@ -1322,11 +1462,12 @@ var AbstractAgentLoop = class {
       args: toolCall.args,
       status: "pending",
       approvalStatus: "none",
-      startedAt: /* @__PURE__ */ new Date()
+      startedAt: /* @__PURE__ */ new Date(),
+      hidden: tool2?.hidden
     };
     this.addToolExecution(execution);
     this.callbacks.onToolStart?.(execution);
-    if (!tool) {
+    if (!tool2) {
       const errorResult = {
         toolCallId: toolCall.id,
         success: false,
@@ -1340,8 +1481,8 @@ var AbstractAgentLoop = class {
       return errorResult;
     }
     let approvalData;
-    if (tool.needsApproval && !this.config.autoApprove) {
-      const approvalMessage = typeof tool.approvalMessage === "function" ? tool.approvalMessage(toolCall.args) : tool.approvalMessage;
+    if (tool2.needsApproval && !this.config.autoApprove) {
+      const approvalMessage = typeof tool2.approvalMessage === "function" ? tool2.approvalMessage(toolCall.args) : tool2.approvalMessage;
       execution.approvalStatus = "required";
       execution.approvalMessage = approvalMessage;
       this.updateToolExecution(toolCall.id, {
@@ -1368,13 +1509,13 @@ var AbstractAgentLoop = class {
     }
     this.updateToolExecution(toolCall.id, { status: "executing" });
     try {
-      if (!tool.handler) {
+      if (!tool2.handler) {
         throw new Error(`Tool "${toolCall.name}" has no handler`);
       }
       if (this._isCancelled || this.abortController?.signal.aborted) {
         throw new Error("Tool execution cancelled");
       }
-      const result = await tool.handler(toolCall.args, {
+      const result = await tool2.handler(toolCall.args, {
         signal: this.abortController?.signal,
         data: { toolCallId: toolCall.id },
         approvalData
@@ -1458,6 +1599,43 @@ var AbstractAgentLoop = class {
     this.setIteration(0);
     this._maxIterationsReached = false;
   }
+  // ============================================
+  // Server-Side Tool Tracking
+  // ============================================
+  /**
+   * Add a server-side tool execution (from streaming action:start event)
+   * Used to track tools executed on the server (not client-side)
+   */
+  addServerToolExecution(info) {
+    const execution = {
+      id: info.id,
+      toolCallId: info.id,
+      name: info.name,
+      args: {},
+      status: "executing",
+      approvalStatus: "none",
+      startedAt: /* @__PURE__ */ new Date(),
+      hidden: info.hidden
+    };
+    this.addToolExecution(execution);
+  }
+  /**
+   * Update a server-side tool execution with args (from action:args event)
+   */
+  updateServerToolArgs(id, args) {
+    this.updateToolExecution(id, { args });
+  }
+  /**
+   * Complete a server-side tool execution (from action:end event)
+   */
+  completeServerToolExecution(info) {
+    this.updateToolExecution(info.id, {
+      status: info.error ? "failed" : "completed",
+      result: info.result,
+      error: info.error,
+      completedAt: /* @__PURE__ */ new Date()
+    });
+  }
   /**
    * Cancel all pending and executing tools
    * This will:
@@ -1599,7 +1777,59 @@ var ChatWithTools = class {
         onMessageDelta: callbacks.onMessageDelta,
         onMessageFinish: callbacks.onMessageFinish,
         onToolCalls: callbacks.onToolCalls,
-        onFinish: callbacks.onFinish
+        onFinish: callbacks.onFinish,
+        // Server-side tool callbacks - track in agentLoop for UI display
+        // IMPORTANT: Only track tools that are NOT registered client-side
+        // Client-side tools are tracked via executeToolCalls() path
+        onServerToolStart: (info) => {
+          const existingExecution = this.agentLoop.toolExecutions.find(
+            (e) => e.id === info.id
+          );
+          if (existingExecution) {
+            if (info.hidden !== void 0 && existingExecution.hidden !== info.hidden) {
+              this.debug(
+                "Updating hidden flag for existing execution:",
+                info.name,
+                info.hidden
+              );
+              this.agentLoop.updateToolExecution(info.id, {
+                hidden: info.hidden
+              });
+            }
+            return;
+          }
+          const isClientTool = this.agentLoop.tools.some(
+            (t) => t.name === info.name && t.location === "client"
+          );
+          if (isClientTool) {
+            this.debug("Skipping server tracking for client tool:", info.name);
+            return;
+          }
+          this.debug("Server tool started:", info.name, {
+            hidden: info.hidden,
+            id: info.id
+          });
+          this.agentLoop.addServerToolExecution(info);
+        },
+        onServerToolArgs: (info) => {
+          const isClientTool = this.agentLoop.tools.some(
+            (t) => t.name === info.name && t.location === "client"
+          );
+          if (isClientTool) return;
+          this.debug("Server tool args:", info.name, info.args);
+          this.agentLoop.updateServerToolArgs(info.id, info.args ?? {});
+        },
+        onServerToolEnd: (info) => {
+          const isClientTool = this.agentLoop.tools.some(
+            (t) => t.name === info.name && t.location === "client"
+          );
+          if (isClientTool) return;
+          this.debug("Server tool ended:", info.name, {
+            error: info.error,
+            hasResult: !!info.result
+          });
+          this.agentLoop.completeServerToolExecution(info);
+        }
       }
     });
     this.wireEvents();
@@ -1796,8 +2026,8 @@ var ChatWithTools = class {
   /**
    * Register a tool
    */
-  registerTool(tool) {
-    this.agentLoop.registerTool(tool);
+  registerTool(tool2) {
+    this.agentLoop.registerTool(tool2);
     this.chat.setTools(this.agentLoop.tools);
   }
   /**
@@ -2265,7 +2495,7 @@ function useMCPTools(config) {
       return [];
     }
     return mcpClient.state.tools.map(
-      (tool) => toolAdapter.toToolDefinition(tool, {
+      (tool2) => toolAdapter.toToolDefinition(tool2, {
         prefix: prefixToolNames,
         asServerTool: true,
         // MCP tools execute remotely
@@ -2294,9 +2524,9 @@ function useMCPTools(config) {
     }
     registeredToolsRef.current = [];
     if (mcpClient.isConnected && toolDefinitions.length > 0) {
-      for (const tool of toolDefinitions) {
-        registerTool(tool);
-        registeredToolsRef.current.push(tool.name);
+      for (const tool2 of toolDefinitions) {
+        registerTool(tool2);
+        registeredToolsRef.current.push(tool2.name);
       }
     }
     return () => {
@@ -2453,8 +2683,8 @@ function CopilotProvider({
   );
   const error = errorFromChat ?? null;
   const isLoading = status === "streaming" || status === "submitted";
-  const registerTool = react.useCallback((tool) => {
-    chatRef.current?.registerTool(tool);
+  const registerTool = react.useCallback((tool2) => {
+    chatRef.current?.registerTool(tool2);
   }, []);
   const unregisterTool = react.useCallback((name) => {
     chatRef.current?.unregisterTool(name);
@@ -2729,17 +2959,17 @@ function useAITools(options = {}) {
   const rememberedConsentRef = react.useRef(/* @__PURE__ */ new Set());
   react.useEffect(() => {
     if (!autoStart || !isEnabled) return;
-    if (consoleCapture && !chunk33JSFVGH_cjs.isConsoleCaptureActive()) {
-      chunk33JSFVGH_cjs.startConsoleCapture(consoleOptions);
+    if (consoleCapture && !chunkWQSK3Z4K_cjs.isConsoleCaptureActive()) {
+      chunkWQSK3Z4K_cjs.startConsoleCapture(consoleOptions);
       setActiveCaptures((prev) => ({ ...prev, console: true }));
     }
-    if (network && !chunk33JSFVGH_cjs.isNetworkCaptureActive()) {
-      chunk33JSFVGH_cjs.startNetworkCapture(networkOptions);
+    if (network && !chunkWQSK3Z4K_cjs.isNetworkCaptureActive()) {
+      chunkWQSK3Z4K_cjs.startNetworkCapture(networkOptions);
       setActiveCaptures((prev) => ({ ...prev, network: true }));
     }
     return () => {
-      chunk33JSFVGH_cjs.stopConsoleCapture();
-      chunk33JSFVGH_cjs.stopNetworkCapture();
+      chunkWQSK3Z4K_cjs.stopConsoleCapture();
+      chunkWQSK3Z4K_cjs.stopNetworkCapture();
     };
   }, [
     autoStart,
@@ -2754,12 +2984,12 @@ function useAITools(options = {}) {
       if (!screenshot) {
         throw new Error("Screenshot capture is not enabled");
       }
-      if (!chunk33JSFVGH_cjs.isScreenshotSupported()) {
+      if (!chunkWQSK3Z4K_cjs.isScreenshotSupported()) {
         throw new Error(
           "Screenshot capture is not supported in this environment"
         );
       }
-      return chunk33JSFVGH_cjs.captureScreenshot({ ...screenshotOptions, ...opts });
+      return chunkWQSK3Z4K_cjs.captureScreenshot({ ...screenshotOptions, ...opts });
     },
     [screenshot, screenshotOptions]
   );
@@ -2768,7 +2998,7 @@ function useAITools(options = {}) {
       if (!consoleCapture) {
         return { logs: [], totalCaptured: 0 };
       }
-      return chunk33JSFVGH_cjs.getConsoleLogs({ ...consoleOptions, ...opts });
+      return chunkWQSK3Z4K_cjs.getConsoleLogs({ ...consoleOptions, ...opts });
     },
     [consoleCapture, consoleOptions]
   );
@@ -2777,16 +3007,16 @@ function useAITools(options = {}) {
       if (!network) {
         return { requests: [], totalCaptured: 0 };
       }
-      return chunk33JSFVGH_cjs.getNetworkRequests({ ...networkOptions, ...opts });
+      return chunkWQSK3Z4K_cjs.getNetworkRequests({ ...networkOptions, ...opts });
     },
     [network, networkOptions]
   );
   const requestConsent = react.useCallback(
     async (tools, reason = "") => {
-      const enabledTools = tools.filter((tool) => {
-        if (tool === "screenshot") return screenshot;
-        if (tool === "console") return consoleCapture;
-        if (tool === "network") return network;
+      const enabledTools = tools.filter((tool2) => {
+        if (tool2 === "screenshot") return screenshot;
+        if (tool2 === "console") return consoleCapture;
+        if (tool2 === "network") return network;
         return false;
       });
       if (enabledTools.length === 0) {
@@ -2796,7 +3026,7 @@ function useAITools(options = {}) {
         return { approved: enabledTools, denied: [] };
       }
       const needsConsent = enabledTools.filter(
-        (tool) => !rememberedConsentRef.current.has(tool)
+        (tool2) => !rememberedConsentRef.current.has(tool2)
       );
       if (needsConsent.length === 0) {
         return { approved: enabledTools, denied: [] };
@@ -2810,7 +3040,7 @@ function useAITools(options = {}) {
         const response = await onConsentRequest(request);
         if (response.remember) {
           response.approved.forEach(
-            (tool) => rememberedConsentRef.current.add(tool)
+            (tool2) => rememberedConsentRef.current.add(tool2)
           );
         }
         return response;
@@ -2820,7 +3050,7 @@ function useAITools(options = {}) {
         consentResolverRef.current = (response) => {
           if (response.remember) {
             response.approved.forEach(
-              (tool) => rememberedConsentRef.current.add(tool)
+              (tool2) => rememberedConsentRef.current.add(tool2)
             );
           }
           resolve(response);
@@ -2870,23 +3100,23 @@ function useAITools(options = {}) {
     ]
   );
   const startCapturing = react.useCallback(() => {
-    if (consoleCapture && !chunk33JSFVGH_cjs.isConsoleCaptureActive()) {
-      chunk33JSFVGH_cjs.startConsoleCapture(consoleOptions);
+    if (consoleCapture && !chunkWQSK3Z4K_cjs.isConsoleCaptureActive()) {
+      chunkWQSK3Z4K_cjs.startConsoleCapture(consoleOptions);
       setActiveCaptures((prev) => ({ ...prev, console: true }));
     }
-    if (network && !chunk33JSFVGH_cjs.isNetworkCaptureActive()) {
-      chunk33JSFVGH_cjs.startNetworkCapture(networkOptions);
+    if (network && !chunkWQSK3Z4K_cjs.isNetworkCaptureActive()) {
+      chunkWQSK3Z4K_cjs.startNetworkCapture(networkOptions);
       setActiveCaptures((prev) => ({ ...prev, network: true }));
     }
   }, [consoleCapture, network, consoleOptions, networkOptions]);
   const stopCapturing = react.useCallback(() => {
-    chunk33JSFVGH_cjs.stopConsoleCapture();
-    chunk33JSFVGH_cjs.stopNetworkCapture();
+    chunkWQSK3Z4K_cjs.stopConsoleCapture();
+    chunkWQSK3Z4K_cjs.stopNetworkCapture();
     setActiveCaptures({ console: false, network: false });
   }, []);
   const clearCaptured = react.useCallback(() => {
-    chunk33JSFVGH_cjs.clearConsoleLogs();
-    chunk33JSFVGH_cjs.clearNetworkRequests();
+    chunkWQSK3Z4K_cjs.clearConsoleLogs();
+    chunkWQSK3Z4K_cjs.clearNetworkRequests();
   }, []);
   const formatForAI = react.useCallback((context) => {
     const parts = [];
@@ -2896,20 +3126,20 @@ function useAITools(options = {}) {
       );
     }
     if (context.consoleLogs && context.consoleLogs.logs.length > 0) {
-      parts.push(chunk33JSFVGH_cjs.formatLogsForAI(context.consoleLogs.logs));
+      parts.push(chunkWQSK3Z4K_cjs.formatLogsForAI(context.consoleLogs.logs));
     }
     if (context.networkRequests && context.networkRequests.requests.length > 0) {
-      parts.push(chunk33JSFVGH_cjs.formatRequestsForAI(context.networkRequests.requests));
+      parts.push(chunkWQSK3Z4K_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 = chunk33JSFVGH_cjs.detectIntent(message);
-      result.suggestedTools = result.suggestedTools.filter((tool) => {
-        if (tool === "screenshot") return screenshot;
-        if (tool === "console") return consoleCapture;
-        if (tool === "network") return network;
+      const result = chunkWQSK3Z4K_cjs.detectIntent(message);
+      result.suggestedTools = result.suggestedTools.filter((tool2) => {
+        if (tool2 === "screenshot") return screenshot;
+        if (tool2 === "console") return consoleCapture;
+        if (tool2 === "network") return network;
         return false;
       });
       return result;
@@ -2956,7 +3186,7 @@ function useTool(config, dependencies = []) {
   const configRef = react.useRef(config);
   configRef.current = config;
   react.useEffect(() => {
-    const tool = {
+    const tool2 = {
       name: config.name,
       description: config.description,
       location: "client",
@@ -2970,7 +3200,7 @@ function useTool(config, dependencies = []) {
       approvalMessage: config.approvalMessage,
       hidden: config.hidden
     };
-    registerTool(tool);
+    registerTool(tool2);
     return () => {
       unregisterTool(config.name);
     };
@@ -3020,7 +3250,7 @@ function convertZodSchema(schema, _toolName) {
     }
   } catch {
   }
-  return chunk33JSFVGH_cjs.zodObjectToInputSchema(schema);
+  return chunkWQSK3Z4K_cjs.zodObjectToInputSchema(schema);
 }
 function useToolWithSchema(config, dependencies = []) {
   const { registerTool, unregisterTool } = useCopilot();
@@ -3041,7 +3271,7 @@ function useToolWithSchema(config, dependencies = []) {
     }
   }, [config.schema, config.name]);
   react.useEffect(() => {
-    const tool = {
+    const tool2 = {
       name: config.name,
       description: config.description,
       location: "client",
@@ -3052,7 +3282,7 @@ function useToolWithSchema(config, dependencies = []) {
       render: config.render,
       available: config.available ?? true
     };
-    registerTool(tool);
+    registerTool(tool2);
     return () => {
       unregisterTool(config.name);
     };
@@ -3075,7 +3305,7 @@ function useToolsWithSchema(tools, dependencies = []) {
         );
         inputSchema = { type: "object", properties: {} };
       }
-      const tool = {
+      const tool2 = {
         name: config.name,
         description: config.description,
         location: "client",
@@ -3091,7 +3321,7 @@ function useToolsWithSchema(tools, dependencies = []) {
         },
         available: config.available ?? true
       };
-      registerTool(tool);
+      registerTool(tool2);
       toolNames.push(config.name);
     }
     return () => {
@@ -3123,14 +3353,14 @@ function useToolExecutor() {
   toolsRef.current = registeredTools;
   const executeTool = react.useCallback(
     async (toolCall) => {
-      const tool = toolsRef.current.find((t) => t.name === toolCall.name);
-      if (!tool) {
+      const tool2 = toolsRef.current.find((t) => t.name === toolCall.name);
+      if (!tool2) {
         return {
           success: false,
           error: `Unknown tool: ${toolCall.name}`
         };
       }
-      if (!tool.handler) {
+      if (!tool2.handler) {
         return {
           success: false,
           error: `Tool "${toolCall.name}" has no handler`
@@ -3142,12 +3372,13 @@ function useToolExecutor() {
         args: toolCall.input,
         status: "executing",
         timestamp: Date.now(),
-        approvalStatus: "none"
+        approvalStatus: "none",
+        hidden: tool2.hidden
       };
       addToolExecution?.(execution);
       try {
         const startTime = Date.now();
-        const result = await tool.handler(toolCall.input);
+        const result = await tool2.handler(toolCall.input);
         const duration = Date.now() - startTime;
         updateToolExecution?.(toolCall.id, {
           status: result.success ? "completed" : "error",
@@ -3328,7 +3559,7 @@ function useAgent(options) {
         if (!response.ok) {
           throw new Error(`Agent error: ${response.status}`);
         }
-        for await (const event of chunk33JSFVGH_cjs.streamSSE(response)) {
+        for await (const event of chunkWQSK3Z4K_cjs.streamSSE(response)) {
           handleAgentEvent(event);
         }
       } catch (err) {
@@ -3622,9 +3853,9 @@ function useDevLogger() {
       })
     );
     const pendingApprovalsCount = ctx.pendingApprovals?.length || 0;
-    const registeredTools = (ctx.registeredTools || []).map((tool) => ({
-      name: tool.name,
-      location: tool.location || "client"
+    const registeredTools = (ctx.registeredTools || []).map((tool2) => ({
+      name: tool2.name,
+      location: tool2.location || "client"
     }));
     const registeredActions = (ctx.registeredActions || []).map((action) => ({
       name: action.name
@@ -3822,7 +4053,7 @@ function createReactThreadManagerState(initialThreads) {
 }
 
 // src/react/internal/ReactThreadManager.ts
-var _ReactThreadManager = class _ReactThreadManager extends chunk33JSFVGH_cjs.ThreadManager {
+var _ReactThreadManager = class _ReactThreadManager extends chunkWQSK3Z4K_cjs.ThreadManager {
   constructor(config = {}, callbacks = {}) {
     const reactState = new ReactThreadManagerState();
     super({ ...config, state: reactState }, callbacks);
@@ -4489,5 +4720,5 @@ exports.useToolExecutor = useToolExecutor;
 exports.useToolWithSchema = useToolWithSchema;
 exports.useTools = useTools;
 exports.useToolsWithSchema = useToolsWithSchema;
-//# sourceMappingURL=chunk-5UMM5VYB.cjs.map
-//# sourceMappingURL=chunk-5UMM5VYB.cjs.map
+//# sourceMappingURL=chunk-R6LKHKAI.cjs.map
+//# sourceMappingURL=chunk-R6LKHKAI.cjs.map