@agents24/chat-react 0.1.0

package/dist/index.js

@@ -0,0 +1,1260 @@
+// src/controller.ts
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+
+// src/model.ts
+var DEFAULT_THREAD_PAGE_SIZE = 5;
+var isRunningThreadStatus = (status) => (/* @__PURE__ */ new Set(["queued", "running"])).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)}`;
+};
+var titleFromMessage = (text, files = []) => {
+  const base = text.trim() || files[0]?.filename || "New chat";
+  return base.replace(/\s+/g, " ").slice(0, 48);
+};
+var threadActivityDate = (thread) => String(thread.updated_at || thread.last_activity_at || thread.created_at || (/* @__PURE__ */ new Date()).toISOString());
+var assistantTextFromBlocks = (blocks) => (blocks || []).filter((block) => block.kind === "assistant_text" && typeof block.text === "string").map((block) => String(block.text)).join("\n\n").trim();
+var textFromFinalOutput = (value) => {
+  if (typeof value === "string") return value;
+  if (!value || typeof value !== "object") return "";
+  const record = value;
+  return String(record.message || record.text || record.answer || "");
+};
+var displayTextWithoutInlineAttachments = (text, hasAttachments) => {
+  if (!hasAttachments) return text;
+  const marker = "Attached text file (";
+  const trimmed = text.trim();
+  if (trimmed.startsWith(marker)) return "";
+  const markerIndex = text.indexOf(`
+
+${marker}`);
+  if (markerIndex === -1) return text;
+  return text.slice(0, markerIndex).trim();
+};
+var attachmentsFromTurn = (turn) => (turn.attachments || []).map((attachment, index) => {
+  const record = attachment || {};
+  return {
+    ...record,
+    type: "file",
+    url: String(record.url || ""),
+    filename: String(record.filename || record.name || `attachment-${index + 1}`),
+    mediaType: String(record.mime_type || record.mediaType || record.type || "application/octet-stream")
+  };
+});
+var latestEventPayloadValue = (events, key) => {
+  for (let index = (events || []).length - 1; index >= 0; index -= 1) {
+    const payload = events?.[index]?.payload;
+    if (payload && payload[key] !== void 0 && payload[key] !== null) return payload[key];
+  }
+  return void 0;
+};
+var responseBlocksFromTurn = (turn) => {
+  if (Array.isArray(turn.response_blocks) && turn.response_blocks.length > 0) return turn.response_blocks;
+  const fromEvents = latestEventPayloadValue(turn.run_events, "response_blocks");
+  return Array.isArray(fromEvents) ? fromEvents : [];
+};
+var assistantTextFromEvents = (events) => {
+  const assistantText = latestEventPayloadValue(events, "assistant_output_text");
+  if (typeof assistantText === "string" && assistantText.trim()) return assistantText;
+  return textFromFinalOutput(latestEventPayloadValue(events, "final_output"));
+};
+var normalizeToolStatus = (status) => {
+  if (status === "running" || status === "active" || status === "pending") return "running";
+  if (status === "failed" || status === "error") return "error";
+  return "done";
+};
+var toolName = (tool) => String(tool.toolName || tool.tool_name || tool.name || tool.slug || tool.action || tool.title || "").trim().toLowerCase();
+var humanize = (value) => value.replace(/[_-]+/g, " ").replace(/\s+/g, " ").trim().replace(/\b\w/g, (char) => char.toUpperCase());
+var toolActionKey = (tool) => {
+  const name = toolName(tool);
+  if (name.includes("search")) return "search";
+  if (name.includes("browse") || name.includes("navigate")) return "navigate";
+  if (name.includes("resolve")) return "resolve";
+  if (name.includes("open") || name.includes("read")) return "read";
+  if (name.includes("context")) return "context";
+  if (name.includes("link")) return "links";
+  return "work";
+};
+var actionLabels = {
+  search: "Searching",
+  navigate: "Navigating",
+  resolve: "Resolving",
+  read: "Reading",
+  context: "Checking context",
+  links: "Finding links",
+  work: "Working"
+};
+var toolTitle = (tool) => {
+  const explicit = tool.title || tool.label || tool.summary;
+  if (explicit) return String(explicit);
+  const name = toolName(tool);
+  return name ? humanize(name) : actionLabels[toolActionKey(tool)];
+};
+var toolDetail = (tool) => {
+  const summary = String(tool.summary || "").trim();
+  const detail = String(tool.detail || "").trim();
+  return summary || detail || void 0;
+};
+var summarizeToolGroup = (tools) => {
+  if (tools.length === 1) return tools[0].title;
+  const counts = /* @__PURE__ */ new Map();
+  tools.forEach((tool) => counts.set(tool.actionKey, (counts.get(tool.actionKey) || 0) + 1));
+  return Array.from(counts.entries()).map(([key, count]) => `${actionLabels[key]} ${count}`).join(", ");
+};
+var toolGroupStatus = (tools) => {
+  if (tools.some((tool) => tool.status === "error")) return "error";
+  if (tools.some((tool) => tool.status === "running")) return "running";
+  return "done";
+};
+var createToolBlock = (block, index) => {
+  const tool = block.tool || {};
+  const actionKey = toolActionKey(tool);
+  return {
+    id: String(block.id || `${block.kind || "tool"}-${index}`),
+    kind: "tool",
+    title: toolTitle(tool),
+    actionLabel: actionLabels[actionKey],
+    actionKey,
+    status: normalizeToolStatus(block.status),
+    detail: toolDetail(tool)
+  };
+};
+var renderBlocksFromResponseBlocks = (blocks, fallbackText) => {
+  const mapped = [];
+  let pendingTools = [];
+  const flushTools = () => {
+    if (pendingTools.length === 0) return;
+    mapped.push({
+      id: `tool-group-${pendingTools[0].id}`,
+      kind: "tool_group",
+      title: summarizeToolGroup(pendingTools),
+      status: toolGroupStatus(pendingTools),
+      tools: pendingTools
+    });
+    pendingTools = [];
+  };
+  (blocks || []).forEach((block, index) => {
+    const id = String(block.id || `${block.kind || "block"}-${index}`);
+    if (block.kind === "assistant_text" && typeof block.text === "string") {
+      flushTools();
+      mapped.push({ id, kind: "text", content: String(block.text) });
+      return;
+    }
+    if (block.kind === "tool_call") pendingTools.push(createToolBlock(block, index));
+  });
+  flushTools();
+  if (!mapped.some((block) => block.kind === "text") && fallbackText?.trim()) {
+    mapped.push({ id: "assistant-fallback-text", kind: "text", content: fallbackText });
+  }
+  return mapped;
+};
+var mergeReasoningSteps = (steps, options) => {
+  if (!steps?.length) return [];
+  const merged = [];
+  const indexMap = /* @__PURE__ */ new Map();
+  steps.forEach((step) => {
+    const key = String(step.label);
+    const status = options?.finalize ? "complete" : step.status || "complete";
+    if (indexMap.has(key)) {
+      const index = indexMap.get(key);
+      merged[index] = { ...merged[index], ...step, status };
+    } else {
+      indexMap.set(key, merged.push({ ...step, status }) - 1);
+    }
+  });
+  return merged;
+};
+var reasoningStepsFromBlocks = (blocks) => (blocks || []).map((block) => {
+  const kind = String(block.kind || "");
+  if (kind === "tool_call") {
+    const tool = block.tool || {};
+    return {
+      label: toolTitle(tool),
+      status: block.status === "running" ? "active" : "complete",
+      description: String(tool.summary || tool.detail || tool.action || "")
+    };
+  }
+  if (kind === "reasoning_note") {
+    return {
+      label: String(block.label || "Reasoning"),
+      status: block.status === "running" ? "active" : "complete",
+      description: String(block.text || block.summary || "")
+    };
+  }
+  return null;
+}).filter(Boolean);
+var turnToMessages = (turn, activeRunId) => {
+  const messages = [];
+  const createdAt = turn.created_at ? new Date(turn.created_at) : /* @__PURE__ */ new Date();
+  const baseId = turn.id || turn.run_id || createChatId();
+  const responseBlocks = responseBlocksFromTurn(turn);
+  const isRunning = isRunningThreadStatus(turn.status) || Boolean(turn.run_id && activeRunId === turn.run_id);
+  const attachments = attachmentsFromTurn(turn);
+  const userContent = displayTextWithoutInlineAttachments(turn.user_input_text || "", attachments.length > 0);
+  if (userContent || attachments.length > 0) {
+    messages.push({
+      id: `${baseId}-user`,
+      role: "user",
+      content: userContent,
+      createdAt,
+      attachments
+    });
+  }
+  const assistantText = turn.assistant_output_text || assistantTextFromBlocks(responseBlocks) || assistantTextFromEvents(turn.run_events) || textFromFinalOutput(turn.final_output);
+  if (assistantText || responseBlocks.length > 0 || isRunning) {
+    messages.push({
+      id: `${baseId}-assistant`,
+      role: "assistant",
+      runId: turn.run_id || null,
+      content: assistantText,
+      createdAt: turn.completed_at ? new Date(turn.completed_at) : createdAt,
+      blocks: renderBlocksFromResponseBlocks(responseBlocks, assistantText),
+      reasoningSteps: mergeReasoningSteps(reasoningStepsFromBlocks(responseBlocks), { finalize: !isRunning }),
+      isFinal: !isRunning
+    });
+  }
+  return messages;
+};
+var threadDetailToMessages = (thread) => {
+  const activeRun = activeRunIdFromThreadDetail(thread);
+  return (thread.turns || []).flatMap((turn) => turnToMessages(turn, activeRun));
+};
+var threadPaging = (thread) => {
+  const nextBeforeTurnIndex = thread.paging?.next_before_turn_index ?? null;
+  return {
+    hasOlderTurns: Boolean(thread.paging?.has_more || nextBeforeTurnIndex !== null),
+    nextBeforeTurnIndex
+  };
+};
+var latestContextWindowFromThread = (thread) => {
+  if (thread.context_window && typeof thread.context_window === "object") return thread.context_window;
+  for (let index = (thread.turns || []).length - 1; index >= 0; index -= 1) {
+    const value = thread.turns?.[index]?.context_window;
+    if (value && typeof value === "object") return value;
+  }
+  return null;
+};
+var activeRunIdFromThread = (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 && isRunningThreadStatus(activeRun?.status || lastRunStatus)) return activeRunId;
+  const lastRunId = hasCamelLastRunId ? thread?.lastRunId : thread?.last_run_id || thread?.lastRunId;
+  return lastRunId && isRunningThreadStatus(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) => {
+  const summaryRunId = activeRunIdFromThread(thread);
+  if (summaryRunId) return summaryRunId;
+  const runningTurn = [...thread?.turns || []].reverse().find((turn) => turn.run_id && isRunningThreadStatus(turn.status));
+  return runningTurn?.run_id ? String(runningTurn.run_id) : null;
+};
+
+// src/controller.ts
+var mergeContextWindow = (current, incoming) => {
+  if (!incoming || typeof incoming !== "object") return current;
+  return { ...current || {}, ...incoming };
+};
+var threadSummaryToStored = (thread) => ({
+  ...thread,
+  id: String(thread.id),
+  title: String(thread.title || "New chat"),
+  updated_at: String(thread.updated_at || thread.last_activity_at || thread.created_at || (/* @__PURE__ */ new Date()).toISOString()),
+  messages: [],
+  isHydrated: false
+});
+function useAgents24ChatController({
+  transport,
+  storage,
+  activeThreadId: controlledActiveThreadId,
+  pageSize = DEFAULT_THREAD_PAGE_SIZE,
+  storageKey,
+  createId = createChatId,
+  onActiveThreadIdChange,
+  onSourceClick,
+  onStreamErrorMessage
+}) {
+  const activeThreadId = controlledActiveThreadId ?? storage.getActiveThreadId?.() ?? null;
+  const initialCached = activeThreadId ? storage.getThread(activeThreadId) : void 0;
+  const [messages, setMessages] = useState(() => initialCached?.messages || []);
+  const [isLoading, setIsLoading] = useState(false);
+  const [isLoadingHistory, setIsLoadingHistory] = useState(() => Boolean(activeThreadId) && !initialCached?.messages?.length);
+  const [isLoadingOlder, setIsLoadingOlder] = useState(false);
+  const [hasOlderTurns, setHasOlderTurns] = useState(Boolean(initialCached?.hasOlderTurns));
+  const [streamingContent, setStreamingContent] = useState("");
+  const [streamingMessageId, setStreamingMessageId] = useState(null);
+  const [contextStatus, setContextStatus] = useState(null);
+  const [currentReasoning, setCurrentReasoning] = useState([]);
+  const [liked, setLiked] = useState({});
+  const [disliked, setDisliked] = useState({});
+  const [copiedMessageId, setCopiedMessageId] = useState(null);
+  const [lastThinkingDurationMs, setLastThinkingDurationMs] = useState(null);
+  const textareaRef = useRef(null);
+  const activeThreadIdRef = useRef(activeThreadId);
+  const messagesRef = useRef(messages);
+  const nextBeforeTurnIndexRef = useRef(initialCached?.nextBeforeTurnIndex ?? null);
+  const hasOlderTurnsRef = useRef(Boolean(initialCached?.hasOlderTurns));
+  const isLoadingOlderRef = useRef(false);
+  const loadedThreadIdRef = useRef(initialCached?.messages?.length ? activeThreadId : null);
+  const requestSeqRef = useRef(0);
+  const isLoadingHistoryRef = useRef(isLoadingHistory);
+  const activeRunIdRef = useRef(null);
+  const reattachedRunIdRef = useRef(null);
+  const abortControllerRef = useRef(null);
+  const streamingContentRef = useRef("");
+  const streamingMessageIdRef = useRef(null);
+  const reasoningRef = useRef([]);
+  const liveVoiceIdsRef = useRef({});
+  useEffect(() => {
+    messagesRef.current = messages;
+  }, [messages]);
+  const persistThread = useCallback(
+    (threadId, nextMessages, paging, options) => {
+      const existing = storage.getThread(threadId);
+      const firstUser = nextMessages.find((message) => message.role === "user");
+      storage.upsertThread({
+        ...existing || {},
+        id: threadId,
+        title: existing?.title || (firstUser ? titleFromMessage(firstUser.content, firstUser.attachments || []) : "New chat"),
+        updated_at: options?.updatedAt || (options?.touch ? (/* @__PURE__ */ new Date()).toISOString() : existing?.updated_at) || (/* @__PURE__ */ new Date()).toISOString(),
+        messages: nextMessages,
+        isHydrated: true,
+        hasOlderTurns: paging?.hasOlderTurns ?? hasOlderTurnsRef.current,
+        nextBeforeTurnIndex: paging?.nextBeforeTurnIndex ?? nextBeforeTurnIndexRef.current
+      });
+    },
+    [storage]
+  );
+  const markThreadRunStatus = useCallback(
+    (threadId, runId, status, lastEventSeq) => {
+      const existing = storage.getThread(threadId);
+      if (!existing || !runId) return;
+      storage.upsertThread({
+        ...existing,
+        last_run_id: runId,
+        last_run_status: status,
+        active_run: {
+          run_id: runId,
+          status,
+          created_at: existing.activeRun?.created_at ?? existing.active_run?.created_at ?? (/* @__PURE__ */ new Date()).toISOString()
+        },
+        lastRunId: runId,
+        lastRunStatus: status,
+        activeRun: {
+          run_id: runId,
+          status,
+          created_at: existing.activeRun?.created_at ?? existing.active_run?.created_at ?? (/* @__PURE__ */ new Date()).toISOString()
+        },
+        lastEventSeq: typeof lastEventSeq === "number" ? lastEventSeq : existing.lastEventSeq ?? null,
+        isRunning: status === "queued" || status === "running"
+      });
+    },
+    [storage]
+  );
+  const refresh = useCallback(async () => {
+    const data = await transport.listThreads();
+    storage.setThreads((data.items || []).map((item) => threadSummaryToStored(item)));
+  }, [storage, transport]);
+  const applyThreadId = useCallback(
+    (threadId, baseMessages) => {
+      if (!threadId || activeThreadIdRef.current === threadId) return;
+      activeThreadIdRef.current = threadId;
+      persistThread(threadId, messagesRef.current.length > 0 ? messagesRef.current : baseMessages, void 0, { touch: true });
+      storage.setActiveThreadId?.(threadId);
+      onActiveThreadIdChange?.(threadId);
+    },
+    [onActiveThreadIdChange, persistThread, storage]
+  );
+  const setStreamingText = (value) => {
+    streamingContentRef.current = value;
+    setStreamingContent(value);
+  };
+  const setLoadingHistory = useCallback((value) => {
+    isLoadingHistoryRef.current = value;
+    setIsLoadingHistory(value);
+  }, []);
+  const setReasoningSteps = useCallback((value) => {
+    reasoningRef.current = value || [];
+    setCurrentReasoning(value || []);
+  }, []);
+  const detachActiveStream = useCallback(() => {
+    const controller = abortControllerRef.current;
+    abortControllerRef.current = null;
+    controller?.abort();
+    activeRunIdRef.current = null;
+    reattachedRunIdRef.current = null;
+    streamingMessageIdRef.current = null;
+    streamingContentRef.current = "";
+    reasoningRef.current = [];
+    setStreamingMessageId(null);
+    setIsLoading(false);
+    setStreamingContent("");
+    setCurrentReasoning([]);
+  }, []);
+  const setLiveAssistantMessage = 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({
+            id: input.messageId,
+            role: "assistant",
+            runId: input.runId ?? null,
+            content: input.content,
+            createdAt: /* @__PURE__ */ new Date(),
+            reasoningSteps: input.reasoning,
+            isFinal: false,
+            blocks: input.blocks
+          });
+          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,
+          blocks: input.blocks ?? next[index].blocks
+        };
+        messagesRef.current = next;
+        return next;
+      });
+    },
+    []
+  );
+  const finalizeAssistantMessage = useCallback(
+    (input) => {
+      const content = input.error || input.assistantText.trim();
+      if (!content) return input.baseMessages;
+      const existingIndex = input.baseMessages.findIndex(
+        (message) => input.messageId && message.id === input.messageId || input.runId && message.role === "assistant" && message.runId === input.runId
+      );
+      const existing = existingIndex >= 0 ? input.baseMessages[existingIndex] : void 0;
+      const blocks = input.blocks || existing?.blocks || renderBlocksFromResponseBlocks(void 0, content);
+      const assistant = {
+        id: existing?.id || input.messageId || createId(),
+        role: "assistant",
+        runId: input.runId ?? existing?.runId ?? null,
+        content,
+        createdAt: /* @__PURE__ */ new Date(),
+        isFinal: true,
+        blocks: blocks.map((block) => {
+          if (block.kind === "tool") return { ...block, status: input.error ? "error" : "done" };
+          if (block.kind === "tool_group") {
+            return { ...block, status: input.error ? "error" : "done", tools: block.tools.map((tool) => ({ ...tool, status: input.error ? "error" : "done" })) };
+          }
+          return block;
+        }),
+        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];
+      setMessages(completed);
+      messagesRef.current = completed;
+      if (input.threadId) {
+        persistThread(input.threadId, completed);
+        const existingThread = storage.getThread(input.threadId);
+        if (existingThread && input.runId) {
+          storage.upsertThread({
+            ...existingThread,
+            messages: completed,
+            last_run_id: input.runId,
+            last_run_status: input.error ? "failed" : "completed",
+            active_run: null,
+            lastRunId: input.runId,
+            lastRunStatus: input.error ? "failed" : "completed",
+            activeRun: null,
+            isRunning: false
+          });
+        }
+      }
+      return completed;
+    },
+    [createId, persistThread, storage]
+  );
+  const loadThread = useCallback(
+    async (threadId) => {
+      const seq = ++requestSeqRef.current;
+      setLoadingHistory(true);
+      setIsLoadingOlder(false);
+      isLoadingOlderRef.current = false;
+      try {
+        const detail = await transport.getThread({ threadId, limit: pageSize });
+        if (activeThreadIdRef.current !== threadId || seq !== requestSeqRef.current) return;
+        const nextMessages = threadDetailToMessages(detail);
+        const paging = threadPaging(detail);
+        setContextStatus(latestContextWindowFromThread(detail));
+        setMessages(nextMessages);
+        messagesRef.current = nextMessages;
+        setHasOlderTurns(paging.hasOlderTurns);
+        hasOlderTurnsRef.current = paging.hasOlderTurns;
+        nextBeforeTurnIndexRef.current = paging.nextBeforeTurnIndex;
+        loadedThreadIdRef.current = threadId;
+        storage.upsertThread({
+          ...threadSummaryToStored(detail),
+          messages: nextMessages,
+          isHydrated: true,
+          hasOlderTurns: paging.hasOlderTurns,
+          nextBeforeTurnIndex: paging.nextBeforeTurnIndex,
+          updated_at: threadActivityDate(detail)
+        });
+      } finally {
+        if (activeThreadIdRef.current === threadId) setLoadingHistory(false);
+      }
+    },
+    [pageSize, setLoadingHistory, storage, transport]
+  );
+  const loadOlderTurns = useCallback(async () => {
+    const threadId = activeThreadIdRef.current;
+    const beforeTurnIndex = nextBeforeTurnIndexRef.current;
+    if (!threadId || beforeTurnIndex === null || isLoadingOlderRef.current) return;
+    isLoadingOlderRef.current = true;
+    setIsLoadingOlder(true);
+    try {
+      const detail = await transport.getThread({ threadId, limit: pageSize, beforeTurnIndex });
+      if (activeThreadIdRef.current !== threadId) return;
+      const older = threadDetailToMessages(detail);
+      const paging = threadPaging(detail);
+      const next = [...older, ...messagesRef.current];
+      setMessages(next);
+      messagesRef.current = next;
+      setHasOlderTurns(paging.hasOlderTurns);
+      hasOlderTurnsRef.current = paging.hasOlderTurns;
+      nextBeforeTurnIndexRef.current = paging.nextBeforeTurnIndex;
+      persistThread(threadId, next, paging);
+    } finally {
+      if (activeThreadIdRef.current === threadId) setIsLoadingOlder(false);
+      isLoadingOlderRef.current = false;
+    }
+  }, [pageSize, persistThread, transport]);
+  const handleStreamEvent = useCallback(
+    (input) => {
+      const { event, assistantMessageId, startedAt, streamThreadIdRef, baseMessages } = input;
+      const payload = event.payload || {};
+      const responseBlocks = Array.isArray(payload.response_blocks) ? payload.response_blocks : null;
+      if (event.run_id) activeRunIdRef.current = event.run_id;
+      setContextStatus((current) => mergeContextWindow(current, payload.context_window));
+      if (responseBlocks) {
+        const blockText = String(payload.assistant_output_text || "") || assistantTextFromBlocks(responseBlocks) || streamingContentRef.current;
+        if (blockText) setStreamingText(blockText);
+        const reasoning = mergeReasoningSteps([...reasoningRef.current, ...reasoningStepsFromBlocks(responseBlocks)]);
+        setReasoningSteps(reasoning);
+        setLiveAssistantMessage({
+          messageId: assistantMessageId,
+          runId: event.run_id || activeRunIdRef.current,
+          content: blockText,
+          reasoning,
+          blocks: renderBlocksFromResponseBlocks(responseBlocks, blockText),
+          baseMessages
+        });
+      }
+      if (event.event === "run.accepted" || event.event === "run.snapshot") {
+        const nextThreadId = String(payload.thread_id || streamThreadIdRef.current || "");
+        if (nextThreadId) {
+          streamThreadIdRef.current = nextThreadId;
+          applyThreadId(nextThreadId, baseMessages);
+          markThreadRunStatus(nextThreadId, event.run_id || activeRunIdRef.current || "", String(payload.status || "running"), typeof payload.last_event_seq === "number" ? payload.last_event_seq : null);
+        }
+        return;
+      }
+      const isTerminal = event.event === "run.completed" || event.event === "run.cancelled" || event.event === "reshet.stream.result";
+      const isFailed = event.event === "run.failed" || event.event.endsWith(".stream.error");
+      if (!isTerminal && !isFailed) return;
+      const terminalThreadId = String(payload.thread_id || "");
+      if (terminalThreadId && !streamThreadIdRef.current) {
+        streamThreadIdRef.current = terminalThreadId;
+        applyThreadId(terminalThreadId, baseMessages);
+      }
+      const finalText = String(payload.assistant_output_text || textFromFinalOutput(payload.final_output) || streamingContentRef.current || "");
+      finalizeAssistantMessage({
+        threadId: streamThreadIdRef.current || activeThreadIdRef.current,
+        baseMessages: messagesRef.current,
+        assistantText: finalText,
+        reasoning: reasoningRef.current,
+        thinkingDurationMs: Date.now() - startedAt,
+        messageId: assistantMessageId,
+        runId: event.run_id || activeRunIdRef.current,
+        blocks: responseBlocks ? renderBlocksFromResponseBlocks(responseBlocks, finalText) : void 0,
+        error: isFailed ? String(payload.message || payload.error || event.diagnostics?.[0]?.message || onStreamErrorMessage?.(event) || "The chat run failed.") : void 0
+      });
+    },
+    [applyThreadId, finalizeAssistantMessage, markThreadRunStatus, onStreamErrorMessage, setLiveAssistantMessage, setReasoningSteps]
+  );
+  const runStream = useCallback(
+    async (input) => {
+      const startedAt = Date.now();
+      const controller = new AbortController();
+      requestSeqRef.current += 1;
+      abortControllerRef.current = controller;
+      setIsLoading(true);
+      setStreamingText("");
+      setReasoningSteps([{ label: input.mode === "attach" ? "Reconnecting" : "Connecting", status: "active" }]);
+      const streamThreadIdRef = { current: input.mode === "attach" ? input.threadId : activeThreadIdRef.current };
+      const attachAssistantMessage = input.mode === "attach" ? [...messagesRef.current].reverse().find(
+        (message) => message.role === "assistant" && (message.runId === input.runId || message.isFinal === false)
+      ) : void 0;
+      let assistantMessageId = input.mode === "attach" ? attachAssistantMessage?.id || `${input.runId}-assistant` : createId();
+      let baseMessages = messagesRef.current;
+      if (input.mode === "submit") {
+        const userMessage = {
+          id: createId(),
+          role: "user",
+          content: input.message.text,
+          createdAt: /* @__PURE__ */ new Date(),
+          attachments: input.message.files
+        };
+        baseMessages = [...messagesRef.current, userMessage];
+      }
+      if (!messagesRef.current.some((message) => message.id === assistantMessageId)) {
+        const assistantMessage = {
+          id: assistantMessageId,
+          role: "assistant",
+          content: "",
+          createdAt: /* @__PURE__ */ new Date(),
+          isFinal: false,
+          reasoningSteps: []
+        };
+        const liveMessages = [...baseMessages, assistantMessage];
+        setMessages(liveMessages);
+        messagesRef.current = liveMessages;
+      } else if (input.mode === "attach" && attachAssistantMessage) {
+        const nextMessages = messagesRef.current.map(
+          (message) => message.id === attachAssistantMessage.id ? { ...message, runId: message.runId || input.runId, isFinal: false } : message
+        );
+        setMessages(nextMessages);
+        messagesRef.current = nextMessages;
+        baseMessages = nextMessages;
+        if (streamThreadIdRef.current) persistThread(streamThreadIdRef.current, nextMessages);
+      }
+      streamingMessageIdRef.current = assistantMessageId;
+      setStreamingMessageId(assistantMessageId);
+      if (streamThreadIdRef.current) {
+        persistThread(
+          streamThreadIdRef.current,
+          messagesRef.current.length > 0 ? messagesRef.current : baseMessages,
+          void 0,
+          { touch: input.mode === "submit" }
+        );
+      }
+      try {
+        if (input.mode === "attach") {
+          activeRunIdRef.current = input.runId;
+          reattachedRunIdRef.current = input.runId;
+          await transport.attachRun(
+            { runId: input.runId, signal: controller.signal },
+            (event) => handleStreamEvent({ event, assistantMessageId, startedAt, streamThreadIdRef, baseMessages })
+          );
+        } else {
+          await transport.streamMessage(
+            { text: input.message.text, files: input.message.files || [], threadId: activeThreadIdRef.current, signal: controller.signal },
+            (event) => handleStreamEvent({ event, assistantMessageId, startedAt, streamThreadIdRef, baseMessages })
+          );
+        }
+        if (streamingContentRef.current.trim() && streamingMessageIdRef.current) {
+          finalizeAssistantMessage({
+            threadId: streamThreadIdRef.current,
+            baseMessages: messagesRef.current,
+            assistantText: streamingContentRef.current,
+            reasoning: reasoningRef.current,
+            thinkingDurationMs: Date.now() - startedAt,
+            messageId: assistantMessageId,
+            runId: activeRunIdRef.current
+          });
+        }
+        await refresh().catch(() => void 0);
+      } catch (error) {
+        if (error.name !== "AbortError") {
+          finalizeAssistantMessage({
+            threadId: streamThreadIdRef.current,
+            baseMessages: messagesRef.current,
+            assistantText: streamingContentRef.current,
+            reasoning: reasoningRef.current,
+            thinkingDurationMs: Date.now() - startedAt,
+            messageId: assistantMessageId,
+            runId: activeRunIdRef.current,
+            error: onStreamErrorMessage?.(error) || error.message || "Failed to reach the chat agent."
+          });
+        }
+      } finally {
+        const isCurrentStream = abortControllerRef.current === controller || streamingMessageIdRef.current === assistantMessageId;
+        if (abortControllerRef.current === controller) abortControllerRef.current = null;
+        if (isCurrentStream) {
+          activeRunIdRef.current = null;
+          streamingMessageIdRef.current = null;
+          reattachedRunIdRef.current = null;
+          setStreamingMessageId(null);
+          setIsLoading(false);
+          setStreamingText("");
+          setReasoningSteps([]);
+          setLastThinkingDurationMs(Date.now() - startedAt);
+        }
+      }
+    },
+    [createId, finalizeAssistantMessage, handleStreamEvent, onStreamErrorMessage, persistThread, refresh, setReasoningSteps, transport]
+  );
+  const handleSubmit = useCallback(
+    async (message) => {
+      if (!message.text.trim() && !(message.files || []).length) return;
+      await runStream({ mode: "submit", message });
+    },
+    [runStream]
+  );
+  const handleStop = useCallback(() => {
+    const runId = activeRunIdRef.current;
+    const partial = streamingContentRef.current;
+    const liveMessageId = streamingMessageIdRef.current;
+    abortControllerRef.current?.abort();
+    abortControllerRef.current = null;
+    activeRunIdRef.current = null;
+    streamingMessageIdRef.current = null;
+    setStreamingMessageId(null);
+    setIsLoading(false);
+    setStreamingText("");
+    setReasoningSteps([]);
+    if (runId) transport.cancelRun({ runId, assistantOutputText: partial }).catch(() => void 0);
+    if (partial.trim()) {
+      finalizeAssistantMessage({
+        threadId: activeThreadIdRef.current,
+        baseMessages: messagesRef.current,
+        assistantText: partial,
+        reasoning: reasoningRef.current,
+        thinkingDurationMs: lastThinkingDurationMs || 0,
+        messageId: liveMessageId
+      });
+    }
+  }, [finalizeAssistantMessage, lastThinkingDurationMs, setReasoningSteps, transport]);
+  useEffect(() => {
+    refresh().catch(() => storage.setThreads([]));
+  }, [refresh, storage]);
+  useEffect(() => {
+    const previous = activeThreadIdRef.current;
+    activeThreadIdRef.current = activeThreadId;
+    if (activeThreadId && previous === activeThreadId && (activeRunIdRef.current || streamingMessageIdRef.current)) {
+      return;
+    }
+    if (previous && previous !== activeThreadId && abortControllerRef.current) {
+      detachActiveStream();
+    }
+    if (!activeThreadId) {
+      requestSeqRef.current += 1;
+      loadedThreadIdRef.current = null;
+      setMessages([]);
+      messagesRef.current = [];
+      setHasOlderTurns(false);
+      setIsLoadingOlder(false);
+      setContextStatus(null);
+      nextBeforeTurnIndexRef.current = null;
+      setLoadingHistory(false);
+      return;
+    }
+    const cached = storage.getThread(activeThreadId);
+    const cachedMessages = cached?.isHydrated && cached.messages?.length ? cached.messages : null;
+    const hasCachedMessages = Boolean(cachedMessages);
+    const shouldRefreshStaleCache = hasCachedMessages && hasStaleUnfinishedAssistantCache(cached);
+    if (cached && cachedMessages) {
+      setMessages(cachedMessages);
+      messagesRef.current = cachedMessages;
+      setHasOlderTurns(Boolean(cached.hasOlderTurns));
+      hasOlderTurnsRef.current = Boolean(cached.hasOlderTurns);
+      nextBeforeTurnIndexRef.current = cached.nextBeforeTurnIndex ?? null;
+      loadedThreadIdRef.current = activeThreadId;
+      setLoadingHistory(false);
+      if (!shouldRefreshStaleCache) return;
+    }
+    if (!hasCachedMessages) {
+      setMessages([]);
+      messagesRef.current = [];
+    }
+    void loadThread(activeThreadId).catch(() => setLoadingHistory(false));
+  }, [activeThreadId, detachActiveStream, loadThread, setLoadingHistory, storage]);
+  useEffect(() => {
+    const threadId = activeThreadId;
+    if (!threadId || isLoadingHistory || loadedThreadIdRef.current !== threadId || activeRunIdRef.current) return;
+    const runId = activeRunIdFromThread(storage.getThread(threadId));
+    if (!runId || reattachedRunIdRef.current === runId) return;
+    void runStream({ mode: "attach", threadId, runId });
+  }, [activeThreadId, isLoadingHistory, runStream, storage, storageKey]);
+  useEffect(() => {
+    const threadId = activeThreadId;
+    if (!threadId || isLoadingHistoryRef.current || activeRunIdRef.current || streamingMessageIdRef.current) {
+      return;
+    }
+    const cached = storage.getThread(threadId);
+    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",
+        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]);
+  return useMemo(() => ({
+    messages,
+    streamingContent,
+    streamingMessageId,
+    contextStatus,
+    currentReasoning,
+    isLoading,
+    isLoadingHistory,
+    isLoadingOlder,
+    hasOlderTurns,
+    liked,
+    disliked,
+    copiedMessageId,
+    lastThinkingDurationMs,
+    activeRunId: activeRunIdRef.current,
+    handleSubmit,
+    handleStop,
+    handleCopy,
+    handleLike,
+    handleDislike,
+    handleRetry,
+    handleSourceClick: (citations) => onSourceClick?.(citations),
+    upsertLiveVoiceMessage,
+    loadOlderTurns,
+    refresh,
+    textareaRef
+  }), [
+    copiedMessageId,
+    contextStatus,
+    currentReasoning,
+    disliked,
+    handleCopy,
+    handleDislike,
+    handleLike,
+    handleRetry,
+    handleStop,
+    handleSubmit,
+    hasOlderTurns,
+    isLoading,
+    isLoadingHistory,
+    isLoadingOlder,
+    lastThinkingDurationMs,
+    liked,
+    loadOlderTurns,
+    messages,
+    onSourceClick,
+    refresh,
+    streamingContent,
+    streamingMessageId,
+    upsertLiveVoiceMessage
+  ]);
+}
+
+// src/sse.ts
+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) => {
+  if (!response.ok) {
+    let message = response.statusText || "Failed to open chat stream.";
+    try {
+      const errorData = await response.json();
+      message = String(errorData.detail || errorData.message || message);
+    } catch {
+    }
+    throw new Error(message);
+  }
+  const reader = response.body?.getReader();
+  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);
+    }
+  }
+  return { threadId, runId };
+};
+
+// src/transport.ts
+var jsonHeaders = (headers) => ({
+  ...headers || {},
+  Accept: "application/json",
+  "Content-Type": "application/json"
+});
+var streamHeaders = (headers) => ({
+  ...headers || {},
+  Accept: "text/event-stream",
+  "Content-Type": "application/json"
+});
+var createFetchChatTransport = ({
+  routes,
+  fetchImpl = fetch,
+  headers,
+  streamBody
+}) => {
+  const loadHeaders = async () => headers?.() ?? {};
+  return {
+    async listThreads(input) {
+      const response = await fetchImpl(routes.listThreads(), {
+        signal: input?.signal,
+        headers: jsonHeaders(await loadHeaders())
+      });
+      if (!response.ok) throw new Error(response.statusText || "Failed to list chat threads.");
+      return response.json();
+    },
+    async getThread(input) {
+      const response = await fetchImpl(routes.getThread(input), {
+        signal: input.signal,
+        headers: jsonHeaders(await loadHeaders())
+      });
+      if (!response.ok) throw new Error(response.statusText || "Failed to load chat thread.");
+      return response.json();
+    },
+    async streamMessage(input, onEvent) {
+      const response = await fetchImpl(routes.streamMessage(), {
+        method: "POST",
+        signal: input.signal,
+        headers: streamHeaders(await loadHeaders()),
+        body: JSON.stringify(
+          streamBody?.(input) ?? {
+            input: input.text,
+            thread_id: input.threadId || void 0,
+            files: input.files || []
+          }
+        )
+      });
+      return consumeSseResponse(response, onEvent);
+    },
+    async attachRun(input, onEvent) {
+      const response = await fetchImpl(routes.attachRun(input), {
+        method: "POST",
+        signal: input.signal,
+        headers: streamHeaders(await loadHeaders()),
+        body: JSON.stringify({})
+      });
+      return consumeSseResponse(response, onEvent);
+    },
+    async cancelRun(input) {
+      const response = await fetchImpl(routes.cancelRun(input), {
+        method: "POST",
+        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.");
+      return response.json();
+    },
+    async deleteThread(input) {
+      if (!routes.deleteThread) return { deleted: false };
+      const response = await fetchImpl(routes.deleteThread(input), {
+        method: "DELETE",
+        headers: jsonHeaders(await loadHeaders())
+      });
+      if (!response.ok) throw new Error(response.statusText || "Failed to delete chat thread.");
+      return response.json();
+    }
+  };
+};
+
+// src/viewport.tsx
+import {
+  useCallback as useCallback2,
+  useEffect as useEffect2,
+  useLayoutEffect,
+  useMemo as useMemo2,
+  useRef as useRef2,
+  useState as useState2
+} from "react";
+import { jsxs } from "react/jsx-runtime";
+var LATEST_EDGE_THRESHOLD_PX = 2;
+var MIN_OLDER_PREFETCH_PX = 320;
+var MAX_OLDER_PREFETCH_PX = 900;
+var isScrollable = (element) => element.scrollHeight - element.clientHeight > LATEST_EDGE_THRESHOLD_PX;
+var isAtTimelineLatestEdge = (element, isTopOrigin) => {
+  if (!isScrollable(element)) return true;
+  return isTopOrigin ? element.scrollHeight - element.clientHeight - element.scrollTop <= LATEST_EDGE_THRESHOLD_PX : Math.abs(element.scrollTop) <= LATEST_EDGE_THRESHOLD_PX;
+};
+var shouldPrefetchOlder = (element) => Math.abs(element.scrollTop) + element.clientHeight >= element.scrollHeight - Math.min(MAX_OLDER_PREFETCH_PX, Math.max(MIN_OLDER_PREFETCH_PX, element.clientHeight * 0.75));
+var getLatestScrollTop = (element, isTopOrigin) => isTopOrigin ? Math.max(0, element.scrollHeight - element.clientHeight) : 0;
+function useLatestThreadViewport({
+  itemCount,
+  hasOlder,
+  isLoadingOlder,
+  onLoadOlder,
+  activeStreamKey,
+  shouldAutoFollow = true,
+  topOriginMaxItems = 4
+}) {
+  const scrollContainerRef = useRef2(null);
+  const olderPagePreserveRef = useRef2(null);
+  const olderPageRequestInFlightRef = useRef2(false);
+  const intrinsicResizePreserveRef = useRef2(null);
+  const autoFollowLatestRef = useRef2(true);
+  const programmaticScrollRef = useRef2(false);
+  const programmaticScrollTimeoutRef = useRef2(null);
+  const activeStreamKeyRef = useRef2(null);
+  const [isAtLatest, setIsAtLatest] = useState2(true);
+  const [topOriginCandidateOverflows, setTopOriginCandidateOverflows] = useState2(false);
+  const topOriginCandidate = !hasOlder && itemCount > 0 && itemCount <= topOriginMaxItems;
+  const isTopOrigin = topOriginCandidate && !topOriginCandidateOverflows;
+  const markProgrammaticScroll = useCallback2(() => {
+    programmaticScrollRef.current = true;
+    if (programmaticScrollTimeoutRef.current) clearTimeout(programmaticScrollTimeoutRef.current);
+    programmaticScrollTimeoutRef.current = setTimeout(() => {
+      programmaticScrollRef.current = false;
+      programmaticScrollTimeoutRef.current = null;
+    }, 80);
+  }, []);
+  const scrollToLatest = useCallback2(() => {
+    const element = scrollContainerRef.current;
+    if (!element) return;
+    markProgrammaticScroll();
+    element.scrollTop = getLatestScrollTop(element, isTopOrigin);
+    setIsAtLatest(true);
+  }, [isTopOrigin, markProgrammaticScroll]);
+  useEffect2(() => {
+    return () => {
+      if (programmaticScrollTimeoutRef.current) clearTimeout(programmaticScrollTimeoutRef.current);
+      const preserve = intrinsicResizePreserveRef.current;
+      if (preserve?.frame !== null && preserve?.frame !== void 0) cancelAnimationFrame(preserve.frame);
+    };
+  }, []);
+  useLayoutEffect(() => {
+    const element = scrollContainerRef.current;
+    const preserve = olderPagePreserveRef.current;
+    if (!element) return;
+    if (topOriginCandidate) {
+      setTopOriginCandidateOverflows(isScrollable(element));
+    } else if (topOriginCandidateOverflows) {
+      setTopOriginCandidateOverflows(false);
+    }
+    if (!preserve) {
+      setIsAtLatest(isAtTimelineLatestEdge(element, isTopOrigin));
+      return;
+    }
+    const addedHeight = element.scrollHeight - preserve.previousHeight;
+    markProgrammaticScroll();
+    element.scrollTop = preserve.previousTop - addedHeight;
+    olderPagePreserveRef.current = null;
+    olderPageRequestInFlightRef.current = false;
+    setIsAtLatest(isAtTimelineLatestEdge(element, isTopOrigin));
+  }, [isTopOrigin, itemCount, markProgrammaticScroll, topOriginCandidate, topOriginCandidateOverflows]);
+  const handleScroll = useCallback2(
+    (event) => {
+      const element = event.currentTarget;
+      const atLatest = isAtTimelineLatestEdge(element, isTopOrigin);
+      setIsAtLatest(atLatest);
+      if (!programmaticScrollRef.current) autoFollowLatestRef.current = atLatest;
+      if (isTopOrigin || !hasOlder || isLoadingOlder || olderPageRequestInFlightRef.current || !shouldPrefetchOlder(element)) {
+        return;
+      }
+      olderPageRequestInFlightRef.current = true;
+      olderPagePreserveRef.current = {
+        previousHeight: element.scrollHeight,
+        previousTop: element.scrollTop
+      };
+      void Promise.resolve(onLoadOlder()).finally(() => {
+        requestAnimationFrame(() => {
+          if (!olderPagePreserveRef.current) return;
+          olderPagePreserveRef.current = null;
+          olderPageRequestInFlightRef.current = false;
+        });
+      });
+    },
+    [hasOlder, isLoadingOlder, isTopOrigin, onLoadOlder]
+  );
+  const preserveIntrinsicResize = useCallback2(() => {
+    const element = scrollContainerRef.current;
+    if (!element || isTopOrigin) return;
+    const active = intrinsicResizePreserveRef.current;
+    if (active?.frame !== null && active?.frame !== void 0) cancelAnimationFrame(active.frame);
+    intrinsicResizePreserveRef.current = {
+      lastHeight: element.scrollHeight,
+      endAt: Date.now() + 260,
+      frame: null
+    };
+    const preserveFrame = () => {
+      const nextElement = scrollContainerRef.current;
+      const preserve = intrinsicResizePreserveRef.current;
+      if (!nextElement || !preserve) return;
+      const heightDelta = nextElement.scrollHeight - preserve.lastHeight;
+      if (Math.abs(heightDelta) >= 1) {
+        markProgrammaticScroll();
+        nextElement.scrollTop -= heightDelta;
+        preserve.lastHeight = nextElement.scrollHeight;
+        setIsAtLatest(isAtTimelineLatestEdge(nextElement, isTopOrigin));
+      }
+      if (Date.now() < preserve.endAt) {
+        preserve.frame = requestAnimationFrame(preserveFrame);
+      } else {
+        intrinsicResizePreserveRef.current = null;
+      }
+    };
+    intrinsicResizePreserveRef.current.frame = requestAnimationFrame(preserveFrame);
+  }, [isTopOrigin, markProgrammaticScroll]);
+  useEffect2(() => {
+    const key = activeStreamKey || null;
+    if (!key || activeStreamKeyRef.current === key) {
+      activeStreamKeyRef.current = key;
+      return;
+    }
+    autoFollowLatestRef.current = true;
+    const frame = requestAnimationFrame(scrollToLatest);
+    activeStreamKeyRef.current = key;
+    return () => cancelAnimationFrame(frame);
+  }, [activeStreamKey, scrollToLatest]);
+  useLayoutEffect(() => {
+    if (!activeStreamKey || !shouldAutoFollow || !autoFollowLatestRef.current) return;
+    if (isLoadingOlder || olderPageRequestInFlightRef.current) return;
+    const frame = requestAnimationFrame(() => {
+      if (autoFollowLatestRef.current && !isLoadingOlder && !olderPageRequestInFlightRef.current) scrollToLatest();
+    });
+    return () => cancelAnimationFrame(frame);
+  }, [activeStreamKey, isLoadingOlder, itemCount, scrollToLatest, shouldAutoFollow]);
+  return {
+    scrollContainerRef,
+    isAtLatest,
+    isTopOrigin,
+    shouldShowLatestButton: !isAtLatest,
+    handleScroll,
+    scrollToLatest,
+    preserveIntrinsicResize
+  };
+}
+function LatestThreadViewport({
+  items,
+  hasOlder,
+  isLoadingOlder,
+  onLoadOlder,
+  activeStreamKey,
+  className,
+  latestSpacer,
+  trailingSpacer,
+  renderItem
+}) {
+  const viewport = useLatestThreadViewport({
+    itemCount: items.length,
+    hasOlder,
+    isLoadingOlder,
+    onLoadOlder,
+    activeStreamKey
+  });
+  const timelineItems = useMemo2(() => viewport.isTopOrigin ? items : [...items].reverse(), [items, viewport.isTopOrigin]);
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      ref: viewport.scrollContainerRef,
+      className,
+      onScroll: viewport.handleScroll,
+      role: "log",
+      style: { overflowAnchor: "none" },
+      children: [
+        !viewport.isTopOrigin && (latestSpacer ?? null),
+        timelineItems.map((item) => renderItem(item, viewport)),
+        viewport.isTopOrigin && (trailingSpacer ?? latestSpacer ?? null)
+      ]
+    }
+  );
+}
+export {
+  DEFAULT_THREAD_PAGE_SIZE,
+  LatestThreadViewport,
+  activeRunIdFromThread,
+  activeRunIdFromThreadDetail,
+  assistantTextFromBlocks,
+  consumeSseResponse,
+  createChatId,
+  createFetchChatTransport,
+  getLatestScrollTop,
+  hasStaleUnfinishedAssistantCache,
+  hasUnfinishedAssistantMessage,
+  isAtTimelineLatestEdge,
+  isRunningThreadStatus,
+  isScrollable,
+  latestContextWindowFromThread,
+  mergeReasoningSteps,
+  parseSseBlock,
+  reasoningStepsFromBlocks,
+  renderBlocksFromResponseBlocks,
+  shouldPrefetchOlder,
+  textFromFinalOutput,
+  threadActivityDate,
+  threadDetailToMessages,
+  threadPaging,
+  titleFromMessage,
+  useAgents24ChatController,
+  useLatestThreadViewport
+};
+//# sourceMappingURL=index.js.map