@yourgpt/copilot-sdk 2.1.2 → 2.1.3

package/dist/{chunk-VXT2O6R6.js → chunk-DMBFN7KO.js}

@@ -1,4 +1,4 @@
-import { ThreadManager, isConsoleCaptureActive, startConsoleCapture, isNetworkCaptureActive, startNetworkCapture, stopConsoleCapture, stopNetworkCapture, isScreenshotSupported, captureScreenshot, getConsoleLogs, getNetworkRequests, clearConsoleLogs, clearNetworkRequests, formatLogsForAI, formatRequestsForAI, detectIntent, streamSSE, zodObjectToInputSchema } from './chunk-XAC7NTIO.js';
+import { ThreadManager, isConsoleCaptureActive, startConsoleCapture, isNetworkCaptureActive, startNetworkCapture, stopConsoleCapture, stopNetworkCapture, isScreenshotSupported, captureScreenshot, getConsoleLogs, getNetworkRequests, clearConsoleLogs, clearNetworkRequests, formatLogsForAI, formatRequestsForAI, detectIntent, streamSSE, zodObjectToInputSchema } from './chunk-VFV5FVVI.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';
@@ -362,17 +362,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: {
@@ -528,16 +522,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":
@@ -893,10 +887,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) {
@@ -913,11 +907,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
         });
       }
     }
@@ -989,7 +983,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,
@@ -1009,17 +1066,30 @@ ${this.dynamicContext}`.trim() : this.config.systemPrompt,
           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" && !msg.tool_calls?.length && msg.content) {
+            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()
+              createdAt: /* @__PURE__ */ new Date(),
+              metadata
             };
             this.state.pushMessage(message);
           }
@@ -1028,15 +1098,32 @@ ${this.dynamicContext}`.trim() : this.config.systemPrompt,
       }
     }
     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";
@@ -1181,8 +1268,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);
       }
     }
   }
@@ -1241,6 +1328,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(
@@ -1249,6 +1342,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
@@ -1262,15 +1358,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
       });
@@ -1336,7 +1432,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,
@@ -1345,11 +1441,11 @@ var AbstractAgentLoop = class {
       status: "pending",
       approvalStatus: "none",
       startedAt: /* @__PURE__ */ new Date(),
-      hidden: tool?.hidden
+      hidden: tool2?.hidden
     };
     this.addToolExecution(execution);
     this.callbacks.onToolStart?.(execution);
-    if (!tool) {
+    if (!tool2) {
       const errorResult = {
         toolCallId: toolCall.id,
         success: false,
@@ -1363,8 +1459,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, {
@@ -1391,13 +1487,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
@@ -1481,6 +1577,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:
@@ -1622,7 +1755,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();
@@ -1819,8 +2004,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);
   }
   /**
@@ -2288,7 +2473,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
@@ -2317,9 +2502,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 () => {
@@ -2476,8 +2661,8 @@ function CopilotProvider({
   );
   const error = errorFromChat ?? null;
   const isLoading = status === "streaming" || status === "submitted";
-  const registerTool = useCallback((tool) => {
-    chatRef.current?.registerTool(tool);
+  const registerTool = useCallback((tool2) => {
+    chatRef.current?.registerTool(tool2);
   }, []);
   const unregisterTool = useCallback((name) => {
     chatRef.current?.unregisterTool(name);
@@ -2806,10 +2991,10 @@ function useAITools(options = {}) {
   );
   const requestConsent = 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) {
@@ -2819,7 +3004,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: [] };
@@ -2833,7 +3018,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;
@@ -2843,7 +3028,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);
@@ -2929,10 +3114,10 @@ function useAITools(options = {}) {
   const detectIntentFn = useCallback(
     (message) => {
       const result = detectIntent(message);
-      result.suggestedTools = result.suggestedTools.filter((tool) => {
-        if (tool === "screenshot") return screenshot;
-        if (tool === "console") return consoleCapture;
-        if (tool === "network") return network;
+      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;
@@ -2979,7 +3164,7 @@ function useTool(config, dependencies = []) {
   const configRef = useRef(config);
   configRef.current = config;
   useEffect(() => {
-    const tool = {
+    const tool2 = {
       name: config.name,
       description: config.description,
       location: "client",
@@ -2993,7 +3178,7 @@ function useTool(config, dependencies = []) {
       approvalMessage: config.approvalMessage,
       hidden: config.hidden
     };
-    registerTool(tool);
+    registerTool(tool2);
     return () => {
       unregisterTool(config.name);
     };
@@ -3064,7 +3249,7 @@ function useToolWithSchema(config, dependencies = []) {
     }
   }, [config.schema, config.name]);
   useEffect(() => {
-    const tool = {
+    const tool2 = {
       name: config.name,
       description: config.description,
       location: "client",
@@ -3075,7 +3260,7 @@ function useToolWithSchema(config, dependencies = []) {
       render: config.render,
       available: config.available ?? true
     };
-    registerTool(tool);
+    registerTool(tool2);
     return () => {
       unregisterTool(config.name);
     };
@@ -3098,7 +3283,7 @@ function useToolsWithSchema(tools, dependencies = []) {
         );
         inputSchema = { type: "object", properties: {} };
       }
-      const tool = {
+      const tool2 = {
         name: config.name,
         description: config.description,
         location: "client",
@@ -3114,7 +3299,7 @@ function useToolsWithSchema(tools, dependencies = []) {
         },
         available: config.available ?? true
       };
-      registerTool(tool);
+      registerTool(tool2);
       toolNames.push(config.name);
     }
     return () => {
@@ -3146,14 +3331,14 @@ function useToolExecutor() {
   toolsRef.current = registeredTools;
   const executeTool = 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`
@@ -3166,12 +3351,12 @@ function useToolExecutor() {
         status: "executing",
         timestamp: Date.now(),
         approvalStatus: "none",
-        hidden: tool.hidden
+        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",
@@ -3646,9 +3831,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
@@ -4473,5 +4658,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-VXT2O6R6.js.map
-//# sourceMappingURL=chunk-VXT2O6R6.js.map
+//# sourceMappingURL=chunk-DMBFN7KO.js.map
+//# sourceMappingURL=chunk-DMBFN7KO.js.map