@agents24/chat-react 0.1.8 → 0.1.10

package/dist/index.cjs

@@ -30,6 +30,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  ChatTransportError: () => ChatTransportError,
   DEFAULT_THREAD_PAGE_SIZE: () => DEFAULT_THREAD_PAGE_SIZE,
   DefaultChatPart: () => DefaultChatPart,
   DefaultToolPart: () => DefaultToolPart,
@@ -44,21 +45,26 @@ __export(index_exports, {
   MessageScroller: () => import_message_scroller2.MessageScroller,
   activeRunIdFromThread: () => activeRunIdFromThread,
   activeRunIdFromThreadDetail: () => activeRunIdFromThreadDetail,
+  appendStableStreamingTurn: () => appendStableStreamingTurn,
   assistantTextFromParts: () => assistantTextFromParts,
   assistantTextFromResponseBlocks: () => assistantTextFromResponseBlocks,
+  autoAttachRunIdFromThread: () => autoAttachRunIdFromThread,
   compressionFromContextWindow: () => compressionFromContextWindow,
   consumeSseResponse: () => consumeSseResponse,
   createChatId: () => createChatId,
   createFetchChatTransport: () => createFetchChatTransport,
+  findStableAssistantMessageIndex: () => findStableAssistantMessageIndex,
   getActiveStreamingTextPartId: () => getActiveStreamingTextPartId,
   hasStaleUnfinishedAssistantCache: () => hasStaleUnfinishedAssistantCache,
   hasUnfinishedAssistantMessage: () => hasUnfinishedAssistantMessage,
   isActiveStreamingTextPart: () => isActiveStreamingTextPart,
+  isAutoAttachThreadStatus: () => isAutoAttachThreadStatus,
   isRunningThreadStatus: () => isRunningThreadStatus,
   latestContextWindowFromThread: () => latestContextWindowFromThread,
   mergeContextWindow: () => mergeContextWindow,
   mergeContextWindowUpdate: () => mergeContextWindowUpdate,
   mergeReasoningSteps: () => mergeReasoningSteps,
+  mergeStoredThreadsForRefresh: () => mergeStoredThreadsForRefresh,
   normalizeContextCompression: () => normalizeContextCompression,
   normalizeContextWindow: () => normalizeContextWindow,
   parseSseBlock: () => parseSseBlock,
@@ -71,6 +77,7 @@ __export(index_exports, {
   threadPaging: () => threadPaging,
   titleFromMessage: () => titleFromMessage,
   toolStateFromStatus: () => toolStateFromStatus,
+  upsertStableAssistantMessage: () => upsertStableAssistantMessage,
   useAgents24ChatController: () => useAgents24ChatController,
   useMessageScroller: () => import_message_scroller2.useMessageScroller,
   useMessageScrollerScrollable: () => import_message_scroller2.useMessageScrollerScrollable,
@@ -80,7 +87,79 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // src/controller.ts
+var import_react2 = require("react");
+
+// src/controller-actions.ts
 var import_react = require("react");
+function useControllerMessageActions(input) {
+  const handleCopy = (0, import_react.useCallback)((content, messageId) => {
+    navigator.clipboard?.writeText(content);
+    input.setCopiedMessageId(messageId);
+    setTimeout(() => input.setCopiedMessageId(null), 200);
+  }, [input]);
+  const handleLike = (0, import_react.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 = (0, import_react.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 = (0, import_react.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 = (0, import_react.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 = (0, import_react.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 = {
@@ -203,7 +282,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)}`;
@@ -369,8 +449,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") {
@@ -496,6 +585,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) => {
@@ -505,7 +611,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),
@@ -514,6 +620,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,
@@ -529,56 +750,59 @@ function useAgents24ChatController({
 }) {
   const activeThreadId = controlledActiveThreadId ?? storage.getActiveThreadId?.() ?? null;
   const initialCached = activeThreadId ? storage.getThread(activeThreadId) : void 0;
-  const [messages, setMessages] = (0, import_react.useState)(() => initialCached?.messages || []);
-  const [isLoading, setIsLoading] = (0, import_react.useState)(false);
-  const [isLoadingHistory, setIsLoadingHistory] = (0, import_react.useState)(() => Boolean(activeThreadId) && !initialCached?.messages?.length);
-  const [isLoadingOlder, setIsLoadingOlder] = (0, import_react.useState)(false);
-  const [hasOlderTurns, setHasOlderTurns] = (0, import_react.useState)(Boolean(initialCached?.hasOlderTurns));
-  const [streamingContent, setStreamingContent] = (0, import_react.useState)("");
-  const [streamingMessageId, setStreamingMessageId] = (0, import_react.useState)(null);
-  const [contextStatus, setContextStatus] = (0, import_react.useState)(null);
-  const [currentReasoning, setCurrentReasoning] = (0, import_react.useState)([]);
-  const [liked, setLiked] = (0, import_react.useState)({});
-  const [disliked, setDisliked] = (0, import_react.useState)({});
-  const [copiedMessageId, setCopiedMessageId] = (0, import_react.useState)(null);
-  const [lastThinkingDurationMs, setLastThinkingDurationMs] = (0, import_react.useState)(null);
-  const [threads, setThreads] = (0, import_react.useState)(() => storage.listThreads());
-  const [isRefreshingThreads, setIsRefreshingThreads] = (0, import_react.useState)(false);
-  const [activeRunId, setActiveRunId] = (0, import_react.useState)(null);
-  const textareaRef = (0, import_react.useRef)(null);
-  const activeThreadIdRef = (0, import_react.useRef)(activeThreadId);
-  const messagesRef = (0, import_react.useRef)(messages);
-  const nextBeforeTurnIndexRef = (0, import_react.useRef)(initialCached?.nextBeforeTurnIndex ?? null);
-  const hasOlderTurnsRef = (0, import_react.useRef)(Boolean(initialCached?.hasOlderTurns));
-  const isLoadingOlderRef = (0, import_react.useRef)(false);
-  const loadedThreadIdRef = (0, import_react.useRef)(initialCached?.messages?.length ? activeThreadId : null);
-  const requestSeqRef = (0, import_react.useRef)(0);
-  const isLoadingHistoryRef = (0, import_react.useRef)(isLoadingHistory);
-  const activeRunIdRef = (0, import_react.useRef)(null);
-  const reattachedRunIdRef = (0, import_react.useRef)(null);
-  const abortControllerRef = (0, import_react.useRef)(null);
-  const streamingContentRef = (0, import_react.useRef)("");
-  const streamingMessageIdRef = (0, import_react.useRef)(null);
-  const reasoningRef = (0, import_react.useRef)([]);
-  const liveVoiceIdsRef = (0, import_react.useRef)({});
-  const setActiveRunIdValue = (0, import_react.useCallback)((runId) => {
+  const [messages, setMessages] = (0, import_react2.useState)(() => initialCached?.messages || []);
+  const [isLoading, setIsLoading] = (0, import_react2.useState)(false);
+  const [isLoadingHistory, setIsLoadingHistory] = (0, import_react2.useState)(() => Boolean(activeThreadId) && !initialCached?.messages?.length);
+  const [isLoadingOlder, setIsLoadingOlder] = (0, import_react2.useState)(false);
+  const [hasOlderTurns, setHasOlderTurns] = (0, import_react2.useState)(Boolean(initialCached?.hasOlderTurns));
+  const [streamingContent, setStreamingContent] = (0, import_react2.useState)("");
+  const [streamingMessageId, setStreamingMessageId] = (0, import_react2.useState)(null);
+  const [contextStatus, setContextStatus] = (0, import_react2.useState)(null);
+  const [currentReasoning, setCurrentReasoning] = (0, import_react2.useState)([]);
+  const [liked, setLiked] = (0, import_react2.useState)({});
+  const [disliked, setDisliked] = (0, import_react2.useState)({});
+  const [copiedMessageId, setCopiedMessageId] = (0, import_react2.useState)(null);
+  const [lastThinkingDurationMs, setLastThinkingDurationMs] = (0, import_react2.useState)(null);
+  const [threads, setThreads] = (0, import_react2.useState)(() => storage.listThreads());
+  const [isRefreshingThreads, setIsRefreshingThreads] = (0, import_react2.useState)(false);
+  const [isSelectingThread, setIsSelectingThread] = (0, import_react2.useState)(false);
+  const [activeRunId, setActiveRunId] = (0, import_react2.useState)(null);
+  const textareaRef = (0, import_react2.useRef)(null);
+  const activeThreadIdRef = (0, import_react2.useRef)(activeThreadId);
+  const messagesRef = (0, import_react2.useRef)(messages);
+  const nextBeforeTurnIndexRef = (0, import_react2.useRef)(initialCached?.nextBeforeTurnIndex ?? null);
+  const hasOlderTurnsRef = (0, import_react2.useRef)(Boolean(initialCached?.hasOlderTurns));
+  const isLoadingOlderRef = (0, import_react2.useRef)(false);
+  const loadedThreadIdRef = (0, import_react2.useRef)(initialCached?.messages?.length ? activeThreadId : null);
+  const requestSeqRef = (0, import_react2.useRef)(0);
+  const isLoadingHistoryRef = (0, import_react2.useRef)(isLoadingHistory);
+  const activeRunIdRef = (0, import_react2.useRef)(null);
+  const reattachedRunIdRef = (0, import_react2.useRef)(null);
+  const abortControllerRef = (0, import_react2.useRef)(null);
+  const streamingContentRef = (0, import_react2.useRef)("");
+  const streamingMessageIdRef = (0, import_react2.useRef)(null);
+  const reasoningRef = (0, import_react2.useRef)([]);
+  const liveVoiceIdsRef = (0, import_react2.useRef)({});
+  const refreshSeqRef = (0, import_react2.useRef)(0);
+  const threadEventsCursorRef = (0, import_react2.useRef)(null);
+  const setActiveRunIdValue = (0, import_react2.useCallback)((runId) => {
     activeRunIdRef.current = runId;
     setActiveRunId(runId);
   }, []);
-  const syncThreadsFromStorage = (0, import_react.useCallback)(() => {
+  const syncThreadsFromStorage = (0, import_react2.useCallback)(() => {
     setThreads(storage.listThreads());
   }, [storage]);
-  const upsertStoredThread = (0, import_react.useCallback)(
+  const upsertStoredThread = (0, import_react2.useCallback)(
     (thread) => {
       storage.upsertThread(thread);
       syncThreadsFromStorage();
     },
     [storage, syncThreadsFromStorage]
   );
-  (0, import_react.useEffect)(() => {
+  (0, import_react2.useEffect)(() => {
     messagesRef.current = messages;
   }, [messages]);
-  const persistThread = (0, import_react.useCallback)(
+  const persistThread = (0, import_react2.useCallback)(
     (threadId, nextMessages, paging, options) => {
       const existing = storage.getThread(threadId);
       const firstUser = nextMessages.find((message) => message.role === "user");
@@ -595,7 +819,7 @@ function useAgents24ChatController({
     },
     [storage, upsertStoredThread]
   );
-  const markThreadRunStatus = (0, import_react.useCallback)(
+  const markThreadRunStatus = (0, import_react2.useCallback)(
     (threadId, runId, status, lastEventSeq) => {
       const existing = storage.getThread(threadId);
       if (!existing || !runId) return;
@@ -625,18 +849,20 @@ function useAgents24ChatController({
     },
     [storage, upsertStoredThread]
   );
-  const refresh = (0, import_react.useCallback)(async () => {
+  const refresh = (0, import_react2.useCallback)(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 = (0, import_react.useCallback)(
+  const applyThreadId = (0, import_react2.useCallback)(
     (threadId, baseMessages) => {
       if (!threadId || activeThreadIdRef.current === threadId) return;
       activeThreadIdRef.current = threadId;
@@ -650,18 +876,18 @@ function useAgents24ChatController({
     streamingContentRef.current = value;
     setStreamingContent(value);
   };
-  const setLoadingHistory = (0, import_react.useCallback)((value) => {
+  const setLoadingHistory = (0, import_react2.useCallback)((value) => {
     isLoadingHistoryRef.current = value;
     setIsLoadingHistory(value);
   }, []);
-  const setReasoningSteps = (0, import_react.useCallback)((value) => {
+  const setReasoningSteps = (0, import_react2.useCallback)((value) => {
     reasoningRef.current = value || [];
     setCurrentReasoning(value || []);
   }, []);
-  const detachActiveStream = (0, import_react.useCallback)(() => {
+  const detachActiveStream = (0, import_react2.useCallback)(() => {
     const controller = abortControllerRef.current;
     abortControllerRef.current = null;
-    controller?.abort();
+    abortDetachedStream(controller);
     setActiveRunIdValue(null);
     reattachedRunIdRef.current = null;
     streamingMessageIdRef.current = null;
@@ -672,21 +898,36 @@ function useAgents24ChatController({
     setStreamingContent("");
     setCurrentReasoning([]);
   }, [setActiveRunIdValue]);
-  const setLiveAssistantMessage = (0, import_react.useCallback)(
+  const clearMissingThread = (0, import_react2.useCallback)(
+    (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 = (0, import_react2.useCallback)(
     (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,
@@ -695,26 +936,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 = (0, import_react.useCallback)(
+  const finalizeAssistantMessage = (0, import_react2.useCallback)(
     (input) => {
       const content = input.error || input.assistantText.trim();
       if (!content) return input.baseMessages;
@@ -734,7 +972,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) {
@@ -758,7 +1006,7 @@ function useAgents24ChatController({
     },
     [createId, persistThread, storage, upsertStoredThread]
   );
-  const loadThread = (0, import_react.useCallback)(
+  const loadThread = (0, import_react2.useCallback)(
     async (threadId) => {
       const seq = ++requestSeqRef.current;
       setLoadingHistory(true);
@@ -789,13 +1037,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 = (0, import_react.useCallback)(async () => {
+  const loadOlderTurns = (0, import_react2.useCallback)(async () => {
     const threadId = activeThreadIdRef.current;
     const beforeTurnIndex = nextBeforeTurnIndexRef.current;
     if (!threadId || beforeTurnIndex === null || isLoadingOlderRef.current) return;
@@ -818,12 +1073,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 = (0, import_react.useCallback)(
+  }, [clearMissingThread, pageSize, persistThread, transport]);
+  const handleStreamEvent = (0, import_react2.useCallback)(
     (input) => {
       const { mode, event, assistantMessageId, startedAt, streamThreadIdRef, baseMessages } = input;
       const payload = event.payload || {};
@@ -884,7 +1146,7 @@ function useAgents24ChatController({
     },
     [applyThreadId, finalizeAssistantMessage, markThreadRunStatus, onRuntimeEvent, onStreamErrorMessage, setActiveRunIdValue, setLiveAssistantMessage, setReasoningSteps]
   );
-  const runStream = (0, import_react.useCallback)(
+  const runStream = (0, import_react2.useCallback)(
     async (input) => {
       const startedAt = Date.now();
       const controller = new AbortController();
@@ -943,19 +1205,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,
@@ -969,7 +1240,7 @@ function useAgents24ChatController({
         }
         await refresh().catch(() => void 0);
       } catch (error) {
-        if (error.name !== "AbortError") {
+        if (!isAbortError(error)) {
           finalizeAssistantMessage({
             threadId: streamThreadIdRef.current,
             baseMessages: messagesRef.current,
@@ -998,18 +1269,22 @@ function useAgents24ChatController({
     },
     [createId, finalizeAssistantMessage, handleStreamEvent, onStreamErrorMessage, persistThread, refresh, setActiveRunIdValue, setReasoningSteps, transport]
   );
-  const handleSubmit = (0, import_react.useCallback)(
+  const handleSubmit = (0, import_react2.useCallback)(
     async (message) => {
       if (!message.text.trim() && !(message.files || []).length) return;
       await runStream({ mode: "submit", message });
     },
     [runStream]
   );
-  const handleStop = (0, import_react.useCallback)(() => {
+  const attachRun = (0, import_react2.useCallback)(async (runId, threadId) => {
+    const resolvedThreadId = threadId ?? activeThreadIdRef.current;
+    if (runId && resolvedThreadId) await runStream({ mode: "attach", runId, threadId: resolvedThreadId });
+  }, [runStream]);
+  const handleStop = (0, import_react2.useCallback)(() => {
     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;
@@ -1029,16 +1304,45 @@ function useAgents24ChatController({
       });
     }
   }, [finalizeAssistantMessage, lastThinkingDurationMs, setActiveRunIdValue, setReasoningSteps, transport]);
-  (0, import_react.useEffect)(() => {
-    refresh().catch(() => {
-      storage.setThreads([]);
-      setThreads([]);
-    });
+  (0, import_react2.useEffect)(() => {
+    refresh().catch(() => setThreads(storage.listThreads()));
   }, [refresh, storage]);
-  (0, import_react.useEffect)(() => {
+  (0, import_react2.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]);
+  (0, import_react2.useEffect)(() => {
     syncThreadsFromStorage();
   }, [storageKey, syncThreadsFromStorage]);
-  (0, import_react.useEffect)(() => {
+  (0, import_react2.useEffect)(() => {
     const previous = activeThreadIdRef.current;
     activeThreadIdRef.current = activeThreadId;
     if (activeThreadId && previous === activeThreadId && (activeRunIdRef.current || streamingMessageIdRef.current)) {
@@ -1048,6 +1352,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([]);
@@ -1079,14 +1386,14 @@ function useAgents24ChatController({
     }
     void loadThread(activeThreadId).catch(() => setLoadingHistory(false));
   }, [activeThreadId, detachActiveStream, loadThread, setLoadingHistory, storage]);
-  (0, import_react.useEffect)(() => {
+  (0, import_react2.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]);
-  (0, import_react.useEffect)(() => {
+  (0, import_react2.useEffect)(() => {
     const threadId = activeThreadId;
     if (!threadId || isLoadingHistoryRef.current || activeRunIdRef.current || streamingMessageIdRef.current) {
       return;
@@ -1095,87 +1402,58 @@ function useAgents24ChatController({
     if (!hasStaleUnfinishedAssistantCache(cached)) return;
     void loadThread(threadId).catch(() => setLoadingHistory(false));
   }, [activeThreadId, loadThread, setLoadingHistory, storage, storageKey]);
-  const handleCopy = (0, import_react.useCallback)((content, messageId) => {
-    navigator.clipboard?.writeText(content);
-    setCopiedMessageId(messageId);
-    setTimeout(() => setCopiedMessageId(null), 200);
-  }, []);
-  const handleLike = (0, import_react.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 = (0, import_react.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 = (0, import_react.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 = (0, import_react.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 = (0, import_react.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 = (0, import_react.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 = (0, import_react2.useCallback)(
     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]
   );
   const activeThread = activeThreadId ? storage.getThread(activeThreadId) || threads.find((thread) => thread.id === activeThreadId) || null : null;
-  return (0, import_react.useMemo)(() => ({
+  return (0, import_react2.useMemo)(() => ({
     threads,
     activeThreadId,
     activeThread,
@@ -1188,6 +1466,7 @@ function useAgents24ChatController({
     isLoadingHistory,
     isLoadingOlder,
     isRefreshingThreads,
+    isSelectingThread,
     hasOlderTurns,
     liked,
     disliked,
@@ -1195,6 +1474,7 @@ function useAgents24ChatController({
     lastThinkingDurationMs,
     activeRunId,
     handleSubmit,
+    attachRun,
     handleStop,
     handleCopy,
     handleLike,
@@ -1212,6 +1492,7 @@ function useAgents24ChatController({
     activeRunId,
     activeThread,
     activeThreadId,
+    attachRun,
     contextStatus,
     currentReasoning,
     disliked,
@@ -1226,6 +1507,7 @@ function useAgents24ChatController({
     isLoadingHistory,
     isLoadingOlder,
     isRefreshingThreads,
+    isSelectingThread,
     lastThinkingDurationMs,
     liked,
     loadThreadById,
@@ -1613,13 +1895,16 @@ var DefaultChatPart = ({
   if (part.kind === "ui-blocks") {
     return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("div", { "data-agents24-ui-blocks-part": true, "data-state": part.state });
   }
-  if (part.kind === "approval") {
-    return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("div", { "data-agents24-approval-part": true });
+  if (part.kind === "hitl") {
+    return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("div", { "data-agents24-hitl-part": part.interruptId || "" });
   }
   if (part.kind === "error") {
     return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("div", { "data-agents24-error-part": true, children: part.errorText });
   }
-  return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("div", { "data-agents24-data-part": part.name });
+  if (part.kind === "data") {
+    return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("div", { "data-agents24-data-part": part.name });
+  }
+  return null;
 };
 var renderChatPart = (part, message, renderOptions) => /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
   DefaultChatPart,
@@ -1632,12 +1917,17 @@ var renderChatPart = (part, message, renderOptions) => /* @__PURE__ */ (0, impor
 );
 
 // 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 {
@@ -1651,30 +1941,47 @@ 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 };
 };
 
 // src/streaming-text.ts
-var import_react2 = require("react");
+var import_react3 = require("react");
 var DEFAULT_COMPLETED_TEXT_CACHE_SIZE = 200;
 var defaultCompletedTextCache = /* @__PURE__ */ new Map();
 var defaultStreamingTextCache = {
@@ -1702,24 +2009,24 @@ function useStreamingText({
   maxCatchupChars = 20
 }) {
   const cacheAdapter = cache === false ? null : cache;
-  const [displayedText, setDisplayedText] = (0, import_react2.useState)(() => {
+  const [displayedText, setDisplayedText] = (0, import_react3.useState)(() => {
     const cachedText = cacheAdapter?.get(id);
     return isStreaming && cachedText !== text ? "" : text;
   });
-  const targetRef = (0, import_react2.useRef)(text);
-  const displayedRef = (0, import_react2.useRef)(displayedText);
-  const rafRef = (0, import_react2.useRef)(null);
-  const lastFrameAtRef = (0, import_react2.useRef)(null);
-  const idRef = (0, import_react2.useRef)(id);
-  const shouldAnimateRef = (0, import_react2.useRef)(isStreaming);
-  (0, import_react2.useEffect)(() => {
+  const targetRef = (0, import_react3.useRef)(text);
+  const displayedRef = (0, import_react3.useRef)(displayedText);
+  const rafRef = (0, import_react3.useRef)(null);
+  const lastFrameAtRef = (0, import_react3.useRef)(null);
+  const idRef = (0, import_react3.useRef)(id);
+  const shouldAnimateRef = (0, import_react3.useRef)(isStreaming);
+  (0, import_react3.useEffect)(() => {
     if (isStreaming || !text) return;
     cacheAdapter?.set(id, text);
   }, [cacheAdapter, id, isStreaming, text]);
-  (0, import_react2.useEffect)(() => {
+  (0, import_react3.useEffect)(() => {
     targetRef.current = text;
   }, [text]);
-  (0, import_react2.useEffect)(() => {
+  (0, import_react3.useEffect)(() => {
     if (idRef.current === id) return;
     idRef.current = id;
     const cachedText = cacheAdapter?.get(id);
@@ -1733,7 +2040,7 @@ function useStreamingText({
     }
     lastFrameAtRef.current = null;
   }, [cacheAdapter, id, isStreaming, text]);
-  (0, import_react2.useEffect)(() => {
+  (0, import_react3.useEffect)(() => {
     if (typeof window === "undefined") {
       displayedRef.current = text;
       setDisplayedText(text);
@@ -1818,6 +2125,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,
@@ -1831,7 +2146,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) {
@@ -1839,7 +2154,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) {
@@ -1872,7 +2187,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) {
@@ -1881,7 +2196,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();
     }
   };
@@ -1891,6 +2245,7 @@ var createFetchChatTransport = ({
 var import_message_scroller2 = require("@shadcn/react/message-scroller");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  ChatTransportError,
   DEFAULT_THREAD_PAGE_SIZE,
   DefaultChatPart,
   DefaultToolPart,
@@ -1905,21 +2260,26 @@ var import_message_scroller2 = require("@shadcn/react/message-scroller");
   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,
@@ -1932,6 +2292,7 @@ var import_message_scroller2 = require("@shadcn/react/message-scroller");
   threadPaging,
   titleFromMessage,
   toolStateFromStatus,
+  upsertStableAssistantMessage,
   useAgents24ChatController,
   useMessageScroller,
   useMessageScrollerScrollable,