@agents24/chat-react 0.1.9 → 0.1.10

package/dist/index.js

@@ -15,7 +15,79 @@ import {
 } from "./chunk-EWZO4QJI.js";
 
 // src/controller.ts
-import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { useCallback as useCallback2, useEffect, useMemo, useRef, useState } from "react";
+
+// src/controller-actions.ts
+import { useCallback } from "react";
+function useControllerMessageActions(input) {
+  const handleCopy = useCallback((content, messageId) => {
+    navigator.clipboard?.writeText(content);
+    input.setCopiedMessageId(messageId);
+    setTimeout(() => input.setCopiedMessageId(null), 200);
+  }, [input]);
+  const handleLike = useCallback(async (msg) => {
+    const nextLiked = !input.liked[msg.id];
+    input.setLiked((prev) => ({ ...prev, [msg.id]: nextLiked }));
+    if (nextLiked) input.setDisliked((prev) => ({ ...prev, [msg.id]: false }));
+  }, [input]);
+  const handleDislike = useCallback(async (msg) => {
+    const nextDisliked = !input.disliked[msg.id];
+    input.setDisliked((prev) => ({ ...prev, [msg.id]: nextDisliked }));
+    if (nextDisliked) input.setLiked((prev) => ({ ...prev, [msg.id]: false }));
+  }, [input]);
+  const handleRetry = useCallback(async (msg) => {
+    const index = input.messagesRef.current.findIndex((message) => message.id === msg.id);
+    if (index <= 0) return;
+    const userMessage = input.messagesRef.current[index - 1];
+    if (userMessage.role !== "user") return;
+    const trimmed = input.messagesRef.current.slice(0, index);
+    input.setMessages(trimmed);
+    input.messagesRef.current = trimmed;
+    if (input.activeThreadIdRef.current) input.persistThread(input.activeThreadIdRef.current, trimmed);
+    await input.handleSubmit({ text: userMessage.content, files: userMessage.attachments || [] });
+  }, [input]);
+  const upsertLiveVoiceMessage = useCallback((payload) => {
+    const content = payload.content?.trim() ?? "";
+    if (!content && !payload.citations?.length && !payload.reasoningSteps?.length) return;
+    input.setMessages((prev) => {
+      const currentId = input.liveVoiceIdsRef.current[payload.role];
+      const index = currentId ? prev.findIndex((message) => message.id === currentId) : -1;
+      const nextMessage = {
+        id: currentId || input.createId(),
+        role: payload.role,
+        content,
+        createdAt: /* @__PURE__ */ new Date(),
+        isFinal: Boolean(payload.isFinal),
+        isVoice: payload.role === "user",
+        parts: content ? [{ id: input.createId(), type: "text", kind: "text", text: content }] : [],
+        citations: payload.citations,
+        reasoningSteps: payload.reasoningSteps
+      };
+      const next = index === -1 ? [...prev, nextMessage] : prev.map((message, itemIndex) => itemIndex === index ? { ...message, ...nextMessage } : message);
+      input.liveVoiceIdsRef.current[payload.role] = payload.isFinal ? void 0 : nextMessage.id;
+      input.messagesRef.current = next;
+      if (input.activeThreadIdRef.current) input.persistThread(input.activeThreadIdRef.current, next);
+      return next;
+    });
+  }, [input]);
+  const startNewThread = useCallback(() => {
+    input.detachActiveStream();
+    input.requestSeqRef.current += 1;
+    input.activeThreadIdRef.current = null;
+    input.loadedThreadIdRef.current = null;
+    input.nextBeforeTurnIndexRef.current = null;
+    input.hasOlderTurnsRef.current = false;
+    input.storage.setActiveThreadId?.(null);
+    input.onActiveThreadIdChange?.(null);
+    input.setMessages([]);
+    input.messagesRef.current = [];
+    input.setHasOlderTurns(false);
+    input.setIsLoadingOlder(false);
+    input.setContextStatus(null);
+    input.setLoadingHistory(false);
+  }, [input]);
+  return { handleCopy, handleDislike, handleLike, handleRetry, startNewThread, upsertLiveVoiceMessage };
+}
 
 // src/context-window.ts
 var SOURCE_PRIORITY = {
@@ -138,7 +210,8 @@ function compressionFromContextWindow(contextWindow) {
 
 // src/model.ts
 var DEFAULT_THREAD_PAGE_SIZE = 5;
-var isRunningThreadStatus = (status) => (/* @__PURE__ */ new Set(["queued", "running", "cancelling"])).has(String(status || "").toLowerCase());
+var isRunningThreadStatus = (status) => (/* @__PURE__ */ new Set(["queued", "running", "cancelling", "paused"])).has(String(status || "").toLowerCase());
+var isAutoAttachThreadStatus = (status) => (/* @__PURE__ */ new Set(["queued", "running", "cancelling"])).has(String(status || "").toLowerCase());
 var createChatId = () => {
   if (typeof crypto !== "undefined" && "randomUUID" in crypto) return crypto.randomUUID();
   return `chat-${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
@@ -304,8 +377,17 @@ var partsFromResponseBlocks = (blocks, fallbackText) => {
       });
       return;
     }
-    if (block.kind === "approval_request") {
-      parts.push({ id, type: "approval", kind: "approval", raw: block });
+    if (block.kind === "hitl_request") {
+      const hitl = asRecord(block.hitl) || block;
+      parts.push({
+        id,
+        type: "hitl",
+        kind: "hitl",
+        hitl,
+        interruptId: optionalString(block.interruptId) || optionalString(hitl.interrupt_id) || null,
+        hitlKind: optionalString(block.hitlKind) || optionalString(hitl.kind) || null,
+        raw: block
+      });
       return;
     }
     if (block.kind === "error") {
@@ -431,6 +513,23 @@ var activeRunIdFromThread = (thread) => {
   const lastRunId = hasCamelLastRunId ? thread?.lastRunId : thread?.last_run_id || thread?.lastRunId;
   return lastRunId && isRunningThreadStatus(lastRunStatus) ? String(lastRunId) : null;
 };
+var autoAttachRunIdFromThread = (thread) => {
+  const hasCamelActiveRun = Boolean(
+    thread && Object.prototype.hasOwnProperty.call(thread, "activeRun")
+  );
+  const hasCamelLastRunStatus = Boolean(
+    thread && Object.prototype.hasOwnProperty.call(thread, "lastRunStatus")
+  );
+  const hasCamelLastRunId = Boolean(
+    thread && Object.prototype.hasOwnProperty.call(thread, "lastRunId")
+  );
+  const activeRun = hasCamelActiveRun ? thread?.activeRun || null : thread?.active_run || null;
+  const lastRunStatus = hasCamelLastRunStatus ? thread?.lastRunStatus || null : thread?.last_run_status || thread?.lastRunStatus || null;
+  const activeRunId = activeRun?.run_id ? String(activeRun.run_id) : "";
+  if (activeRunId && isAutoAttachThreadStatus(activeRun?.status || lastRunStatus)) return activeRunId;
+  const lastRunId = hasCamelLastRunId ? thread?.lastRunId : thread?.last_run_id || thread?.lastRunId;
+  return lastRunId && isAutoAttachThreadStatus(lastRunStatus) ? String(lastRunId) : null;
+};
 var hasUnfinishedAssistantMessage = (messages) => Boolean(messages?.some((message) => message.role === "assistant" && message.isFinal === false));
 var hasStaleUnfinishedAssistantCache = (thread) => hasUnfinishedAssistantMessage(thread?.messages) && !activeRunIdFromThread(thread);
 var activeRunIdFromThreadDetail = (thread) => {
@@ -440,7 +539,7 @@ var activeRunIdFromThreadDetail = (thread) => {
   return runningTurn?.run_id ? String(runningTurn.run_id) : null;
 };
 
-// src/controller.ts
+// src/controller-helpers.ts
 var threadSummaryToStored = (thread) => ({
   ...thread,
   id: String(thread.id),
@@ -449,6 +548,121 @@ var threadSummaryToStored = (thread) => ({
   messages: [],
   isHydrated: false
 });
+var isThreadNotFoundError = (error) => {
+  if (!error || typeof error !== "object" || !("status" in error)) return false;
+  return Number(error.status) === 404;
+};
+var isAbortError = (error) => {
+  if (!error || typeof error !== "object") return false;
+  const maybe = error;
+  return maybe.name === "AbortError" || String(maybe.message || "").toLowerCase().includes("aborted");
+};
+var abortDetachedStream = (controller) => {
+  if (!controller || controller.signal.aborted) return;
+  try {
+    const reason = typeof DOMException !== "undefined" ? new DOMException("Chat stream detached.", "AbortError") : new Error("Chat stream detached.");
+    controller.abort(reason);
+  } catch {
+  }
+};
+var hasRunState = (thread) => Boolean(
+  thread.active_run || thread.activeRun || thread.last_run_id || thread.lastRunId || thread.last_run_status || thread.lastRunStatus || thread.isRunning
+);
+var mergeStoredThreadsForRefresh = (currentThreads, serverThreads) => {
+  const currentById = new Map(currentThreads.map((thread) => [thread.id, thread]));
+  const serverIds = new Set(serverThreads.map((thread) => thread.id));
+  const mergedServerThreads = serverThreads.map((serverThread) => {
+    const current = currentById.get(serverThread.id);
+    if (!current) return serverThread;
+    const incomingHasRunState = hasRunState(serverThread);
+    return {
+      ...current,
+      ...serverThread,
+      messages: current.messages || [],
+      isHydrated: current.isHydrated,
+      hasOlderTurns: current.hasOlderTurns,
+      nextBeforeTurnIndex: current.nextBeforeTurnIndex,
+      active_run: incomingHasRunState ? serverThread.active_run : current.active_run,
+      activeRun: incomingHasRunState ? serverThread.activeRun : current.activeRun,
+      last_run_id: incomingHasRunState ? serverThread.last_run_id : current.last_run_id,
+      lastRunId: incomingHasRunState ? serverThread.lastRunId : current.lastRunId,
+      last_run_status: incomingHasRunState ? serverThread.last_run_status : current.last_run_status,
+      lastRunStatus: incomingHasRunState ? serverThread.lastRunStatus : current.lastRunStatus,
+      lastEventSeq: incomingHasRunState ? serverThread.lastEventSeq : current.lastEventSeq,
+      isRunning: incomingHasRunState ? serverThread.isRunning : current.isRunning
+    };
+  });
+  const localOnlyThreads = currentThreads.filter((thread) => {
+    if (serverIds.has(thread.id)) return false;
+    return Boolean(thread.isHydrated || thread.messages?.length || thread.isRunning || thread.activeRun || thread.active_run);
+  });
+  return [...mergedServerThreads, ...localOnlyThreads];
+};
+var stableStringify = (value) => JSON.stringify(value ?? null);
+var sameStoredThread = (left, right) => {
+  if (left === right) return true;
+  if (!left || !right) return false;
+  return stableStringify(left) === stableStringify(right);
+};
+var applyThreadSummaryEvent = (currentThreads, event) => {
+  if (event.event === "snapshot_required") return currentThreads;
+  if (event.event === "thread.deleted") {
+    const next2 = currentThreads.filter((thread) => thread.id !== event.thread_id);
+    return next2.length === currentThreads.length ? currentThreads : next2;
+  }
+  const incoming = threadSummaryToStored(event.thread);
+  const index = currentThreads.findIndex((thread) => thread.id === incoming.id);
+  const sortByActivity = (threads) => [...threads].sort((a, b) => {
+    const left = Date.parse(String(a.updated_at || a.last_activity_at || a.created_at || ""));
+    const right = Date.parse(String(b.updated_at || b.last_activity_at || b.created_at || ""));
+    return (Number.isFinite(right) ? right : 0) - (Number.isFinite(left) ? left : 0);
+  });
+  if (index === -1) return sortByActivity([...currentThreads, incoming]);
+  const [merged] = mergeStoredThreadsForRefresh([currentThreads[index]], [incoming]);
+  if (sameStoredThread(currentThreads[index], merged)) return currentThreads;
+  const next = [...currentThreads];
+  next[index] = merged;
+  return sortByActivity(next);
+};
+
+// src/message-lifecycle.ts
+function findStableAssistantMessageIndex(messages, input) {
+  return messages.findIndex(
+    (message) => message.role === "assistant" && (input.messageId && message.id === input.messageId || Boolean(input.runId && message.runId === input.runId))
+  );
+}
+function appendStableStreamingTurn(messages, userMessage, assistantMessage) {
+  const next = [...messages];
+  if (!next.some((message) => message.id === userMessage.id)) {
+    next.push(userMessage);
+  }
+  if (!next.some(
+    (message) => message.id === assistantMessage.id || Boolean(
+      assistantMessage.runId && message.role === "assistant" && message.runId === assistantMessage.runId
+    )
+  )) {
+    next.push(assistantMessage);
+  }
+  return next;
+}
+function upsertStableAssistantMessage(messages, input) {
+  const next = [...messages];
+  for (const baseMessage of input.baseMessages || []) {
+    const matchesTarget = baseMessage.role === "assistant" && (input.messageId && baseMessage.id === input.messageId || Boolean(input.runId && baseMessage.runId === input.runId));
+    if (!matchesTarget && !next.some((message) => message.id === baseMessage.id)) {
+      next.push(baseMessage);
+    }
+  }
+  const index = findStableAssistantMessageIndex(next, input);
+  if (index === -1) {
+    next.push(input.create());
+    return next;
+  }
+  next[index] = input.update(next[index]);
+  return next;
+}
+
+// src/controller.ts
 function useAgents24ChatController({
   transport,
   storage,
@@ -479,6 +693,7 @@ function useAgents24ChatController({
   const [lastThinkingDurationMs, setLastThinkingDurationMs] = useState(null);
   const [threads, setThreads] = useState(() => storage.listThreads());
   const [isRefreshingThreads, setIsRefreshingThreads] = useState(false);
+  const [isSelectingThread, setIsSelectingThread] = useState(false);
   const [activeRunId, setActiveRunId] = useState(null);
   const textareaRef = useRef(null);
   const activeThreadIdRef = useRef(activeThreadId);
@@ -496,14 +711,16 @@ function useAgents24ChatController({
   const streamingMessageIdRef = useRef(null);
   const reasoningRef = useRef([]);
   const liveVoiceIdsRef = useRef({});
-  const setActiveRunIdValue = useCallback((runId) => {
+  const refreshSeqRef = useRef(0);
+  const threadEventsCursorRef = useRef(null);
+  const setActiveRunIdValue = useCallback2((runId) => {
     activeRunIdRef.current = runId;
     setActiveRunId(runId);
   }, []);
-  const syncThreadsFromStorage = useCallback(() => {
+  const syncThreadsFromStorage = useCallback2(() => {
     setThreads(storage.listThreads());
   }, [storage]);
-  const upsertStoredThread = useCallback(
+  const upsertStoredThread = useCallback2(
     (thread) => {
       storage.upsertThread(thread);
       syncThreadsFromStorage();
@@ -513,7 +730,7 @@ function useAgents24ChatController({
   useEffect(() => {
     messagesRef.current = messages;
   }, [messages]);
-  const persistThread = useCallback(
+  const persistThread = useCallback2(
     (threadId, nextMessages, paging, options) => {
       const existing = storage.getThread(threadId);
       const firstUser = nextMessages.find((message) => message.role === "user");
@@ -530,7 +747,7 @@ function useAgents24ChatController({
     },
     [storage, upsertStoredThread]
   );
-  const markThreadRunStatus = useCallback(
+  const markThreadRunStatus = useCallback2(
     (threadId, runId, status, lastEventSeq) => {
       const existing = storage.getThread(threadId);
       if (!existing || !runId) return;
@@ -560,18 +777,20 @@ function useAgents24ChatController({
     },
     [storage, upsertStoredThread]
   );
-  const refresh = useCallback(async () => {
+  const refresh = useCallback2(async () => {
+    const seq = ++refreshSeqRef.current;
     setIsRefreshingThreads(true);
     try {
       const data = await transport.listThreads();
+      if (seq !== refreshSeqRef.current) return;
       const nextThreads = (data.items || []).map((item) => threadSummaryToStored(item));
-      storage.setThreads(nextThreads);
+      storage.setThreads(mergeStoredThreadsForRefresh(storage.listThreads(), nextThreads));
       setThreads(storage.listThreads());
     } finally {
-      setIsRefreshingThreads(false);
+      if (seq === refreshSeqRef.current) setIsRefreshingThreads(false);
     }
   }, [storage, transport]);
-  const applyThreadId = useCallback(
+  const applyThreadId = useCallback2(
     (threadId, baseMessages) => {
       if (!threadId || activeThreadIdRef.current === threadId) return;
       activeThreadIdRef.current = threadId;
@@ -585,18 +804,18 @@ function useAgents24ChatController({
     streamingContentRef.current = value;
     setStreamingContent(value);
   };
-  const setLoadingHistory = useCallback((value) => {
+  const setLoadingHistory = useCallback2((value) => {
     isLoadingHistoryRef.current = value;
     setIsLoadingHistory(value);
   }, []);
-  const setReasoningSteps = useCallback((value) => {
+  const setReasoningSteps = useCallback2((value) => {
     reasoningRef.current = value || [];
     setCurrentReasoning(value || []);
   }, []);
-  const detachActiveStream = useCallback(() => {
+  const detachActiveStream = useCallback2(() => {
     const controller = abortControllerRef.current;
     abortControllerRef.current = null;
-    controller?.abort();
+    abortDetachedStream(controller);
     setActiveRunIdValue(null);
     reattachedRunIdRef.current = null;
     streamingMessageIdRef.current = null;
@@ -607,21 +826,36 @@ function useAgents24ChatController({
     setStreamingContent("");
     setCurrentReasoning([]);
   }, [setActiveRunIdValue]);
-  const setLiveAssistantMessage = useCallback(
+  const clearMissingThread = useCallback2(
+    (threadId) => {
+      storage.deleteThread?.(threadId);
+      syncThreadsFromStorage();
+      if (activeThreadIdRef.current !== threadId) return;
+      requestSeqRef.current += 1;
+      detachActiveStream();
+      activeThreadIdRef.current = null;
+      loadedThreadIdRef.current = null;
+      nextBeforeTurnIndexRef.current = null;
+      hasOlderTurnsRef.current = false;
+      storage.setActiveThreadId?.(null);
+      onActiveThreadIdChange?.(null);
+      setMessages([]);
+      messagesRef.current = [];
+      setHasOlderTurns(false);
+      setIsLoadingOlder(false);
+      setContextStatus(null);
+      setLoadingHistory(false);
+    },
+    [detachActiveStream, onActiveThreadIdChange, setLoadingHistory, storage, syncThreadsFromStorage]
+  );
+  const setLiveAssistantMessage = useCallback2(
     (input) => {
       setMessages((prev) => {
-        const index = prev.findIndex(
-          (message) => message.id === input.messageId || input.runId && message.role === "assistant" && message.runId === input.runId
-        );
-        if (index === -1) {
-          const next2 = [...prev];
-          (input.baseMessages || []).forEach((message) => {
-            const isSameAssistant = message.id === input.messageId || Boolean(input.runId && message.role === "assistant" && message.runId === input.runId);
-            if (!isSameAssistant && !next2.some((item) => item.id === message.id)) {
-              next2.push(message);
-            }
-          });
-          next2.push({
+        const next = upsertStableAssistantMessage(prev, {
+          baseMessages: input.baseMessages,
+          messageId: input.messageId,
+          runId: input.runId,
+          create: () => ({
             id: input.messageId,
             role: "assistant",
             runId: input.runId ?? null,
@@ -630,26 +864,23 @@ function useAgents24ChatController({
             reasoningSteps: input.reasoning,
             isFinal: false,
             parts: input.parts || []
-          });
-          messagesRef.current = next2;
-          return next2;
-        }
-        const next = [...prev];
-        next[index] = {
-          ...next[index],
-          runId: input.runId ?? next[index].runId ?? null,
-          content: input.content,
-          reasoningSteps: input.reasoning,
-          isFinal: false,
-          parts: input.parts ?? next[index].parts
-        };
+          }),
+          update: (message) => ({
+            ...message,
+            runId: input.runId ?? message.runId ?? null,
+            content: input.content,
+            reasoningSteps: input.reasoning,
+            isFinal: false,
+            parts: input.parts ?? message.parts
+          })
+        });
         messagesRef.current = next;
         return next;
       });
     },
     []
   );
-  const finalizeAssistantMessage = useCallback(
+  const finalizeAssistantMessage = useCallback2(
     (input) => {
       const content = input.error || input.assistantText.trim();
       if (!content) return input.baseMessages;
@@ -669,7 +900,17 @@ function useAgents24ChatController({
         reasoningSteps: mergeReasoningSteps(input.reasoning, { finalize: true }),
         thinkingDurationMs: input.thinkingDurationMs
       };
-      const completed = existingIndex >= 0 ? input.baseMessages.map((message, index) => index === existingIndex ? assistant : message) : [...input.baseMessages, assistant];
+      const completed = upsertStableAssistantMessage(input.baseMessages, {
+        messageId: input.messageId,
+        runId: input.runId,
+        create: () => assistant,
+        update: (message) => ({
+          ...message,
+          ...assistant,
+          id: message.id,
+          createdAt: message.createdAt
+        })
+      });
       setMessages(completed);
       messagesRef.current = completed;
       if (input.threadId) {
@@ -693,7 +934,7 @@ function useAgents24ChatController({
     },
     [createId, persistThread, storage, upsertStoredThread]
   );
-  const loadThread = useCallback(
+  const loadThread = useCallback2(
     async (threadId) => {
       const seq = ++requestSeqRef.current;
       setLoadingHistory(true);
@@ -724,13 +965,20 @@ function useAgents24ChatController({
           nextBeforeTurnIndex: paging.nextBeforeTurnIndex,
           updated_at: threadActivityDate(detail)
         });
+      } catch (error) {
+        if (isAbortError(error)) return;
+        if (isThreadNotFoundError(error)) {
+          clearMissingThread(threadId);
+          return;
+        }
+        throw error;
       } finally {
-        if (activeThreadIdRef.current === threadId) setLoadingHistory(false);
+        if (activeThreadIdRef.current === threadId && seq === requestSeqRef.current) setLoadingHistory(false);
       }
     },
-    [onThreadDetailLoaded, pageSize, setLoadingHistory, transport, upsertStoredThread]
+    [clearMissingThread, onThreadDetailLoaded, pageSize, setLoadingHistory, transport, upsertStoredThread]
   );
-  const loadOlderTurns = useCallback(async () => {
+  const loadOlderTurns = useCallback2(async () => {
     const threadId = activeThreadIdRef.current;
     const beforeTurnIndex = nextBeforeTurnIndexRef.current;
     if (!threadId || beforeTurnIndex === null || isLoadingOlderRef.current) return;
@@ -753,12 +1001,19 @@ function useAgents24ChatController({
       hasOlderTurnsRef.current = paging.hasOlderTurns;
       nextBeforeTurnIndexRef.current = paging.nextBeforeTurnIndex;
       persistThread(threadId, next, paging);
+    } catch (error) {
+      if (isAbortError(error)) return;
+      if (isThreadNotFoundError(error)) {
+        clearMissingThread(threadId);
+        return;
+      }
+      throw error;
     } finally {
       if (activeThreadIdRef.current === threadId) setIsLoadingOlder(false);
       isLoadingOlderRef.current = false;
     }
-  }, [pageSize, persistThread, transport]);
-  const handleStreamEvent = useCallback(
+  }, [clearMissingThread, pageSize, persistThread, transport]);
+  const handleStreamEvent = useCallback2(
     (input) => {
       const { mode, event, assistantMessageId, startedAt, streamThreadIdRef, baseMessages } = input;
       const payload = event.payload || {};
@@ -819,7 +1074,7 @@ function useAgents24ChatController({
     },
     [applyThreadId, finalizeAssistantMessage, markThreadRunStatus, onRuntimeEvent, onStreamErrorMessage, setActiveRunIdValue, setLiveAssistantMessage, setReasoningSteps]
   );
-  const runStream = useCallback(
+  const runStream = useCallback2(
     async (input) => {
       const startedAt = Date.now();
       const controller = new AbortController();
@@ -878,19 +1133,28 @@ function useAgents24ChatController({
         );
       }
       try {
+        let streamResult = null;
         if (input.mode === "attach") {
           setActiveRunIdValue(input.runId);
           reattachedRunIdRef.current = input.runId;
-          await transport.attachRun(
+          streamResult = await transport.attachRun(
             { runId: input.runId, signal: controller.signal },
             (event) => handleStreamEvent({ mode: "attach", event, assistantMessageId, startedAt, streamThreadIdRef, baseMessages })
           );
         } else {
-          await transport.streamMessage(
+          streamResult = await transport.streamMessage(
             { ...input.message, files: input.message.files || [], threadId: activeThreadIdRef.current, signal: controller.signal },
             (event) => handleStreamEvent({ mode: "submit", event, assistantMessageId, startedAt, streamThreadIdRef, baseMessages })
           );
         }
+        if (streamResult?.runId) setActiveRunIdValue(streamResult.runId);
+        if (streamResult?.threadId) {
+          streamThreadIdRef.current = streamResult.threadId;
+          applyThreadId(streamResult.threadId, baseMessages);
+          if (streamResult.runId) {
+            markThreadRunStatus(streamResult.threadId, streamResult.runId, "running");
+          }
+        }
         if (streamingContentRef.current.trim() && streamingMessageIdRef.current) {
           finalizeAssistantMessage({
             threadId: streamThreadIdRef.current,
@@ -904,7 +1168,7 @@ function useAgents24ChatController({
         }
         await refresh().catch(() => void 0);
       } catch (error) {
-        if (error.name !== "AbortError") {
+        if (!isAbortError(error)) {
           finalizeAssistantMessage({
             threadId: streamThreadIdRef.current,
             baseMessages: messagesRef.current,
@@ -933,18 +1197,22 @@ function useAgents24ChatController({
     },
     [createId, finalizeAssistantMessage, handleStreamEvent, onStreamErrorMessage, persistThread, refresh, setActiveRunIdValue, setReasoningSteps, transport]
   );
-  const handleSubmit = useCallback(
+  const handleSubmit = useCallback2(
     async (message) => {
       if (!message.text.trim() && !(message.files || []).length) return;
       await runStream({ mode: "submit", message });
     },
     [runStream]
   );
-  const handleStop = useCallback(() => {
+  const attachRun = useCallback2(async (runId, threadId) => {
+    const resolvedThreadId = threadId ?? activeThreadIdRef.current;
+    if (runId && resolvedThreadId) await runStream({ mode: "attach", runId, threadId: resolvedThreadId });
+  }, [runStream]);
+  const handleStop = useCallback2(() => {
     const runId = activeRunIdRef.current;
     const partial = streamingContentRef.current;
     const liveMessageId = streamingMessageIdRef.current;
-    abortControllerRef.current?.abort();
+    abortDetachedStream(abortControllerRef.current);
     abortControllerRef.current = null;
     setActiveRunIdValue(null);
     streamingMessageIdRef.current = null;
@@ -965,11 +1233,40 @@ function useAgents24ChatController({
     }
   }, [finalizeAssistantMessage, lastThinkingDurationMs, setActiveRunIdValue, setReasoningSteps, transport]);
   useEffect(() => {
-    refresh().catch(() => {
-      storage.setThreads([]);
-      setThreads([]);
-    });
+    refresh().catch(() => setThreads(storage.listThreads()));
   }, [refresh, storage]);
+  useEffect(() => {
+    if (!transport.subscribeThreadEvents) return;
+    let cancelled = false;
+    let retryTimeout = null;
+    let controller = null;
+    const connect = () => {
+      if (cancelled) return;
+      controller = new AbortController();
+      transport.subscribeThreadEvents?.(
+        { cursor: threadEventsCursorRef.current, signal: controller.signal },
+        async (event) => {
+          if (typeof event.cursor === "number") threadEventsCursorRef.current = event.cursor;
+          if (event.event === "snapshot_required") {
+            await refresh().catch(() => void 0);
+            return;
+          }
+          const next = applyThreadSummaryEvent(storage.listThreads(), event);
+          storage.setThreads(next);
+          setThreads(storage.listThreads());
+        }
+      ).catch((error) => {
+        if (cancelled || isAbortError(error)) return;
+        retryTimeout = setTimeout(connect, 1500);
+      });
+    };
+    connect();
+    return () => {
+      cancelled = true;
+      if (retryTimeout) clearTimeout(retryTimeout);
+      controller?.abort();
+    };
+  }, [refresh, storage, transport]);
   useEffect(() => {
     syncThreadsFromStorage();
   }, [storageKey, syncThreadsFromStorage]);
@@ -983,6 +1280,9 @@ function useAgents24ChatController({
       detachActiveStream();
     }
     if (!activeThreadId) {
+      if (previous === null && loadedThreadIdRef.current === null && messagesRef.current.length === 0 && !hasOlderTurnsRef.current && !isLoadingHistoryRef.current && !isLoadingOlderRef.current && nextBeforeTurnIndexRef.current === null) {
+        return;
+      }
       requestSeqRef.current += 1;
       loadedThreadIdRef.current = null;
       setMessages([]);
@@ -1017,7 +1317,7 @@ function useAgents24ChatController({
   useEffect(() => {
     const threadId = activeThreadId;
     if (!threadId || isLoadingHistory || loadedThreadIdRef.current !== threadId || activeRunIdRef.current) return;
-    const runId = activeRunIdFromThread(storage.getThread(threadId));
+    const runId = autoAttachRunIdFromThread(storage.getThread(threadId));
     if (!runId || reattachedRunIdRef.current === runId) return;
     void runStream({ mode: "attach", threadId, runId });
   }, [activeThreadId, isLoadingHistory, runStream, storage, storageKey]);
@@ -1030,82 +1330,53 @@ function useAgents24ChatController({
     if (!hasStaleUnfinishedAssistantCache(cached)) return;
     void loadThread(threadId).catch(() => setLoadingHistory(false));
   }, [activeThreadId, loadThread, setLoadingHistory, storage, storageKey]);
-  const handleCopy = useCallback((content, messageId) => {
-    navigator.clipboard?.writeText(content);
-    setCopiedMessageId(messageId);
-    setTimeout(() => setCopiedMessageId(null), 200);
-  }, []);
-  const handleLike = useCallback(async (msg) => {
-    const nextLiked = !liked[msg.id];
-    setLiked((prev) => ({ ...prev, [msg.id]: nextLiked }));
-    if (nextLiked) setDisliked((prev) => ({ ...prev, [msg.id]: false }));
-  }, [liked]);
-  const handleDislike = useCallback(async (msg) => {
-    const nextDisliked = !disliked[msg.id];
-    setDisliked((prev) => ({ ...prev, [msg.id]: nextDisliked }));
-    if (nextDisliked) setLiked((prev) => ({ ...prev, [msg.id]: false }));
-  }, [disliked]);
-  const handleRetry = useCallback(async (msg) => {
-    const index = messagesRef.current.findIndex((message) => message.id === msg.id);
-    if (index <= 0) return;
-    const userMessage = messagesRef.current[index - 1];
-    if (userMessage.role !== "user") return;
-    const trimmed = messagesRef.current.slice(0, index);
-    setMessages(trimmed);
-    messagesRef.current = trimmed;
-    if (activeThreadIdRef.current) persistThread(activeThreadIdRef.current, trimmed);
-    await handleSubmit({ text: userMessage.content, files: userMessage.attachments || [] });
-  }, [handleSubmit, persistThread]);
-  const upsertLiveVoiceMessage = useCallback((input) => {
-    const content = input.content?.trim() ?? "";
-    if (!content && !input.citations?.length && !input.reasoningSteps?.length) return;
-    setMessages((prev) => {
-      const currentId = liveVoiceIdsRef.current[input.role];
-      const index = currentId ? prev.findIndex((message) => message.id === currentId) : -1;
-      const nextMessage = {
-        id: currentId || createId(),
-        role: input.role,
-        content,
-        createdAt: /* @__PURE__ */ new Date(),
-        isFinal: Boolean(input.isFinal),
-        isVoice: input.role === "user",
-        parts: content ? [{ id: createId(), type: "text", kind: "text", text: content }] : [],
-        citations: input.citations,
-        reasoningSteps: input.reasoningSteps
-      };
-      const next = index === -1 ? [...prev, nextMessage] : prev.map((message, itemIndex) => itemIndex === index ? { ...message, ...nextMessage } : message);
-      liveVoiceIdsRef.current[input.role] = input.isFinal ? void 0 : nextMessage.id;
-      messagesRef.current = next;
-      if (activeThreadIdRef.current) persistThread(activeThreadIdRef.current, next);
-      return next;
-    });
-  }, [createId, persistThread]);
-  const startNewThread = useCallback(() => {
-    detachActiveStream();
-    requestSeqRef.current += 1;
-    activeThreadIdRef.current = null;
-    loadedThreadIdRef.current = null;
-    nextBeforeTurnIndexRef.current = null;
-    hasOlderTurnsRef.current = false;
-    storage.setActiveThreadId?.(null);
-    onActiveThreadIdChange?.(null);
-    setMessages([]);
-    messagesRef.current = [];
-    setHasOlderTurns(false);
-    setIsLoadingOlder(false);
-    setContextStatus(null);
-    setLoadingHistory(false);
-  }, [detachActiveStream, onActiveThreadIdChange, setLoadingHistory, storage]);
-  const loadThreadById = useCallback(
+  const {
+    handleCopy,
+    handleDislike,
+    handleLike,
+    handleRetry,
+    startNewThread,
+    upsertLiveVoiceMessage
+  } = useControllerMessageActions({
+    activeThreadIdRef,
+    createId,
+    detachActiveStream,
+    disliked,
+    handleSubmit,
+    hasOlderTurnsRef,
+    liked,
+    liveVoiceIdsRef,
+    loadedThreadIdRef,
+    messagesRef,
+    nextBeforeTurnIndexRef,
+    onActiveThreadIdChange,
+    persistThread,
+    requestSeqRef,
+    setContextStatus,
+    setCopiedMessageId,
+    setDisliked,
+    setHasOlderTurns,
+    setIsLoadingOlder,
+    setLiked,
+    setLoadingHistory,
+    setMessages,
+    storage
+  });
+  const loadThreadById = useCallback2(
     async (threadId) => {
       if (!threadId) return;
+      setIsSelectingThread(true);
       if (activeThreadIdRef.current !== threadId) {
         if (abortControllerRef.current) detachActiveStream();
         activeThreadIdRef.current = threadId;
         storage.setActiveThreadId?.(threadId);
         onActiveThreadIdChange?.(threadId);
       }
-      await loadThread(threadId);
+      try {
+        await loadThread(threadId);
+      } finally {
+        if (activeThreadIdRef.current === threadId) setIsSelectingThread(false);
+      }
     },
     [detachActiveStream, loadThread, onActiveThreadIdChange, storage]
   );
@@ -1123,6 +1394,7 @@ function useAgents24ChatController({
     isLoadingHistory,
     isLoadingOlder,
     isRefreshingThreads,
+    isSelectingThread,
     hasOlderTurns,
     liked,
     disliked,
@@ -1130,6 +1402,7 @@ function useAgents24ChatController({
     lastThinkingDurationMs,
     activeRunId,
     handleSubmit,
+    attachRun,
     handleStop,
     handleCopy,
     handleLike,
@@ -1147,6 +1420,7 @@ function useAgents24ChatController({
     activeRunId,
     activeThread,
     activeThreadId,
+    attachRun,
     contextStatus,
     currentReasoning,
     disliked,
@@ -1161,6 +1435,7 @@ function useAgents24ChatController({
     isLoadingHistory,
     isLoadingOlder,
     isRefreshingThreads,
+    isSelectingThread,
     lastThinkingDurationMs,
     liked,
     loadThreadById,
@@ -1205,13 +1480,16 @@ var DefaultChatPart = ({
   if (part.kind === "ui-blocks") {
     return /* @__PURE__ */ jsx("div", { "data-agents24-ui-blocks-part": true, "data-state": part.state });
   }
-  if (part.kind === "approval") {
-    return /* @__PURE__ */ jsx("div", { "data-agents24-approval-part": true });
+  if (part.kind === "hitl") {
+    return /* @__PURE__ */ jsx("div", { "data-agents24-hitl-part": part.interruptId || "" });
   }
   if (part.kind === "error") {
     return /* @__PURE__ */ jsx("div", { "data-agents24-error-part": true, children: part.errorText });
   }
-  return /* @__PURE__ */ jsx("div", { "data-agents24-data-part": part.name });
+  if (part.kind === "data") {
+    return /* @__PURE__ */ jsx("div", { "data-agents24-data-part": part.name });
+  }
+  return null;
 };
 var renderChatPart = (part, message, renderOptions) => /* @__PURE__ */ jsx(
   DefaultChatPart,
@@ -1224,12 +1502,17 @@ var renderChatPart = (part, message, renderOptions) => /* @__PURE__ */ jsx(
 );
 
 // src/sse.ts
+var isAbortError2 = (error) => {
+  if (!error || typeof error !== "object") return false;
+  const maybe = error;
+  return maybe.name === "AbortError" || String(maybe.message || "").toLowerCase().includes("aborted");
+};
 var parseSseBlock = (block) => {
   const data = block.split("\n").filter((line) => line.startsWith("data:")).map((line) => line.replace(/^data:\s?/, "")).join("\n").trim();
   if (!data) return null;
   return JSON.parse(data);
 };
-var consumeSseResponse = async (response, onEvent) => {
+var consumeSseResponse = async (response, onEvent, options = {}) => {
   if (!response.ok) {
     let message = response.statusText || "Failed to open chat stream.";
     try {
@@ -1243,24 +1526,41 @@ var consumeSseResponse = async (response, onEvent) => {
   if (!reader) throw new Error("The chat stream did not return a readable body.");
   const decoder = new TextDecoder();
   let buffer = "";
-  let threadId = null;
-  let runId = null;
-  while (true) {
-    const { value, done } = await reader.read();
-    if (done) break;
-    buffer += decoder.decode(value, { stream: true });
-    let boundary = buffer.indexOf("\n\n");
-    while (boundary !== -1) {
-      const block = buffer.slice(0, boundary);
-      buffer = buffer.slice(boundary + 2);
-      boundary = buffer.indexOf("\n\n");
-      const event = parseSseBlock(block);
-      if (!event) continue;
-      if (event.run_id) runId = event.run_id;
-      const payloadThreadId = event.payload?.thread_id;
-      if (payloadThreadId) threadId = String(payloadThreadId);
-      await onEvent(event);
+  let threadId = response.headers.get("X-Thread-ID") || null;
+  let runId = response.headers.get("X-Run-ID") || null;
+  let closed = false;
+  const closeReader = () => {
+    closed = true;
+    void reader.cancel().catch(() => {
+    });
+  };
+  if (options.signal?.aborted) {
+    closeReader();
+    return { threadId, runId };
+  }
+  options.signal?.addEventListener("abort", closeReader, { once: true });
+  try {
+    while (!closed) {
+      const { value, done } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      let boundary = buffer.indexOf("\n\n");
+      while (boundary !== -1) {
+        const block = buffer.slice(0, boundary);
+        buffer = buffer.slice(boundary + 2);
+        boundary = buffer.indexOf("\n\n");
+        const event = parseSseBlock(block);
+        if (!event) continue;
+        if (event.run_id) runId = event.run_id;
+        const payloadThreadId = event.payload?.thread_id;
+        if (payloadThreadId) threadId = String(payloadThreadId);
+        await onEvent(event);
+      }
     }
+  } catch (error) {
+    if (!isAbortError2(error)) throw error;
+  } finally {
+    options.signal?.removeEventListener("abort", closeReader);
   }
   return { threadId, runId };
 };
@@ -1276,6 +1576,14 @@ var streamHeaders = (headers) => ({
   Accept: "text/event-stream",
   "Content-Type": "application/json"
 });
+var ChatTransportError = class extends Error {
+  constructor(message, status) {
+    super(message);
+    this.name = "ChatTransportError";
+    this.status = status;
+  }
+};
+var transportError = (response, fallback) => new ChatTransportError(response.statusText || fallback, response.status);
 var createFetchChatTransport = ({
   routes,
   fetchImpl = fetch,
@@ -1289,7 +1597,7 @@ var createFetchChatTransport = ({
         signal: input?.signal,
         headers: jsonHeaders(await loadHeaders())
       });
-      if (!response.ok) throw new Error(response.statusText || "Failed to list chat threads.");
+      if (!response.ok) throw transportError(response, "Failed to list chat threads.");
       return response.json();
     },
     async getThread(input) {
@@ -1297,7 +1605,7 @@ var createFetchChatTransport = ({
         signal: input.signal,
         headers: jsonHeaders(await loadHeaders())
       });
-      if (!response.ok) throw new Error(response.statusText || "Failed to load chat thread.");
+      if (!response.ok) throw transportError(response, "Failed to load chat thread.");
       return response.json();
     },
     async streamMessage(input, onEvent) {
@@ -1330,7 +1638,7 @@ var createFetchChatTransport = ({
         headers: jsonHeaders(await loadHeaders()),
         body: JSON.stringify({ assistant_output_text: input.assistantOutputText || void 0 })
       });
-      if (!response.ok) throw new Error(response.statusText || "Failed to cancel chat run.");
+      if (!response.ok) throw transportError(response, "Failed to cancel chat run.");
       return response.json();
     },
     async deleteThread(input) {
@@ -1339,7 +1647,46 @@ var createFetchChatTransport = ({
         method: "DELETE",
         headers: jsonHeaders(await loadHeaders())
       });
-      if (!response.ok) throw new Error(response.statusText || "Failed to delete chat thread.");
+      if (!response.ok) throw transportError(response, "Failed to delete chat thread.");
+      return response.json();
+    },
+    async subscribeThreadEvents(input, onEvent) {
+      if (!routes.threadEvents) return;
+      const response = await fetchImpl(routes.threadEvents({ cursor: input.cursor }), {
+        method: "GET",
+        signal: input.signal,
+        headers: streamHeaders(await loadHeaders())
+      });
+      await consumeSseResponse(response, (event) => onEvent(event));
+    },
+    async resumeHitl(input) {
+      if (!routes.resumeRun) throw new ChatTransportError("HITL resume is not configured.", 501);
+      const response = await fetchImpl(routes.resumeRun({ runId: input.runId }), {
+        method: "POST",
+        headers: jsonHeaders(await loadHeaders()),
+        body: JSON.stringify({
+          schema_version: "agents24.hitl.resume.v1",
+          interrupt_id: input.interruptId,
+          decisions: input.decisions,
+          client: input.client
+        })
+      });
+      if (!response.ok) throw transportError(response, "Failed to resume chat run.");
+      return response.json();
+    },
+    async startMcpAuth(input) {
+      if (!routes.startMcpAuth) throw new ChatTransportError("MCP auth is not configured.", 501);
+      const response = await fetchImpl(routes.startMcpAuth({ runId: input.runId, serverId: input.serverId }), {
+        method: "POST",
+        headers: jsonHeaders(await loadHeaders()),
+        body: JSON.stringify({
+          interrupt_id: input.interruptId || void 0,
+          principal_type: input.principalType || void 0,
+          principal_id: input.principalId || void 0,
+          client: input.client
+        })
+      });
+      if (!response.ok) throw transportError(response, "Failed to start MCP authorization.");
       return response.json();
     }
   };
@@ -1353,6 +1700,7 @@ import {
   useMessageScrollerVisibility
 } from "@shadcn/react/message-scroller";
 export {
+  ChatTransportError,
   DEFAULT_THREAD_PAGE_SIZE,
   DefaultChatPart,
   DefaultToolPart,
@@ -1367,21 +1715,26 @@ export {
   MessageScroller,
   activeRunIdFromThread,
   activeRunIdFromThreadDetail,
+  appendStableStreamingTurn,
   assistantTextFromParts,
   assistantTextFromResponseBlocks,
+  autoAttachRunIdFromThread,
   compressionFromContextWindow,
   consumeSseResponse,
   createChatId,
   createFetchChatTransport,
+  findStableAssistantMessageIndex,
   getActiveStreamingTextPartId,
   hasStaleUnfinishedAssistantCache,
   hasUnfinishedAssistantMessage,
   isActiveStreamingTextPart,
+  isAutoAttachThreadStatus,
   isRunningThreadStatus,
   latestContextWindowFromThread,
   mergeContextWindow,
   mergeContextWindowUpdate,
   mergeReasoningSteps,
+  mergeStoredThreadsForRefresh,
   normalizeContextCompression,
   normalizeContextWindow,
   parseSseBlock,
@@ -1394,6 +1747,7 @@ export {
   threadPaging,
   titleFromMessage,
   toolStateFromStatus,
+  upsertStableAssistantMessage,
   useAgents24ChatController,
   useMessageScroller,
   useMessageScrollerScrollable,