@yourgpt/copilot-sdk 2.5.1-beta.1 → 2.5.2-alpha.0

package/dist/{chunk-ZYLHGNIG.cjs → chunk-GW5ZZHJ7.cjs}

@@ -1561,6 +1561,10 @@ var AbstractChat = class {
   get isStreaming() {
     return this.transport.isStreaming();
   }
+  /** The thread id currently associated with this chat, if any. */
+  get threadId() {
+    return this.config.threadId;
+  }
   // ============================================
   // Public Actions
   // ============================================
@@ -2206,6 +2210,7 @@ ${this.dynamicContext}`.trim() : this.config.systemPrompt;
     this.debug("Starting to process stream");
     let chunkCount = 0;
     let toolCallsEmitted = false;
+    let postToolTextStreamed = false;
     let pendingClientToolCalls;
     for await (const chunk of stream) {
       chunkCount++;
@@ -2262,15 +2267,27 @@ ${this.dynamicContext}`.trim() : this.config.systemPrompt;
         continue;
       }
       if (!this.streamState) {
-        if (chunk.type === "tool_calls") {
+        if (chunk.type === "message:delta") {
+          this.debug(
+            "message:delta with no streamState \u2014 auto-init new message"
+          );
+          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);
+          postToolTextStreamed = true;
+        } else if (chunk.type === "tool_calls") {
           pendingClientToolCalls = chunk.toolCalls;
           this.debug("tool_calls (post-message:end, stored as pending)", {
             count: pendingClientToolCalls?.length,
             ids: pendingClientToolCalls?.map((tc) => tc.id)
           });
           continue;
-        }
-        if (chunk.type === "done") {
+        } else if (chunk.type === "done") {
           this.debug("done (post-message:end)", {
             hasPendingToolCalls: !!pendingClientToolCalls?.length,
             pendingCount: pendingClientToolCalls?.length ?? 0,
@@ -2362,9 +2379,10 @@ ${this.dynamicContext}`.trim() : this.config.systemPrompt;
             });
           }
           continue;
+        } else {
+          this.debug("warning", "streamState is null, skipping chunk");
+          continue;
         }
-        this.debug("warning", "streamState is null, skipping chunk");
-        continue;
       }
       this.streamState = processStreamChunk(chunk, this.streamState);
       if (chunk.type === "action:start") {
@@ -2460,9 +2478,12 @@ ${this.dynamicContext}`.trim() : this.config.systemPrompt;
               }
             }
           }
+          let seenToolResult = false;
           for (const msg of chunk.messages) {
+            if (msg.role === "tool") seenToolResult = true;
             if (msg.role === "assistant" && !msg.tool_calls?.length) {
-              continue;
+              if (!seenToolResult) continue;
+              if (postToolTextStreamed) continue;
             }
             if (msg.role === "assistant" && msg.tool_calls?.length && msg.tool_calls.every(
               (toolCall) => currentStreamToolCallIds.has(toolCall.id)
@@ -2990,6 +3011,7 @@ var AbstractAgentLoop = class {
       }
       const result = await tool.handler(toolCall.args, {
         signal: this.abortController?.signal,
+        threadId: this.config.getThreadId?.(),
         data: { toolCallId: toolCall.id },
         approvalData
       });
@@ -3517,7 +3539,13 @@ var ChatWithTools = class {
     this.agentLoop = new AbstractAgentLoop(
       {
         maxIterations: config.maxIterations ?? 20,
-        tools: config.tools
+        tools: config.tools,
+        // Expose this chat's current threadId to tool handlers via
+        // ToolContext.threadId. Read lazily per invocation so it reflects
+        // the id assigned by the server mid-stream (thread:created).
+        // If the caller provided a getThreadId override (e.g. the React
+        // provider exposing its stable registry key), prefer that.
+        getThreadId: config.getThreadId ? () => config.getThreadId() : () => this.chat?.threadId
       },
       {
         onExecutionsChange: (executions) => {
@@ -5427,7 +5455,8 @@ function CopilotProvider(props) {
     mcpServers,
     optimization,
     messageHistory,
-    skills
+    skills,
+    concurrentThreads = false
   } = props;
   const isThreadIdControlled = Object.prototype.hasOwnProperty.call(
     props,
@@ -5465,87 +5494,350 @@ function CopilotProvider(props) {
     controlled: isThreadIdControlled,
     value: threadId
   });
+  const SINGLE_INSTANCE_KEY = "__single__";
   const chatRef = React2.useRef(null);
-  if (chatRef.current !== null && chatRef.current.disposed) {
-    chatRef.current.revive();
-    debugLog("Revived disposed instance (React StrictMode)");
-  }
-  if (chatRef.current === null) {
-    const uiInitialMessages = initialMessages;
-    chatRef.current = new ReactChatWithTools(
-      {
-        runtimeUrl,
-        systemPrompt,
-        threadId,
-        onCreateSession,
-        yourgptConfig,
-        initialMessages: uiInitialMessages,
-        streaming,
-        headers,
-        body,
-        parseError,
-        debug,
-        maxIterations,
-        maxIterationsMessage,
-        optimization
-      },
-      {
-        onToolExecutionsChange: (executions) => {
-          debugLog("Tool executions changed:", executions.length);
-          setToolExecutions(executions);
-          setAgentIteration(chatRef.current?.iteration ?? 0);
-        },
-        onApprovalRequired: (execution) => {
-          debugLog("Tool approval required:", execution.name);
-        },
-        onContextUsageChange: (usage) => {
-          setContextUsage(usage);
-        },
-        onError: (error2) => {
-          if (error2) onError?.(error2);
-        },
-        onThreadChange: (id) => {
-          debugLog("Thread/session ID assigned:", id);
-          setActualThreadId(id);
-          onThreadChange?.(id);
-        },
-        onSessionStatusChange: (status2) => {
-          debugLog("Session status:", status2);
-          setSessionStatus(status2);
+  const instancesRef = React2.useRef(/* @__PURE__ */ new Map());
+  const activeInstanceKeyRef = React2.useRef(SINGLE_INSTANCE_KEY);
+  const pendingCounterRef = React2.useRef(0);
+  const sharedToolsRef = React2.useRef(/* @__PURE__ */ new Map());
+  const sharedSkillsRef = React2.useRef([]);
+  const sharedSystemContextRef = React2.useRef("");
+  const subscribersRef = React2.useRef(/* @__PURE__ */ new Set());
+  const stableSubscribe = React2.useMemo(
+    () => (cb) => {
+      subscribersRef.current.add(cb);
+      return () => {
+        subscribersRef.current.delete(cb);
+      };
+    },
+    []
+  );
+  const [busyThreadIds, setBusyThreadIds] = React2.useState(
+    () => /* @__PURE__ */ new Set()
+  );
+  const recomputeBusyThreadIds = React2.useCallback(() => {
+    if (!concurrentThreads) return;
+    const next = /* @__PURE__ */ new Set();
+    for (const [key, inst] of instancesRef.current) {
+      if (key === SINGLE_INSTANCE_KEY) continue;
+      if (key.startsWith("__pending_")) continue;
+      const s = inst.status;
+      if (s === "streaming" || s === "submitted") next.add(key);
+    }
+    setBusyThreadIds((prev) => {
+      if (prev.size === next.size) {
+        let same = true;
+        for (const id of next) {
+          if (!prev.has(id)) {
+            same = false;
+            break;
+          }
+        }
+        if (same) return prev;
+      }
+      return next;
+    });
+  }, [concurrentThreads]);
+  const [pendingApprovalsByThread, setPendingApprovalsByThread] = React2.useState(() => /* @__PURE__ */ new Map());
+  const recomputePendingApprovalsByThread = React2.useCallback(() => {
+    if (!concurrentThreads) return;
+    const next = /* @__PURE__ */ new Map();
+    for (const [key, inst] of instancesRef.current) {
+      if (key === SINGLE_INSTANCE_KEY) continue;
+      if (key.startsWith("__pending_")) continue;
+      const pending = inst.toolExecutions.filter(
+        (e) => e.approvalStatus === "required"
+      );
+      if (pending.length > 0) next.set(key, pending);
+    }
+    setPendingApprovalsByThread((prev) => {
+      if (prev.size !== next.size) return next;
+      for (const [id, execs] of next) {
+        const prevExecs = prev.get(id);
+        if (!prevExecs || prevExecs.length !== execs.length) return next;
+        for (let i = 0; i < execs.length; i++) {
+          if (prevExecs[i] !== execs[i]) return next;
+        }
+      }
+      return prev;
+    });
+  }, [concurrentThreads]);
+  const notifyStateChange = React2.useCallback(() => {
+    for (const cb of subscribersRef.current) cb();
+    recomputeBusyThreadIds();
+    recomputePendingApprovalsByThread();
+  }, [recomputeBusyThreadIds, recomputePendingApprovalsByThread]);
+  const configRef = React2.useRef({
+    runtimeUrl,
+    systemPrompt,
+    threadId,
+    onCreateSession,
+    yourgptConfig,
+    initialMessages,
+    streaming,
+    headers,
+    body,
+    parseError,
+    debug,
+    maxIterations,
+    maxIterationsMessage,
+    optimization
+  });
+  configRef.current = {
+    runtimeUrl,
+    systemPrompt,
+    threadId,
+    onCreateSession,
+    yourgptConfig,
+    initialMessages,
+    streaming,
+    headers,
+    body,
+    parseError,
+    debug,
+    maxIterations,
+    maxIterationsMessage,
+    optimization
+  };
+  const callbacksRef = React2.useRef({ onError, onThreadChange });
+  callbacksRef.current = { onError, onThreadChange };
+  const handleInstanceThreadAssigned = React2.useCallback(
+    (inst, newId) => {
+      let oldKey;
+      for (const [k, v] of instancesRef.current) {
+        if (v === inst) {
+          oldKey = k;
+          break;
+        }
+      }
+      if (oldKey === void 0) return;
+      const isInternalKey = oldKey === SINGLE_INSTANCE_KEY || oldKey.startsWith("__pending_");
+      const shouldRekey = !concurrentThreads || isInternalKey;
+      if (shouldRekey && oldKey !== newId && !instancesRef.current.has(newId)) {
+        instancesRef.current.delete(oldKey);
+        instancesRef.current.set(newId, inst);
+        if (activeInstanceKeyRef.current === oldKey) {
+          activeInstanceKeyRef.current = newId;
+        }
+        if (inst === chatRef.current) {
+          debugLog("Thread/session ID assigned:", newId);
+          setActualThreadId(newId);
+          callbacksRef.current.onThreadChange?.(newId);
+        }
+      }
+      recomputeBusyThreadIds();
+      recomputePendingApprovalsByThread();
+    },
+    [
+      concurrentThreads,
+      debugLog,
+      recomputeBusyThreadIds,
+      recomputePendingApprovalsByThread
+    ]
+  );
+  const createInstance = React2.useCallback(
+    (key, opts) => {
+      const cfg = configRef.current;
+      const initialThreadId = key === SINGLE_INSTANCE_KEY || key.startsWith("__pending_") ? cfg.threadId : key;
+      const inst = new ReactChatWithTools(
+        {
+          runtimeUrl: cfg.runtimeUrl,
+          systemPrompt: cfg.systemPrompt,
+          threadId: initialThreadId,
+          onCreateSession: cfg.onCreateSession,
+          yourgptConfig: cfg.yourgptConfig,
+          initialMessages: opts?.initialMessages ?? cfg.initialMessages,
+          streaming: cfg.streaming,
+          headers: cfg.headers,
+          body: cfg.body,
+          parseError: cfg.parseError,
+          debug: cfg.debug,
+          maxIterations: cfg.maxIterations,
+          maxIterationsMessage: cfg.maxIterationsMessage,
+          optimization: cfg.optimization,
+          // Expose the registry key (usually the UI thread id after
+          // assignLocalThreadId runs) to tool handlers, NOT chat.config.threadId.
+          // For extensions that key per-thread state on context.threadId (e.g.
+          // browser-tab pinning), this guarantees a stable id — even while the
+          // backend session id is still being resolved. Internal keys
+          // (__single__, __pending_*) return undefined so handlers can treat
+          // them as "not yet committed".
+          getThreadId: () => {
+            for (const [k, v] of instancesRef.current) {
+              if (v === inst) {
+                if (k === SINGLE_INSTANCE_KEY || k.startsWith("__pending_")) {
+                  return void 0;
+                }
+                return k;
+              }
+            }
+            return void 0;
+          }
         },
-        onStreamChunk: (chunk) => {
-          if (streamListenersRef.current.size > 0) {
-            for (const handler of streamListenersRef.current) {
-              handler(chunk);
+        {
+          onToolExecutionsChange: (executions) => {
+            debugLog("Tool executions changed:", executions.length);
+            if (inst === chatRef.current) {
+              setToolExecutions(executions);
+              setAgentIteration(inst.iteration ?? 0);
+            }
+            recomputePendingApprovalsByThread();
+          },
+          onApprovalRequired: (execution) => {
+            debugLog("Tool approval required:", execution.name);
+            recomputePendingApprovalsByThread();
+          },
+          onContextUsageChange: (usage) => {
+            if (inst === chatRef.current) {
+              setContextUsage(usage);
+            }
+          },
+          onError: (error2) => {
+            if (error2 && inst === chatRef.current) {
+              callbacksRef.current.onError?.(error2);
+            }
+          },
+          onThreadChange: (id) => {
+            handleInstanceThreadAssigned(inst, id);
+          },
+          onSessionStatusChange: (status2) => {
+            debugLog("Session status:", status2);
+            if (inst === chatRef.current) {
+              setSessionStatus(status2);
+            }
+          },
+          onStreamChunk: (chunk) => {
+            if (streamListenersRef.current.size > 0) {
+              for (const handler of streamListenersRef.current) {
+                handler(chunk);
+              }
             }
           }
         }
+      );
+      for (const { tool } of sharedToolsRef.current.values()) {
+        inst.registerTool(tool);
       }
-    );
+      if (sharedSkillsRef.current.length > 0) {
+        inst.setInlineSkills(sharedSkillsRef.current);
+      }
+      if (sharedSystemContextRef.current) {
+        inst.setContext(sharedSystemContextRef.current);
+      }
+      inst.subscribe(notifyStateChange);
+      instancesRef.current.set(key, inst);
+      return inst;
+    },
+    [
+      debugLog,
+      handleInstanceThreadAssigned,
+      notifyStateChange,
+      recomputePendingApprovalsByThread
+    ]
+  );
+  if (chatRef.current !== null && chatRef.current.disposed) {
+    for (const inst of instancesRef.current.values()) {
+      inst.revive();
+      inst.subscribe(notifyStateChange);
+    }
+    debugLog("Revived disposed instance(s) (React StrictMode)");
   }
+  if (chatRef.current === null) {
+    const initialKey = concurrentThreads && threadId ? threadId : SINGLE_INSTANCE_KEY;
+    activeInstanceKeyRef.current = initialKey;
+    chatRef.current = createInstance(initialKey);
+  }
+  const switchActiveInstance = React2.useCallback(
+    (key, opts) => {
+      if (!concurrentThreads) {
+        chatRef.current?.setActiveThread(key);
+        return;
+      }
+      let targetKey;
+      if (key == null) {
+        const currentKey = activeInstanceKeyRef.current;
+        const currentInst = instancesRef.current.get(currentKey);
+        const isCurrentFreshEmpty = currentInst !== void 0 && currentInst.messages.length === 0 && (currentKey === SINGLE_INSTANCE_KEY || currentKey.startsWith("__pending_"));
+        if (isCurrentFreshEmpty) {
+          return;
+        }
+        targetKey = `__pending_${++pendingCounterRef.current}__`;
+      } else {
+        targetKey = key;
+      }
+      let inst = instancesRef.current.get(targetKey);
+      const wasFresh = !inst;
+      if (!inst) {
+        const currentKey = activeInstanceKeyRef.current;
+        const currentInst = instancesRef.current.get(currentKey);
+        const currentIsPromotableSlot = currentInst !== void 0 && currentInst.messages.length === 0 && (currentKey === SINGLE_INSTANCE_KEY || currentKey.startsWith("__pending_"));
+        if (currentIsPromotableSlot) {
+          instancesRef.current.delete(currentKey);
+          instancesRef.current.set(targetKey, currentInst);
+          currentInst.setActiveThread(targetKey);
+          inst = currentInst;
+          if (opts?.hydrateMessages) {
+            inst.setMessages(opts.hydrateMessages);
+          }
+          if (opts?.hydrateActiveLeafId) {
+            inst.switchBranch(opts.hydrateActiveLeafId);
+          }
+        } else {
+          inst = createInstance(targetKey, {
+            initialMessages: opts?.hydrateMessages
+          });
+          if (opts?.hydrateActiveLeafId) {
+            inst.switchBranch(opts.hydrateActiveLeafId);
+          }
+        }
+      } else if (wasFresh && opts?.hydrateMessages && inst.messages.length === 0) {
+        inst.setMessages(opts.hydrateMessages);
+        if (opts.hydrateActiveLeafId)
+          inst.switchBranch(opts.hydrateActiveLeafId);
+      }
+      if (activeInstanceKeyRef.current === targetKey) return;
+      activeInstanceKeyRef.current = targetKey;
+      chatRef.current = inst;
+      if (targetKey === SINGLE_INSTANCE_KEY || targetKey.startsWith("__pending_")) {
+        setActualThreadId(void 0);
+      } else {
+        setActualThreadId(targetKey);
+      }
+      setSessionStatus(inst.getSessionStatus());
+      setToolExecutions(inst.toolExecutions);
+      setAgentIteration(inst.iteration);
+      notifyStateChange();
+      debugLog("Active instance switched", { key: targetKey });
+    },
+    [concurrentThreads, createInstance, debugLog, notifyStateChange]
+  );
   React2.useEffect(() => {
-    if (chatRef.current && systemPrompt !== void 0) {
-      chatRef.current.setSystemPrompt(systemPrompt);
-      debugLog("System prompt updated from prop");
+    if (systemPrompt === void 0) return;
+    for (const inst of instancesRef.current.values()) {
+      inst.setSystemPrompt(systemPrompt);
     }
+    debugLog("System prompt updated from prop");
   }, [systemPrompt, debugLog]);
   React2.useEffect(() => {
-    if (chatRef.current && headers !== void 0) {
-      chatRef.current.setHeaders(headers);
-      debugLog("Headers config updated from prop");
+    if (headers === void 0) return;
+    for (const inst of instancesRef.current.values()) {
+      inst.setHeaders(headers);
     }
+    debugLog("Headers config updated from prop");
   }, [headers, debugLog]);
   React2.useEffect(() => {
-    if (chatRef.current && body !== void 0) {
-      chatRef.current.setBody(body);
-      debugLog("Body config updated from prop");
+    if (body === void 0) return;
+    for (const inst of instancesRef.current.values()) {
+      inst.setBody(body);
     }
+    debugLog("Body config updated from prop");
   }, [body, debugLog]);
   React2.useEffect(() => {
-    if (chatRef.current && runtimeUrl !== void 0) {
-      chatRef.current.setUrl(runtimeUrl);
-      debugLog("URL config updated from prop");
+    if (runtimeUrl === void 0) return;
+    for (const inst of instancesRef.current.values()) {
+      inst.setUrl(runtimeUrl);
     }
+    debugLog("URL config updated from prop");
   }, [runtimeUrl, debugLog]);
   React2.useEffect(() => {
     const prev = lastControlledThreadIdRef.current;
@@ -5561,11 +5853,21 @@ function CopilotProvider(props) {
     if (!isThreadIdControlled) {
       return;
     }
-    chatRef.current?.setActiveThread(threadId ?? null);
-    setActualThreadId(threadId);
-    setSessionStatus(threadId ? "ready" : "idle");
+    if (concurrentThreads) {
+      switchActiveInstance(threadId ?? null);
+    } else {
+      chatRef.current?.setActiveThread(threadId ?? null);
+      setActualThreadId(threadId);
+      setSessionStatus(threadId ? "ready" : "idle");
+    }
     debugLog("Thread/session synced from prop", { threadId });
-  }, [debugLog, isThreadIdControlled, threadId]);
+  }, [
+    debugLog,
+    isThreadIdControlled,
+    threadId,
+    concurrentThreads,
+    switchActiveInstance
+  ]);
   const EMPTY_MESSAGES = React2.useRef([]);
   const getMessagesSnapshot = React2.useCallback(() => chatRef.current.messages, []);
   const getServerMessagesSnapshot = React2.useCallback(
@@ -5575,36 +5877,110 @@ function CopilotProvider(props) {
   const getStatusSnapshot = React2.useCallback(() => chatRef.current.status, []);
   const getErrorSnapshot = React2.useCallback(() => chatRef.current.error, []);
   const messages = React2.useSyncExternalStore(
-    chatRef.current.subscribe,
+    stableSubscribe,
     getMessagesSnapshot,
     getServerMessagesSnapshot
   );
   const status = React2.useSyncExternalStore(
-    chatRef.current.subscribe,
+    stableSubscribe,
     getStatusSnapshot,
     () => "ready"
   );
   const errorFromChat = React2.useSyncExternalStore(
-    chatRef.current.subscribe,
+    stableSubscribe,
     getErrorSnapshot,
     () => void 0
   );
   const error = errorFromChat ?? null;
   const isLoading = status === "streaming" || status === "submitted";
-  const setActiveThread = React2.useCallback((id) => {
-    chatRef.current?.setActiveThread(id);
-    setActualThreadId(id ?? void 0);
-  }, []);
+  const setActiveThread = React2.useCallback(
+    (id, opts) => {
+      if (concurrentThreads) {
+        switchActiveInstance(id, opts);
+      } else {
+        chatRef.current?.setActiveThread(id);
+        setActualThreadId(id ?? void 0);
+      }
+    },
+    [concurrentThreads, switchActiveInstance]
+  );
+  const disposeThreadInstance = React2.useCallback(
+    (id) => {
+      if (!concurrentThreads) return;
+      const inst = instancesRef.current.get(id);
+      if (!inst) return;
+      inst.dispose();
+      instancesRef.current.delete(id);
+      if (activeInstanceKeyRef.current === id) {
+        switchActiveInstance(null);
+      } else {
+        recomputeBusyThreadIds();
+        recomputePendingApprovalsByThread();
+      }
+    },
+    [
+      concurrentThreads,
+      switchActiveInstance,
+      recomputeBusyThreadIds,
+      recomputePendingApprovalsByThread
+    ]
+  );
+  const assignLocalThreadId = React2.useCallback(
+    (localId) => {
+      if (!concurrentThreads) return;
+      if (!localId) return;
+      const currentKey = activeInstanceKeyRef.current;
+      if (currentKey === localId) return;
+      const currentInst = instancesRef.current.get(currentKey);
+      if (!currentInst) return;
+      const isInternalSlot = currentKey === SINGLE_INSTANCE_KEY || currentKey.startsWith("__pending_");
+      if (!isInternalSlot) return;
+      if (instancesRef.current.has(localId)) return;
+      instancesRef.current.delete(currentKey);
+      instancesRef.current.set(localId, currentInst);
+      activeInstanceKeyRef.current = localId;
+      if (currentInst === chatRef.current) {
+        setActualThreadId(localId);
+        callbacksRef.current.onThreadChange?.(localId);
+      }
+      recomputeBusyThreadIds();
+      recomputePendingApprovalsByThread();
+      debugLog("Assigned local thread id", { localId });
+    },
+    [
+      concurrentThreads,
+      debugLog,
+      recomputeBusyThreadIds,
+      recomputePendingApprovalsByThread
+    ]
+  );
   const renewSession = React2.useCallback(() => {
     chatRef.current?.renewSession();
     setActualThreadId(void 0);
     setSessionStatus("idle");
   }, []);
   const registerTool = React2.useCallback((tool) => {
-    chatRef.current?.registerTool(tool);
+    const existing = sharedToolsRef.current.get(tool.name);
+    if (existing) {
+      existing.tool = tool;
+      existing.refCount++;
+    } else {
+      sharedToolsRef.current.set(tool.name, { tool, refCount: 1 });
+    }
+    for (const inst of instancesRef.current.values()) {
+      inst.registerTool(tool);
+    }
   }, []);
   const unregisterTool = React2.useCallback((name) => {
-    chatRef.current?.unregisterTool(name);
+    const entry = sharedToolsRef.current.get(name);
+    if (!entry) return;
+    entry.refCount = Math.max(0, entry.refCount - 1);
+    for (const inst of instancesRef.current.values()) {
+      inst.unregisterTool(name);
+    }
+    if (entry.refCount === 0) {
+      sharedToolsRef.current.delete(name);
+    }
   }, []);
   const approveToolExecution = React2.useCallback(
     (id, extraData, permissionLevel) => {
@@ -5655,6 +6031,7 @@ function CopilotProvider(props) {
         parentId
       );
       const contextString = printTree(contextTreeRef.current);
+      sharedSystemContextRef.current = contextString;
       chatRef.current?.setContext(contextString);
       setContextChars(contextString.length);
       debugLog("Context added:", id);
@@ -5666,6 +6043,7 @@ function CopilotProvider(props) {
     (id) => {
       contextTreeRef.current = removeNode(contextTreeRef.current, id);
       const contextString = printTree(contextTreeRef.current);
+      sharedSystemContextRef.current = contextString;
       chatRef.current?.setContext(contextString);
       setContextChars(contextString.length);
       debugLog("Context removed:", id);
@@ -5674,14 +6052,19 @@ function CopilotProvider(props) {
   );
   const setSystemPrompt = React2.useCallback(
     (prompt) => {
-      chatRef.current?.setSystemPrompt(prompt);
+      for (const inst of instancesRef.current.values()) {
+        inst.setSystemPrompt(prompt);
+      }
       debugLog("System prompt updated via function");
     },
     [debugLog]
   );
   const setInlineSkills = React2.useCallback(
     (skills2) => {
-      chatRef.current?.setInlineSkills(skills2);
+      sharedSkillsRef.current = skills2;
+      for (const inst of instancesRef.current.values()) {
+        inst.setInlineSkills(skills2);
+      }
       debugLog("Inline skills updated", { count: skills2.length });
     },
     [debugLog]
@@ -5729,7 +6112,7 @@ function CopilotProvider(props) {
     []
   );
   const hasBranches = React2.useSyncExternalStore(
-    chatRef.current.subscribe,
+    stableSubscribe,
     getHasBranchesSnapshot,
     () => false
   );
@@ -5764,7 +6147,9 @@ function CopilotProvider(props) {
   }, [error, onError]);
   React2.useEffect(() => {
     return () => {
-      chatRef.current?.dispose();
+      for (const inst of instancesRef.current.values()) {
+        inst.dispose();
+      }
     };
   }, []);
   const contextValue = React2.useMemo(
@@ -5818,7 +6203,13 @@ function CopilotProvider(props) {
       toolsConfig,
       // Headless primitives
       subscribeToStreamEvents,
-      messageMeta: messageMetaStoreRef.current
+      messageMeta: messageMetaStoreRef.current,
+      // Multi-thread streaming
+      concurrentThreads,
+      busyThreadIds,
+      pendingApprovalsByThread,
+      disposeThreadInstance,
+      assignLocalThreadId
     }),
     [
       messages,
@@ -5858,7 +6249,12 @@ function CopilotProvider(props) {
       renewSession,
       sessionStatus,
       runtimeUrl,
-      toolsConfig
+      toolsConfig,
+      concurrentThreads,
+      busyThreadIds,
+      pendingApprovalsByThread,
+      disposeThreadInstance,
+      assignLocalThreadId
     ]
   );
   const messageHistoryContextValue = React2__default.default.useMemo(
@@ -5988,5 +6384,5 @@ exports.useMessageHistoryContext = useMessageHistoryContext;
 exports.useSkillContext = useSkillContext;
 exports.useTool = useTool;
 exports.useTools = useTools;
-//# sourceMappingURL=chunk-ZYLHGNIG.cjs.map
-//# sourceMappingURL=chunk-ZYLHGNIG.cjs.map
+//# sourceMappingURL=chunk-GW5ZZHJ7.cjs.map
+//# sourceMappingURL=chunk-GW5ZZHJ7.cjs.map