@yourgpt/copilot-sdk 2.1.5-alpha.3 → 2.1.5-alpha.5

package/dist/{chunk-TCPAT3WG.cjs → chunk-LHLVTGIP.cjs}

@@ -1,34 +1,14 @@
 'use strict';
 
-var chunkWIXFZUEZ_cjs = require('./chunk-WIXFZUEZ.cjs');
+var chunkKGYDGK3U_cjs = require('./chunk-KGYDGK3U.cjs');
 var chunkJGPDQDY4_cjs = require('./chunk-JGPDQDY4.cjs');
 var chunkBJYA5NDL_cjs = require('./chunk-BJYA5NDL.cjs');
 var React2 = require('react');
 var jsxRuntime = require('react/jsx-runtime');
-var z = require('zod');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
-function _interopNamespace(e) {
-  if (e && e.__esModule) return e;
-  var n = Object.create(null);
-  if (e) {
-    Object.keys(e).forEach(function (k) {
-      if (k !== 'default') {
-        var d = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n, k, d.get ? d : {
-          enumerable: true,
-          get: function () { return e[k]; }
-        });
-      }
-    });
-  }
-  n.default = e;
-  return Object.freeze(n);
-}
-
 var React2__default = /*#__PURE__*/_interopDefault(React2);
-var z__namespace = /*#__PURE__*/_interopNamespace(z);
 
 // src/chat/types/tool.ts
 var initialAgentLoopState = {
@@ -39,88 +19,6 @@ var initialAgentLoopState = {
   isProcessing: false
 };
 
-// src/chat/interfaces/ChatState.ts
-var SimpleChatState = class {
-  constructor() {
-    this._messages = [];
-    this._status = "ready";
-    this._error = void 0;
-    this.callbacks = /* @__PURE__ */ new Set();
-  }
-  get messages() {
-    return this._messages;
-  }
-  set messages(value) {
-    this._messages = value;
-    this.notify();
-  }
-  get status() {
-    return this._status;
-  }
-  set status(value) {
-    this._status = value;
-    this.notify();
-  }
-  get error() {
-    return this._error;
-  }
-  set error(value) {
-    this._error = value;
-    this.notify();
-  }
-  pushMessage(message) {
-    this._messages = [...this._messages, message];
-    this.notify();
-  }
-  popMessage() {
-    this._messages = this._messages.slice(0, -1);
-    this.notify();
-  }
-  replaceMessage(index, message) {
-    this._messages = [
-      ...this._messages.slice(0, index),
-      message,
-      ...this._messages.slice(index + 1)
-    ];
-    this.notify();
-  }
-  updateLastMessage(updater) {
-    if (this._messages.length === 0) return;
-    const lastIndex = this._messages.length - 1;
-    this.replaceMessage(lastIndex, updater(this._messages[lastIndex]));
-  }
-  updateMessageById(id, updater) {
-    const index = this._messages.findIndex((m) => m.id === id);
-    if (index === -1) return false;
-    this.replaceMessage(index, updater(this._messages[index]));
-    return true;
-  }
-  setMessages(messages) {
-    this._messages = messages;
-    this.notify();
-  }
-  clearMessages() {
-    this._messages = [];
-    this.notify();
-  }
-  subscribe(callback) {
-    this.callbacks.add(callback);
-    return () => this.callbacks.delete(callback);
-  }
-  getMessagesSnapshot() {
-    return this._messages;
-  }
-  getStatusSnapshot() {
-    return this._status;
-  }
-  getErrorSnapshot() {
-    return this._error;
-  }
-  notify() {
-    this.callbacks.forEach((cb) => cb());
-  }
-};
-
 // src/chat/functions/stream/parseSSE.ts
 function parseSSELine(line) {
   if (!line || line.trim() === "") {
@@ -541,6 +439,88 @@ var HttpTransport = class {
   }
 };
 
+// src/chat/interfaces/ChatState.ts
+var SimpleChatState = class {
+  constructor() {
+    this._messages = [];
+    this._status = "ready";
+    this._error = void 0;
+    this.callbacks = /* @__PURE__ */ new Set();
+  }
+  get messages() {
+    return this._messages;
+  }
+  set messages(value) {
+    this._messages = value;
+    this.notify();
+  }
+  get status() {
+    return this._status;
+  }
+  set status(value) {
+    this._status = value;
+    this.notify();
+  }
+  get error() {
+    return this._error;
+  }
+  set error(value) {
+    this._error = value;
+    this.notify();
+  }
+  pushMessage(message) {
+    this._messages = [...this._messages, message];
+    this.notify();
+  }
+  popMessage() {
+    this._messages = this._messages.slice(0, -1);
+    this.notify();
+  }
+  replaceMessage(index, message) {
+    this._messages = [
+      ...this._messages.slice(0, index),
+      message,
+      ...this._messages.slice(index + 1)
+    ];
+    this.notify();
+  }
+  updateLastMessage(updater) {
+    if (this._messages.length === 0) return;
+    const lastIndex = this._messages.length - 1;
+    this.replaceMessage(lastIndex, updater(this._messages[lastIndex]));
+  }
+  updateMessageById(id, updater) {
+    const index = this._messages.findIndex((m) => m.id === id);
+    if (index === -1) return false;
+    this.replaceMessage(index, updater(this._messages[index]));
+    return true;
+  }
+  setMessages(messages) {
+    this._messages = messages;
+    this.notify();
+  }
+  clearMessages() {
+    this._messages = [];
+    this.notify();
+  }
+  subscribe(callback) {
+    this.callbacks.add(callback);
+    return () => this.callbacks.delete(callback);
+  }
+  getMessagesSnapshot() {
+    return this._messages;
+  }
+  getStatusSnapshot() {
+    return this._status;
+  }
+  getErrorSnapshot() {
+    return this._error;
+  }
+  notify() {
+    this.callbacks.forEach((cb) => cb());
+  }
+};
+
 // src/chat/optimizations.ts
 var DEFAULT_CHARS_PER_TOKEN = 4;
 var DEFAULT_SAFETY_MARGIN = 1.2;
@@ -662,15 +642,15 @@ ${attachments}`,
     charsPerToken
   );
 }
-function estimateToolTokens(tool2, charsPerToken = DEFAULT_CHARS_PER_TOKEN) {
-  return estimateTokens(JSON.stringify(tool2), charsPerToken);
+function estimateToolTokens(tool, charsPerToken = DEFAULT_CHARS_PER_TOKEN) {
+  return estimateTokens(JSON.stringify(tool), charsPerToken);
 }
 function buildToolQuery(messages) {
   return messages.filter(
     (message) => message.role === "user" || message.role === "assistant"
   ).slice(-3).map((message) => message.content).filter(Boolean).join(" ");
 }
-function matchesSelector(tool2, selector, activeProfile) {
+function matchesSelector(tool, selector, activeProfile) {
   const normalized = selector.trim().toLowerCase();
   if (!normalized) {
     return false;
@@ -678,40 +658,40 @@ function matchesSelector(tool2, selector, activeProfile) {
   if (normalized === "*" || normalized === "all") {
     return true;
   }
-  if (normalized === tool2.name.toLowerCase()) {
+  if (normalized === tool.name.toLowerCase()) {
     return true;
   }
   if (normalized.startsWith("group:")) {
-    return (tool2.group ?? "").toLowerCase() === normalized.slice(6);
+    return (tool.group ?? "").toLowerCase() === normalized.slice(6);
   }
   if (normalized.startsWith("category:")) {
-    return (tool2.category ?? "").toLowerCase() === normalized.slice(9);
+    return (tool.category ?? "").toLowerCase() === normalized.slice(9);
   }
   if (normalized.startsWith("profile:")) {
-    return (tool2.profiles ?? []).map((value) => value.toLowerCase()).includes(normalized.slice(8));
+    return (tool.profiles ?? []).map((value) => value.toLowerCase()).includes(normalized.slice(8));
   }
   if (activeProfile && normalized === activeProfile.toLowerCase()) {
-    return (tool2.profiles ?? []).map((value) => value.toLowerCase()).includes(normalized);
+    return (tool.profiles ?? []).map((value) => value.toLowerCase()).includes(normalized);
   }
   return false;
 }
-function scoreTool(tool2, queryTokens, activeProfile) {
+function scoreTool(tool, queryTokens, activeProfile) {
   const haystack = [
-    tool2.name,
-    tool2.description,
-    tool2.category,
-    tool2.group,
-    ...tool2.profiles ?? [],
-    ...tool2.searchKeywords ?? []
+    tool.name,
+    tool.description,
+    tool.category,
+    tool.group,
+    ...tool.profiles ?? [],
+    ...tool.searchKeywords ?? []
   ].filter(Boolean).join(" ").toLowerCase();
-  let score = tool2.deferLoading ? 0 : 2;
-  if (activeProfile && tool2.profiles?.includes(activeProfile)) {
+  let score = tool.deferLoading ? 0 : 2;
+  if (activeProfile && tool.profiles?.includes(activeProfile)) {
     score += 2;
   }
   for (const token of queryTokens) {
-    if (tool2.name.toLowerCase() === token) {
+    if (tool.name.toLowerCase() === token) {
       score += 6;
-    } else if (tool2.name.toLowerCase().includes(token)) {
+    } else if (tool.name.toLowerCase().includes(token)) {
       score += 4;
     } else if (haystack.includes(token)) {
       score += 2;
@@ -925,15 +905,15 @@ function buildToolDefinitions(selectedTools) {
   if (selectedTools.length === 0) {
     return void 0;
   }
-  return selectedTools.map((tool2) => ({
-    name: tool2.name,
-    description: tool2.description,
-    category: tool2.category,
-    group: tool2.group,
-    deferLoading: tool2.deferLoading,
-    profiles: tool2.profiles,
-    searchKeywords: tool2.searchKeywords,
-    inputSchema: tool2.inputSchema
+  return selectedTools.map((tool) => ({
+    name: tool.name,
+    description: tool.description,
+    category: tool.category,
+    group: tool.group,
+    deferLoading: tool.deferLoading,
+    profiles: tool.profiles,
+    searchKeywords: tool.searchKeywords,
+    inputSchema: tool.inputSchema
   }));
 }
 function resolveTruncationConfig(params) {
@@ -963,21 +943,21 @@ function resolveTruncationConfig(params) {
     preserveErrors: merged.preserveErrors ?? true
   };
 }
-function buildToolResultContent(result, tool2, args) {
+function buildToolResultContent(result, tool, args) {
   if (typeof result === "string") {
     return result;
   }
   const typedResult = result ?? null;
-  const responseMode = typedResult?._aiResponseMode ?? tool2?.aiResponseMode ?? "full";
+  const responseMode = typedResult?._aiResponseMode ?? tool?.aiResponseMode ?? "full";
   if (typedResult?._aiContent) {
     return JSON.stringify(typedResult._aiContent);
   }
   let aiContext = typedResult?._aiContext;
-  if (!aiContext && tool2?.aiContext) {
-    aiContext = typeof tool2.aiContext === "function" ? tool2.aiContext(
+  if (!aiContext && tool?.aiContext) {
+    aiContext = typeof tool.aiContext === "function" ? tool.aiContext(
       typedResult ?? { success: true },
       args ?? {}
-    ) : tool2.aiContext;
+    ) : tool.aiContext;
   }
   switch (responseMode) {
     case "none":
@@ -1006,9 +986,9 @@ Full data: ${JSON.stringify(dataOnly)}`;
     }
   }
 }
-function buildToolResultContentForPrompt(result, tool2, args, config) {
-  const text = buildToolResultContent(result, tool2, args);
-  const truncation = resolveTruncationConfig({ tool: tool2, config });
+function buildToolResultContentForPrompt(result, tool, args, config) {
+  const text = buildToolResultContent(result, tool, args);
+  const truncation = resolveTruncationConfig({ tool, config });
   if (!truncation.enabled) {
     return text;
   }
@@ -1114,7 +1094,7 @@ function fitToolsToBudget(params) {
     return tools;
   }
   const getToolTokens = () => tools.reduce(
-    (sum, tool2) => sum + estimateToolTokens(tool2, params.charsPerToken),
+    (sum, tool) => sum + estimateToolTokens(tool, params.charsPerToken),
     0
   );
   while (tools.length > 0 && getToolTokens() > params.maxTokens) {
@@ -1152,7 +1132,7 @@ function calculateBuckets(params) {
     0
   );
   const toolDefinitionTokens = (params.requestTools ?? []).reduce(
-    (sum, tool2) => sum + estimateToolTokens(tool2, params.charsPerToken),
+    (sum, tool) => sum + estimateToolTokens(tool, params.charsPerToken),
     0
   );
   const total = systemPromptTokens + historyTokens + toolResultsTokens + toolDefinitionTokens;
@@ -1391,7 +1371,7 @@ var ChatContextOptimizer = class {
     if (!tools.length) {
       return [];
     }
-    const available = tools.filter((tool2) => tool2.available !== false);
+    const available = tools.filter((tool) => tool.available !== false);
     const profileConfig = this.config?.toolProfiles;
     if (!profileConfig?.enabled) {
       return available;
@@ -1402,22 +1382,22 @@ var ChatContextOptimizer = class {
     let filtered = available;
     if (profile?.include?.length) {
       filtered = filtered.filter(
-        (tool2) => profile.include.some(
-          (selector) => matchesSelector(tool2, selector, activeProfile)
-        ) || !!activeProfile && tool2.profiles?.includes(activeProfile)
+        (tool) => profile.include.some(
+          (selector) => matchesSelector(tool, selector, activeProfile)
+        ) || !!activeProfile && tool.profiles?.includes(activeProfile)
       );
     } else if (activeProfile) {
-      filtered = filtered.filter((tool2) => {
-        if (tool2.profiles?.length) {
-          return tool2.profiles.includes(activeProfile);
+      filtered = filtered.filter((tool) => {
+        if (tool.profiles?.length) {
+          return tool.profiles.includes(activeProfile);
         }
         return includeUnprofiled;
       });
     }
     if (profile?.exclude?.length) {
       filtered = filtered.filter(
-        (tool2) => !profile.exclude.some(
-          (selector) => matchesSelector(tool2, selector, activeProfile)
+        (tool) => !profile.exclude.some(
+          (selector) => matchesSelector(tool, selector, activeProfile)
         )
       );
     }
@@ -1461,7 +1441,7 @@ var ChatContextOptimizer = class {
       }
     }
     const toolDefMap = new Map(
-      allTools.map((tool2) => [tool2.name, tool2])
+      allTools.map((tool) => [tool.name, tool])
     );
     return messages.map((message) => {
       if (message.role !== "tool") {
@@ -1474,20 +1454,20 @@ var ChatContextOptimizer = class {
         };
       }
       const toolCall = message.toolCallId ? toolCallMap.get(message.toolCallId) : void 0;
-      const tool2 = toolCall ? toolDefMap.get(toolCall.toolName) : void 0;
+      const tool = toolCall ? toolDefMap.get(toolCall.toolName) : void 0;
       let content = message.content;
       try {
         const parsed = JSON.parse(message.content);
         content = buildToolResultContentForPrompt(
           parsed,
-          tool2,
+          tool,
           toolCall?.args ?? {},
           this.config
         );
       } catch {
         content = buildToolResultContentForPrompt(
           message.content,
-          tool2,
+          tool,
           toolCall?.args ?? {},
           this.config
         );
@@ -1610,10 +1590,20 @@ var AbstractChat = class {
       this.state.pushMessage(userMessage);
       this.state.status = "submitted";
       this.state.error = void 0;
+      let preCreatedMessageId;
+      if (this.config.streaming !== false) {
+        const visibleMessages2 = this.state.messages;
+        const currentLeafId = visibleMessages2.length > 0 ? visibleMessages2[visibleMessages2.length - 1].id : void 0;
+        const preMsg = createEmptyAssistantMessage(void 0, {
+          parentId: currentLeafId
+        });
+        this.state.pushMessage(preMsg);
+        preCreatedMessageId = preMsg.id;
+      }
       this.callbacks.onMessagesChange?.(this._allMessages());
       this.callbacks.onStatusChange?.("submitted");
       await Promise.resolve();
-      await this.processRequest();
+      await this.processRequest({ preCreatedMessageId });
       return true;
     } catch (error) {
       this.handleError(error);
@@ -1733,6 +1723,44 @@ var AbstractChat = class {
       this.handleError(error);
     }
   }
+  /**
+   * Add tool result messages to history and stop — does NOT trigger a new LLM request.
+   *
+   * Use this instead of continueWithToolResults when you want to close out pending
+   * tool_use blocks (so the history stays valid) without letting the AI continue.
+   * Optionally appends a final assistant message (e.g. an iteration-limit notice).
+   */
+  async addToolResultMessages(toolResults, finalAssistantContent) {
+    const visibleMessages = this.state.messages;
+    let chainParentId = visibleMessages.length > 0 ? visibleMessages[visibleMessages.length - 1].id : void 0;
+    for (const { toolCallId, result } of toolResults) {
+      const messageContent = typeof result === "string" ? result : JSON.stringify(result);
+      const toolMessageId = generateMessageId();
+      const toolMessage = {
+        id: toolMessageId,
+        role: "tool",
+        content: messageContent,
+        toolCallId,
+        createdAt: /* @__PURE__ */ new Date(),
+        ...chainParentId !== void 0 ? { parentId: chainParentId } : {}
+      };
+      this.state.pushMessage(toolMessage);
+      chainParentId = toolMessageId;
+    }
+    if (finalAssistantContent) {
+      const assistantMsg = {
+        id: generateMessageId(),
+        role: "assistant",
+        content: finalAssistantContent,
+        createdAt: /* @__PURE__ */ new Date(),
+        ...chainParentId !== void 0 ? { parentId: chainParentId } : {}
+      };
+      this.state.pushMessage(assistantMsg);
+    }
+    this.callbacks.onMessagesChange?.(this._allMessages());
+    this.state.status = "ready";
+    this.callbacks.onStatusChange?.("ready");
+  }
   /**
    * Stop generation
    */
@@ -1837,10 +1865,10 @@ var AbstractChat = class {
   /**
    * Process a chat request
    */
-  async processRequest() {
+  async processRequest(options) {
     const request = this.buildRequest();
-    let preCreatedMessageId;
-    if (this.config.streaming !== false) {
+    let preCreatedMessageId = options?.preCreatedMessageId;
+    if (this.config.streaming !== false && !preCreatedMessageId) {
       const visibleMessages = this.state.messages;
       const currentLeafId = visibleMessages.length > 0 ? visibleMessages[visibleMessages.length - 1].id : void 0;
       const preMsg = createEmptyAssistantMessage(void 0, {
@@ -1973,15 +2001,15 @@ ${this.dynamicContext}`.trim() : this.config.systemPrompt;
       threadId: this.config.threadId,
       systemPrompt,
       llm: this.config.llm,
-      tools: this.config.tools?.length ? this.config.tools.map((tool2) => ({
-        name: tool2.name,
-        description: tool2.description,
-        category: tool2.category,
-        group: tool2.group,
-        deferLoading: tool2.deferLoading,
-        profiles: tool2.profiles,
-        searchKeywords: tool2.searchKeywords,
-        inputSchema: tool2.inputSchema
+      tools: this.config.tools?.length ? this.config.tools.map((tool) => ({
+        name: tool.name,
+        description: tool.description,
+        category: tool.category,
+        group: tool.group,
+        deferLoading: tool.deferLoading,
+        profiles: tool.profiles,
+        searchKeywords: tool.searchKeywords,
+        inputSchema: tool.inputSchema
       })) : void 0,
       __skills: this.inlineSkills.length ? this.inlineSkills : void 0
     };
@@ -2058,7 +2086,11 @@ ${this.dynamicContext}`.trim() : this.config.systemPrompt;
       }
       if (chunk.type === "message:start" && this.streamState === null) {
         this.debug("message:start after mid-stream end - creating new message");
-        const newMessage = createEmptyAssistantMessage();
+        const currentLeaf = this.state.messages;
+        const currentLeafId = currentLeaf.length > 0 ? currentLeaf[currentLeaf.length - 1].id : void 0;
+        const newMessage = createEmptyAssistantMessage(void 0, {
+          parentId: currentLeafId
+        });
         this.state.pushMessage(newMessage);
         this.streamState = createStreamState(newMessage.id);
         this.callbacks.onMessageStart?.(newMessage.id);
@@ -2128,10 +2160,19 @@ ${this.dynamicContext}`.trim() : this.config.systemPrompt;
                   break;
                 }
               }
+              const insertParentId = insertIdx > 0 ? currentMessages[insertIdx - 1].id : void 0;
+              const linkedToInsert = messagesToInsert.map((msg, i) => ({
+                ...msg,
+                parentId: i === 0 ? insertParentId : messagesToInsert[i - 1].id
+              }));
+              const lastInsertedId = linkedToInsert[linkedToInsert.length - 1].id;
+              const updatedCurrent = currentMessages.map(
+                (m, idx) => idx === insertIdx ? { ...m, parentId: lastInsertedId } : m
+              );
               this.state.setMessages([
-                ...currentMessages.slice(0, insertIdx),
-                ...messagesToInsert,
-                ...currentMessages.slice(insertIdx)
+                ...updatedCurrent.slice(0, insertIdx),
+                ...linkedToInsert,
+                ...updatedCurrent.slice(insertIdx)
               ]);
             }
           }
@@ -2196,6 +2237,10 @@ ${this.dynamicContext}`.trim() : this.config.systemPrompt;
           ...existing.childrenIds !== void 0 ? { childrenIds: existing.childrenIds } : {}
         })
       );
+      this.callbacks.onStreamChunk?.({
+        ...chunk,
+        messageId: assistantMessage.id
+      });
       if (chunk.type === "message:delta") {
         this.callbacks.onMessageDelta?.(assistantMessage.id, chunk.content);
       }
@@ -2257,12 +2302,26 @@ ${this.dynamicContext}`.trim() : this.config.systemPrompt;
               (message) => message.id === this.streamState.messageId
             ) : -1;
             if (currentStreamIndex === -1) {
-              this.state.setMessages([...currentMessages, ...messagesToInsert]);
+              const appendParentId = currentMessages.length > 0 ? currentMessages[currentMessages.length - 1].id : void 0;
+              const linkedToInsert = messagesToInsert.map((msg, i) => ({
+                ...msg,
+                parentId: i === 0 ? appendParentId : messagesToInsert[i - 1].id
+              }));
+              this.state.setMessages([...currentMessages, ...linkedToInsert]);
             } else {
+              const insertParentId = currentStreamIndex > 0 ? currentMessages[currentStreamIndex - 1].id : void 0;
+              const linkedToInsert = messagesToInsert.map((msg, i) => ({
+                ...msg,
+                parentId: i === 0 ? insertParentId : messagesToInsert[i - 1].id
+              }));
+              const lastInsertedId = linkedToInsert[linkedToInsert.length - 1].id;
+              const updatedCurrent = currentMessages.map(
+                (m, idx) => idx === currentStreamIndex ? { ...m, parentId: lastInsertedId } : m
+              );
               this.state.setMessages([
-                ...currentMessages.slice(0, currentStreamIndex),
-                ...messagesToInsert,
-                ...currentMessages.slice(currentStreamIndex)
+                ...updatedCurrent.slice(0, currentStreamIndex),
+                ...linkedToInsert,
+                ...updatedCurrent.slice(currentStreamIndex)
               ]);
             }
           }
@@ -2419,7 +2478,7 @@ ${this.dynamicContext}`.trim() : this.config.systemPrompt;
   }
   get log() {
     if (!this._log) {
-      this._log = chunkWIXFZUEZ_cjs.createLogger("streaming", () => this.config.debug ?? false);
+      this._log = chunkKGYDGK3U_cjs.createLogger("streaming", () => this.config.debug ?? false);
     }
     return this._log;
   }
@@ -2502,8 +2561,8 @@ var AbstractAgentLoop = class {
     this._maxIterations = config.maxIterations ?? 20;
     this._maxExecutionHistory = config.maxExecutionHistory ?? 100;
     if (config.tools) {
-      for (const tool2 of config.tools) {
-        this.registerTool(tool2);
+      for (const tool of config.tools) {
+        this.registerTool(tool);
       }
     }
   }
@@ -2592,15 +2651,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(tool2) {
-    const existing = this.registeredTools.get(tool2.name);
+  registerTool(tool) {
+    const existing = this.registeredTools.get(tool.name);
     if (existing) {
-      existing.tool = tool2;
+      existing.tool = tool;
       existing.refCount++;
       existing.active = true;
     } else {
-      this.registeredTools.set(tool2.name, {
-        tool: tool2,
+      this.registeredTools.set(tool.name, {
+        tool,
         refCount: 1,
         active: true
       });
@@ -2665,7 +2724,7 @@ var AbstractAgentLoop = class {
    * Execute a single tool
    */
   async executeSingleTool(toolCall) {
-    const tool2 = this.getTool(toolCall.name);
+    const tool = this.getTool(toolCall.name);
     const execution = {
       id: toolCall.id,
       toolCallId: toolCall.id,
@@ -2674,11 +2733,11 @@ var AbstractAgentLoop = class {
       status: "pending",
       approvalStatus: "none",
       startedAt: /* @__PURE__ */ new Date(),
-      hidden: tool2?.hidden
+      hidden: tool?.hidden
     };
     this.addToolExecution(execution);
     this.callbacks.onToolStart?.(execution);
-    if (!tool2) {
+    if (!tool) {
       const errorResult = {
         toolCallId: toolCall.id,
         success: false,
@@ -2692,9 +2751,9 @@ var AbstractAgentLoop = class {
       return errorResult;
     }
     let approvalData;
-    if (tool2.needsApproval && !this.config.autoApprove) {
-      const approvalTitle = typeof tool2.approvalTitle === "function" ? tool2.approvalTitle(toolCall.args) : tool2.approvalTitle;
-      const approvalMessage = typeof tool2.approvalMessage === "function" ? tool2.approvalMessage(toolCall.args) : tool2.approvalMessage;
+    if (tool.needsApproval && !this.config.autoApprove) {
+      const approvalTitle = typeof tool.approvalTitle === "function" ? tool.approvalTitle(toolCall.args) : tool.approvalTitle;
+      const approvalMessage = typeof tool.approvalMessage === "function" ? tool.approvalMessage(toolCall.args) : tool.approvalMessage;
       execution.approvalStatus = "required";
       execution.approvalTitle = approvalTitle;
       execution.approvalMessage = approvalMessage;
@@ -2723,13 +2782,13 @@ var AbstractAgentLoop = class {
     }
     this.updateToolExecution(toolCall.id, { status: "executing" });
     try {
-      if (!tool2.handler) {
+      if (!tool.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 tool2.handler(toolCall.args, {
+      const result = await tool.handler(toolCall.args, {
         signal: this.abortController?.signal,
         data: { toolCallId: toolCall.id },
         approvalData
@@ -2952,736 +3011,745 @@ var AbstractAgentLoop = class {
   }
 };
 
-// src/chat/ChatWithTools.ts
-var ChatWithTools = class {
-  constructor(config, callbacks = {}) {
-    this.config = config;
-    this.callbacks = callbacks;
-    this.agentLoop = new AbstractAgentLoop(
-      {
-        maxIterations: config.maxIterations ?? 20,
-        tools: config.tools
-      },
-      {
-        onExecutionsChange: (executions) => {
-          callbacks.onToolExecutionsChange?.(executions);
-        },
-        onApprovalRequired: (execution) => {
-          callbacks.onApprovalRequired?.(execution);
-        }
+// src/chat/branching/MessageTree.ts
+var _MessageTree = class _MessageTree {
+  constructor(messages) {
+    /** All messages by ID */
+    this.nodeMap = /* @__PURE__ */ new Map();
+    /** parentKey → ordered list of child IDs (insertion order = oldest-first) */
+    this.childrenOf = /* @__PURE__ */ new Map();
+    /** parentKey → currently-active child ID */
+    this.activeChildMap = /* @__PURE__ */ new Map();
+    /** Current leaf message ID (tip of the active path) */
+    this._currentLeafId = null;
+    /** Cached visible messages — invalidated on every mutation */
+    this._visibleCache = null;
+    if (messages?.length) {
+      this._buildFromMessages(messages);
+    }
+  }
+  // ============================================
+  // Static Migration Helpers
+  // ============================================
+  /**
+   * Convert a legacy flat array (no parentId) to a tree-linked array.
+   *
+   * Rules:
+   * - Tool messages get parentId = the owning assistant message's id
+   *   (matched via toolCallId → toolCall.id), chained in sequence.
+   * - All other messages get parentId = the previous message in the linear
+   *   chain (including tool messages, so the next non-tool after tool results
+   *   is a child of the last tool result, not a sibling).
+   *
+   * Returns a new array with parentId/childrenIds filled in.
+   * Does NOT mutate the original messages.
+   */
+  static fromFlatArray(messages) {
+    if (messages.length === 0) return messages;
+    const alreadyLinked = messages.some((m) => m.parentId !== void 0);
+    if (alreadyLinked) return messages;
+    const result = [];
+    let prevId = null;
+    const assistantById = /* @__PURE__ */ new Map();
+    for (const msg of messages) {
+      if (msg.role === "assistant") {
+        assistantById.set(msg.id, msg);
       }
-    );
-    this.chat = new AbstractChat({
-      runtimeUrl: config.runtimeUrl,
-      llm: config.llm,
-      systemPrompt: config.systemPrompt,
-      streaming: config.streaming,
-      headers: config.headers,
-      body: config.body,
-      optimization: config.optimization,
-      threadId: config.threadId,
-      debug: config.debug,
-      initialMessages: config.initialMessages,
-      state: config.state,
-      transport: config.transport,
-      callbacks: {
-        onMessagesChange: callbacks.onMessagesChange,
-        onStatusChange: callbacks.onStatusChange,
-        onError: callbacks.onError,
-        onMessageStart: callbacks.onMessageStart,
-        onMessageDelta: callbacks.onMessageDelta,
-        onMessageFinish: callbacks.onMessageFinish,
-        onToolCalls: callbacks.onToolCalls,
-        onFinish: callbacks.onFinish,
-        onContextUsageChange: callbacks.onContextUsageChange,
-        // 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();
-  }
-  /**
-   * Wire up internal events between chat and agent loop
-   */
-  wireEvents() {
-    this.debug("Wiring up toolCalls event handler");
-    this.chat.on("toolCalls", async (event) => {
-      const toolCalls = event.toolCalls;
-      if (!toolCalls?.length) {
-        return;
-      }
-      this.debug("Tool calls received:", toolCalls.length);
-      const toolCallInfos = toolCalls.map((tc) => {
-        const tcAny = tc;
-        const name = tcAny.function?.name ?? tcAny.name ?? "";
-        let args = {};
-        if (tcAny.function?.arguments) {
-          try {
-            args = JSON.parse(tcAny.function.arguments);
-          } catch {
-            args = {};
+    }
+    const lastToolIdByAssistant = /* @__PURE__ */ new Map();
+    for (const msg of messages) {
+      if (msg.role === "tool" && msg.toolCallId) {
+        let ownerAssistantId = null;
+        for (const [, assistant] of assistantById) {
+          if (assistant.toolCalls?.some((tc) => tc.id === msg.toolCallId)) {
+            ownerAssistantId = assistant.id;
+            break;
           }
-        } else if (tcAny.args) {
-          args = tcAny.args;
         }
-        return { id: tc.id, name, args };
-      });
-      try {
-        const results = await this.agentLoop.executeToolCalls(toolCallInfos);
-        this.debug("Tool results:", results);
-        if (results.length > 0) {
-          const toolResults = results.map((r) => ({
-            toolCallId: r.toolCallId,
-            result: r.success ? r.result : { success: false, error: r.error }
-          }));
-          await this.chat.continueWithToolResults(toolResults);
-        } else if (this.agentLoop.maxIterationsReached && toolCallInfos.length > 0) {
-          this.debug("Max iterations reached, adding blocked tool results");
-          const errorMessage = this.config.maxIterationsMessage || "Tool execution paused: iteration limit reached. User can say 'continue' to resume.";
-          const blockedResults = toolCallInfos.map((tc) => ({
-            toolCallId: tc.id,
-            result: {
-              success: false,
-              error: errorMessage
-            }
-          }));
-          await this.chat.continueWithToolResults(blockedResults);
+        const chainParent = ownerAssistantId ? lastToolIdByAssistant.get(ownerAssistantId) ?? ownerAssistantId : prevId ?? null;
+        result.push({
+          ...msg,
+          parentId: chainParent,
+          childrenIds: []
+        });
+        if (ownerAssistantId) {
+          lastToolIdByAssistant.set(ownerAssistantId, msg.id);
         }
-      } catch (error) {
-        this.debug("Error executing tools:", error);
-        console.error("[ChatWithTools] Tool execution error:", error);
+        prevId = msg.id;
+      } else {
+        result.push({
+          ...msg,
+          parentId: prevId,
+          childrenIds: []
+        });
+        prevId = msg.id;
       }
-    });
+    }
+    const childrenMap = /* @__PURE__ */ new Map();
+    for (const msg of result) {
+      const parentKey = msg.parentId == null ? _MessageTree.ROOT_KEY : msg.parentId;
+      if (!childrenMap.has(parentKey)) {
+        childrenMap.set(parentKey, []);
+      }
+      childrenMap.get(parentKey).push(msg.id);
+    }
+    return result.map((msg) => ({
+      ...msg,
+      childrenIds: childrenMap.get(msg.id) ?? []
+    }));
   }
   // ============================================
-  // Chat Getters
+  // Core Queries
   // ============================================
-  get messages() {
-    return this.chat.messages;
-  }
-  get status() {
-    return this.chat.status;
-  }
-  get error() {
-    return this.chat.error;
+  /**
+   * Returns the visible path (root → current leaf) — what the UI renders
+   * and what gets sent to the API.
+   *
+   * Backward-compat: if NO message has parentId set (all undefined),
+   * falls back to insertion order (legacy linear mode).
+   */
+  getVisibleMessages() {
+    if (this._visibleCache !== null) return this._visibleCache;
+    if (this.nodeMap.size === 0) {
+      this._visibleCache = [];
+      return this._visibleCache;
+    }
+    const hasTreeStructure = Array.from(this.nodeMap.values()).some(
+      (m) => m.parentId !== void 0
+    );
+    this._visibleCache = hasTreeStructure ? this._getActivePath().map((id) => this.nodeMap.get(id)) : Array.from(this.nodeMap.values());
+    return this._visibleCache;
   }
-  get isStreaming() {
-    return this.chat.isStreaming;
+  _invalidateCache() {
+    this._visibleCache = null;
   }
   /**
-   * Whether any operation is in progress (chat or tools)
-   * Use this to show loading indicators and disable send button
+   * Returns ALL messages across every branch (for persistence / ThreadManager).
    */
-  get isLoading() {
-    const chatBusy = this.status === "submitted" || this.status === "streaming";
-    const toolsBusy = this.agentLoop.isProcessing;
-    const hasPendingApprovals = this.agentLoop.pendingApprovalExecutions.length > 0;
-    return chatBusy || toolsBusy || hasPendingApprovals;
+  getAllMessages() {
+    return Array.from(this.nodeMap.values());
   }
   /**
-   * Check if a request is currently in progress (excludes pending approvals)
-   * Use this to prevent sending new messages
+   * Branch navigation info for the UI navigator.
+   * Returns null if the message has no siblings (only child).
    */
-  get isBusy() {
-    const chatBusy = this.status === "submitted" || this.status === "streaming";
-    const toolsBusy = this.agentLoop.isProcessing;
-    return chatBusy || toolsBusy;
-  }
-  // ============================================
-  // Tool Execution Getters
-  // ============================================
-  get toolExecutions() {
-    return this.agentLoop.toolExecutions;
-  }
-  get tools() {
-    return this.agentLoop.tools;
-  }
-  get iteration() {
-    return this.agentLoop.iteration;
+  getBranchInfo(messageId) {
+    const msg = this.nodeMap.get(messageId);
+    if (!msg) return null;
+    const parentKey = this._parentKey(msg.parentId);
+    const siblings = this.childrenOf.get(parentKey) ?? [];
+    if (siblings.length <= 1) return null;
+    const siblingIndex = siblings.indexOf(messageId);
+    return {
+      siblingIndex,
+      totalSiblings: siblings.length,
+      siblingIds: [...siblings],
+      hasPrevious: siblingIndex > 0,
+      hasNext: siblingIndex < siblings.length - 1
+    };
   }
-  get maxIterations() {
-    return this.agentLoop.maxIterations;
+  get currentLeafId() {
+    return this._currentLeafId;
   }
-  get isProcessing() {
-    return this.agentLoop.isProcessing;
+  get hasBranches() {
+    for (const children of this.childrenOf.values()) {
+      if (children.length > 1) return true;
+    }
+    return false;
   }
   // ============================================
-  // Chat Actions
+  // Mutations
   // ============================================
   /**
-   * Send a message
-   * Returns false if a request is already in progress
-   *
-   * @param options.editMessageId - Edit flow: new message branches from the
-   *   same parent as this message ID
+   * Insert a new message.
+   * - Updates childrenOf and nodeMap.
+   * - New branch becomes active (activeChildMap updated).
+   * - Updates current leaf.
    */
-  async sendMessage(content, attachments, options) {
-    if (this.isLoading) {
-      this.debug("sendMessage blocked - request already in progress");
-      return false;
+  addMessage(message) {
+    this.nodeMap.set(message.id, message);
+    const parentKey = this._parentKey(message.parentId);
+    if (!this.childrenOf.has(parentKey)) {
+      this.childrenOf.set(parentKey, []);
     }
-    this.agentLoop.resetIterations();
-    return await this.chat.sendMessage(content, attachments, options);
-  }
-  /**
-   * Stop generation and cancel any running tools
-   */
-  stop() {
-    this.agentLoop.cancel();
-    this.chat.stop();
-    this.debug("Stopped - cancelled tools and aborted stream");
-  }
-  /**
-   * Clear all messages
-   */
-  clearMessages() {
-    this.chat.clearMessages();
-    this.agentLoop.clearToolExecutions();
-  }
-  /**
-   * Set messages directly
-   */
-  setMessages(messages) {
-    this.chat.setMessages(messages);
-  }
-  /**
-   * Regenerate last response
-   */
-  async regenerate(messageId) {
-    await this.chat.regenerate(messageId);
-  }
-  /**
-   * Set tools available for the LLM
-   */
-  setTools(tools) {
-    this.chat.setTools(tools);
-  }
-  /**
-   * Update prompt/tool optimization controls.
-   */
-  setOptimizationConfig(config) {
-    this.config.optimization = config;
-    this.chat.setOptimizationConfig(config);
-  }
-  /**
-   * Set the active tool profile used for request-time tool selection.
-   */
-  setToolProfile(profile) {
-    this.chat.setToolProfile(profile);
-  }
-  /**
-   * Get the most recent prompt context usage snapshot.
-   */
-  getContextUsage() {
-    return this.chat.getContextUsage();
-  }
-  /**
-   * Set dynamic context (from useAIContext hook)
-   */
-  setContext(context) {
-    this.chat.setContext(context);
-  }
-  /**
-   * Set system prompt dynamically
-   */
-  setSystemPrompt(prompt) {
-    this.chat.setSystemPrompt(prompt);
-  }
-  /**
-   * Set headers configuration
-   * Can be static headers or a getter function for dynamic resolution
-   */
-  setHeaders(headers) {
-    this.chat.setHeaders(headers);
-  }
-  /**
-   * Set URL configuration
-   * Can be static URL or a getter function for dynamic resolution
-   */
-  setUrl(url) {
-    this.chat.setUrl(url);
-  }
-  /**
-   * Set body configuration
-   * Additional properties merged into every request body
-   */
-  setBody(body) {
-    this.chat.setBody(body);
-  }
-  setRequestMessageTransform(fn) {
-    this.chat.setRequestMessageTransform(fn);
-  }
-  /**
-   * Set inline skills (forwarded to underlying chat instance)
-   */
-  setInlineSkills(skills) {
-    this.chat.setInlineSkills(skills);
-  }
-  // ============================================
-  // Tool Registration
-  // ============================================
-  /**
-   * Register a tool
-   */
-  registerTool(tool2) {
-    this.agentLoop.registerTool(tool2);
-    this.chat.setTools(this.agentLoop.tools);
+    const siblings = this.childrenOf.get(parentKey);
+    if (!siblings.includes(message.id)) {
+      siblings.push(message.id);
+    }
+    this.activeChildMap.set(parentKey, message.id);
+    this._currentLeafId = this._walkToLeaf(message.id);
+    this._invalidateCache();
+    return message;
   }
   /**
-   * Unregister a tool
+   * Navigate: make messageId the active child at its parent fork,
+   * then walk to its leaf and update currentLeafId.
    */
-  unregisterTool(name) {
-    this.agentLoop.unregisterTool(name);
-    this.chat.setTools(this.agentLoop.tools);
+  switchBranch(messageId) {
+    const msg = this.nodeMap.get(messageId);
+    if (!msg) return;
+    const parentKey = this._parentKey(msg.parentId);
+    this.activeChildMap.set(parentKey, messageId);
+    this._currentLeafId = this._walkToLeaf(messageId);
+    this._invalidateCache();
   }
-  // ============================================
-  // Tool Approval
-  // ============================================
   /**
-   * Approve a tool execution with optional extra data
+   * Update message content in-place (streaming updates).
+   * No tree structure change.
    */
-  approveToolExecution(id, extraData, permissionLevel) {
-    this.agentLoop.approveToolExecution(id, extraData, permissionLevel);
+  updateMessage(id, updater) {
+    const existing = this.nodeMap.get(id);
+    if (!existing) return false;
+    this.nodeMap.set(id, updater(existing));
+    this._invalidateCache();
+    return true;
   }
   /**
-   * Reject a tool execution
+   * Set current leaf explicitly.
+   * Used by regenerate() to rewind the active path before pushing a new message.
    */
-  rejectToolExecution(id, reason, permissionLevel) {
-    this.agentLoop.rejectToolExecution(id, reason, permissionLevel);
+  setCurrentLeaf(leafId) {
+    this._currentLeafId = leafId;
+    if (leafId === null) return;
+    const msg = this.nodeMap.get(leafId);
+    if (!msg) return;
+    let current = msg;
+    while (current) {
+      const parentKey = this._parentKey(current.parentId);
+      this.activeChildMap.set(parentKey, current.id);
+      if (current.parentId == null || current.parentId === void 0) break;
+      current = this.nodeMap.get(current.parentId);
+    }
+    this._invalidateCache();
   }
   /**
-   * Clear tool executions
+   * Rebuild entire tree from a message array.
+   * Used by setMessages().
    */
-  clearToolExecutions() {
-    this.agentLoop.clearToolExecutions();
+  reset(messages) {
+    this.nodeMap.clear();
+    this.childrenOf.clear();
+    this.activeChildMap.clear();
+    this._currentLeafId = null;
+    this._invalidateCache();
+    if (messages.length > 0) {
+      this._buildFromMessages(messages);
+    }
   }
   // ============================================
-  // Event Subscriptions (for framework adapters)
+  // Private Helpers
   // ============================================
-  /**
-   * Subscribe to chat events
-   */
-  on(event, handler) {
-    return this.chat.on(event, handler);
+  _buildFromMessages(messages) {
+    const linked = messages.some((m) => m.parentId !== void 0) ? messages : _MessageTree.fromFlatArray(messages);
+    for (const msg of linked) {
+      this.nodeMap.set(msg.id, msg);
+      const parentKey = this._parentKey(msg.parentId);
+      if (!this.childrenOf.has(parentKey)) {
+        this.childrenOf.set(parentKey, []);
+      }
+      const siblings = this.childrenOf.get(parentKey);
+      if (!siblings.includes(msg.id)) {
+        siblings.push(msg.id);
+      }
+    }
+    for (const [parentKey, children] of this.childrenOf) {
+      if (children.length > 0) {
+        this.activeChildMap.set(parentKey, children[children.length - 1]);
+      }
+    }
+    const path = this._getActivePath();
+    this._currentLeafId = path.length > 0 ? path[path.length - 1] : null;
   }
-  // ============================================
-  // Cleanup
-  // ============================================
-  /**
-   * Whether this instance has been disposed
-   */
-  get disposed() {
-    return this.chat.disposed;
+  _parentKey(parentId) {
+    if (parentId == null || parentId === void 0) {
+      return _MessageTree.ROOT_KEY;
+    }
+    return parentId;
   }
   /**
-   * Revive a disposed instance (for React StrictMode compatibility)
-   * This allows reusing an instance after dispose() was called,
-   * preserving registered tools and state
+   * Walk forward from a message along active children to find the leaf.
    */
-  revive() {
-    this.chat.revive();
-    this.agentLoop.revive();
+  _walkToLeaf(fromId) {
+    let current = fromId;
+    while (true) {
+      const children = this.childrenOf.get(current);
+      if (!children || children.length === 0) break;
+      const activeChild = this.activeChildMap.get(current);
+      if (!activeChild) break;
+      if (!this.nodeMap.has(activeChild)) break;
+      current = activeChild;
+    }
+    return current;
   }
   /**
-   * Dispose and cleanup
+   * Walk the active path from root to the current leaf.
    */
-  dispose() {
-    this.chat.dispose();
-    this.agentLoop.dispose();
-  }
-  // ============================================
-  // Private
-  // ============================================
-  debug(message, ...args) {
-    chunkWIXFZUEZ_cjs.createLogger("tools", () => this.config.debug ?? false)(
-      message,
-      args.length === 1 ? args[0] : args.length > 1 ? args : void 0
-    );
+  _getActivePath() {
+    const path = [];
+    const visited = /* @__PURE__ */ new Set();
+    const rootChildren = this.childrenOf.get(_MessageTree.ROOT_KEY) ?? [];
+    if (rootChildren.length === 0) return path;
+    let activeId = this.activeChildMap.get(_MessageTree.ROOT_KEY);
+    if (!activeId) {
+      activeId = rootChildren[rootChildren.length - 1];
+    }
+    let current = activeId;
+    while (current && !visited.has(current)) {
+      if (!this.nodeMap.has(current)) break;
+      visited.add(current);
+      path.push(current);
+      const activeChild = this.activeChildMap.get(current);
+      if (!activeChild || !this.nodeMap.has(activeChild)) break;
+      current = activeChild;
+    }
+    return path;
   }
 };
+/** Sentinel key used for root-level messages (parentId === null) */
+_MessageTree.ROOT_KEY = "__root__";
+var MessageTree = _MessageTree;
 
-// src/chat/branching/MessageTree.ts
-var _MessageTree = class _MessageTree {
-  constructor(messages) {
-    /** All messages by ID */
-    this.nodeMap = /* @__PURE__ */ new Map();
-    /** parentKey → ordered list of child IDs (insertion order = oldest-first) */
-    this.childrenOf = /* @__PURE__ */ new Map();
-    /** parentKey → currently-active child ID */
-    this.activeChildMap = /* @__PURE__ */ new Map();
-    /** Current leaf message ID (tip of the active path) */
-    this._currentLeafId = null;
-    /** Cached visible messages — invalidated on every mutation */
-    this._visibleCache = null;
-    if (messages?.length) {
-      this._buildFromMessages(messages);
-    }
+// src/chat/ChatWithTools.ts
+var ChatWithTools = class {
+  constructor(config, callbacks = {}) {
+    this.config = config;
+    this.callbacks = callbacks;
+    this.agentLoop = new AbstractAgentLoop(
+      {
+        maxIterations: config.maxIterations ?? 20,
+        tools: config.tools
+      },
+      {
+        onExecutionsChange: (executions) => {
+          callbacks.onToolExecutionsChange?.(executions);
+        },
+        onApprovalRequired: (execution) => {
+          callbacks.onApprovalRequired?.(execution);
+        }
+      }
+    );
+    this.chat = new AbstractChat({
+      runtimeUrl: config.runtimeUrl,
+      llm: config.llm,
+      systemPrompt: config.systemPrompt,
+      streaming: config.streaming,
+      headers: config.headers,
+      body: config.body,
+      optimization: config.optimization,
+      threadId: config.threadId,
+      debug: config.debug,
+      initialMessages: config.initialMessages,
+      state: config.state,
+      transport: config.transport,
+      callbacks: {
+        onMessagesChange: callbacks.onMessagesChange,
+        onStatusChange: callbacks.onStatusChange,
+        onError: callbacks.onError,
+        onMessageStart: callbacks.onMessageStart,
+        onMessageDelta: callbacks.onMessageDelta,
+        onMessageFinish: callbacks.onMessageFinish,
+        onToolCalls: callbacks.onToolCalls,
+        onFinish: callbacks.onFinish,
+        onContextUsageChange: callbacks.onContextUsageChange,
+        // 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();
   }
-  // ============================================
-  // Static Migration Helpers
-  // ============================================
   /**
-   * Convert a legacy flat array (no parentId) to a tree-linked array.
-   *
-   * Rules:
-   * - Tool messages get parentId = the owning assistant message's id
-   *   (matched via toolCallId → toolCall.id).
-   * - All other messages get parentId of the previous non-tool message
-   *   (or null for the first message).
-   *
-   * Returns a new array with parentId/childrenIds filled in.
-   * Does NOT mutate the original messages.
+   * Wire up internal events between chat and agent loop
    */
-  static fromFlatArray(messages) {
-    if (messages.length === 0) return messages;
-    const alreadyLinked = messages.some((m) => m.parentId !== void 0);
-    if (alreadyLinked) return messages;
-    const result = [];
-    let prevNonToolId = null;
-    const assistantById = /* @__PURE__ */ new Map();
-    for (const msg of messages) {
-      if (msg.role === "assistant") {
-        assistantById.set(msg.id, msg);
+  wireEvents() {
+    this.debug("Wiring up toolCalls event handler");
+    this.chat.on("toolCalls", async (event) => {
+      const toolCalls = event.toolCalls;
+      if (!toolCalls?.length) {
+        return;
       }
-    }
-    for (const msg of messages) {
-      if (msg.role === "tool" && msg.toolCallId) {
-        let ownerAssistantId = null;
-        for (const [, assistant] of assistantById) {
-          if (assistant.toolCalls?.some((tc) => tc.id === msg.toolCallId)) {
-            ownerAssistantId = assistant.id;
-            break;
+      this.debug("Tool calls received:", toolCalls.length);
+      const toolCallInfos = toolCalls.map((tc) => {
+        const tcAny = tc;
+        const name = tcAny.function?.name ?? tcAny.name ?? "";
+        let args = {};
+        if (tcAny.function?.arguments) {
+          try {
+            args = JSON.parse(tcAny.function.arguments);
+          } catch {
+            args = {};
           }
+        } else if (tcAny.args) {
+          args = tcAny.args;
         }
-        result.push({
-          ...msg,
-          parentId: ownerAssistantId ?? prevNonToolId,
-          childrenIds: []
-        });
-      } else {
-        result.push({
-          ...msg,
-          parentId: prevNonToolId,
-          childrenIds: []
-        });
-        prevNonToolId = msg.id;
-      }
-    }
-    const childrenMap = /* @__PURE__ */ new Map();
-    for (const msg of result) {
-      const parentKey = msg.parentId == null ? _MessageTree.ROOT_KEY : msg.parentId;
-      if (!childrenMap.has(parentKey)) {
-        childrenMap.set(parentKey, []);
+        return { id: tc.id, name, args };
+      });
+      try {
+        const results = await this.agentLoop.executeToolCalls(toolCallInfos);
+        this.debug("Tool results:", results);
+        if (results.length > 0) {
+          const toolResults = results.map((r) => ({
+            toolCallId: r.toolCallId,
+            result: r.success ? r.result : { success: false, error: r.error }
+          }));
+          await this.chat.continueWithToolResults(toolResults);
+        } else if (this.agentLoop.maxIterationsReached && toolCallInfos.length > 0) {
+          this.debug(
+            "Max iterations reached, stopping loop without new LLM request"
+          );
+          const errorMessage = this.config.maxIterationsMessage || "Tool execution paused: iteration limit reached. User can say 'continue' to resume.";
+          const blockedResults = toolCallInfos.map((tc) => ({
+            toolCallId: tc.id,
+            result: {
+              success: false,
+              error: errorMessage
+            }
+          }));
+          await this.chat.addToolResultMessages(blockedResults, errorMessage);
+        }
+      } catch (error) {
+        this.debug("Error executing tools:", error);
+        console.error("[ChatWithTools] Tool execution error:", error);
       }
-      childrenMap.get(parentKey).push(msg.id);
-    }
-    return result.map((msg) => ({
-      ...msg,
-      childrenIds: childrenMap.get(msg.id) ?? []
-    }));
+    });
   }
   // ============================================
-  // Core Queries
+  // Chat Getters
   // ============================================
-  /**
-   * Returns the visible path (root → current leaf) — what the UI renders
-   * and what gets sent to the API.
-   *
-   * Backward-compat: if NO message has parentId set (all undefined),
-   * falls back to insertion order (legacy linear mode).
-   */
-  getVisibleMessages() {
-    if (this._visibleCache !== null) return this._visibleCache;
-    if (this.nodeMap.size === 0) {
-      this._visibleCache = [];
-      return this._visibleCache;
-    }
-    const hasTreeStructure = Array.from(this.nodeMap.values()).some(
-      (m) => m.parentId !== void 0
-    );
-    this._visibleCache = hasTreeStructure ? this._getActivePath().map((id) => this.nodeMap.get(id)) : Array.from(this.nodeMap.values());
-    return this._visibleCache;
+  get messages() {
+    return this.chat.messages;
   }
-  _invalidateCache() {
-    this._visibleCache = null;
+  get status() {
+    return this.chat.status;
+  }
+  get error() {
+    return this.chat.error;
+  }
+  get isStreaming() {
+    return this.chat.isStreaming;
   }
   /**
-   * Returns ALL messages across every branch (for persistence / ThreadManager).
+   * Whether any operation is in progress (chat or tools)
+   * Use this to show loading indicators and disable send button
    */
-  getAllMessages() {
-    return Array.from(this.nodeMap.values());
+  get isLoading() {
+    const chatBusy = this.status === "submitted" || this.status === "streaming";
+    const toolsBusy = this.agentLoop.isProcessing;
+    const hasPendingApprovals = this.agentLoop.pendingApprovalExecutions.length > 0;
+    return chatBusy || toolsBusy || hasPendingApprovals;
   }
   /**
-   * Branch navigation info for the UI navigator.
-   * Returns null if the message has no siblings (only child).
+   * Check if a request is currently in progress (excludes pending approvals)
+   * Use this to prevent sending new messages
    */
-  getBranchInfo(messageId) {
-    const msg = this.nodeMap.get(messageId);
-    if (!msg) return null;
-    const parentKey = this._parentKey(msg.parentId);
-    const siblings = this.childrenOf.get(parentKey) ?? [];
-    if (siblings.length <= 1) return null;
-    const siblingIndex = siblings.indexOf(messageId);
-    return {
-      siblingIndex,
-      totalSiblings: siblings.length,
-      siblingIds: [...siblings],
-      hasPrevious: siblingIndex > 0,
-      hasNext: siblingIndex < siblings.length - 1
-    };
+  get isBusy() {
+    const chatBusy = this.status === "submitted" || this.status === "streaming";
+    const toolsBusy = this.agentLoop.isProcessing;
+    return chatBusy || toolsBusy;
   }
-  get currentLeafId() {
-    return this._currentLeafId;
+  // ============================================
+  // Tool Execution Getters
+  // ============================================
+  get toolExecutions() {
+    return this.agentLoop.toolExecutions;
   }
-  get hasBranches() {
-    for (const children of this.childrenOf.values()) {
-      if (children.length > 1) return true;
-    }
-    return false;
+  get tools() {
+    return this.agentLoop.tools;
+  }
+  get iteration() {
+    return this.agentLoop.iteration;
+  }
+  get maxIterations() {
+    return this.agentLoop.maxIterations;
+  }
+  get isProcessing() {
+    return this.agentLoop.isProcessing;
   }
   // ============================================
-  // Mutations
+  // Chat Actions
   // ============================================
   /**
-   * Insert a new message.
-   * - Updates childrenOf and nodeMap.
-   * - New branch becomes active (activeChildMap updated).
-   * - Updates current leaf.
+   * Send a message
+   * Returns false if a request is already in progress
+   *
+   * @param options.editMessageId - Edit flow: new message branches from the
+   *   same parent as this message ID
    */
-  addMessage(message) {
-    this.nodeMap.set(message.id, message);
-    const parentKey = this._parentKey(message.parentId);
-    if (!this.childrenOf.has(parentKey)) {
-      this.childrenOf.set(parentKey, []);
-    }
-    const siblings = this.childrenOf.get(parentKey);
-    if (!siblings.includes(message.id)) {
-      siblings.push(message.id);
+  async sendMessage(content, attachments, options) {
+    if (this.isLoading) {
+      this.debug("sendMessage blocked - request already in progress");
+      return false;
     }
-    this.activeChildMap.set(parentKey, message.id);
-    this._currentLeafId = this._walkToLeaf(message.id);
-    this._invalidateCache();
-    return message;
+    this.agentLoop.resetIterations();
+    return await this.chat.sendMessage(content, attachments, options);
   }
   /**
-   * Navigate: make messageId the active child at its parent fork,
-   * then walk to its leaf and update currentLeafId.
+   * Stop generation and cancel any running tools
    */
-  switchBranch(messageId) {
-    const msg = this.nodeMap.get(messageId);
-    if (!msg) return;
-    const parentKey = this._parentKey(msg.parentId);
-    this.activeChildMap.set(parentKey, messageId);
-    this._currentLeafId = this._walkToLeaf(messageId);
-    this._invalidateCache();
+  stop() {
+    this.agentLoop.cancel();
+    this.chat.stop();
+    this.debug("Stopped - cancelled tools and aborted stream");
   }
   /**
-   * Update message content in-place (streaming updates).
-   * No tree structure change.
+   * Clear all messages
    */
-  updateMessage(id, updater) {
-    const existing = this.nodeMap.get(id);
-    if (!existing) return false;
-    this.nodeMap.set(id, updater(existing));
-    this._invalidateCache();
-    return true;
+  clearMessages() {
+    this.chat.clearMessages();
+    this.agentLoop.clearToolExecutions();
   }
   /**
-   * Set current leaf explicitly.
-   * Used by regenerate() to rewind the active path before pushing a new message.
+   * Set messages directly
    */
-  setCurrentLeaf(leafId) {
-    this._currentLeafId = leafId;
-    if (leafId === null) return;
-    const msg = this.nodeMap.get(leafId);
-    if (!msg) return;
-    let current = msg;
-    while (current) {
-      const parentKey = this._parentKey(current.parentId);
-      this.activeChildMap.set(parentKey, current.id);
-      if (current.parentId == null || current.parentId === void 0) break;
-      current = this.nodeMap.get(current.parentId);
-    }
-    this._invalidateCache();
+  setMessages(messages) {
+    this.chat.setMessages(messages);
   }
   /**
-   * Rebuild entire tree from a message array.
-   * Used by setMessages().
+   * Regenerate last response
    */
-  reset(messages) {
-    this.nodeMap.clear();
-    this.childrenOf.clear();
-    this.activeChildMap.clear();
-    this._currentLeafId = null;
-    this._invalidateCache();
-    if (messages.length > 0) {
-      this._buildFromMessages(messages);
-    }
-  }
-  // ============================================
-  // Private Helpers
-  // ============================================
-  _buildFromMessages(messages) {
-    const linked = messages.some((m) => m.parentId !== void 0) ? messages : _MessageTree.fromFlatArray(messages);
-    for (const msg of linked) {
-      this.nodeMap.set(msg.id, msg);
-      const parentKey = this._parentKey(msg.parentId);
-      if (!this.childrenOf.has(parentKey)) {
-        this.childrenOf.set(parentKey, []);
-      }
-      const siblings = this.childrenOf.get(parentKey);
-      if (!siblings.includes(msg.id)) {
-        siblings.push(msg.id);
-      }
-    }
-    for (const [parentKey, children] of this.childrenOf) {
-      if (children.length > 0) {
-        this.activeChildMap.set(parentKey, children[children.length - 1]);
-      }
-    }
-    const path = this._getActivePath();
-    this._currentLeafId = path.length > 0 ? path[path.length - 1] : null;
+  async regenerate(messageId) {
+    await this.chat.regenerate(messageId);
   }
-  _parentKey(parentId) {
-    if (parentId == null || parentId === void 0) {
-      return _MessageTree.ROOT_KEY;
-    }
-    return parentId;
+  /**
+   * Set tools available for the LLM
+   */
+  setTools(tools) {
+    this.chat.setTools(tools);
   }
   /**
-   * Walk forward from a message along active children to find the leaf.
+   * Update prompt/tool optimization controls.
    */
-  _walkToLeaf(fromId) {
-    let current = fromId;
-    while (true) {
-      const children = this.childrenOf.get(current);
-      if (!children || children.length === 0) break;
-      const activeChild = this.activeChildMap.get(current);
-      if (!activeChild) break;
-      if (!this.nodeMap.has(activeChild)) break;
-      current = activeChild;
-    }
-    return current;
+  setOptimizationConfig(config) {
+    this.config.optimization = config;
+    this.chat.setOptimizationConfig(config);
   }
   /**
-   * Walk the active path from root to the current leaf.
+   * Set the active tool profile used for request-time tool selection.
    */
-  _getActivePath() {
-    const path = [];
-    const visited = /* @__PURE__ */ new Set();
-    const rootChildren = this.childrenOf.get(_MessageTree.ROOT_KEY) ?? [];
-    if (rootChildren.length === 0) return path;
-    let activeId = this.activeChildMap.get(_MessageTree.ROOT_KEY);
-    if (!activeId) {
-      activeId = rootChildren[rootChildren.length - 1];
-    }
-    let current = activeId;
-    while (current && !visited.has(current)) {
-      if (!this.nodeMap.has(current)) break;
-      visited.add(current);
-      path.push(current);
-      const activeChild = this.activeChildMap.get(current);
-      if (!activeChild || !this.nodeMap.has(activeChild)) break;
-      current = activeChild;
-    }
-    return path;
+  setToolProfile(profile) {
+    this.chat.setToolProfile(profile);
   }
-};
-/** Sentinel key used for root-level messages (parentId === null) */
-_MessageTree.ROOT_KEY = "__root__";
-var MessageTree = _MessageTree;
-
-// src/react/internal/ReactChatState.ts
-var ReactChatState = class {
-  constructor(initialMessages) {
-    this._status = "ready";
-    this._error = void 0;
-    // Callbacks for React subscriptions (useSyncExternalStore)
-    this.subscribers = /* @__PURE__ */ new Set();
-    // ============================================
-    // Subscription (for useSyncExternalStore)
-    // ============================================
-    /**
-     * Subscribe to state changes.
-     * Returns an unsubscribe function.
-     *
-     * @example
-     * ```tsx
-     * const messages = useSyncExternalStore(
-     *   state.subscribe,
-     *   () => state.messages
-     * );
-     * ```
-     */
-    this.subscribe = (callback) => {
-      this.subscribers.add(callback);
-      return () => {
-        this.subscribers.delete(callback);
-      };
-    };
-    this.tree = new MessageTree(initialMessages);
+  /**
+   * Get the most recent prompt context usage snapshot.
+   */
+  getContextUsage() {
+    return this.chat.getContextUsage();
   }
-  // ============================================
-  // Getters — visible path only
-  // ============================================
   /**
-   * Returns the VISIBLE PATH (active branch) — what the UI renders
-   * and what gets sent to the API.
-   *
-   * For all messages across all branches, use getAllMessages().
+   * Set dynamic context (from useAIContext hook)
    */
-  get messages() {
-    return this.tree.getVisibleMessages();
+  setContext(context) {
+    this.chat.setContext(context);
+  }
+  /**
+   * Set system prompt dynamically
+   */
+  setSystemPrompt(prompt) {
+    this.chat.setSystemPrompt(prompt);
+  }
+  /**
+   * Set headers configuration
+   * Can be static headers or a getter function for dynamic resolution
+   */
+  setHeaders(headers) {
+    this.chat.setHeaders(headers);
+  }
+  /**
+   * Set URL configuration
+   * Can be static URL or a getter function for dynamic resolution
+   */
+  setUrl(url) {
+    this.chat.setUrl(url);
+  }
+  /**
+   * Set body configuration
+   * Additional properties merged into every request body
+   */
+  setBody(body) {
+    this.chat.setBody(body);
+  }
+  setRequestMessageTransform(fn) {
+    this.chat.setRequestMessageTransform(fn);
+  }
+  /**
+   * Set inline skills (forwarded to underlying chat instance)
+   */
+  setInlineSkills(skills) {
+    this.chat.setInlineSkills(skills);
+  }
+  // ============================================
+  // Tool Registration
+  // ============================================
+  /**
+   * Register a tool
+   */
+  registerTool(tool) {
+    this.agentLoop.registerTool(tool);
+    this.chat.setTools(this.agentLoop.tools);
+  }
+  /**
+   * Unregister a tool
+   */
+  unregisterTool(name) {
+    this.agentLoop.unregisterTool(name);
+    this.chat.setTools(this.agentLoop.tools);
+  }
+  // ============================================
+  // Tool Approval
+  // ============================================
+  /**
+   * Approve a tool execution with optional extra data
+   */
+  approveToolExecution(id, extraData, permissionLevel) {
+    this.agentLoop.approveToolExecution(id, extraData, permissionLevel);
+  }
+  /**
+   * Reject a tool execution
+   */
+  rejectToolExecution(id, reason, permissionLevel) {
+    this.agentLoop.rejectToolExecution(id, reason, permissionLevel);
+  }
+  /**
+   * Clear tool executions
+   */
+  clearToolExecutions() {
+    this.agentLoop.clearToolExecutions();
+  }
+  // ============================================
+  // Event Subscriptions (for framework adapters)
+  // ============================================
+  /**
+   * Subscribe to chat events
+   */
+  on(event, handler) {
+    return this.chat.on(event, handler);
+  }
+  // ============================================
+  // 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
+   */
+  dispose() {
+    this.chat.dispose();
+    this.agentLoop.dispose();
+  }
+  // ============================================
+  // Private
+  // ============================================
+  debug(message, ...args) {
+    chunkKGYDGK3U_cjs.createLogger("tools", () => this.config.debug ?? false)(
+      message,
+      args.length === 1 ? args[0] : args.length > 1 ? args : void 0
+    );
+  }
+};
+
+// src/react/internal/ReactChatState.ts
+var ReactChatState = class {
+  constructor(initialMessages) {
+    this._status = "ready";
+    this._error = void 0;
+    // Callbacks for React subscriptions (useSyncExternalStore)
+    this.subscribers = /* @__PURE__ */ new Set();
+    // ============================================
+    // Subscription (for useSyncExternalStore)
+    // ============================================
+    /**
+     * Subscribe to state changes.
+     * Returns an unsubscribe function.
+     *
+     * @example
+     * ```tsx
+     * const messages = useSyncExternalStore(
+     *   state.subscribe,
+     *   () => state.messages
+     * );
+     * ```
+     */
+    this.subscribe = (callback) => {
+      this.subscribers.add(callback);
+      return () => {
+        this.subscribers.delete(callback);
+      };
+    };
+    this.tree = new MessageTree(initialMessages);
+  }
+  // ============================================
+  // Getters — visible path only
+  // ============================================
+  /**
+   * Returns the VISIBLE PATH (active branch) — what the UI renders
+   * and what gets sent to the API.
+   *
+   * For all messages across all branches, use getAllMessages().
+   */
+  get messages() {
+    return this.tree.getVisibleMessages();
   }
   get status() {
     return this._status;
@@ -3807,149 +3875,21 @@ var ReactChatState = class {
 function createReactChatState(initialMessages) {
   return new ReactChatState(initialMessages);
 }
-
-// src/react/internal/ReactChatWithTools.ts
-var ReactChatWithTools = class extends ChatWithTools {
-  constructor(config, callbacks = {}) {
-    const reactState = new ReactChatState(config.initialMessages);
-    super({ ...config, state: reactState }, callbacks);
-    /**
-     * Subscribe to state changes (for useSyncExternalStore)
-     */
-    this.subscribe = (callback) => {
-      return this.reactState.subscribe(callback);
-    };
-    this.reactState = reactState;
-  }
-  // ============================================
-  // Branching API — pass-throughs to ReactChatState
-  // ============================================
-  /**
-   * Navigate to a sibling branch.
-   */
-  switchBranch(messageId) {
-    this.reactState.switchBranch(messageId);
-  }
-  /**
-   * Get branch navigation info for a message.
-   */
-  getBranchInfo(messageId) {
-    return this.reactState.getBranchInfo(messageId);
-  }
-  /**
-   * Get all messages across all branches (for persistence).
-   */
-  getAllMessages() {
-    return this.reactState.getAllMessages();
-  }
-  /**
-   * Whether any message has siblings (branching has occurred).
-   */
-  get hasBranches() {
-    return this.reactState.hasBranches;
-  }
-  /**
-   * Dispose and cleanup
-   */
-  dispose() {
-    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
-function addNode(tree, node, parentId) {
-  const newNode = {
-    ...node,
-    children: node.children || []
-  };
-  if (!parentId) {
-    return [...tree, newNode];
-  }
-  return tree.map((n) => {
-    if (n.id === parentId) {
-      return { ...n, children: [...n.children, newNode] };
-    }
-    if (n.children.length > 0) {
-      return { ...n, children: addNode(n.children, node, parentId) };
-    }
-    return n;
-  });
-}
-function removeNode(tree, id) {
-  return tree.reduce((result, node) => {
-    if (node.id !== id) {
-      const newNode = { ...node, children: removeNode(node.children, id) };
-      result.push(newNode);
-    }
-    return result;
-  }, []);
-}
-function getIndentPrefix(index, level) {
-  if (level === 0) {
-    return `${index + 1}.`;
-  } else if (level === 1) {
-    return `${String.fromCharCode(65 + index)}.`;
-  } else if (level === 2) {
-    return `${String.fromCharCode(97 + index)}.`;
-  } else {
-    return "-";
-  }
-}
-function printNode(node, prefix = "", indentLevel = 0) {
-  const indent = "   ".repeat(indentLevel);
-  const prefixLength = prefix.length + indent.length;
-  const subsequentIndent = " ".repeat(prefixLength);
-  const lines = node.value.split("\n");
-  const firstLine = `${indent}${prefix}${lines[0]}`;
-  const subsequentLines = lines.slice(1).map((line) => `${subsequentIndent}${line}`).join("\n");
-  let output = `${firstLine}
-`;
-  if (subsequentLines) {
-    output += `${subsequentLines}
-`;
-  }
-  node.children.forEach((child, index) => {
-    const childPrefix = `${" ".repeat(prefix.length)}${getIndentPrefix(index, indentLevel + 1)} `;
-    output += printNode(child, childPrefix, indentLevel + 1);
-  });
-  return output;
-}
-function printTree(tree) {
-  if (tree.length === 0) {
-    return "";
-  }
-  let output = "";
-  tree.forEach((node, index) => {
-    if (index > 0) {
-      output += "\n";
-    }
-    output += printNode(node, `${getIndentPrefix(index, 0)} `);
-  });
-  return output.trim();
-}
-function useMCPClient(config) {
-  const {
-    autoConnect = true,
-    onConnectionStateChange,
-    onToolsChange,
-    onElicitationRequest,
-    onError,
-    onNotification,
-    ...clientConfig
-  } = config;
-  const clientRef = React2.useRef(null);
-  const mountedRef = React2.useRef(true);
-  const [state, setState] = React2.useState({
-    connectionState: "disconnected",
-    tools: []
+function useMCPClient(config) {
+  const {
+    autoConnect = true,
+    onConnectionStateChange,
+    onToolsChange,
+    onElicitationRequest,
+    onError,
+    onNotification,
+    ...clientConfig
+  } = config;
+  const clientRef = React2.useRef(null);
+  const mountedRef = React2.useRef(true);
+  const [state, setState] = React2.useState({
+    connectionState: "disconnected",
+    tools: []
   });
   const getClient = React2.useCallback(() => {
     if (!clientRef.current) {
@@ -4082,78 +4022,132 @@ function useMCPClient(config) {
   };
 }
 
-// src/react/hooks/useMCPTools.ts
-function useMCPTools(config) {
-  const {
-    prefixToolNames = true,
-    autoRegister = true,
-    hidden = false,
-    source = "mcp",
-    ...clientConfig
-  } = config;
-  const { registerTool, unregisterTool } = useCopilot();
-  const registeredToolsRef = React2.useRef([]);
-  const mcpClient = useMCPClient(clientConfig);
-  const toolAdapter = React2.useMemo(
-    () => new chunkJGPDQDY4_cjs.MCPToolAdapter(clientConfig.name),
-    [clientConfig.name]
-  );
-  const toolDefinitions = React2.useMemo(() => {
-    if (!mcpClient.isConnected || mcpClient.state.tools.length === 0) {
-      return [];
+// src/react/internal/ReactChatWithTools.ts
+var ReactChatWithTools = class extends ChatWithTools {
+  constructor(config, callbacks = {}) {
+    const reactState = new ReactChatState(config.initialMessages);
+    super({ ...config, state: reactState }, callbacks);
+    /**
+     * Subscribe to state changes (for useSyncExternalStore)
+     */
+    this.subscribe = (callback) => {
+      return this.reactState.subscribe(callback);
+    };
+    this.reactState = reactState;
+  }
+  // ============================================
+  // Branching API — pass-throughs to ReactChatState
+  // ============================================
+  /**
+   * Navigate to a sibling branch.
+   */
+  switchBranch(messageId) {
+    this.reactState.switchBranch(messageId);
+  }
+  /**
+   * Get branch navigation info for a message.
+   */
+  getBranchInfo(messageId) {
+    return this.reactState.getBranchInfo(messageId);
+  }
+  /**
+   * Get all messages across all branches (for persistence).
+   */
+  getAllMessages() {
+    return this.reactState.getAllMessages();
+  }
+  /**
+   * Whether any message has siblings (branching has occurred).
+   */
+  get hasBranches() {
+    return this.reactState.hasBranches;
+  }
+  /**
+   * Dispose and cleanup
+   */
+  dispose() {
+    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
+function addNode(tree, node, parentId) {
+  const newNode = {
+    ...node,
+    children: node.children || []
+  };
+  if (!parentId) {
+    return [...tree, newNode];
+  }
+  return tree.map((n) => {
+    if (n.id === parentId) {
+      return { ...n, children: [...n.children, newNode] };
     }
-    return mcpClient.state.tools.map(
-      (tool2) => toolAdapter.toToolDefinition(tool2, {
-        prefix: prefixToolNames,
-        asServerTool: true,
-        // MCP tools execute remotely
-        callTool: mcpClient.callTool,
-        hidden,
-        // Hide from chat UI
-        source
-        // Tool source for UI differentiation
-      })
-    );
-  }, [
-    mcpClient.isConnected,
-    mcpClient.state.tools,
-    mcpClient.callTool,
-    toolAdapter,
-    prefixToolNames,
-    hidden,
-    source
-  ]);
-  React2.useEffect(() => {
-    if (!autoRegister) {
-      return;
+    if (n.children.length > 0) {
+      return { ...n, children: addNode(n.children, node, parentId) };
     }
-    for (const toolName of registeredToolsRef.current) {
-      unregisterTool(toolName);
+    return n;
+  });
+}
+function removeNode(tree, id) {
+  return tree.reduce((result, node) => {
+    if (node.id !== id) {
+      const newNode = { ...node, children: removeNode(node.children, id) };
+      result.push(newNode);
     }
-    registeredToolsRef.current = [];
-    if (mcpClient.isConnected && toolDefinitions.length > 0) {
-      for (const tool2 of toolDefinitions) {
-        registerTool(tool2);
-        registeredToolsRef.current.push(tool2.name);
-      }
+    return result;
+  }, []);
+}
+function getIndentPrefix(index, level) {
+  if (level === 0) {
+    return `${index + 1}.`;
+  } else if (level === 1) {
+    return `${String.fromCharCode(65 + index)}.`;
+  } else if (level === 2) {
+    return `${String.fromCharCode(97 + index)}.`;
+  } else {
+    return "-";
+  }
+}
+function printNode(node, prefix = "", indentLevel = 0) {
+  const indent = "   ".repeat(indentLevel);
+  const prefixLength = prefix.length + indent.length;
+  const subsequentIndent = " ".repeat(prefixLength);
+  const lines = node.value.split("\n");
+  const firstLine = `${indent}${prefix}${lines[0]}`;
+  const subsequentLines = lines.slice(1).map((line) => `${subsequentIndent}${line}`).join("\n");
+  let output = `${firstLine}
+`;
+  if (subsequentLines) {
+    output += `${subsequentLines}
+`;
+  }
+  node.children.forEach((child, index) => {
+    const childPrefix = `${" ".repeat(prefix.length)}${getIndentPrefix(index, indentLevel + 1)} `;
+    output += printNode(child, childPrefix, indentLevel + 1);
+  });
+  return output;
+}
+function printTree(tree) {
+  if (tree.length === 0) {
+    return "";
+  }
+  let output = "";
+  tree.forEach((node, index) => {
+    if (index > 0) {
+      output += "\n";
     }
-    return () => {
-      for (const toolName of registeredToolsRef.current) {
-        unregisterTool(toolName);
-      }
-      registeredToolsRef.current = [];
-    };
-  }, [
-    autoRegister,
-    mcpClient.isConnected,
-    toolDefinitions,
-    registerTool,
-    unregisterTool
-  ]);
-  return {
-    ...mcpClient,
-    toolDefinitions
-  };
+    output += printNode(node, `${getIndentPrefix(index, 0)} `);
+  });
+  return output.trim();
 }
 var defaultTokenUsage = {
   current: 0,
@@ -4857,12 +4851,12 @@ function useTool(config, dependencies = []) {
   configRef.current = config;
   const inputSchema = React2.useMemo(() => {
     if (isZodSchema(config.inputSchema)) {
-      return chunkWIXFZUEZ_cjs.zodToJsonSchema(config.inputSchema);
+      return chunkKGYDGK3U_cjs.zodToJsonSchema(config.inputSchema);
     }
     return config.inputSchema;
   }, [config.inputSchema]);
   React2.useEffect(() => {
-    const tool2 = {
+    const tool = {
       name: config.name,
       description: config.description,
       location: "client",
@@ -4888,7 +4882,7 @@ function useTool(config, dependencies = []) {
       aiResponseMode: config.aiResponseMode,
       aiContext: config.aiContext
     };
-    registerTool(tool2);
+    registerTool(tool);
     return () => {
       unregisterTool(config.name);
     };
@@ -5182,6 +5176,35 @@ ${cs.rollingSummary}`,
   }, []);
   return null;
 }
+var _MessageMetaStore = class _MessageMetaStore {
+  constructor() {
+    this.store = /* @__PURE__ */ new Map();
+    this.listeners = /* @__PURE__ */ new Set();
+    this.subscribe = (cb) => {
+      this.listeners.add(cb);
+      return () => this.listeners.delete(cb);
+    };
+    this.getSnapshot = () => this.store;
+    this.getMeta = (messageId) => this.store.get(messageId) ?? _MessageMetaStore.EMPTY;
+    this.setMeta = (messageId, meta) => {
+      this.store.set(messageId, meta);
+      this.listeners.forEach((cb) => cb());
+    };
+    this.updateMeta = (messageId, updater) => {
+      const prev = this.store.get(messageId) ?? {};
+      this.store.set(messageId, updater(prev));
+      this.listeners.forEach((cb) => cb());
+    };
+    this.clear = () => {
+      this.store.clear();
+      this.listeners.forEach((cb) => cb());
+    };
+  }
+};
+// Stable empty object — returned for unknown messageIds so useSyncExternalStore
+// sees the same reference and doesn't trigger infinite re-renders.
+_MessageMetaStore.EMPTY = {};
+var MessageMetaStore = _MessageMetaStore;
 var CopilotContext = React2.createContext(null);
 function useCopilot() {
   const context = React2.useContext(CopilotContext);
@@ -5210,9 +5233,18 @@ function CopilotProvider({
   messageHistory,
   skills
 }) {
+  const streamListenersRef = React2.useRef(/* @__PURE__ */ new Set());
+  const subscribeToStreamEvents = React2.useCallback(
+    (handler) => {
+      streamListenersRef.current.add(handler);
+      return () => streamListenersRef.current.delete(handler);
+    },
+    []
+  );
+  const messageMetaStoreRef = React2.useRef(new MessageMetaStore());
   const debugLog = React2.useCallback(
     (action, data) => {
-      chunkWIXFZUEZ_cjs.createLogger("provider", () => debug ?? false)(action, data);
+      chunkKGYDGK3U_cjs.createLogger("provider", () => debug ?? false)(action, data);
     },
     [debug]
   );
@@ -5224,6 +5256,7 @@ function CopilotProvider({
     }
   }, [toolsConfig]);
   const [toolExecutions, setToolExecutions] = React2.useState([]);
+  const [agentIteration, setAgentIteration] = React2.useState(0);
   const chatRef = React2.useRef(null);
   if (chatRef.current !== null && chatRef.current.disposed) {
     chatRef.current.revive();
@@ -5238,7 +5271,9 @@ function CopilotProvider({
         createdAt: m.created_at ?? /* @__PURE__ */ new Date(),
         attachments: m.metadata?.attachments,
         toolCalls: m.tool_calls,
-        toolCallId: m.tool_call_id
+        toolCallId: m.tool_call_id,
+        parentId: m.parent_id,
+        childrenIds: m.children_ids
       })
     );
     chatRef.current = new ReactChatWithTools(
@@ -5259,6 +5294,7 @@ function CopilotProvider({
         onToolExecutionsChange: (executions) => {
           debugLog("Tool executions changed:", executions.length);
           setToolExecutions(executions);
+          setAgentIteration(chatRef.current?.iteration ?? 0);
         },
         onApprovalRequired: (execution) => {
           debugLog("Tool approval required:", execution.name);
@@ -5268,6 +5304,13 @@ function CopilotProvider({
         },
         onError: (error2) => {
           if (error2) onError?.(error2);
+        },
+        onStreamChunk: (chunk) => {
+          if (streamListenersRef.current.size > 0) {
+            for (const handler of streamListenersRef.current) {
+              handler(chunk);
+            }
+          }
         }
       }
     );
@@ -5321,8 +5364,8 @@ function CopilotProvider({
   );
   const error = errorFromChat ?? null;
   const isLoading = status === "streaming" || status === "submitted";
-  const registerTool = React2.useCallback((tool2) => {
-    chatRef.current?.registerTool(tool2);
+  const registerTool = React2.useCallback((tool) => {
+    chatRef.current?.registerTool(tool);
   }, []);
   const unregisterTool = React2.useCallback((name) => {
     chatRef.current?.unregisterTool(name);
@@ -5379,2005 +5422,41 @@ function CopilotProvider({
       chatRef.current?.setContext(contextString);
       setContextChars(contextString.length);
       debugLog("Context added:", id);
-      return id;
-    },
-    [debugLog]
-  );
-  const removeContext = React2.useCallback(
-    (id) => {
-      contextTreeRef.current = removeNode(contextTreeRef.current, id);
-      const contextString = printTree(contextTreeRef.current);
-      chatRef.current?.setContext(contextString);
-      setContextChars(contextString.length);
-      debugLog("Context removed:", id);
-    },
-    [debugLog]
-  );
-  const setSystemPrompt = React2.useCallback(
-    (prompt) => {
-      chatRef.current?.setSystemPrompt(prompt);
-      debugLog("System prompt updated via function");
-    },
-    [debugLog]
-  );
-  const setInlineSkills = React2.useCallback(
-    (skills2) => {
-      chatRef.current?.setInlineSkills(skills2);
-      debugLog("Inline skills updated", { count: skills2.length });
-    },
-    [debugLog]
-  );
-  const sendMessage = React2.useCallback(
-    async (content, attachments) => {
-      debugLog("Sending message:", content);
-      await chatRef.current?.sendMessage(content, attachments);
-    },
-    [debugLog]
-  );
-  const stop = React2.useCallback(() => {
-    chatRef.current?.stop();
-  }, []);
-  const clearMessages = React2.useCallback(() => {
-    chatRef.current?.clearMessages();
-  }, []);
-  const setMessages = React2.useCallback((messages2) => {
-    chatRef.current?.setMessages(messages2);
-  }, []);
-  const regenerate = React2.useCallback(async (messageId) => {
-    await chatRef.current?.regenerate(messageId);
-  }, []);
-  const switchBranch = React2.useCallback((messageId) => {
-    chatRef.current?.switchBranch(messageId);
-  }, []);
-  const getBranchInfo = React2.useCallback(
-    (messageId) => chatRef.current?.getBranchInfo(messageId) ?? null,
-    []
-  );
-  const editMessage = React2.useCallback(
-    async (messageId, newContent) => {
-      await chatRef.current?.sendMessage(newContent, void 0, {
-        editMessageId: messageId
-      });
-    },
-    []
-  );
-  const getHasBranchesSnapshot = React2.useCallback(
-    () => chatRef.current.hasBranches,
-    []
-  );
-  const hasBranches = React2.useSyncExternalStore(
-    chatRef.current.subscribe,
-    getHasBranchesSnapshot,
-    () => false
-  );
-  const getAllMessages = React2.useCallback(
-    () => chatRef.current?.getAllMessages?.() ?? [],
-    []
-  );
-  React2.useEffect(() => {
-    if (onMessagesChange && messages.length > 0) {
-      const allUIMessages = chatRef.current?.getAllMessages?.() ?? messages;
-      const coreMessages = allUIMessages.map((m) => ({
-        id: m.id,
-        role: m.role,
-        content: m.content,
-        created_at: m.createdAt,
-        tool_calls: m.toolCalls,
-        tool_call_id: m.toolCallId,
-        parent_id: m.parentId,
-        children_ids: m.childrenIds,
-        metadata: {
-          attachments: m.attachments,
-          thinking: m.thinking
-        }
-      }));
-      onMessagesChange(coreMessages);
-    }
-  }, [messages, onMessagesChange]);
-  React2.useEffect(() => {
-    if (error && onError) {
-      onError(error);
-    }
-  }, [error, onError]);
-  React2.useEffect(() => {
-    return () => {
-      chatRef.current?.dispose();
-    };
-  }, []);
-  const contextValue = React2.useMemo(
-    () => ({
-      // Chat state
-      messages,
-      status,
-      error,
-      isLoading,
-      // Chat actions
-      sendMessage,
-      stop,
-      clearMessages,
-      setMessages,
-      regenerate,
-      // Branching
-      switchBranch,
-      getBranchInfo,
-      editMessage,
-      hasBranches,
-      getAllMessages,
-      // Tool execution
-      registerTool,
-      unregisterTool,
-      registeredTools,
-      toolExecutions,
-      pendingApprovals,
-      approveToolExecution,
-      rejectToolExecution,
-      // Actions
-      registerAction,
-      unregisterAction,
-      registeredActions,
-      // AI Context
-      addContext,
-      removeContext,
-      contextChars,
-      contextUsage,
-      // System Prompt
-      setSystemPrompt,
-      // Skills
-      setInlineSkills,
-      // Config
-      threadId,
-      runtimeUrl,
-      toolsConfig
-    }),
-    [
-      messages,
-      status,
-      error,
-      isLoading,
-      sendMessage,
-      stop,
-      clearMessages,
-      setMessages,
-      regenerate,
-      switchBranch,
-      getBranchInfo,
-      editMessage,
-      hasBranches,
-      getAllMessages,
-      registerTool,
-      unregisterTool,
-      registeredTools,
-      toolExecutions,
-      pendingApprovals,
-      approveToolExecution,
-      rejectToolExecution,
-      registerAction,
-      unregisterAction,
-      registeredActions,
-      addContext,
-      removeContext,
-      contextChars,
-      contextUsage,
-      setSystemPrompt,
-      setInlineSkills,
-      threadId,
-      runtimeUrl,
-      toolsConfig
-    ]
-  );
-  const messageHistoryContextValue = React2__default.default.useMemo(
-    () => ({
-      config: { ...defaultMessageHistoryConfig, ...messageHistory },
-      tokenUsage: {
-        current: 0,
-        max: messageHistory?.maxContextTokens ?? 128e3,
-        percentage: 0,
-        isApproaching: false
-      },
-      compactionState: {
-        rollingSummary: null,
-        lastCompactionAt: null,
-        compactionCount: 0,
-        totalTokensSaved: 0,
-        workingMemory: [],
-        displayMessageCount: 0,
-        llmMessageCount: 0
-      }
-    }),
-    [messageHistory]
-  );
-  return /* @__PURE__ */ jsxRuntime.jsx(MessageHistoryContext.Provider, { value: messageHistoryContextValue, children: /* @__PURE__ */ jsxRuntime.jsxs(CopilotContext.Provider, { value: contextValue, children: [
-    mcpServers?.map((config) => /* @__PURE__ */ jsxRuntime.jsx(MCPConnection, { config }, config.name)),
-    messageHistory?.strategy && messageHistory.strategy !== "none" && /* @__PURE__ */ jsxRuntime.jsx(MessageHistoryBridge, { chatRef }),
-    skills ? /* @__PURE__ */ jsxRuntime.jsx(SkillProvider, { skills, children }) : children
-  ] }) });
-}
-function useAIActions(actions) {
-  const { registerAction, unregisterAction } = useCopilot();
-  React2.useEffect(() => {
-    for (const action of actions) {
-      registerAction(action);
-    }
-    return () => {
-      for (const action of actions) {
-        unregisterAction(action.name);
-      }
-    };
-  }, [actions, registerAction, unregisterAction]);
-}
-function useAIAction(action) {
-  useAIActions([action]);
-}
-function useAITools(options = {}) {
-  const {
-    screenshot = false,
-    console: consoleCapture = false,
-    network = false,
-    requireConsent = true,
-    screenshotOptions,
-    consoleOptions,
-    networkOptions,
-    onConsentRequest,
-    autoStart = true
-  } = options;
-  const [isEnabled] = React2.useState(screenshot || consoleCapture || network);
-  const [activeCaptures, setActiveCaptures] = React2.useState({
-    console: false,
-    network: false
-  });
-  const [pendingConsent, setPendingConsent] = React2.useState(null);
-  const consentResolverRef = React2.useRef(null);
-  const rememberedConsentRef = React2.useRef(/* @__PURE__ */ new Set());
-  React2.useEffect(() => {
-    if (!autoStart || !isEnabled) return;
-    if (consoleCapture && !chunkWIXFZUEZ_cjs.isConsoleCaptureActive()) {
-      chunkWIXFZUEZ_cjs.startConsoleCapture(consoleOptions);
-      setActiveCaptures((prev) => ({ ...prev, console: true }));
-    }
-    if (network && !chunkWIXFZUEZ_cjs.isNetworkCaptureActive()) {
-      chunkWIXFZUEZ_cjs.startNetworkCapture(networkOptions);
-      setActiveCaptures((prev) => ({ ...prev, network: true }));
-    }
-    return () => {
-      chunkWIXFZUEZ_cjs.stopConsoleCapture();
-      chunkWIXFZUEZ_cjs.stopNetworkCapture();
-    };
-  }, [
-    autoStart,
-    isEnabled,
-    consoleCapture,
-    network,
-    consoleOptions,
-    networkOptions
-  ]);
-  const captureScreenshotFn = React2.useCallback(
-    async (opts) => {
-      if (!screenshot) {
-        throw new Error("Screenshot capture is not enabled");
-      }
-      if (!chunkWIXFZUEZ_cjs.isScreenshotSupported()) {
-        throw new Error(
-          "Screenshot capture is not supported in this environment"
-        );
-      }
-      return chunkWIXFZUEZ_cjs.captureScreenshot({ ...screenshotOptions, ...opts });
-    },
-    [screenshot, screenshotOptions]
-  );
-  const getConsoleLogsFn = React2.useCallback(
-    (opts) => {
-      if (!consoleCapture) {
-        return { logs: [], totalCaptured: 0 };
-      }
-      return chunkWIXFZUEZ_cjs.getConsoleLogs({ ...consoleOptions, ...opts });
-    },
-    [consoleCapture, consoleOptions]
-  );
-  const getNetworkRequestsFn = React2.useCallback(
-    (opts) => {
-      if (!network) {
-        return { requests: [], totalCaptured: 0 };
-      }
-      return chunkWIXFZUEZ_cjs.getNetworkRequests({ ...networkOptions, ...opts });
-    },
-    [network, networkOptions]
-  );
-  const requestConsent = React2.useCallback(
-    async (tools, reason = "") => {
-      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) {
-        return { approved: [], denied: [] };
-      }
-      if (!requireConsent) {
-        return { approved: enabledTools, denied: [] };
-      }
-      const needsConsent = enabledTools.filter(
-        (tool2) => !rememberedConsentRef.current.has(tool2)
-      );
-      if (needsConsent.length === 0) {
-        return { approved: enabledTools, denied: [] };
-      }
-      const request = {
-        tools: needsConsent,
-        reason,
-        keywords: []
-      };
-      if (onConsentRequest) {
-        const response = await onConsentRequest(request);
-        if (response.remember) {
-          response.approved.forEach(
-            (tool2) => rememberedConsentRef.current.add(tool2)
-          );
-        }
-        return response;
-      }
-      return new Promise((resolve) => {
-        setPendingConsent(request);
-        consentResolverRef.current = (response) => {
-          if (response.remember) {
-            response.approved.forEach(
-              (tool2) => rememberedConsentRef.current.add(tool2)
-            );
-          }
-          resolve(response);
-        };
-      });
-    },
-    [screenshot, consoleCapture, network, requireConsent, onConsentRequest]
-  );
-  const respondToConsent = React2.useCallback((response) => {
-    if (consentResolverRef.current) {
-      consentResolverRef.current(response);
-      consentResolverRef.current = null;
-    }
-    setPendingConsent(null);
-  }, []);
-  const captureContext = React2.useCallback(
-    async (tools) => {
-      const toolsToCapture = tools || ["screenshot", "console", "network"];
-      const context = {
-        timestamp: Date.now()
-      };
-      const captures = [];
-      if (toolsToCapture.includes("screenshot") && screenshot) {
-        captures.push(
-          captureScreenshotFn().then((result) => {
-            context.screenshot = result;
-          }).catch(() => {
-          })
-        );
-      }
-      if (toolsToCapture.includes("console") && consoleCapture) {
-        context.consoleLogs = getConsoleLogsFn();
-      }
-      if (toolsToCapture.includes("network") && network) {
-        context.networkRequests = getNetworkRequestsFn();
-      }
-      await Promise.all(captures);
-      return context;
-    },
-    [
-      screenshot,
-      consoleCapture,
-      network,
-      captureScreenshotFn,
-      getConsoleLogsFn,
-      getNetworkRequestsFn
-    ]
-  );
-  const startCapturing = React2.useCallback(() => {
-    if (consoleCapture && !chunkWIXFZUEZ_cjs.isConsoleCaptureActive()) {
-      chunkWIXFZUEZ_cjs.startConsoleCapture(consoleOptions);
-      setActiveCaptures((prev) => ({ ...prev, console: true }));
-    }
-    if (network && !chunkWIXFZUEZ_cjs.isNetworkCaptureActive()) {
-      chunkWIXFZUEZ_cjs.startNetworkCapture(networkOptions);
-      setActiveCaptures((prev) => ({ ...prev, network: true }));
-    }
-  }, [consoleCapture, network, consoleOptions, networkOptions]);
-  const stopCapturing = React2.useCallback(() => {
-    chunkWIXFZUEZ_cjs.stopConsoleCapture();
-    chunkWIXFZUEZ_cjs.stopNetworkCapture();
-    setActiveCaptures({ console: false, network: false });
-  }, []);
-  const clearCaptured = React2.useCallback(() => {
-    chunkWIXFZUEZ_cjs.clearConsoleLogs();
-    chunkWIXFZUEZ_cjs.clearNetworkRequests();
-  }, []);
-  const formatForAI = React2.useCallback((context) => {
-    const parts = [];
-    if (context.screenshot) {
-      parts.push(
-        `Screenshot captured (${context.screenshot.width}x${context.screenshot.height}, ${context.screenshot.format})`
-      );
-    }
-    if (context.consoleLogs && context.consoleLogs.logs.length > 0) {
-      parts.push(chunkWIXFZUEZ_cjs.formatLogsForAI(context.consoleLogs.logs));
-    }
-    if (context.networkRequests && context.networkRequests.requests.length > 0) {
-      parts.push(chunkWIXFZUEZ_cjs.formatRequestsForAI(context.networkRequests.requests));
-    }
-    return parts.length > 0 ? parts.join("\n\n---\n\n") : "No context captured.";
-  }, []);
-  const detectIntentFn = React2.useCallback(
-    (message) => {
-      const result = chunkWIXFZUEZ_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;
-    },
-    [screenshot, consoleCapture, network]
-  );
-  return React2.useMemo(
-    () => ({
-      isEnabled,
-      activeCaptures,
-      captureScreenshot: captureScreenshotFn,
-      getConsoleLogs: getConsoleLogsFn,
-      getNetworkRequests: getNetworkRequestsFn,
-      captureContext,
-      detectIntent: detectIntentFn,
-      requestConsent,
-      startCapturing,
-      stopCapturing,
-      clearCaptured,
-      formatForAI,
-      pendingConsent,
-      respondToConsent
-    }),
-    [
-      isEnabled,
-      activeCaptures,
-      captureScreenshotFn,
-      getConsoleLogsFn,
-      getNetworkRequestsFn,
-      captureContext,
-      detectIntentFn,
-      requestConsent,
-      startCapturing,
-      stopCapturing,
-      clearCaptured,
-      formatForAI,
-      pendingConsent,
-      respondToConsent
-    ]
-  );
-}
-function convertZodSchema(schema, _toolName) {
-  try {
-    const zodWithJsonSchema = z__namespace;
-    if (typeof zodWithJsonSchema.toJSONSchema === "function") {
-      const jsonSchema = zodWithJsonSchema.toJSONSchema(
-        schema
-      );
-      if (jsonSchema.type === "object") {
-        return {
-          type: "object",
-          properties: jsonSchema.properties || {},
-          required: jsonSchema.required
-        };
-      }
-    }
-  } catch {
-  }
-  return chunkWIXFZUEZ_cjs.zodObjectToInputSchema(schema);
-}
-function useToolWithSchema(config, dependencies = []) {
-  const { registerTool, unregisterTool } = useCopilot();
-  const configRef = React2.useRef(config);
-  configRef.current = config;
-  const inputSchema = React2.useMemo(() => {
-    try {
-      return convertZodSchema(config.schema, config.name);
-    } catch (error) {
-      console.warn(
-        `[useToolWithSchema] Failed to convert Zod schema for tool "${config.name}"`,
-        error
-      );
-      return {
-        type: "object",
-        properties: {}
-      };
-    }
-  }, [config.schema, config.name]);
-  React2.useEffect(() => {
-    const tool2 = {
-      name: config.name,
-      description: config.description,
-      location: "client",
-      inputSchema,
-      handler: async (params, context) => {
-        return configRef.current.handler(params, context);
-      },
-      render: config.render,
-      available: config.available ?? true
-    };
-    registerTool(tool2);
-    return () => {
-      unregisterTool(config.name);
-    };
-  }, [config.name, inputSchema, ...dependencies]);
-}
-function useToolsWithSchema(tools, dependencies = []) {
-  const { registerTool, unregisterTool } = useCopilot();
-  const toolsRef = React2.useRef(tools);
-  toolsRef.current = tools;
-  React2.useEffect(() => {
-    const toolNames = [];
-    for (const config of tools) {
-      let inputSchema;
-      try {
-        inputSchema = convertZodSchema(config.schema, config.name);
-      } catch (error) {
-        console.warn(
-          `[useToolsWithSchema] Failed to convert Zod schema for tool "${config.name}"`,
-          error
-        );
-        inputSchema = { type: "object", properties: {} };
-      }
-      const tool2 = {
-        name: config.name,
-        description: config.description,
-        location: "client",
-        inputSchema,
-        handler: async (params, context) => {
-          const currentConfig = toolsRef.current.find(
-            (t) => t.name === config.name
-          );
-          if (currentConfig) {
-            return currentConfig.handler(params, context);
-          }
-          return { success: false, error: "Tool handler not found" };
-        },
-        available: config.available ?? true
-      };
-      registerTool(tool2);
-      toolNames.push(config.name);
-    }
-    return () => {
-      for (const name of toolNames) {
-        unregisterTool(name);
-      }
-    };
-  }, [tools.map((t) => t.name).join(","), ...dependencies]);
-}
-var CopilotContext2 = React2.createContext(null);
-function useCopilotContext() {
-  const context = React2.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,
-    config,
-    chat,
-    addToolExecution,
-    updateToolExecution
-  } = useCopilotContext();
-  const toolsRef = React2.useRef(registeredTools);
-  toolsRef.current = registeredTools;
-  const executeTool = React2.useCallback(
-    async (toolCall) => {
-      const tool2 = toolsRef.current.find((t) => t.name === toolCall.name);
-      if (!tool2) {
-        return {
-          success: false,
-          error: `Unknown tool: ${toolCall.name}`
-        };
-      }
-      if (!tool2.handler) {
-        return {
-          success: false,
-          error: `Tool "${toolCall.name}" has no handler`
-        };
-      }
-      const execution = {
-        id: toolCall.id,
-        name: toolCall.name,
-        args: toolCall.input,
-        status: "executing",
-        timestamp: Date.now(),
-        approvalStatus: "none",
-        hidden: tool2.hidden
-      };
-      addToolExecution?.(execution);
-      try {
-        const startTime = Date.now();
-        const result = await tool2.handler(toolCall.input);
-        const duration = Date.now() - startTime;
-        updateToolExecution?.(toolCall.id, {
-          status: result.success ? "completed" : "error",
-          result,
-          error: result.error,
-          duration
-        });
-        return result;
-      } catch (error) {
-        const errorMessage = error instanceof Error ? error.message : "Tool execution failed";
-        updateToolExecution?.(toolCall.id, {
-          status: "error",
-          error: errorMessage
-        });
-        return {
-          success: false,
-          error: errorMessage
-        };
-      }
-    },
-    [addToolExecution, updateToolExecution]
-  );
-  const sendToolResult = React2.useCallback(
-    async (toolCallId, result) => {
-      const runtimeUrl = config.runtimeUrl || config.cloud?.endpoint;
-      if (!runtimeUrl) {
-        console.warn(
-          "[useToolExecutor] No runtime URL configured, cannot send tool result"
-        );
-        return;
-      }
-      const baseUrl = runtimeUrl.replace(/\/chat\/?$/, "");
-      try {
-        const response = await fetch(`${baseUrl}/tool-result`, {
-          method: "POST",
-          headers: {
-            "Content-Type": "application/json"
-          },
-          body: JSON.stringify({
-            threadId: chat.threadId || "default",
-            toolCallId,
-            result
-          })
-        });
-        if (!response.ok) {
-          console.error(
-            "[useToolExecutor] Failed to send tool result:",
-            await response.text()
-          );
-        }
-      } catch (error) {
-        console.error("[useToolExecutor] Error sending tool result:", error);
-      }
-    },
-    [config.runtimeUrl, config.cloud?.endpoint, chat.threadId]
-  );
-  const getTool = React2.useCallback((name) => {
-    return toolsRef.current.find((t) => t.name === name);
-  }, []);
-  const hasTool = React2.useCallback((name) => {
-    return toolsRef.current.some((t) => t.name === name);
-  }, []);
-  return {
-    executeTool,
-    sendToolResult,
-    getTool,
-    hasTool
-  };
-}
-function useSuggestions(options = {}) {
-  const {
-    count = 3,
-    context,
-    suggestions: staticSuggestions,
-    autoRefresh = true
-  } = options;
-  const { chat, actions, config } = useCopilotContext();
-  const [suggestions, setSuggestions] = React2.useState([]);
-  const [isLoading, setIsLoading] = React2.useState(false);
-  const normalizedStatic = React2.useMemo(
-    () => staticSuggestions?.map((s) => typeof s === "string" ? { text: s } : s),
-    [staticSuggestions]
-  );
-  const refresh = React2.useCallback(async () => {
-    if (normalizedStatic) {
-      setSuggestions(normalizedStatic.slice(0, count));
-      return;
-    }
-    if (!config.cloud) {
-      return;
-    }
-    setIsLoading(true);
-    try {
-      const endpoint = config.cloud.endpoint || "https://api.yourgpt.ai/v1";
-      const response = await fetch(`${endpoint}/suggestions`, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          Authorization: `Bearer ${config.cloud.apiKey}`
-        },
-        body: JSON.stringify({
-          botId: config.cloud.botId,
-          count,
-          context,
-          messages: chat.messages.slice(-5)
-          // Last 5 messages for context
-        })
-      });
-      if (response.ok) {
-        const data = await response.json();
-        setSuggestions(
-          data.suggestions.map(
-            (s) => typeof s === "string" ? { text: s } : s
-          )
-        );
-      }
-    } catch (error) {
-      console.error("Failed to fetch suggestions:", error);
-    } finally {
-      setIsLoading(false);
-    }
-  }, [config.cloud, count, context, chat.messages, normalizedStatic]);
-  const select = React2.useCallback(
-    (suggestion) => {
-      const text = typeof suggestion === "string" ? suggestion : suggestion.text;
-      actions.sendMessage(text);
-    },
-    [actions]
-  );
-  React2.useEffect(() => {
-    if (autoRefresh && chat.messages.length === 0) {
-      refresh();
-    }
-  }, [autoRefresh, chat.messages.length, refresh]);
-  return {
-    suggestions: normalizedStatic?.slice(0, count) || suggestions,
-    isLoading,
-    refresh,
-    select
-  };
-}
-function useAgent(options) {
-  const { name, initialState = {}, onStateChange } = options;
-  const { config } = useCopilotContext();
-  const [state, setStateInternal] = React2.useState(initialState);
-  const [isRunning, setIsRunning] = React2.useState(false);
-  const [nodeName, setNodeName] = React2.useState(null);
-  const [error, setError] = React2.useState(null);
-  const abortControllerRef = React2.useRef(null);
-  const getEndpoint = React2.useCallback(() => {
-    if (config.cloud) {
-      return `${config.cloud.endpoint || "https://api.yourgpt.ai/v1"}/agents/${name}`;
-    }
-    return `${config.runtimeUrl || "/api"}/agents/${name}`;
-  }, [config, name]);
-  const start = React2.useCallback(
-    async (input) => {
-      setIsRunning(true);
-      setError(null);
-      abortControllerRef.current = new AbortController();
-      try {
-        const endpoint = getEndpoint();
-        const headers = {
-          "Content-Type": "application/json"
-        };
-        if (config.cloud?.apiKey) {
-          headers["Authorization"] = `Bearer ${config.cloud.apiKey}`;
-        }
-        const response = await fetch(`${endpoint}/start`, {
-          method: "POST",
-          headers,
-          body: JSON.stringify({
-            input: typeof input === "string" ? { message: input } : input,
-            state
-          }),
-          signal: abortControllerRef.current.signal
-        });
-        if (!response.ok) {
-          throw new Error(`Agent error: ${response.status}`);
-        }
-        for await (const event of chunkWIXFZUEZ_cjs.streamSSE(response)) {
-          handleAgentEvent(event);
-        }
-      } catch (err) {
-        if (err.name !== "AbortError") {
-          setError(err instanceof Error ? err : new Error("Unknown error"));
-        }
-      } finally {
-        setIsRunning(false);
-        abortControllerRef.current = null;
-      }
-    },
-    [config, getEndpoint, state]
-  );
-  const handleAgentEvent = React2.useCallback(
-    (event) => {
-      if (event.type === "error") {
-        setError(new Error(event.message));
-        return;
-      }
-      if ("state" in event && event.state) {
-        setStateInternal(event.state);
-        onStateChange?.(event.state);
-      }
-      if ("nodeName" in event && event.nodeName) {
-        setNodeName(event.nodeName);
-      }
-    },
-    [onStateChange]
-  );
-  const stop = React2.useCallback(() => {
-    abortControllerRef.current?.abort();
-  }, []);
-  const setState = React2.useCallback(
-    (partialState) => {
-      setStateInternal((prev) => {
-        const newState = { ...prev, ...partialState };
-        onStateChange?.(newState);
-        return newState;
-      });
-    },
-    [onStateChange]
-  );
-  React2.useEffect(() => {
-    return () => {
-      abortControllerRef.current?.abort();
-    };
-  }, []);
-  return {
-    state,
-    isRunning,
-    nodeName,
-    start,
-    stop,
-    setState,
-    error
-  };
-}
-
-// src/react/utils/knowledge-base.ts
-var KNOWLEDGE_BASE_API = "https://api.yourgpt.ai/chatbot/v1/searchIndexDocument";
-async function searchKnowledgeBase(query, config) {
-  try {
-    const response = await fetch(KNOWLEDGE_BASE_API, {
-      method: "POST",
-      headers: {
-        accept: "*/*",
-        "content-type": "application/json",
-        authorization: `Bearer ${config.token}`
-      },
-      body: JSON.stringify({
-        project_uid: config.projectUid,
-        query,
-        page: 1,
-        limit: String(config.limit || 10),
-        app_id: config.appId || "1"
-      })
-    });
-    if (!response.ok) {
-      return {
-        success: false,
-        results: [],
-        error: `API error: ${response.status} ${response.statusText}`
-      };
-    }
-    const data = await response.json();
-    const results = (data.data || data.results || []).map((item) => ({
-      id: item.id || item._id || String(Math.random()),
-      title: item.title || item.name || void 0,
-      content: item.content || item.text || item.snippet || "",
-      score: item.score || item.relevance || void 0,
-      url: item.url || item.source_url || void 0,
-      metadata: item.metadata || {}
-    }));
-    return {
-      success: true,
-      results,
-      total: data.total || results.length,
-      page: data.page || 1
-    };
-  } catch (error) {
-    return {
-      success: false,
-      results: [],
-      error: error instanceof Error ? error.message : "Unknown error"
-    };
-  }
-}
-function formatKnowledgeResultsForAI(results) {
-  if (results.length === 0) {
-    return "No relevant documents found in the knowledge base.";
-  }
-  return results.map((result, index) => {
-    const parts = [`[${index + 1}]`];
-    if (result.title) parts.push(`**${result.title}**`);
-    parts.push(result.content);
-    if (result.url) parts.push(`Source: ${result.url}`);
-    return parts.join("\n");
-  }).join("\n\n---\n\n");
-}
-
-// src/react/hooks/useKnowledgeBase.ts
-function useKnowledgeBase(config) {
-  const { registerTool, unregisterTool } = useCopilot();
-  const configRef = React2.useRef(config);
-  configRef.current = config;
-  const handleSearch = React2.useCallback(
-    async (params) => {
-      const query = params.query;
-      if (!query) {
-        return {
-          success: false,
-          error: "Query is required"
-        };
-      }
-      const currentConfig = configRef.current;
-      const kbConfig = {
-        projectUid: currentConfig.projectUid,
-        token: currentConfig.token,
-        appId: currentConfig.appId,
-        limit: currentConfig.limit || 5
-      };
-      const response = await searchKnowledgeBase(
-        query,
-        kbConfig
-      );
-      if (!response.success) {
-        return {
-          success: false,
-          error: response.error || "Knowledge base search failed"
-        };
-      }
-      const formattedResults = formatKnowledgeResultsForAI(response.results);
-      return {
-        success: true,
-        message: formattedResults,
-        data: {
-          resultCount: response.results.length,
-          total: response.total
-        }
-      };
-    },
-    []
-  );
-  React2.useEffect(() => {
-    if (config.enabled === false) {
-      return;
-    }
-    registerTool({
-      name: "search_knowledge",
-      description: "Search the knowledge base for relevant information about the product, documentation, or company. Use this to answer questions about features, pricing, policies, guides, or any factual information.",
-      location: "client",
-      inputSchema: {
-        type: "object",
-        properties: {
-          query: {
-            type: "string",
-            description: "The search query to find relevant information in the knowledge base"
-          }
-        },
-        required: ["query"]
-      },
-      handler: handleSearch
-    });
-    return () => {
-      unregisterTool("search_knowledge");
-    };
-  }, [
-    config.enabled,
-    config.projectUid,
-    config.token,
-    registerTool,
-    unregisterTool,
-    handleSearch
-  ]);
-}
-var DEFAULT_CAPABILITIES = {
-  supportsVision: false,
-  supportsTools: true,
-  supportsThinking: false,
-  supportsStreaming: true,
-  supportsPDF: false,
-  supportsAudio: false,
-  supportsVideo: false,
-  maxTokens: 8192,
-  supportedImageTypes: [],
-  supportsJsonMode: false,
-  supportsSystemMessages: true
-};
-function useCapabilities() {
-  const { config } = useCopilotContext();
-  const [capabilities, setCapabilities] = React2.useState(DEFAULT_CAPABILITIES);
-  const [provider, setProvider] = React2.useState("unknown");
-  const [model, setModel] = React2.useState("unknown");
-  const [supportedModels, setSupportedModels] = React2.useState([]);
-  const [isLoading, setIsLoading] = React2.useState(true);
-  const [error, setError] = React2.useState(null);
-  const capabilitiesUrl = config.runtimeUrl ? config.runtimeUrl.replace(/\/chat\/?$/, "/capabilities") : null;
-  const fetchCapabilities = React2.useCallback(async () => {
-    if (!capabilitiesUrl) {
-      setIsLoading(false);
-      return;
-    }
-    try {
-      setIsLoading(true);
-      setError(null);
-      const response = await fetch(capabilitiesUrl);
-      if (!response.ok) {
-        throw new Error(`Failed to fetch capabilities: ${response.status}`);
-      }
-      const data = await response.json();
-      setCapabilities(data.capabilities);
-      setProvider(data.provider);
-      setModel(data.model);
-      setSupportedModels(data.supportedModels);
-    } catch (err) {
-      setError(err instanceof Error ? err : new Error("Unknown error"));
-    } finally {
-      setIsLoading(false);
-    }
-  }, [capabilitiesUrl]);
-  React2.useEffect(() => {
-    fetchCapabilities();
-  }, [fetchCapabilities]);
-  return {
-    /** Current model capabilities */
-    capabilities,
-    /** Current provider name */
-    provider,
-    /** Current model ID */
-    model,
-    /** List of supported models for current provider */
-    supportedModels,
-    /** Whether capabilities are being loaded */
-    isLoading,
-    /** Error if fetch failed */
-    error,
-    /** Refetch capabilities */
-    refetch: fetchCapabilities
-  };
-}
-function useFeatureSupport(feature) {
-  const { capabilities } = useCapabilities();
-  return capabilities[feature] ?? false;
-}
-function useSupportedMediaTypes() {
-  const { capabilities } = useCapabilities();
-  return {
-    /** Supported image MIME types */
-    imageTypes: capabilities.supportedImageTypes || [],
-    /** Supported audio MIME types */
-    audioTypes: capabilities.supportedAudioTypes || [],
-    /** Supported video MIME types */
-    videoTypes: capabilities.supportedVideoTypes || [],
-    /** Whether any image types are supported */
-    hasImageSupport: (capabilities.supportedImageTypes?.length ?? 0) > 0,
-    /** Whether any audio types are supported */
-    hasAudioSupport: (capabilities.supportedAudioTypes?.length ?? 0) > 0,
-    /** Whether any video types are supported */
-    hasVideoSupport: (capabilities.supportedVideoTypes?.length ?? 0) > 0
-  };
-}
-function useDevLogger() {
-  const ctx = useCopilotContext();
-  return React2.useMemo(() => {
-    const toolExecutions = (ctx.agentLoop?.toolExecutions || []).map(
-      (exec) => ({
-        id: exec.id,
-        name: exec.name,
-        status: exec.status,
-        approvalStatus: exec.approvalStatus || "not_required"
-      })
-    );
-    const pendingApprovalsCount = ctx.pendingApprovals?.length || 0;
-    const registeredTools = (ctx.registeredTools || []).map((tool2) => ({
-      name: tool2.name,
-      location: tool2.location || "client"
-    }));
-    const registeredActions = (ctx.registeredActions || []).map((action) => ({
-      name: action.name
-    }));
-    const storedPermissions = (ctx.storedPermissions || []).map((p) => ({
-      toolName: p.toolName,
-      level: p.level
-    }));
-    return {
-      chat: {
-        isLoading: ctx.chat?.isLoading || false,
-        messageCount: ctx.chat?.messages?.length || 0,
-        threadId: ctx.chat?.threadId || "none",
-        error: ctx.chat?.error?.message || null
-      },
-      tools: {
-        isEnabled: !!ctx.toolsConfig,
-        isCapturing: ctx.tools?.isCapturing || false,
-        pendingConsent: !!ctx.tools?.pendingConsent
-      },
-      agentLoop: {
-        toolExecutions,
-        pendingApprovals: pendingApprovalsCount,
-        iteration: ctx.agentLoop?.iteration || 0,
-        maxIterations: ctx.agentLoop?.maxIterations || 10
-      },
-      registered: {
-        tools: registeredTools,
-        actions: registeredActions,
-        contextCount: ctx.contextTree?.length || 0
-      },
-      permissions: {
-        stored: storedPermissions,
-        loaded: ctx.permissionsLoaded || false
-      },
-      config: {
-        runtimeUrl: ctx.config?.runtimeUrl || ctx.config?.cloud?.endpoint || ""
-      }
-    };
-  }, [
-    ctx.chat,
-    ctx.tools,
-    ctx.toolsConfig,
-    ctx.agentLoop,
-    ctx.pendingApprovals,
-    ctx.registeredTools,
-    ctx.registeredActions,
-    ctx.contextTree,
-    ctx.storedPermissions,
-    ctx.permissionsLoaded,
-    ctx.config
-  ]);
-}
-
-// src/react/internal/ReactThreadManagerState.ts
-var ReactThreadManagerState = class {
-  constructor(initialThreads) {
-    this._threads = [];
-    this._currentThreadId = null;
-    this._currentThread = null;
-    this._loadStatus = "idle";
-    this._error = void 0;
-    // Callbacks for React subscriptions (useSyncExternalStore)
-    this.subscribers = /* @__PURE__ */ new Set();
-    // ============================================
-    // Subscription (for useSyncExternalStore)
-    // ============================================
-    /**
-     * Subscribe to state changes.
-     * Returns an unsubscribe function.
-     *
-     * @example
-     * ```tsx
-     * const threads = useSyncExternalStore(
-     *   state.subscribe,
-     *   () => state.threads
-     * );
-     * ```
-     */
-    this.subscribe = (callback) => {
-      this.subscribers.add(callback);
-      return () => {
-        this.subscribers.delete(callback);
-      };
-    };
-    if (initialThreads) {
-      this._threads = initialThreads;
-    }
-  }
-  // ============================================
-  // Getters
-  // ============================================
-  get threads() {
-    return this._threads;
-  }
-  get currentThreadId() {
-    return this._currentThreadId;
-  }
-  get currentThread() {
-    return this._currentThread;
-  }
-  get loadStatus() {
-    return this._loadStatus;
-  }
-  get error() {
-    return this._error;
-  }
-  // ============================================
-  // Setters (trigger reactivity)
-  // ============================================
-  set threads(value) {
-    this._threads = value;
-    this.notify();
-  }
-  // ============================================
-  // Mutations
-  // ============================================
-  setThreads(threads) {
-    this._threads = threads;
-    this.notify();
-  }
-  setCurrentThread(thread) {
-    this._currentThread = thread;
-    this._currentThreadId = thread?.id ?? null;
-    this.notify();
-  }
-  setCurrentThreadId(id) {
-    this._currentThreadId = id;
-    this.notify();
-  }
-  addThread(thread) {
-    this._threads = [thread, ...this._threads];
-    this.notify();
-  }
-  updateThread(id, updates) {
-    this._threads = this._threads.map(
-      (t) => t.id === id ? { ...t, ...updates } : t
-    );
-    if (updates.updatedAt) {
-      this._threads = [...this._threads].sort(
-        (a, b) => b.updatedAt.getTime() - a.updatedAt.getTime()
-      );
-    }
-    if (this._currentThread?.id === id) {
-      this._currentThread = { ...this._currentThread, ...updates };
-    }
-    this.notify();
-  }
-  removeThread(id) {
-    this._threads = this._threads.filter((t) => t.id !== id);
-    if (this._currentThreadId === id) {
-      this._currentThreadId = null;
-      this._currentThread = null;
-    }
-    this.notify();
-  }
-  setLoadStatus(status) {
-    this._loadStatus = status;
-    this.notify();
-  }
-  setError(error) {
-    this._error = error;
-    this.notify();
-  }
-  // ============================================
-  // Snapshots (for useSyncExternalStore)
-  // ============================================
-  getThreadsSnapshot() {
-    return this._threads;
-  }
-  getCurrentThreadSnapshot() {
-    return this._currentThread;
-  }
-  getLoadStatusSnapshot() {
-    return this._loadStatus;
-  }
-  getErrorSnapshot() {
-    return this._error;
-  }
-  // ============================================
-  // Private Methods
-  // ============================================
-  notify() {
-    this.subscribers.forEach((cb) => cb());
-  }
-  /**
-   * Cleanup subscriptions
-   */
-  dispose() {
-    this.subscribers.clear();
-  }
-};
-function createReactThreadManagerState(initialThreads) {
-  return new ReactThreadManagerState(initialThreads);
-}
-
-// src/react/internal/ReactThreadManager.ts
-var _ReactThreadManager = class _ReactThreadManager extends chunkWIXFZUEZ_cjs.ThreadManager {
-  constructor(config = {}, callbacks = {}) {
-    const reactState = new ReactThreadManagerState();
-    super({ ...config, state: reactState }, callbacks);
-    // ============================================
-    // Subscription Methods (for useSyncExternalStore)
-    // ============================================
-    /**
-     * Subscribe to state changes
-     * Use with useSyncExternalStore
-     */
-    this.subscribe = (callback) => {
-      return this.state.subscribe(callback);
-    };
-    // ============================================
-    // Snapshot Getters (for useSyncExternalStore)
-    // ============================================
-    /**
-     * Get threads snapshot
-     */
-    this.getThreadsSnapshot = () => {
-      return this.state.getThreadsSnapshot();
-    };
-    /**
-     * Get current thread snapshot
-     */
-    this.getCurrentThreadSnapshot = () => {
-      return this.state.getCurrentThreadSnapshot();
-    };
-    /**
-     * Get current thread ID snapshot
-     */
-    this.getCurrentThreadIdSnapshot = () => {
-      return this.state.currentThreadId;
-    };
-    /**
-     * Get load status snapshot
-     */
-    this.getLoadStatusSnapshot = () => {
-      return this.state.getLoadStatusSnapshot();
-    };
-    /**
-     * Get error snapshot
-     */
-    this.getErrorSnapshot = () => {
-      return this.state.getErrorSnapshot();
-    };
-    /**
-     * Get isLoading snapshot
-     */
-    this.getIsLoadingSnapshot = () => {
-      return this.state.getLoadStatusSnapshot() === "loading";
-    };
-    /**
-     * Get threads snapshot for server (always empty for hydration consistency)
-     */
-    this.getThreadsServerSnapshot = () => {
-      return _ReactThreadManager.EMPTY_THREADS;
-    };
-    /**
-     * Get current thread snapshot for server (always null)
-     */
-    this.getCurrentThreadServerSnapshot = () => {
-      return null;
-    };
-    /**
-     * Get current thread ID snapshot for server (always null)
-     */
-    this.getCurrentThreadIdServerSnapshot = () => {
-      return null;
-    };
-    /**
-     * Get load status snapshot for server (always "idle")
-     */
-    this.getLoadStatusServerSnapshot = () => {
-      return _ReactThreadManager.IDLE_STATUS;
-    };
-    /**
-     * Get error snapshot for server (always undefined)
-     */
-    this.getErrorServerSnapshot = () => {
-      return void 0;
-    };
-    /**
-     * Get isLoading snapshot for server (always false)
-     */
-    this.getIsLoadingServerSnapshot = () => {
-      return false;
-    };
-  }
-  // ============================================
-  // Cleanup
-  // ============================================
-  /**
-   * Dispose of the manager
-   */
-  async dispose() {
-    this.state.dispose();
-    await super.dispose();
-  }
-};
-// ============================================
-// Server Snapshots (for SSR - stable cached values)
-// ============================================
-// Cached values for server snapshots (must be stable references)
-_ReactThreadManager.EMPTY_THREADS = [];
-_ReactThreadManager.IDLE_STATUS = "idle";
-var ReactThreadManager = _ReactThreadManager;
-function createReactThreadManager(config, callbacks) {
-  return new ReactThreadManager(config, callbacks);
-}
-
-// src/react/hooks/useThreadManager.ts
-var defaultManager = null;
-function getDefaultManager() {
-  if (!defaultManager) {
-    defaultManager = createReactThreadManager();
-  }
-  return defaultManager;
-}
-var internalManager = null;
-function getInternalManager(config) {
-  if (!internalManager) {
-    internalManager = createReactThreadManager(
-      {
-        adapter: config.adapter,
-        saveDebounce: config.saveDebounce,
-        autoLoad: config.autoLoad,
-        autoRestoreLastThread: config.autoRestoreLastThread
-      },
-      config.callbacks
-    );
-  }
-  return internalManager;
-}
-function useThreadManager(config) {
-  const manager = React2.useMemo(() => {
-    if (!config) {
-      return getDefaultManager();
-    }
-    if (!config.adapter) {
-      return getInternalManager(config);
-    }
-    return createReactThreadManager(
-      {
-        adapter: config.adapter,
-        saveDebounce: config.saveDebounce,
-        autoLoad: config.autoLoad,
-        autoRestoreLastThread: config.autoRestoreLastThread
-      },
-      config.callbacks
-    );
-  }, [
-    config?.adapter,
-    config?.saveDebounce,
-    config?.autoLoad,
-    config?.autoRestoreLastThread
-    // Note: callbacks are intentionally not in deps to avoid recreating manager
-  ]);
-  const threads = React2.useSyncExternalStore(
-    manager.subscribe,
-    manager.getThreadsSnapshot,
-    manager.getThreadsServerSnapshot
-    // SSR - always empty array
-  );
-  const currentThread = React2.useSyncExternalStore(
-    manager.subscribe,
-    manager.getCurrentThreadSnapshot,
-    manager.getCurrentThreadServerSnapshot
-    // SSR - always null
-  );
-  const currentThreadId = React2.useSyncExternalStore(
-    manager.subscribe,
-    manager.getCurrentThreadIdSnapshot,
-    manager.getCurrentThreadIdServerSnapshot
-    // SSR - always null
-  );
-  const loadStatus = React2.useSyncExternalStore(
-    manager.subscribe,
-    manager.getLoadStatusSnapshot,
-    manager.getLoadStatusServerSnapshot
-    // SSR - always "idle"
-  );
-  const error = React2.useSyncExternalStore(
-    manager.subscribe,
-    manager.getErrorSnapshot,
-    manager.getErrorServerSnapshot
-    // SSR - always undefined
-  );
-  const isLoading = React2.useSyncExternalStore(
-    manager.subscribe,
-    manager.getIsLoadingSnapshot,
-    manager.getIsLoadingServerSnapshot
-    // SSR - always false
-  );
-  React2.useEffect(() => {
-    return () => {
-      if (config?.adapter && manager !== defaultManager && manager !== internalManager) {
-        manager.dispose();
-      }
-    };
-  }, [manager, config]);
-  React2.useEffect(() => {
-    const handleBeforeUnload = () => {
-      if (manager.hasPendingChanges) {
-        manager.saveNow().catch(() => {
-        });
-      }
-    };
-    if (typeof window !== "undefined") {
-      window.addEventListener("beforeunload", handleBeforeUnload);
-      return () => {
-        window.removeEventListener("beforeunload", handleBeforeUnload);
-      };
-    }
-  }, [manager]);
-  const createThread = React2.useCallback(
-    (options) => manager.createThread(options),
-    [manager]
-  );
-  const switchThread = React2.useCallback(
-    (id) => manager.switchThread(id),
-    [manager]
-  );
-  const updateCurrentThread = React2.useCallback(
-    (updates) => manager.updateCurrentThread(updates),
-    [manager]
-  );
-  const deleteThread = React2.useCallback(
-    (id) => manager.deleteThread(id),
-    [manager]
-  );
-  const clearCurrentThread = React2.useCallback(
-    () => manager.clearCurrentThread(),
-    [manager]
-  );
-  const refreshThreads = React2.useCallback(() => manager.loadThreads(), [manager]);
-  const saveNow = React2.useCallback(() => manager.saveNow(), [manager]);
-  const clearAllThreads = React2.useCallback(
-    () => manager.clearAllThreads(),
-    [manager]
-  );
-  const messages = React2.useMemo(
-    () => currentThread?.messages ?? [],
-    [currentThread]
-  );
-  const setMessages = React2.useCallback(
-    (newMessages) => updateCurrentThread({ messages: newMessages }),
-    [updateCurrentThread]
-  );
-  const hasPendingChanges = manager.hasPendingChanges;
-  return {
-    // State
-    threads,
-    currentThread,
-    currentThreadId,
-    isLoading,
-    loadStatus,
-    error,
-    // Actions
-    createThread,
-    switchThread,
-    updateCurrentThread,
-    deleteThread,
-    clearCurrentThread,
-    refreshThreads,
-    saveNow,
-    clearAllThreads,
-    // Utilities
-    messages,
-    setMessages,
-    hasPendingChanges
-  };
-}
-function useMCPUIIntents(config = {}) {
-  const {
-    onToolCall,
-    onIntent,
-    onPrompt,
-    onNotify,
-    onLink,
-    requireConsent = { tool: false, link: true }
-  } = config;
-  const handleIntent = React2.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 React2.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);
-    }
-  };
-}
-function getLastResponseUsage(messages) {
-  for (let i = messages.length - 1; i >= 0; i--) {
-    const msg = messages[i];
-    if (msg.role === "assistant" && msg.metadata?.usage) {
-      const u = msg.metadata.usage;
-      const prompt = u.prompt_tokens ?? 0;
-      const completion = u.completion_tokens ?? 0;
-      return {
-        prompt_tokens: prompt,
-        completion_tokens: completion,
-        total_tokens: u.total_tokens ?? prompt + completion
-      };
-    }
-  }
-  return null;
-}
-function useContextStats() {
-  const { contextChars, contextUsage, registeredTools, messages } = useCopilot();
-  const toolCount = React2.useMemo(() => registeredTools.length, [registeredTools]);
-  const messageCount = React2.useMemo(
-    () => messages.filter((m) => m.role !== "system").length,
-    [messages]
-  );
-  const totalTokens = React2.useMemo(() => {
-    if (contextUsage) return contextUsage.total.tokens;
-    return Math.ceil(contextChars / 3.5);
-  }, [contextUsage, contextChars]);
-  const usagePercent = React2.useMemo(() => {
-    if (contextUsage) return contextUsage.total.percent;
-    return 0;
-  }, [contextUsage]);
-  const lastResponseUsage = React2.useMemo(
-    () => getLastResponseUsage(messages),
-    [messages]
-  );
-  return {
-    contextUsage,
-    totalTokens,
-    usagePercent,
-    contextChars,
-    toolCount,
-    messageCount,
-    lastResponseUsage
-  };
-}
-var DEV_CONTENT_WARN_THRESHOLD = 2e3;
-function useSkill(skill) {
-  const { register, unregister } = useSkillContext();
-  if (process.env.NODE_ENV !== "production" && skill.source.type === "inline" && skill.source.content.length > DEV_CONTENT_WARN_THRESHOLD) {
-    console.warn(
-      `[copilot-sdk/skills] Inline skill "${skill.name}" has ${skill.source.content.length} characters. Inline skills are sent on every request \u2014 keep them under ${DEV_CONTENT_WARN_THRESHOLD} characters. Consider using a file or URL skill instead.`
-    );
-  }
-  React2.useEffect(() => {
-    if (skill.source.type !== "inline") {
-      console.warn(
-        `[copilot-sdk/skills] useSkill only supports inline skills client-side. Skill "${skill.name}" has source type "${skill.source.type}" and will be skipped.`
-      );
-      return;
-    }
-    const resolved = {
-      ...skill,
-      content: skill.source.content
-    };
-    register(resolved);
-    return () => {
-      unregister(skill.name);
-    };
-  }, [
-    skill.name,
-    skill.source.type === "inline" ? skill.source.content : "",
-    skill.strategy,
-    skill.description
-  ]);
-}
-function useSkillStatus() {
-  const { skills, registry } = useSkillContext();
-  const has = React2.useCallback(
-    (name) => registry.has(name),
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-    [skills]
-  );
-  return {
-    skills,
-    count: skills.length,
-    has
-  };
-}
-
-// src/react/utils/permission-storage.ts
-var DEFAULT_KEY_PREFIX = "yourgpt-permissions";
-function createPermissionStorage(config) {
-  switch (config.type) {
-    case "localStorage":
-      return createBrowserStorageAdapter(
-        typeof window !== "undefined" ? localStorage : null,
-        config.keyPrefix
-      );
-    case "sessionStorage":
-      return createBrowserStorageAdapter(
-        typeof window !== "undefined" ? sessionStorage : null,
-        config.keyPrefix
-      );
-    case "memory":
-    default:
-      return createMemoryStorageAdapter();
-  }
-}
-function createBrowserStorageAdapter(storage, keyPrefix = DEFAULT_KEY_PREFIX) {
-  const getStorageKey = () => keyPrefix;
-  const loadPermissions = () => {
-    if (!storage) return /* @__PURE__ */ new Map();
-    try {
-      const data = storage.getItem(getStorageKey());
-      if (!data) return /* @__PURE__ */ new Map();
-      const parsed = JSON.parse(data);
-      return new Map(parsed.map((p) => [p.toolName, p]));
-    } catch {
-      return /* @__PURE__ */ new Map();
-    }
-  };
-  const savePermissions = (permissions) => {
-    if (!storage) return;
-    try {
-      storage.setItem(
-        getStorageKey(),
-        JSON.stringify(Array.from(permissions.values()))
-      );
-    } catch (e) {
-      console.warn("[PermissionStorage] Failed to save permissions:", e);
-    }
-  };
-  return {
-    async get(toolName) {
-      const permissions = loadPermissions();
-      return permissions.get(toolName) || null;
-    },
-    async set(permission) {
-      const permissions = loadPermissions();
-      permissions.set(permission.toolName, permission);
-      savePermissions(permissions);
-    },
-    async remove(toolName) {
-      const permissions = loadPermissions();
-      permissions.delete(toolName);
-      savePermissions(permissions);
-    },
-    async getAll() {
-      const permissions = loadPermissions();
-      return Array.from(permissions.values());
-    },
-    async clear() {
-      if (!storage) return;
-      storage.removeItem(getStorageKey());
-    }
-  };
-}
-function createMemoryStorageAdapter() {
-  const permissions = /* @__PURE__ */ new Map();
-  return {
-    async get(toolName) {
-      return permissions.get(toolName) || null;
-    },
-    async set(permission) {
-      permissions.set(permission.toolName, permission);
-    },
-    async remove(toolName) {
-      permissions.delete(toolName);
-    },
-    async getAll() {
-      return Array.from(permissions.values());
-    },
-    async clear() {
-      permissions.clear();
-    }
-  };
-}
-function createSessionPermissionCache() {
-  return /* @__PURE__ */ new Map();
-}
-
-// src/react/internal/ReactChat.ts
-var ReactChat = class extends AbstractChat {
-  constructor(config) {
-    const reactState = new ReactChatState(config.initialMessages);
-    const init = {
-      runtimeUrl: config.runtimeUrl,
-      systemPrompt: config.systemPrompt,
-      llm: config.llm,
-      threadId: config.threadId,
-      streaming: config.streaming ?? true,
-      headers: config.headers,
-      initialMessages: config.initialMessages,
-      state: reactState,
-      callbacks: config.callbacks,
-      debug: config.debug
-    };
-    super(init);
-    // ============================================
-    // Subscribe (for useSyncExternalStore)
-    // ============================================
-    /**
-     * Subscribe to state changes.
-     * Returns an unsubscribe function.
-     *
-     * @example
-     * ```tsx
-     * const messages = useSyncExternalStore(
-     *   chat.subscribe,
-     *   () => chat.messages
-     * );
-     * ```
-     */
-    this.subscribe = (callback) => {
-      return this.reactState.subscribe(callback);
-    };
-    this.reactState = reactState;
-  }
-  // ============================================
-  // Event handling shortcuts
-  // ============================================
-  /**
-   * Subscribe to tool calls events
-   */
-  onToolCalls(handler) {
-    return this.on("toolCalls", handler);
-  }
-  /**
-   * Subscribe to done events
-   */
-  onDone(handler) {
-    return this.on("done", handler);
-  }
-  /**
-   * Subscribe to error events
-   */
-  onError(handler) {
-    return this.on("error", handler);
-  }
-  // ============================================
-  // Branching API — pass-throughs to ReactChatState
-  // ============================================
-  /**
-   * Navigate to a sibling branch (makes it the active path).
-   */
-  switchBranch(messageId) {
-    this.reactState.switchBranch(messageId);
-  }
-  /**
-   * Get branch navigation info for a message.
-   * Returns null if the message has no siblings.
-   */
-  getBranchInfo(messageId) {
-    return this.reactState.getBranchInfo(messageId);
-  }
-  /**
-   * Get all messages across all branches (for persistence).
-   */
-  getAllMessages() {
-    return this.reactState.getAllMessages();
-  }
-  /**
-   * Whether any message has siblings (branching has occurred).
-   */
-  get hasBranches() {
-    return this.reactState.hasBranches;
-  }
-  // ============================================
-  // Override dispose to clean up state
-  // ============================================
-  dispose() {
-    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);
-}
-function useChat(config) {
-  const chatRef = React2.useRef(null);
-  const [input, setInput] = React2.useState("");
-  if (chatRef.current !== null && chatRef.current.disposed) {
-    chatRef.current.revive();
-  }
-  if (chatRef.current === null) {
-    chatRef.current = createReactChat({
-      runtimeUrl: config.runtimeUrl,
-      systemPrompt: config.systemPrompt,
-      llm: config.llm,
-      threadId: config.threadId,
-      streaming: config.streaming,
-      headers: config.headers,
-      initialMessages: config.initialMessages,
-      debug: config.debug,
-      callbacks: {
-        onMessagesChange: config.onMessagesChange,
-        onError: config.onError,
-        onFinish: config.onFinish,
-        onToolCalls: config.onToolCalls
-      }
-    });
-  }
-  const messages = React2.useSyncExternalStore(
-    chatRef.current.subscribe,
-    () => chatRef.current.messages,
-    () => chatRef.current.messages
-    // Server snapshot
+      return id;
+    },
+    [debugLog]
   );
-  const status = React2.useSyncExternalStore(
-    chatRef.current.subscribe,
-    () => chatRef.current.status,
-    () => "ready"
-    // Server snapshot
+  const removeContext = React2.useCallback(
+    (id) => {
+      contextTreeRef.current = removeNode(contextTreeRef.current, id);
+      const contextString = printTree(contextTreeRef.current);
+      chatRef.current?.setContext(contextString);
+      setContextChars(contextString.length);
+      debugLog("Context removed:", id);
+    },
+    [debugLog]
   );
-  const error = React2.useSyncExternalStore(
-    chatRef.current.subscribe,
-    () => chatRef.current.error,
-    () => void 0
-    // Server snapshot
+  const setSystemPrompt = React2.useCallback(
+    (prompt) => {
+      chatRef.current?.setSystemPrompt(prompt);
+      debugLog("System prompt updated via function");
+    },
+    [debugLog]
   );
-  const hasBranches = React2.useSyncExternalStore(
-    chatRef.current.subscribe,
-    () => chatRef.current.hasBranches,
-    () => false
+  const setInlineSkills = React2.useCallback(
+    (skills2) => {
+      chatRef.current?.setInlineSkills(skills2);
+      debugLog("Inline skills updated", { count: skills2.length });
+    },
+    [debugLog]
   );
-  const isLoading = status === "streaming" || status === "submitted";
   const sendMessage = React2.useCallback(
     async (content, attachments) => {
+      debugLog("Sending message:", content);
+      setAgentIteration(0);
       await chatRef.current?.sendMessage(content, attachments);
-      setInput("");
     },
-    []
+    [debugLog]
   );
   const stop = React2.useCallback(() => {
     chatRef.current?.stop();
@@ -7391,19 +5470,11 @@ function useChat(config) {
   const regenerate = React2.useCallback(async (messageId) => {
     await chatRef.current?.regenerate(messageId);
   }, []);
-  const continueWithToolResults = React2.useCallback(
-    async (toolResults) => {
-      await chatRef.current?.continueWithToolResults(toolResults);
-    },
-    []
-  );
   const switchBranch = React2.useCallback((messageId) => {
     chatRef.current?.switchBranch(messageId);
   }, []);
   const getBranchInfo = React2.useCallback(
-    (messageId) => {
-      return chatRef.current?.getBranchInfo(messageId) ?? null;
-    },
+    (messageId) => chatRef.current?.getBranchInfo(messageId) ?? null,
     []
   );
   const editMessage = React2.useCallback(
@@ -7411,40 +5482,238 @@ function useChat(config) {
       await chatRef.current?.sendMessage(newContent, void 0, {
         editMessageId: messageId
       });
-      setInput("");
     },
     []
   );
+  const getHasBranchesSnapshot = React2.useCallback(
+    () => chatRef.current.hasBranches,
+    []
+  );
+  const hasBranches = React2.useSyncExternalStore(
+    chatRef.current.subscribe,
+    getHasBranchesSnapshot,
+    () => false
+  );
+  const getAllMessages = React2.useCallback(
+    () => chatRef.current?.getAllMessages?.() ?? [],
+    []
+  );
+  React2.useEffect(() => {
+    if (onMessagesChange && messages.length > 0) {
+      const allUIMessages = chatRef.current?.getAllMessages?.() ?? messages;
+      const coreMessages = allUIMessages.map((m) => ({
+        id: m.id,
+        role: m.role,
+        content: m.content,
+        created_at: m.createdAt,
+        tool_calls: m.toolCalls,
+        tool_call_id: m.toolCallId,
+        parent_id: m.parentId,
+        children_ids: m.childrenIds,
+        metadata: {
+          attachments: m.attachments,
+          thinking: m.thinking
+        }
+      }));
+      onMessagesChange(coreMessages);
+    }
+  }, [messages, onMessagesChange]);
+  React2.useEffect(() => {
+    if (error && onError) {
+      onError(error);
+    }
+  }, [error, onError]);
   React2.useEffect(() => {
     return () => {
       chatRef.current?.dispose();
     };
   }, []);
-  return {
-    messages,
-    status,
-    error,
-    isLoading,
-    input,
-    setInput,
-    sendMessage,
-    stop,
-    clearMessages,
-    setMessages,
-    regenerate,
-    continueWithToolResults,
-    chatRef,
-    // Branching
-    switchBranch,
-    getBranchInfo,
-    editMessage,
-    hasBranches
-  };
+  const contextValue = React2.useMemo(
+    () => ({
+      // Chat state
+      messages,
+      status,
+      error,
+      isLoading,
+      // Chat actions
+      sendMessage,
+      stop,
+      clearMessages,
+      setMessages,
+      regenerate,
+      // Branching
+      switchBranch,
+      getBranchInfo,
+      editMessage,
+      hasBranches,
+      getAllMessages,
+      // Tool execution
+      registerTool,
+      unregisterTool,
+      registeredTools,
+      toolExecutions,
+      pendingApprovals,
+      approveToolExecution,
+      rejectToolExecution,
+      agentIteration,
+      // Actions
+      registerAction,
+      unregisterAction,
+      registeredActions,
+      // AI Context
+      addContext,
+      removeContext,
+      contextChars,
+      contextUsage,
+      // System Prompt
+      setSystemPrompt,
+      // Skills
+      setInlineSkills,
+      // Config
+      threadId,
+      runtimeUrl,
+      toolsConfig,
+      // Headless primitives
+      subscribeToStreamEvents,
+      messageMeta: messageMetaStoreRef.current
+    }),
+    [
+      messages,
+      status,
+      error,
+      isLoading,
+      sendMessage,
+      stop,
+      clearMessages,
+      setMessages,
+      regenerate,
+      switchBranch,
+      getBranchInfo,
+      editMessage,
+      hasBranches,
+      getAllMessages,
+      registerTool,
+      unregisterTool,
+      registeredTools,
+      toolExecutions,
+      pendingApprovals,
+      approveToolExecution,
+      rejectToolExecution,
+      agentIteration,
+      registerAction,
+      unregisterAction,
+      registeredActions,
+      addContext,
+      removeContext,
+      contextChars,
+      contextUsage,
+      setSystemPrompt,
+      setInlineSkills,
+      threadId,
+      runtimeUrl,
+      toolsConfig
+    ]
+  );
+  const messageHistoryContextValue = React2__default.default.useMemo(
+    () => ({
+      config: { ...defaultMessageHistoryConfig, ...messageHistory },
+      tokenUsage: {
+        current: 0,
+        max: messageHistory?.maxContextTokens ?? 128e3,
+        percentage: 0,
+        isApproaching: false
+      },
+      compactionState: {
+        rollingSummary: null,
+        lastCompactionAt: null,
+        compactionCount: 0,
+        totalTokensSaved: 0,
+        workingMemory: [],
+        displayMessageCount: 0,
+        llmMessageCount: 0
+      }
+    }),
+    [messageHistory]
+  );
+  return /* @__PURE__ */ jsxRuntime.jsx(MessageHistoryContext.Provider, { value: messageHistoryContextValue, children: /* @__PURE__ */ jsxRuntime.jsxs(CopilotContext.Provider, { value: contextValue, children: [
+    mcpServers?.map((config) => /* @__PURE__ */ jsxRuntime.jsx(MCPConnection, { config }, config.name)),
+    messageHistory?.strategy && messageHistory.strategy !== "none" && /* @__PURE__ */ jsxRuntime.jsx(MessageHistoryBridge, { chatRef }),
+    skills ? /* @__PURE__ */ jsxRuntime.jsx(SkillProvider, { skills, children }) : children
+  ] }) });
 }
 
-// src/react/skill/define-skill.ts
-function defineSkill(def) {
-  return def;
+// src/react/hooks/useMCPTools.ts
+function useMCPTools(config) {
+  const {
+    prefixToolNames = true,
+    autoRegister = true,
+    hidden = false,
+    source = "mcp",
+    ...clientConfig
+  } = config;
+  const { registerTool, unregisterTool } = useCopilot();
+  const registeredToolsRef = React2.useRef([]);
+  const mcpClient = useMCPClient(clientConfig);
+  const toolAdapter = React2.useMemo(
+    () => new chunkJGPDQDY4_cjs.MCPToolAdapter(clientConfig.name),
+    [clientConfig.name]
+  );
+  const toolDefinitions = React2.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,
+        hidden,
+        // Hide from chat UI
+        source
+        // Tool source for UI differentiation
+      })
+    );
+  }, [
+    mcpClient.isConnected,
+    mcpClient.state.tools,
+    mcpClient.callTool,
+    toolAdapter,
+    prefixToolNames,
+    hidden,
+    source
+  ]);
+  React2.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
+  };
 }
 
 exports.AbstractAgentLoop = AbstractAgentLoop;
@@ -7452,56 +5721,25 @@ exports.AbstractChat = AbstractChat;
 exports.CopilotProvider = CopilotProvider;
 exports.MessageHistoryContext = MessageHistoryContext;
 exports.MessageTree = MessageTree;
-exports.ReactChat = ReactChat;
 exports.ReactChatState = ReactChatState;
-exports.ReactThreadManager = ReactThreadManager;
-exports.ReactThreadManagerState = ReactThreadManagerState;
 exports.SkillProvider = SkillProvider;
-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.defaultMessageHistoryConfig = defaultMessageHistoryConfig;
-exports.defineSkill = defineSkill;
-exports.formatKnowledgeResultsForAI = formatKnowledgeResultsForAI;
 exports.initialAgentLoopState = initialAgentLoopState;
 exports.isCompactionMarker = isCompactionMarker;
 exports.keepToolPairsAtomic = keepToolPairsAtomic;
-exports.searchKnowledgeBase = searchKnowledgeBase;
 exports.toDisplayMessage = toDisplayMessage;
 exports.toLLMMessage = toLLMMessage;
 exports.toLLMMessages = toLLMMessages;
-exports.useAIAction = useAIAction;
-exports.useAIActions = useAIActions;
 exports.useAIContext = useAIContext;
 exports.useAIContexts = useAIContexts;
-exports.useAITools = useAITools;
-exports.useAgent = useAgent;
-exports.useCapabilities = useCapabilities;
-exports.useChat = useChat;
-exports.useContextStats = useContextStats;
 exports.useCopilot = useCopilot;
-exports.useDevLogger = useDevLogger;
-exports.useFeatureSupport = useFeatureSupport;
-exports.useKnowledgeBase = useKnowledgeBase;
 exports.useMCPClient = useMCPClient;
 exports.useMCPTools = useMCPTools;
-exports.useMCPUIIntents = useMCPUIIntents;
 exports.useMessageHistory = useMessageHistory;
 exports.useMessageHistoryContext = useMessageHistoryContext;
-exports.useSkill = useSkill;
-exports.useSkillStatus = useSkillStatus;
-exports.useSuggestions = useSuggestions;
-exports.useSupportedMediaTypes = useSupportedMediaTypes;
-exports.useThreadManager = useThreadManager;
+exports.useSkillContext = useSkillContext;
 exports.useTool = useTool;
-exports.useToolExecutor = useToolExecutor;
-exports.useToolWithSchema = useToolWithSchema;
 exports.useTools = useTools;
-exports.useToolsWithSchema = useToolsWithSchema;
-//# sourceMappingURL=chunk-TCPAT3WG.cjs.map
-//# sourceMappingURL=chunk-TCPAT3WG.cjs.map
+//# sourceMappingURL=chunk-LHLVTGIP.cjs.map
+//# sourceMappingURL=chunk-LHLVTGIP.cjs.map