@yushaw/sanqian-chat 0.2.44 → 0.3.1

package/dist/renderer/index.js

@@ -88,6 +88,67 @@ module.exports = __toCommonJS(renderer_exports);
 
 // src/renderer/hooks/useChat.ts
 var import_react = require("react");
+
+// src/core/tool-status.ts
+function normalizeToolExecutionStatus(status) {
+  if (typeof status !== "string") return void 0;
+  switch (status.trim().toLowerCase()) {
+    case "success":
+    case "completed":
+    case "ok":
+      return "completed";
+    case "error":
+    case "failed":
+      return "error";
+    case "cancelled":
+    case "canceled":
+      return "cancelled";
+    case "running":
+      return "running";
+    case "pending":
+      return "pending";
+    default:
+      return void 0;
+  }
+}
+function deriveToolExecutionStatus(options) {
+  if (typeof options.actionRequired === "string" && options.actionRequired.length > 0) {
+    return "error";
+  }
+  if (options.error === true) {
+    return "error";
+  }
+  if (typeof options.error === "string" && options.error.trim().length > 0) {
+    return "error";
+  }
+  const normalizedStatus = normalizeToolExecutionStatus(options.status);
+  if (normalizedStatus) {
+    return normalizedStatus;
+  }
+  if (options.result !== void 0 && options.result !== null) {
+    if (typeof options.result === "string") {
+      const normalizedResult = options.result.trimStart();
+      if (normalizedResult.startsWith("\u274C") || normalizedResult.startsWith("Error:")) {
+        return "error";
+      }
+    }
+    return "completed";
+  }
+  return options.fallback ?? "running";
+}
+function formatToolResultContent(result, error) {
+  const value = result ?? error;
+  if (value === void 0 || value === null) return void 0;
+  if (typeof value === "string") return value;
+  try {
+    const serialized = JSON.stringify(value);
+    return serialized === void 0 ? String(value) : serialized;
+  } catch {
+    return String(value);
+  }
+}
+
+// src/renderer/hooks/useChat.ts
 var TYPEWRITER_DELAYS = { VERY_FAST: 2, FAST: 5, NORMAL: 10, SLOW: 20 };
 var TYPEWRITER_THRESHOLDS = { VERY_FAST: 100, FAST: 50, NORMAL: 20 };
 var MAX_DETACHED_SNAPSHOTS = 30;
@@ -108,12 +169,240 @@ var findLastBlock = (blocks, predicate) => {
   }
   return void 0;
 };
+function getToolResultStatus(event) {
+  return deriveToolExecutionStatus({
+    status: event.status,
+    result: event.result,
+    actionRequired: event.action_required,
+    error: event.error,
+    fallback: "completed"
+  });
+}
 function cloneBlocks(blocks) {
   return blocks?.map((block) => ({
     ...block,
     toolArgs: block.toolArgs ? { ...block.toolArgs } : block.toolArgs
   }));
 }
+function updateDetachedSnapshotForEvent(streamContext, event) {
+  const snapshot = streamContext.detachedSnapshot;
+  if (!snapshot?.length) return false;
+  const assistantIndex = snapshot.findIndex((message) => message.id === streamContext.assistantMessageId);
+  if (assistantIndex === -1) return false;
+  const assistant = snapshot[assistantIndex];
+  switch (event.type) {
+    case "text": {
+      const rawContent = event.content;
+      if (!rawContent) return false;
+      const nextChunk = assistant.content ? rawContent : rawContent.trimStart();
+      if (!nextChunk) return false;
+      snapshot[assistantIndex] = {
+        ...assistant,
+        content: `${assistant.content}${nextChunk}`,
+        isStreaming: true,
+        isComplete: false
+      };
+      return true;
+    }
+    case "thinking": {
+      const rawThinking = event.content;
+      if (!rawThinking) return false;
+      const nextChunk = assistant.thinking ? rawThinking : rawThinking.trimStart();
+      if (!nextChunk) return false;
+      snapshot[assistantIndex] = {
+        ...assistant,
+        thinking: `${assistant.thinking ?? ""}${nextChunk}`,
+        currentThinking: `${assistant.currentThinking ?? ""}${nextChunk}`,
+        isStreaming: true,
+        isComplete: false,
+        isThinkingStreaming: true,
+        isThinkingPaused: false
+      };
+      return true;
+    }
+    case "tool_call": {
+      const tc = event.tool_call;
+      if (!tc) return false;
+      const toolName = tc.function?.name || tc.name || "";
+      const toolId = tc.id || "";
+      let args = {};
+      if (tc.args) {
+        args = tc.args;
+      } else if (tc.function?.arguments) {
+        try {
+          args = JSON.parse(tc.function.arguments);
+        } catch {
+          args = {};
+        }
+      }
+      const toolCalls = [...assistant.toolCalls || []];
+      toolCalls.push({
+        id: toolId,
+        name: toolName,
+        args,
+        status: "running"
+      });
+      const blocks = cloneBlocks(assistant.blocks) || [];
+      blocks.push({
+        type: "tool_call",
+        content: "",
+        timestamp: Date.now(),
+        toolName,
+        toolArgs: args,
+        toolCallId: toolId,
+        toolStatus: "running",
+        isIntermediate: true
+      });
+      snapshot[assistantIndex] = {
+        ...assistant,
+        toolCalls,
+        blocks,
+        isStreaming: true,
+        isComplete: false,
+        isThinkingStreaming: false,
+        isThinkingPaused: !!assistant.thinking,
+        isToolCallsStreaming: true
+      };
+      return true;
+    }
+    case "tool_args_chunk": {
+      const chunk = event.chunk;
+      if (!chunk) return false;
+      const toolCalls = [...assistant.toolCalls || []];
+      const toolCallIndex = findToolCallIndex(toolCalls, event.tool_call_id, event.tool_name);
+      if (toolCallIndex === -1) return false;
+      const existingRaw = toolCalls[toolCallIndex].argsRaw || "";
+      toolCalls[toolCallIndex] = {
+        ...toolCalls[toolCallIndex],
+        argsRaw: `${existingRaw}${chunk}`
+      };
+      const blocks = cloneBlocks(assistant.blocks) || [];
+      const blockIndex = blocks.findIndex(
+        (block) => block.type === "tool_call" && (block.toolCallId === event.tool_call_id || !event.tool_call_id && event.tool_name && block.toolName === event.tool_name)
+      );
+      if (blockIndex !== -1) {
+        blocks[blockIndex] = {
+          ...blocks[blockIndex],
+          toolArgsRaw: `${blocks[blockIndex].toolArgsRaw || ""}${chunk}`
+        };
+      }
+      snapshot[assistantIndex] = {
+        ...assistant,
+        toolCalls,
+        blocks
+      };
+      return true;
+    }
+    case "tool_args": {
+      const toolCalls = [...assistant.toolCalls || []];
+      const toolCallIndex = findToolCallIndex(toolCalls, event.tool_call_id, event.tool_name);
+      if (toolCallIndex === -1) return false;
+      toolCalls[toolCallIndex] = {
+        ...toolCalls[toolCallIndex],
+        args: event.args || {},
+        argsRaw: void 0
+      };
+      const blocks = cloneBlocks(assistant.blocks) || [];
+      const blockIndex = blocks.findIndex(
+        (block) => block.type === "tool_call" && (block.toolCallId === event.tool_call_id || !event.tool_call_id && event.tool_name && block.toolName === event.tool_name)
+      );
+      if (blockIndex !== -1) {
+        blocks[blockIndex] = {
+          ...blocks[blockIndex],
+          toolArgs: event.args || {},
+          toolArgsRaw: void 0
+        };
+      }
+      snapshot[assistantIndex] = {
+        ...assistant,
+        toolCalls,
+        blocks
+      };
+      return true;
+    }
+    case "tool_result": {
+      const toolStatus = getToolResultStatus(event);
+      const resultContent = formatToolResultContent(event.result, event.error);
+      const toolCalls = (assistant.toolCalls || []).map((toolCall) => toolCall.id === event.tool_call_id ? {
+        ...toolCall,
+        status: toolStatus,
+        result: event.result,
+        error: toolStatus === "error" ? typeof event.error === "string" && event.error.trim().length > 0 ? event.error : resultContent : void 0,
+        actionRequired: event.action_required,
+        settingsTab: event.settings_tab,
+        settingsSubTab: event.settings_sub_tab
+      } : toolCall);
+      const hasRunning = toolCalls.some((toolCall) => toolCall.status === "running");
+      const blocks = cloneBlocks(assistant.blocks) || [];
+      const toolBlockIndex = blocks.findIndex(
+        (block) => block.type === "tool_call" && block.toolCallId === event.tool_call_id
+      );
+      if (toolBlockIndex !== -1) {
+        blocks[toolBlockIndex] = {
+          ...blocks[toolBlockIndex],
+          toolStatus
+        };
+      }
+      if (resultContent) {
+        blocks.push({
+          type: "tool_result",
+          content: resultContent,
+          timestamp: Date.now(),
+          toolName: toolBlockIndex !== -1 ? blocks[toolBlockIndex].toolName : void 0,
+          toolCallId: event.tool_call_id,
+          isIntermediate: true
+        });
+      }
+      snapshot[assistantIndex] = {
+        ...assistant,
+        toolCalls,
+        blocks,
+        isToolCallsStreaming: hasRunning
+      };
+      return true;
+    }
+    case "done": {
+      snapshot[assistantIndex] = {
+        ...assistant,
+        thinking: assistant.thinking?.trimEnd(),
+        currentThinking: void 0,
+        isStreaming: false,
+        isComplete: true,
+        isThinkingStreaming: false,
+        isThinkingPaused: false,
+        isToolCallsStreaming: false
+      };
+      return true;
+    }
+    case "cancelled": {
+      snapshot[assistantIndex] = {
+        ...assistant,
+        thinking: assistant.thinking?.trimEnd(),
+        currentThinking: void 0,
+        isStreaming: false,
+        isComplete: true,
+        isThinkingStreaming: false,
+        isThinkingPaused: false,
+        isToolCallsStreaming: false
+      };
+      return true;
+    }
+    case "error": {
+      snapshot[assistantIndex] = {
+        ...assistant,
+        content: assistant.content || `Error: ${event.error}`,
+        isStreaming: false,
+        isComplete: true,
+        isThinkingStreaming: false,
+        isThinkingPaused: false,
+        isToolCallsStreaming: false
+      };
+      return true;
+    }
+    default:
+      return false;
+  }
+}
 function cloneMessages(messages) {
   return messages.map((message) => ({
     ...message,
@@ -164,6 +453,8 @@ function useChat(options) {
   const pendingCancelFnRef = (0, import_react.useRef)(null);
   const suppressStreamRef = (0, import_react.useRef)(false);
   const activeStreamContextRef = (0, import_react.useRef)(null);
+  const streamContextsRef = (0, import_react.useRef)(/* @__PURE__ */ new Map());
+  const conversationStreamTokensRef = (0, import_react.useRef)(/* @__PURE__ */ new Map());
   const currentBlocksRef = (0, import_react.useRef)([]);
   const currentTextBlockIndexRef = (0, import_react.useRef)(-1);
   const needsContentClearRef = (0, import_react.useRef)(false);
@@ -187,6 +478,13 @@ function useChat(options) {
     return () => {
       isMountedRef.current = false;
       cancelRef.current?.();
+      streamContextsRef.current.forEach((context) => {
+        context.suppressed = true;
+        context.terminal = true;
+        context.cancel?.();
+      });
+      streamContextsRef.current.clear();
+      conversationStreamTokensRef.current.clear();
       if (typewriterIntervalRef.current) clearTimeout(typewriterIntervalRef.current);
     };
   }, []);
@@ -264,12 +562,89 @@ function useChat(options) {
       map.delete(oldestKey);
     }
   }, []);
+  const upsertConversationStreamToken = (0, import_react.useCallback)((id, token) => {
+    const map = conversationStreamTokensRef.current;
+    const existing = map.get(id);
+    if (existing) {
+      existing.delete(token);
+      existing.add(token);
+      return;
+    }
+    map.set(id, /* @__PURE__ */ new Set([token]));
+  }, []);
+  const removeConversationStreamToken = (0, import_react.useCallback)((id, token) => {
+    const map = conversationStreamTokensRef.current;
+    const tokens = map.get(id);
+    if (!tokens) return;
+    tokens.delete(token);
+    if (tokens.size === 0) {
+      map.delete(id);
+    }
+  }, []);
+  const bindStreamToConversation = (0, import_react.useCallback)((streamContext, id) => {
+    const nextConversationId = typeof id === "string" && id.trim().length > 0 ? id : null;
+    const previousConversationId = streamContext.conversationId;
+    if (previousConversationId && previousConversationId !== nextConversationId) {
+      removeConversationStreamToken(previousConversationId, streamContext.token);
+    }
+    streamContext.conversationId = nextConversationId;
+    if (nextConversationId) {
+      upsertConversationStreamToken(nextConversationId, streamContext.token);
+    }
+  }, [removeConversationStreamToken, upsertConversationStreamToken]);
+  const touchStreamContext = (0, import_react.useCallback)((streamContext) => {
+    streamContext.updatedAt = Date.now();
+    const id = streamContext.conversationId;
+    if (!id) return;
+    upsertConversationStreamToken(id, streamContext.token);
+  }, [upsertConversationStreamToken]);
+  const getLatestConversationStreamContext = (0, import_react.useCallback)((id) => {
+    if (!id) return null;
+    const tokenSet = conversationStreamTokensRef.current.get(id);
+    if (!tokenSet || tokenSet.size === 0) return null;
+    const tokens = Array.from(tokenSet.values()).reverse();
+    for (const token of tokens) {
+      const context = streamContextsRef.current.get(token);
+      if (!context || context.terminal) {
+        tokenSet.delete(token);
+        continue;
+      }
+      if (context.suppressed) {
+        continue;
+      }
+      return context;
+    }
+    if (tokenSet.size === 0) {
+      conversationStreamTokensRef.current.delete(id);
+    }
+    return null;
+  }, []);
+  const hasLiveConversationStream = (0, import_react.useCallback)((id) => {
+    return getLatestConversationStreamContext(id) !== null;
+  }, [getLatestConversationStreamContext]);
+  const finalizeStreamContext = (0, import_react.useCallback)((streamContext) => {
+    if (streamContext.terminal) {
+      return;
+    }
+    streamContext.terminal = true;
+    if (streamContext.conversationId) {
+      removeConversationStreamToken(streamContext.conversationId, streamContext.token);
+    }
+    streamContextsRef.current.delete(streamContext.token);
+    if (activeStreamContextRef.current?.token === streamContext.token) {
+      activeStreamContextRef.current = null;
+    }
+  }, [removeConversationStreamToken]);
   const detachActiveStream = (0, import_react.useCallback)((detachContext) => {
     const context = activeStreamContextRef.current;
-    if (!context || context.detached) {
+    if (!context || context.detached || context.terminal) {
       return;
     }
-    const detachedSnapshot = cloneMessages(normalizeConversationMessages(messagesRef.current));
+    const normalizedLiveMessages = cloneMessages(normalizeConversationMessages(messagesRef.current));
+    const liveSnapshotHasAssistant = normalizedLiveMessages.some(
+      (message) => message.id === context.assistantMessageId
+    );
+    const detachedSnapshot = liveSnapshotHasAssistant ? normalizedLiveMessages : context.initialSnapshot ? cloneMessages(context.initialSnapshot) : normalizedLiveMessages;
     const detachedAssistantMessageIndex = detachedSnapshot.findIndex(
       (message) => message.id === context.assistantMessageId
     );
@@ -295,7 +670,9 @@ function useChat(options) {
       setDetachedConversationSnapshot(context.conversationId, detachedSnapshot);
     }
     context.detached = true;
+    context.suppressed = false;
     context.detachContext = detachContext;
+    touchStreamContext(context);
     if (typewriterIntervalRef.current) {
       clearTimeout(typewriterIntervalRef.current);
       typewriterIntervalRef.current = null;
@@ -309,7 +686,7 @@ function useChat(options) {
     pendingInterruptStreamIdRef.current = null;
     clearPendingCancel();
     suppressStreamRef.current = false;
-  }, [clearPendingCancel, resetStreamBuffers, setDetachedConversationSnapshot]);
+  }, [clearPendingCancel, resetStreamBuffers, setDetachedConversationSnapshot, touchStreamContext]);
   const refreshConversationIfVisible = (0, import_react.useCallback)(async (id) => {
     if (!id || conversationIdRef.current !== id) return false;
     try {
@@ -320,12 +697,13 @@ function useChat(options) {
       detachedConversationSnapshotsRef.current.delete(id);
       setMessages(normalizedMessages);
       setConversationTitle(detail.title ?? null);
+      setIsStreaming(hasLiveConversationStream(id) || normalizedMessages.some((message) => !!message.isStreaming));
       return true;
     } catch (refreshError) {
       console.warn("[useChat] Failed to refresh conversation after detached stream completion:", refreshError);
       return false;
     }
-  }, [adapter]);
+  }, [adapter, hasLiveConversationStream]);
   const refreshConversationIfVisibleWithRetry = (0, import_react.useCallback)((id, retryDelaysMs) => {
     if (!id) return;
     void (async () => {
@@ -343,15 +721,49 @@ function useChat(options) {
       }
     })();
   }, [refreshConversationIfVisible]);
+  const syncDetachedSnapshotToVisibleConversation = (0, import_react.useCallback)((streamContext) => {
+    const id = streamContext.conversationId;
+    if (!id || conversationIdRef.current !== id) return;
+    const activeContext = activeStreamContextRef.current;
+    if (activeContext && !activeContext.detached && activeContext.conversationId === id) return;
+    if (!streamContext.detachedSnapshot?.length) return;
+    const nextMessages = cloneMessages(streamContext.detachedSnapshot);
+    setMessages(nextMessages);
+    setIsStreaming(
+      hasLiveConversationStream(id) || nextMessages.some((message) => message.isStreaming)
+    );
+  }, [hasLiveConversationStream]);
   const handleStreamEvent = (0, import_react.useCallback)((event, streamContext) => {
     if (!isMountedRef.current) return;
+    if (streamContext.terminal) return;
+    touchStreamContext(streamContext);
+    const isTerminalEvent = event.type === "done" || event.type === "cancelled" || event.type === "error";
+    if (streamContext.suppressed && event.type !== "start" && !isTerminalEvent) {
+      return;
+    }
     const isActiveStream = activeStreamContextRef.current?.token === streamContext.token && !streamContext.detached;
     if (!isActiveStream) {
+      if (event.type === "start" && event.conversationId) {
+        if (streamContext.conversationId && streamContext.conversationId !== event.conversationId) {
+          detachedConversationSnapshotsRef.current.delete(streamContext.conversationId);
+        }
+        bindStreamToConversation(streamContext, event.conversationId);
+        if (streamContext.detachedSnapshot?.length) {
+          setDetachedConversationSnapshot(event.conversationId, streamContext.detachedSnapshot);
+        }
+      }
+      const snapshotUpdated = updateDetachedSnapshotForEvent(streamContext, event);
+      if (snapshotUpdated && streamContext.conversationId && streamContext.detachedSnapshot?.length) {
+        setDetachedConversationSnapshot(streamContext.conversationId, streamContext.detachedSnapshot);
+      }
+      if (snapshotUpdated) {
+        syncDetachedSnapshotToVisibleConversation(streamContext);
+      }
       if (event.type === "done" && event.conversationId && !streamContext.didReportConversationChange) {
         if (streamContext.conversationId && streamContext.conversationId !== event.conversationId) {
           detachedConversationSnapshotsRef.current.delete(streamContext.conversationId);
         }
-        streamContext.conversationId = event.conversationId;
+        bindStreamToConversation(streamContext, event.conversationId);
         streamContext.didReportConversationChange = true;
         if (streamContext.detachedSnapshot?.length) {
           setDetachedConversationSnapshot(event.conversationId, streamContext.detachedSnapshot);
@@ -364,17 +776,19 @@ function useChat(options) {
         });
         refreshConversationIfVisibleWithRetry(event.conversationId, [0, 300, 900]);
       } else if (event.type === "done" && event.conversationId && streamContext.didReportConversationChange) {
+        bindStreamToConversation(streamContext, event.conversationId);
         if (streamContext.detachedSnapshot?.length) {
           setDetachedConversationSnapshot(event.conversationId, streamContext.detachedSnapshot);
         }
         refreshConversationIfVisibleWithRetry(event.conversationId, [0, 300, 900]);
       }
-      const isTerminalEvent = event.type === "done" || event.type === "cancelled" || event.type === "error";
       if (isTerminalEvent) {
         streamContext.detachedSnapshot = void 0;
-      }
-      if (isTerminalEvent && activeStreamContextRef.current?.token === streamContext.token) {
-        activeStreamContextRef.current = null;
+        streamContext.initialSnapshot = void 0;
+        finalizeStreamContext(streamContext);
+        if (conversationIdRef.current === streamContext.conversationId) {
+          setIsStreaming(hasLiveConversationStream(streamContext.conversationId));
+        }
       }
       return;
     }
@@ -386,6 +800,9 @@ function useChat(options) {
     switch (event.type) {
       case "start": {
         currentRunIdRef.current = event.run_id;
+        if (event.conversationId) {
+          bindStreamToConversation(streamContext, event.conversationId);
+        }
         if (pendingCancelRef.current) {
           const pendingCancel = pendingCancelFnRef.current || cancelRef.current;
           if (pendingCancel) {
@@ -657,24 +1074,35 @@ function useChat(options) {
       case "tool_result": {
         flushTypewriter();
         const toolId = event.tool_call_id;
-        const result = typeof event.result === "string" ? event.result : JSON.stringify(event.result);
+        const toolStatus = getToolResultStatus(event);
+        const resultContent = formatToolResultContent(event.result, event.error);
         const blockIdx = currentBlocksRef.current.findIndex((b) => b.type === "tool_call" && b.toolCallId === toolId);
         const toolName = blockIdx !== -1 ? currentBlocksRef.current[blockIdx].toolName : void 0;
-        if (blockIdx !== -1) currentBlocksRef.current[blockIdx].toolStatus = "completed";
-        currentBlocksRef.current.push({
-          type: "tool_result",
-          content: result,
-          timestamp: Date.now(),
-          toolName,
-          toolCallId: toolId,
-          isIntermediate: true
-        });
+        if (blockIdx !== -1) currentBlocksRef.current[blockIdx].toolStatus = toolStatus;
+        if (resultContent) {
+          currentBlocksRef.current.push({
+            type: "tool_result",
+            content: resultContent,
+            timestamp: Date.now(),
+            toolName,
+            toolCallId: toolId,
+            isIntermediate: true
+          });
+        }
         setMessages((prev) => {
           const idx = prev.findIndex((m) => m.id === assistantMessageId);
           if (idx === -1) return prev;
           const msg = prev[idx];
           const updatedCalls = (msg.toolCalls || []).map(
-            (t) => t.id === toolId ? { ...t, status: "completed", result: event.result } : t
+            (t) => t.id === toolId ? {
+              ...t,
+              status: toolStatus,
+              result: event.result,
+              error: toolStatus === "error" ? typeof event.error === "string" && event.error.trim().length > 0 ? event.error : resultContent : void 0,
+              actionRequired: event.action_required,
+              settingsTab: event.settings_tab,
+              settingsSubTab: event.settings_sub_tab
+            } : t
           );
           const hasRunning = updatedCalls.some((tc) => tc.status === "running");
           const updated = [...prev];
@@ -724,7 +1152,7 @@ function useChat(options) {
         });
         resetStreamBuffers();
         if (event.conversationId) {
-          streamContext.conversationId = event.conversationId;
+          bindStreamToConversation(streamContext, event.conversationId);
           streamContext.didReportConversationChange = true;
           setConversationId(event.conversationId);
           onConversationChange?.(event.conversationId, event.title, {
@@ -734,13 +1162,13 @@ function useChat(options) {
           });
         }
         if (event.title) setConversationTitle(event.title);
-        setIsStreaming(false);
         setIsLoading(false);
         currentRunIdRef.current = null;
         pendingInterruptStreamIdRef.current = null;
         suppressStreamRef.current = false;
         clearPendingCancel();
-        activeStreamContextRef.current = null;
+        finalizeStreamContext(streamContext);
+        setIsStreaming(hasLiveConversationStream(conversationIdRef.current));
         break;
       }
       case "cancelled": {
@@ -771,14 +1199,14 @@ function useChat(options) {
           return updated;
         });
         resetStreamBuffers();
-        setIsStreaming(false);
         setIsLoading(false);
         setPendingInterrupt(null);
         currentRunIdRef.current = null;
         pendingInterruptStreamIdRef.current = null;
         suppressStreamRef.current = false;
         clearPendingCancel();
-        activeStreamContextRef.current = null;
+        finalizeStreamContext(streamContext);
+        setIsStreaming(hasLiveConversationStream(conversationIdRef.current));
         break;
       }
       case "error": {
@@ -801,13 +1229,13 @@ function useChat(options) {
         resetStreamBuffers();
         setError(event.error);
         onError?.(new Error(event.error));
-        setIsStreaming(false);
         setIsLoading(false);
         currentRunIdRef.current = null;
         pendingInterruptStreamIdRef.current = null;
         suppressStreamRef.current = false;
         clearPendingCancel();
-        activeStreamContextRef.current = null;
+        finalizeStreamContext(streamContext);
+        setIsStreaming(hasLiveConversationStream(conversationIdRef.current));
         break;
       }
       case "interrupt": {
@@ -825,7 +1253,20 @@ function useChat(options) {
         break;
       }
     }
-  }, [clearPendingCancel, flushTypewriter, onConversationChange, onError, refreshConversationIfVisibleWithRetry, resetStreamBuffers, setDetachedConversationSnapshot]);
+  }, [
+    bindStreamToConversation,
+    clearPendingCancel,
+    finalizeStreamContext,
+    flushTypewriter,
+    hasLiveConversationStream,
+    onConversationChange,
+    onError,
+    refreshConversationIfVisibleWithRetry,
+    resetStreamBuffers,
+    setDetachedConversationSnapshot,
+    syncDetachedSnapshotToVisibleConversation,
+    touchStreamContext
+  ]);
   const trySendMessage = (0, import_react.useCallback)(async (content, sendOptions) => {
     const trimmedContent = content.trim();
     const hasAttachedResources = (sendOptions?.attachedResources?.length ?? 0) > 0;
@@ -858,15 +1299,27 @@ function useChat(options) {
       blocks: [],
       isComplete: false
     };
+    const shouldRenderUserMessage = trimmedContent.length > 0 || hasAttachedResources;
+    const initialSnapshot = cloneMessages(normalizeConversationMessages(
+      shouldRenderUserMessage ? [...messagesRef.current, userMessage, assistantMessage] : [...messagesRef.current, assistantMessage]
+    ));
     const streamContext = {
       token: crypto.randomUUID(),
       assistantMessageId: assistantMessage.id,
       conversationId: conversationIdRef.current,
       detached: false,
+      terminal: false,
+      suppressed: false,
+      updatedAt: Date.now(),
+      pendingCancel: false,
+      initialSnapshot,
       didReportConversationChange: false
     };
+    streamContextsRef.current.set(streamContext.token, streamContext);
+    if (streamContext.conversationId) {
+      bindStreamToConversation(streamContext, streamContext.conversationId);
+    }
     activeStreamContextRef.current = streamContext;
-    const shouldRenderUserMessage = trimmedContent.length > 0 || hasAttachedResources;
     setMessages(
       (prev) => shouldRenderUserMessage ? [...prev, userMessage, assistantMessage] : [...prev, assistantMessage]
     );
@@ -895,6 +1348,11 @@ function useChat(options) {
           sessionResources: sessionResourceIds.length ? sessionResourceIds : void 0
         }
       );
+      streamContext.cancel = cancel;
+      if (streamContext.pendingCancel) {
+        streamContext.pendingCancel = false;
+        cancel();
+      }
       cancelRef.current = cancel;
       if (pendingCancelRef.current) {
         pendingCancelFnRef.current = cancel;
@@ -923,56 +1381,132 @@ function useChat(options) {
       pendingInterruptStreamIdRef.current = null;
       setIsLoading(false);
       setIsStreaming(false);
-      if (activeStreamContextRef.current?.token === streamContext.token) {
-        activeStreamContextRef.current = null;
-      }
+      finalizeStreamContext(streamContext);
       return false;
     }
-  }, [adapter, clearPendingCancel, handleStreamEvent, onError, resetStreamBuffers, sessionResources]);
+  }, [
+    adapter,
+    bindStreamToConversation,
+    clearPendingCancel,
+    finalizeStreamContext,
+    handleStreamEvent,
+    onError,
+    resetStreamBuffers,
+    sessionResources
+  ]);
   const sendMessage = (0, import_react.useCallback)(async (content, sendOptions) => {
     await trySendMessage(content, sendOptions);
   }, [trySendMessage]);
+  const getVisibleStreamContext = (0, import_react.useCallback)(() => {
+    const activeContext = activeStreamContextRef.current;
+    if (activeContext && !activeContext.detached && !activeContext.terminal) {
+      return activeContext;
+    }
+    return getLatestConversationStreamContext(conversationIdRef.current);
+  }, [getLatestConversationStreamContext]);
   const stopStreaming = (0, import_react.useCallback)(() => {
-    pendingCancelRef.current = true;
-    pendingCancelFnRef.current = cancelRef.current;
-    suppressStreamRef.current = true;
-    if (cancelRef.current) {
-      cancelRef.current();
-      clearPendingCancel();
-      cancelRef.current = null;
+    const targetContext = getVisibleStreamContext();
+    if (!targetContext) {
+      setIsStreaming(false);
+      setIsLoading(false);
+      return;
     }
-    flushTypewriter();
-    setMessages((prev) => {
-      const last = [...prev].reverse().find((m) => m.role === "assistant");
-      if (!last?.isStreaming) return prev;
-      return prev.map((m) => {
-        if (m.id !== last.id) return m;
-        return {
-          ...m,
-          content: fullContentRef.current || m.content,
-          thinking: m.thinking?.trimEnd(),
+    targetContext.suppressed = true;
+    touchStreamContext(targetContext);
+    const isActiveVisibleStream = activeStreamContextRef.current?.token === targetContext.token && !targetContext.detached;
+    if (isActiveVisibleStream) {
+      pendingCancelRef.current = true;
+      pendingCancelFnRef.current = cancelRef.current;
+      suppressStreamRef.current = true;
+      if (cancelRef.current) {
+        cancelRef.current();
+        clearPendingCancel();
+        cancelRef.current = null;
+      }
+      flushTypewriter();
+      setMessages((prev) => {
+        const last = [...prev].reverse().find((m) => m.role === "assistant");
+        if (!last?.isStreaming) return prev;
+        return prev.map((m) => {
+          if (m.id !== last.id) return m;
+          return {
+            ...m,
+            content: fullContentRef.current || m.content,
+            thinking: m.thinking?.trimEnd(),
+            currentThinking: void 0,
+            isStreaming: false,
+            isThinkingStreaming: false,
+            isThinkingPaused: false,
+            isToolCallsStreaming: false,
+            isComplete: true,
+            toolCalls: m.toolCalls?.map(
+              (tc) => tc.status === "running" ? { ...tc, status: "cancelled" } : tc
+            ),
+            blocks: [...currentBlocksRef.current]
+          };
+        });
+      });
+      resetStreamBuffers();
+      currentRunIdRef.current = null;
+      pendingInterruptStreamIdRef.current = null;
+      activeStreamContextRef.current = null;
+      setIsStreaming(false);
+      setIsLoading(false);
+      return;
+    }
+    suppressStreamRef.current = false;
+    const cancelStream = targetContext.cancel;
+    if (cancelStream) {
+      cancelStream();
+    } else {
+      targetContext.pendingCancel = true;
+    }
+    const detachedSnapshot = targetContext.detachedSnapshot;
+    if (detachedSnapshot?.length) {
+      const assistantIndex = detachedSnapshot.findIndex((message) => message.id === targetContext.assistantMessageId);
+      if (assistantIndex !== -1) {
+        const assistant = detachedSnapshot[assistantIndex];
+        detachedSnapshot[assistantIndex] = {
+          ...assistant,
+          thinking: assistant.thinking?.trimEnd(),
           currentThinking: void 0,
           isStreaming: false,
+          isComplete: true,
           isThinkingStreaming: false,
           isThinkingPaused: false,
           isToolCallsStreaming: false,
-          isComplete: true,
-          toolCalls: m.toolCalls?.map(
-            (tc) => tc.status === "running" ? { ...tc, status: "cancelled" } : tc
-          ),
-          blocks: [...currentBlocksRef.current]
+          toolCalls: assistant.toolCalls?.map((tc) => tc.status === "running" ? { ...tc, status: "cancelled" } : tc)
         };
-      });
+      }
+      setDetachedConversationSnapshot(targetContext.conversationId, detachedSnapshot);
+      if (targetContext.conversationId && targetContext.conversationId === conversationIdRef.current) {
+        setMessages(cloneMessages(detachedSnapshot));
+      }
+    }
+    setIsStreaming(hasLiveConversationStream(conversationIdRef.current));
+    setIsLoading(false);
+  }, [
+    clearPendingCancel,
+    flushTypewriter,
+    getVisibleStreamContext,
+    hasLiveConversationStream,
+    resetStreamBuffers,
+    setDetachedConversationSnapshot,
+    touchStreamContext
+  ]);
+  const cancelAllStreamContexts = (0, import_react.useCallback)(() => {
+    streamContextsRef.current.forEach((context) => {
+      context.suppressed = true;
+      context.terminal = true;
+      context.cancel?.();
     });
-    resetStreamBuffers();
-    currentRunIdRef.current = null;
-    pendingInterruptStreamIdRef.current = null;
+    streamContextsRef.current.clear();
+    conversationStreamTokensRef.current.clear();
     activeStreamContextRef.current = null;
-    setIsStreaming(false);
-    setIsLoading(false);
-  }, [clearPendingCancel, flushTypewriter, resetStreamBuffers]);
+    cancelRef.current = null;
+  }, []);
   const clearMessages = (0, import_react.useCallback)(() => {
-    cancelRef.current?.();
+    cancelAllStreamContexts();
     if (typewriterIntervalRef.current) clearTimeout(typewriterIntervalRef.current);
     setMessages([]);
     setError(null);
@@ -981,18 +1515,17 @@ function useChat(options) {
     resetStreamBuffers();
     currentRunIdRef.current = null;
     pendingInterruptStreamIdRef.current = null;
-    activeStreamContextRef.current = null;
     clearPendingCancel();
     suppressStreamRef.current = false;
     detachedConversationSnapshotsRef.current.clear();
-  }, [clearPendingCancel, resetStreamBuffers]);
+  }, [cancelAllStreamContexts, clearPendingCancel, resetStreamBuffers]);
   const loadConversation = (0, import_react.useCallback)(async (id, optionsArg) => {
     const cancelActiveStream = optionsArg?.cancelActiveStream ?? true;
-    const activeStream = activeStreamContextRef.current;
-    if (activeStream && !activeStream.detached) {
+    const visibleStream = getVisibleStreamContext();
+    if (visibleStream) {
       if (cancelActiveStream) {
         stopStreaming();
-      } else {
+      } else if (activeStreamContextRef.current && !activeStreamContextRef.current.detached) {
         detachActiveStream(optionsArg?.detachContext);
       }
     }
@@ -1011,6 +1544,9 @@ function useChat(options) {
         refreshConversationIfVisibleWithRetry(id, [250, 800, 1800]);
       }
       setMessages(nextMessages);
+      setIsStreaming(
+        hasLiveConversationStream(detail.id) || nextMessages.some((message) => !!message.isStreaming)
+      );
       setConversationId(detail.id);
       setConversationTitle(detail.title);
       currentAgentIdRef.current = detail.agentId ?? currentAgentIdRef.current;
@@ -1021,18 +1557,24 @@ function useChat(options) {
     } finally {
       if (isMountedRef.current) setIsLoading(false);
     }
-  }, [adapter, detachActiveStream, onError, refreshConversationIfVisibleWithRetry, stopStreaming]);
+  }, [
+    adapter,
+    detachActiveStream,
+    getVisibleStreamContext,
+    hasLiveConversationStream,
+    onError,
+    refreshConversationIfVisibleWithRetry,
+    stopStreaming
+  ]);
   const newConversation = (0, import_react.useCallback)((optionsArg) => {
     const cancelActiveStream = optionsArg?.cancelActiveStream ?? true;
-    const activeStream = activeStreamContextRef.current;
-    if (activeStream && !activeStream.detached) {
+    const visibleStream = getVisibleStreamContext();
+    if (visibleStream) {
       if (cancelActiveStream) {
         stopStreaming();
-      } else {
+      } else if (activeStreamContextRef.current && !activeStreamContextRef.current.detached) {
         detachActiveStream(optionsArg?.detachContext);
       }
-    } else if (cancelActiveStream) {
-      cancelRef.current?.();
     }
     if (typewriterIntervalRef.current) clearTimeout(typewriterIntervalRef.current);
     setMessages([]);
@@ -1047,7 +1589,7 @@ function useChat(options) {
     pendingInterruptStreamIdRef.current = null;
     activeStreamContextRef.current = null;
     clearPendingCancel();
-  }, [clearPendingCancel, detachActiveStream, resetStreamBuffers, stopStreaming]);
+  }, [clearPendingCancel, detachActiveStream, getVisibleStreamContext, resetStreamBuffers, stopStreaming]);
   const sendHitlResponse = (0, import_react.useCallback)((response) => {
     const runId = currentRunIdRef.current ?? void 0;
     const streamId = pendingInterruptStreamIdRef.current ?? void 0;
@@ -5946,12 +6488,25 @@ function parseToolCalls(toolCalls) {
     const rawArgs = fn?.arguments ?? tc.args ?? tc.arguments;
     const args = safeParseArgs(rawArgs);
     const id = tc.id || tc.tool_call_id || tc.call_id;
+    const actionRequired = tc.action_required || tc.actionRequired;
+    const settingsTab = tc.settings_tab || tc.settingsTab;
+    const settingsSubTab = tc.settings_sub_tab || tc.settingsSubTab;
     return {
       id,
       name,
       args,
-      status: "completed",
-      result: tc.result
+      result: tc.result,
+      error: typeof tc.error === "string" ? tc.error : void 0,
+      actionRequired,
+      settingsTab,
+      settingsSubTab,
+      status: deriveToolExecutionStatus({
+        status: tc.status,
+        result: tc.result,
+        actionRequired,
+        error: tc.error,
+        fallback: "completed"
+      })
     };
   }).filter((tc) => tc.name || tc.id);
 }
@@ -6042,7 +6597,10 @@ function mergeConsecutiveAssistantMessages(rawMessages) {
           id: (toolMessage.tool_call_id || void 0) ?? `tool-${idx}`,
           name: "",
           args: void 0,
-          status: "completed",
+          status: deriveToolExecutionStatus({
+            result: toolMessage.content,
+            fallback: "completed"
+          }),
           result: toolMessage.content
         })) : void 0;
         const effectiveToolCalls = msgToolCalls && msgToolCalls.length > 0 ? msgToolCalls : fallbackCalls;
@@ -6075,6 +6633,16 @@ function mergeConsecutiveAssistantMessages(rawMessages) {
           const toolResultBlocks = [];
           for (const tc of effectiveToolCalls) {
             const toolIndex = effectiveToolCalls.indexOf(tc);
+            const toolResultById = tc.id ? toolMessages.find((tm) => tm.tool_call_id === tc.id) : void 0;
+            const toolResultByIndex = toolMessages[toolIndex];
+            const toolResult = toolResultById || toolResultByIndex;
+            const toolStatus = deriveToolExecutionStatus({
+              status: tc.status,
+              result: tc.result ?? toolResult?.content,
+              actionRequired: tc.actionRequired,
+              error: tc.error,
+              fallback: "completed"
+            });
             blocks.push({
               type: "tool_call",
               content: "",
@@ -6082,12 +6650,9 @@ function mergeConsecutiveAssistantMessages(rawMessages) {
               toolName: tc.name,
               toolArgs: tc.args,
               toolCallId: tc.id,
-              toolStatus: "completed",
+              toolStatus,
               isIntermediate: true
             });
-            const toolResultById = tc.id ? toolMessages.find((tm) => tm.tool_call_id === tc.id) : void 0;
-            const toolResultByIndex = toolMessages[toolIndex];
-            const toolResult = toolResultById || toolResultByIndex;
             const resultContent = tc.result ?? toolResult?.content;
             const toolResultId = toolResult?.tool_call_id || void 0;
             if (resultContent) {
@@ -6130,6 +6695,13 @@ function mergeConsecutiveAssistantMessages(rawMessages) {
           );
           if (matchingToolCall) {
             matchingToolCall.result = toolMsg.content;
+            matchingToolCall.status = deriveToolExecutionStatus({
+              status: matchingToolCall.status,
+              result: toolMsg.content,
+              actionRequired: matchingToolCall.actionRequired,
+              error: matchingToolCall.error,
+              fallback: "completed"
+            });
           }
         }
         const thinkingParts = consecutiveAssistantMsgs.map((m) => m.thinking).filter((t) => t && t.trim());
@@ -6728,9 +7300,20 @@ function processStreamEvents(stream, onEvent, sdk, setCurrentRunId, streamId) {
               args: event.args || {}
             });
             break;
-          case "tool_result":
-            forward({ type: "tool_result", tool_call_id: event.tool_call_id || "", result: event.result });
+          case "tool_result": {
+            const toolResultEvent = event;
+            forward({
+              type: "tool_result",
+              tool_call_id: toolResultEvent.tool_call_id || "",
+              result: toolResultEvent.result,
+              error: toolResultEvent.error,
+              status: toolResultEvent.status,
+              action_required: toolResultEvent.action_required,
+              settings_tab: toolResultEvent.settings_tab,
+              settings_sub_tab: toolResultEvent.settings_sub_tab
+            });
             break;
+          }
           case "done":
             forward({ type: "done", conversationId: event.conversationId || "", title: event.title });
             currentRunId = null;
@@ -7480,8 +8063,8 @@ function ToolCallItem({ toolCall, toolResult }) {
         style: { color: "var(--chat-text)" },
         children: [
           /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("span", { className: "font-mono", children: displayName }),
-          toolResult && /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("span", { className: "text-green-600 dark:text-green-400", children: TimelineIcons.check }),
-          !toolResult && toolCall.toolStatus === "error" && /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("span", { className: "text-red-500", children: TimelineIcons.error }),
+          toolCall.toolStatus === "completed" && /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("span", { className: "text-green-600 dark:text-green-400", children: TimelineIcons.check }),
+          toolCall.toolStatus === "error" && /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("span", { className: "text-red-500", children: TimelineIcons.error }),
           hasArgs && !expanded && /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)("span", { className: "font-mono", style: { color: "var(--chat-text)", opacity: 0.6, fontSize: "0.75rem" }, children: [
             "(",
             Object.values(toolCall.toolArgs).slice(0, 1).map((v) => typeof v === "string" ? v.length > 18 ? v.slice(0, 18) + "\u2026" : v : "\u2026"),
@@ -7518,7 +8101,8 @@ function StreamingToolCallItem({
         style: { color: "var(--chat-text)" },
         children: [
           /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("span", { className: "font-mono", children: displayName }),
-          toolResult && /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("span", { className: "text-green-600 dark:text-green-400", children: TimelineIcons.check }),
+          toolCall.toolStatus === "completed" && /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("span", { className: "text-green-600 dark:text-green-400", children: TimelineIcons.check }),
+          toolCall.toolStatus === "error" && /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("span", { className: "text-red-500", children: TimelineIcons.error }),
           isActive && /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("span", { className: "ml-0.5 text-amber-500 animate-pulse", children: "\u25C6" }),
           hasArgs && !expanded && /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)("span", { className: "font-mono", style: { color: "var(--chat-text)", opacity: 0.6, fontSize: "0.75rem" }, children: [
             "(",
@@ -7939,7 +8523,13 @@ function buildFallbackBlocksFromToolCalls(toolCalls) {
   const blocks = [];
   let timestamp = Date.now();
   for (const toolCall of toolCalls) {
-    const toolStatus = toolCall.status || (toolCall.result !== void 0 ? "completed" : "running");
+    const toolStatus = deriveToolExecutionStatus({
+      status: toolCall.status,
+      result: toolCall.result,
+      actionRequired: toolCall.actionRequired,
+      error: toolCall.error,
+      fallback: "running"
+    });
     blocks.push({
       type: "tool_call",
       content: "",