@dudousxd/nestjs-agent-react 0.5.4 → 0.6.0

package/dist/index.js

@@ -4,6 +4,7 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
 // src/agent-chat-transport.ts
 var HEADER_RUN_ID = "x-agent-run-id";
 var HEADER_THREAD_ID = "x-agent-thread-id";
+var ASK_TOOL_NAME = "ask";
 var AgentChatTransport = class {
   static {
     __name(this, "AgentChatTransport");
@@ -11,6 +12,14 @@ var AgentChatTransport = class {
   options;
   currentRunId;
   currentThreadId;
+  /**
+  * One attempt at a time. The AI SDK keeps a single in-flight response per chat and decides
+  * whether its streamed message REPLACES the list's last entry or is appended by comparing that
+  * response's message id against the last entry alone. Two attempts writing into one chat
+  * therefore append alternating copies of each other's message, and the list ends up holding
+  * several entries under each id — which React renders as duplicate keys.
+  */
+  attemptLive = false;
   constructor(options = {}) {
     this.options = options;
   }
@@ -22,59 +31,84 @@ var AgentChatTransport = class {
   get threadId() {
     return this.currentThreadId;
   }
+  /**
+  * True from the moment a send or resume attempt starts until its chunk stream terminates. A
+  * caller that can refuse a turn BEFORE the SDK commits to one — `useAgentChat` wrapping
+  * `sendMessage` — reads this; the transport itself can only refuse a resume, which is the one
+  * attempt the SDK lets a transport decline.
+  */
+  get isAttemptLive() {
+    return this.attemptLive;
+  }
   async sendMessages(options) {
     this.options.onAttemptStart?.();
-    const lastMessage = options.messages.at(-1);
-    const message = lastMessage ? extractText(lastMessage) : "";
-    const body = {
-      ...this.options.agent !== void 0 ? {
-        agent: this.options.agent
-      } : {},
-      ...this.options.getBody?.() ?? {},
-      ...options.body ?? {},
-      message
-    };
-    const response = await this.fetchImpl()(`${this.baseUrl()}/agent/chat`, {
-      method: "POST",
-      headers: {
-        "content-type": "application/json",
-        accept: "text/event-stream",
-        ...await this.resolveHeaders(options.headers)
-      },
-      body: JSON.stringify(body),
-      ...this.options.credentials !== void 0 ? {
-        credentials: this.options.credentials
-      } : {},
-      ...options.abortSignal ? {
-        signal: options.abortSignal
-      } : {}
-    });
-    if (!response.ok || !response.body) {
-      throw new Error(`Agent chat request failed: ${response.status} ${response.statusText}`);
+    this.attemptLive = true;
+    try {
+      const lastMessage = options.messages.at(-1);
+      const message = lastMessage ? extractText(lastMessage) : "";
+      const body = {
+        ...this.options.agent !== void 0 ? {
+          agent: this.options.agent
+        } : {},
+        ...this.options.getBody?.() ?? {},
+        ...options.body ?? {},
+        message
+      };
+      const response = await this.fetchImpl()(`${this.baseUrl()}/agent/chat`, {
+        method: "POST",
+        headers: {
+          "content-type": "application/json",
+          accept: "text/event-stream",
+          ...await this.resolveHeaders(options.headers)
+        },
+        body: JSON.stringify(body),
+        ...this.options.credentials !== void 0 ? {
+          credentials: this.options.credentials
+        } : {},
+        ...options.abortSignal ? {
+          signal: options.abortSignal
+        } : {}
+      });
+      if (!response.ok || !response.body) {
+        throw new Error(`Agent chat request failed: ${response.status} ${response.statusText}`);
+      }
+      this.captureHeaderMeta(response.headers);
+      return this.toChunkStream(response.body);
+    } catch (error) {
+      this.attemptLive = false;
+      throw error;
     }
-    this.captureHeaderMeta(response.headers);
-    return this.toChunkStream(response.body);
   }
   async reconnectToStream(options) {
+    if (this.attemptLive) return null;
     this.options.onAttemptStart?.();
     const runId = this.options.getResumeRunId?.();
     if (runId === void 0) return null;
-    const response = await this.fetchImpl()(`${this.baseUrl()}/agent/chat/${encodeURIComponent(runId)}/stream`, {
-      method: "GET",
-      headers: {
-        accept: "text/event-stream",
-        ...await this.resolveHeaders(options.headers)
-      },
-      ...this.options.credentials !== void 0 ? {
-        credentials: this.options.credentials
-      } : {}
-    });
-    if (response.status === 404) return null;
-    if (!response.ok || !response.body) {
-      throw new Error(`Agent stream reconnect failed: ${response.status} ${response.statusText}`);
+    this.attemptLive = true;
+    try {
+      const response = await this.fetchImpl()(`${this.baseUrl()}/agent/chat/${encodeURIComponent(runId)}/stream`, {
+        method: "GET",
+        headers: {
+          accept: "text/event-stream",
+          ...await this.resolveHeaders(options.headers)
+        },
+        ...this.options.credentials !== void 0 ? {
+          credentials: this.options.credentials
+        } : {}
+      });
+      if (response.status === 404) {
+        this.attemptLive = false;
+        return null;
+      }
+      if (!response.ok || !response.body) {
+        throw new Error(`Agent stream reconnect failed: ${response.status} ${response.statusText}`);
+      }
+      this.captureHeaderMeta(response.headers);
+      return this.toChunkStream(response.body);
+    } catch (error) {
+      this.attemptLive = false;
+      throw error;
     }
-    this.captureHeaderMeta(response.headers);
-    return this.toChunkStream(response.body);
   }
   fetchImpl() {
     return this.options.fetch ?? globalThis.fetch;
@@ -123,7 +157,11 @@ var AgentChatTransport = class {
     let stepIndex = 0;
     let textId = null;
     let reasoningId = null;
+    const announced = /* @__PURE__ */ new Set();
     const record = /* @__PURE__ */ __name((meta) => this.recordMeta(meta), "record");
+    const endAttempt = /* @__PURE__ */ __name(() => {
+      this.attemptLive = false;
+    }, "endAttempt");
     return new ReadableStream({
       async pull(controller) {
         function ensureStarted() {
@@ -220,6 +258,7 @@ var AgentChatTransport = class {
               break;
             case "tool-input-start":
               ensureStep();
+              announced.add(event.id);
               controller.enqueue({
                 type: "tool-input-start",
                 toolCallId: event.id,
@@ -244,6 +283,7 @@ var AgentChatTransport = class {
               break;
             case "tool-input-available":
               ensureStep();
+              announced.add(event.id);
               controller.enqueue({
                 type: "tool-input-available",
                 toolCallId: event.id,
@@ -256,6 +296,23 @@ var AgentChatTransport = class {
                 } : {}
               });
               break;
+            case "elicitation":
+              ensureStep();
+              if (!announced.has(event.id)) {
+                announced.add(event.id);
+                controller.enqueue({
+                  type: "tool-input-available",
+                  toolCallId: event.id,
+                  toolName: ASK_TOOL_NAME,
+                  input: {
+                    ...event.request.preamble !== void 0 ? {
+                      preamble: event.request.preamble
+                    } : {},
+                    questions: event.request.questions
+                  }
+                });
+              }
+              break;
             case "tool-output":
               ensureStep();
               controller.enqueue({
@@ -284,6 +341,7 @@ var AgentChatTransport = class {
             type: "finish"
           });
           controller.close();
+          endAttempt();
         }
         __name(finish, "finish");
         try {
@@ -312,6 +370,7 @@ var AgentChatTransport = class {
                   errorText: parseErrorText(frame.data)
                 });
                 controller.close();
+                endAttempt();
                 return;
               }
               if (frame.event === "meta") {
@@ -330,10 +389,12 @@ var AgentChatTransport = class {
             errorText: error instanceof Error ? error.message : "Agent stream error"
           });
           controller.close();
+          endAttempt();
         }
       },
       cancel() {
         void reader.cancel();
+        endAttempt();
       }
     });
   }
@@ -401,6 +462,53 @@ function extractText(message) {
 }
 __name(extractText, "extractText");
 
+// src/background-runs.ts
+function asReceipt(output) {
+  if (typeof output !== "object" || output === null) {
+    return null;
+  }
+  const candidate = output;
+  if (candidate.detached !== true || candidate.status !== "started" || typeof candidate.agent !== "string" || typeof candidate.runId !== "string") {
+    return null;
+  }
+  return {
+    detached: true,
+    status: "started",
+    agent: candidate.agent,
+    runId: candidate.runId
+  };
+}
+__name(asReceipt, "asReceipt");
+function backgroundRunsFromThread(messages) {
+  const byRun = /* @__PURE__ */ new Map();
+  for (const message of messages) {
+    for (const result of message.toolResults ?? []) {
+      const receipt = asReceipt(result.output);
+      if (receipt === null || byRun.has(receipt.runId)) {
+        continue;
+      }
+      byRun.set(receipt.runId, {
+        runId: receipt.runId,
+        agent: receipt.agent,
+        toolCallId: result.id,
+        toolName: result.name,
+        status: "running"
+      });
+    }
+  }
+  for (const message of messages) {
+    const run = message.runId === void 0 ? void 0 : byRun.get(message.runId);
+    if (run !== void 0) {
+      run.status = "delivered";
+      run.message = message;
+    }
+  }
+  return [
+    ...byRun.values()
+  ];
+}
+__name(backgroundRunsFromThread, "backgroundRunsFromThread");
+
 // src/client.ts
 var AgentHttpError = class extends Error {
   static {
@@ -425,6 +533,16 @@ var AgentClient = class {
   listThreads() {
     return this.request("GET", "/agent/threads");
   }
+  /**
+  * The skills this caller can invoke right now, scope-resolved — the same list, built by the same
+  * call, that the model is offered, so what a user can type after a `/` and what the agent can
+  * reach cannot drift apart. `threadId` reaches the host's own resolver, which may scope a skill to
+  * one conversation; omitted, the server reads it as a brand-new thread.
+  */
+  listSkills(threadId) {
+    const query = threadId === void 0 ? "" : `?threadId=${encodeURIComponent(threadId)}`;
+    return this.request("GET", `/agent/skills${query}`);
+  }
   getThread(id) {
     return this.request("GET", `/agent/threads/${encodeURIComponent(id)}`);
   }
@@ -486,6 +604,23 @@ var AgentClient = class {
   rejectToolCall(input) {
     return this.request("POST", "/agent/tool-call/reject", input);
   }
+  /**
+  * Settle a parked question set. `answers` is questionId → chosen option values; a question left
+  * out takes the pre-picked default the request carried, resolved server-side against the request
+  * the run already holds. Omit the whole object and the user has confirmed every pre-picked
+  * answer — which is the point of the surface, so it is a valid submission rather than a blank.
+  */
+  answerToolCall(input) {
+    return this.request("POST", "/agent/tool-call/answer", input);
+  }
+  /**
+  * Decline to answer and let the agent proceed on its own pre-picked values. Lands on the same
+  * values a confirmation would, and persists differently on purpose — only one of them is
+  * evidence the user chose them.
+  */
+  skipToolCall(input) {
+    return this.request("POST", "/agent/tool-call/skip", input);
+  }
   async request(method, path, body) {
     const fetchImpl = this.options.fetch ?? globalThis.fetch;
     const baseUrl = (this.options.baseUrl ?? "").replace(/\/$/, "");
@@ -520,414 +655,76 @@ var AgentClient = class {
   }
 };
 
-// src/stored-message-to-ui-message.ts
-function storedMessageToUiMessage(message) {
-  const parts = [];
-  if (message.content) {
-    parts.push({
-      type: "text",
-      text: message.content
-    });
-  }
-  for (const attachment of message.attachments ?? []) {
-    parts.push({
-      type: "file",
-      mediaType: attachment.contentType,
-      filename: attachment.name,
-      url: attachment.url
-    });
-  }
-  for (const call of message.toolCalls ?? []) {
-    const result = message.toolResults?.find((candidate) => candidate.id === call.id);
-    const toolKind = call.kind;
-    parts.push({
-      type: `tool-${call.name}`,
-      toolCallId: call.id,
-      ...toolKind !== void 0 ? {
-        toolMetadata: {
-          toolKind
-        }
-      } : {},
-      ...result !== void 0 ? {
-        state: "output-available",
-        input: call.input,
-        output: result.output
-      } : {
-        state: "input-available",
-        input: call.input
-      }
-    });
-  }
-  return {
-    id: message.id,
-    role: message.role,
-    parts
-  };
-}
-__name(storedMessageToUiMessage, "storedMessageToUiMessage");
-
-// src/stored-thread-to-ui-messages.ts
-function storedThreadToUiMessages(messages) {
-  const turns = [];
-  for (const message of messages) {
-    const currentTurn = turns.at(-1);
-    const previousRow = currentTurn?.at(-1);
-    if (message.role === "assistant" && previousRow?.role === "assistant" && currentTurn) {
-      currentTurn.push(message);
-    } else {
-      turns.push([
-        message
-      ]);
-    }
-  }
-  return turns.map(mergeTurn);
-}
-__name(storedThreadToUiMessages, "storedThreadToUiMessages");
-function mergeTurn(rows) {
-  const lastRow = rows.at(-1);
-  if (lastRow === void 0) {
-    throw new Error("storedThreadToUiMessages: encountered an empty turn");
-  }
-  if (rows.length === 1) {
-    return storedMessageToUiMessage(lastRow);
-  }
-  const parts = rows.flatMap((row) => storedMessageToUiMessage(row).parts);
-  const usage = sumUsage(rows);
-  return {
-    id: lastRow.id,
-    role: lastRow.role,
-    parts,
-    ...usage !== void 0 ? {
-      metadata: {
-        usage
-      }
-    } : {}
-  };
-}
-__name(mergeTurn, "mergeTurn");
-function sumUsage(rows) {
-  const usages = rows.map((row) => row.usage).filter((usage) => usage !== void 0);
-  if (usages.length === 0) {
-    return void 0;
-  }
-  const allCostsUnknown = usages.every((usage) => usage.costUsd === null || usage.costUsd === void 0);
-  return {
-    inputTokens: usages.reduce((sum, usage) => sum + usage.inputTokens, 0),
-    outputTokens: usages.reduce((sum, usage) => sum + usage.outputTokens, 0),
-    costUsd: allCostsUnknown ? null : usages.reduce((sum, usage) => sum + (usage.costUsd ?? 0), 0)
-  };
-}
-__name(sumUsage, "sumUsage");
+// src/components/chat-input.tsx
+import React2, { useEffect as useEffect2, useState as useState2 } from "react";
 
-// src/use-agent-chat.ts
-import { useChat } from "@ai-sdk/react";
+// src/components/use-speech-recognition.ts
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
-function useAgentChat(options) {
-  const latest = useRef(options);
-  latest.current = options;
-  const [runId, setRunId] = useState(options.resumeRunId);
-  const runIdRef = useRef(runId);
-  runIdRef.current = runId;
-  const settlingRunIdRef = useRef(void 0);
-  const autoResumeRunIdRef = useRef(void 0);
-  const [autoResume, setAutoResume] = useState(false);
-  const [activeRunId, setActiveRunId] = useState(null);
-  const regenerateNext = useRef(false);
-  const createdThreadId = useRef(void 0);
-  const client = useMemo(() => {
-    if (options.client) return options.client;
-    return new AgentClient({
-      ...options.baseUrl !== void 0 ? {
-        baseUrl: options.baseUrl
-      } : {},
-      ...options.credentials !== void 0 ? {
-        credentials: options.credentials
-      } : {},
-      ...options.fetch !== void 0 ? {
-        fetch: options.fetch
-      } : {},
-      getHeaders: /* @__PURE__ */ __name(async () => mergeHeaders(latest.current), "getHeaders")
-    });
-  }, []);
+function getRecognitionCtor() {
+  if (typeof window === "undefined") return null;
+  const scope = window;
+  return scope.SpeechRecognition ?? scope.webkitSpeechRecognition ?? null;
+}
+__name(getRecognitionCtor, "getRecognitionCtor");
+function useSpeechRecognition({ lang = "en-US", onFinalTranscript, onInterimTranscript }) {
+  const recognitionRef = useRef(null);
+  const [isListening, setIsListening] = useState(false);
+  const ctor = useMemo(() => getRecognitionCtor(), []);
+  const isSupported = ctor !== null;
+  const finalRef = useRef(onFinalTranscript);
+  const interimRef = useRef(onInterimTranscript);
+  finalRef.current = onFinalTranscript;
+  interimRef.current = onInterimTranscript;
   useEffect(() => {
-    if (!options.resume || options.threadId === void 0) return;
-    let cancelled = false;
-    const threadId = options.threadId;
-    void client.getThread(threadId).then((thread) => {
-      if (cancelled) return;
-      setActiveRunId(thread.activeRunId ?? null);
-      if (thread.activeRunId != null) {
-        autoResumeRunIdRef.current = thread.activeRunId;
-        setAutoResume(true);
+    if (!ctor) return;
+    const recognition = new ctor();
+    recognition.lang = lang;
+    recognition.continuous = false;
+    recognition.interimResults = true;
+    recognition.onresult = (event) => {
+      let interim = "";
+      for (let i = event.resultIndex; i < event.results.length; i++) {
+        const result = event.results[i];
+        if (!result) continue;
+        const text = result[0]?.transcript ?? "";
+        if (result.isFinal) {
+          finalRef.current(text);
+        } else {
+          interim += text;
+        }
       }
-    });
+      if (interim && interimRef.current) interimRef.current(interim);
+    };
+    recognition.onerror = (event) => {
+      if (event.error !== "no-speech" && event.error !== "aborted") {
+        console.warn("SpeechRecognition error", event.error);
+      }
+      setIsListening(false);
+    };
+    recognition.onend = () => setIsListening(false);
+    recognitionRef.current = recognition;
     return () => {
-      cancelled = true;
+      try {
+        recognition.stop();
+      } catch {
+      }
+      recognitionRef.current = null;
     };
   }, [
-    client,
-    options.resume,
-    options.threadId
+    ctor,
+    lang
   ]);
-  const transport = useMemo(() => {
-    function onMeta(meta) {
-      settlingRunIdRef.current = meta.runId;
-      setRunId(meta.runId);
-      if (latest.current.threadId === void 0 && meta.threadId && createdThreadId.current !== meta.threadId) {
-        createdThreadId.current = meta.threadId;
-        latest.current.onThreadCreated?.(meta.threadId);
-      }
-    }
-    __name(onMeta, "onMeta");
-    return new AgentChatTransport({
-      ...options.baseUrl !== void 0 ? {
-        baseUrl: options.baseUrl
-      } : {},
-      ...options.credentials !== void 0 ? {
-        credentials: options.credentials
-      } : {},
-      ...options.fetch !== void 0 ? {
-        fetch: options.fetch
-      } : {},
-      ...options.agent !== void 0 ? {
-        agent: options.agent
-      } : {},
-      getHeaders: /* @__PURE__ */ __name(async () => mergeHeaders(latest.current), "getHeaders"),
-      getBody: /* @__PURE__ */ __name(() => {
-        const current = latest.current;
-        const pageContext = current.getPageContext?.() ?? null;
-        const regenerate2 = regenerateNext.current;
-        regenerateNext.current = false;
-        const threadId = current.threadId ?? createdThreadId.current;
-        return {
-          ...threadId !== void 0 ? {
-            threadId
-          } : {},
-          ...pageContext ? {
-            pageContext
-          } : {},
-          ...regenerate2 ? {
-            regenerate: true
-          } : {}
-        };
-      }, "getBody"),
-      getResumeRunId: /* @__PURE__ */ __name(() => latest.current.resumeRunId ?? autoResumeRunIdRef.current, "getResumeRunId"),
-      onMeta,
-      onAttemptStart: /* @__PURE__ */ __name(() => {
-        settlingRunIdRef.current = void 0;
-      }, "onAttemptStart")
-    });
-  }, []);
-  const chat = useChat({
-    transport,
-    resume: options.resumeRunId !== void 0 || autoResume,
-    ...options.threadId !== void 0 ? {
-      id: options.threadId
-    } : {},
-    ...options.initialMessages !== void 0 ? {
-      messages: options.initialMessages
-    } : {},
-    onFinish: /* @__PURE__ */ __name(({ isError }) => {
-      latest.current.onFinish?.();
-      const settledRunId = settlingRunIdRef.current;
-      if (settledRunId !== void 0) {
-        latest.current.onRunSettled?.({
-          runId: settledRunId,
-          status: isError ? "failed" : "completed"
-        });
-      }
-    }, "onFinish")
-  });
-  const chatRef = useRef(chat);
-  chatRef.current = chat;
-  const addToolResult = useCallback(({ tool, toolCallId, output }) => chatRef.current.addToolResult({
-    tool,
-    toolCallId,
-    output
-  }), []);
-  const [threads, setThreads] = useState([]);
-  const [quota, setQuota] = useState(null);
-  const loadThreads = useCallback(async () => {
-    const list = await client.listThreads();
-    setThreads(list);
-    return list;
-  }, [
-    client
-  ]);
-  const loadThread = useCallback((id) => client.getThread(id), [
-    client
-  ]);
-  const deleteThread = useCallback(async (id) => {
-    await client.deleteThread(id);
-    setThreads((current) => current.filter((thread) => thread.id !== id));
-  }, [
-    client
-  ]);
-  const forkThread = useCallback((threadId, messageId) => client.forkFromMessage(threadId, messageId), [
-    client
-  ]);
-  const renameThread = useCallback(async (id, title) => {
-    await client.renameThread(id, title);
-    setThreads((current) => current.map((thread) => thread.id === id ? {
-      ...thread,
-      title
-    } : thread));
-  }, [
-    client
-  ]);
-  const promoteThread = useCallback(async (id) => {
-    await client.promoteThread(id);
-    await loadThreads();
-  }, [
-    client,
-    loadThreads
-  ]);
-  const truncateFromMessage = useCallback((threadId, messageId) => client.truncateFromMessage(threadId, messageId).then(() => void 0), [
-    client
-  ]);
-  const loadQuota = useCallback(async () => {
-    const today = await client.getQuotaToday();
-    setQuota(today);
-    return today;
-  }, [
-    client
-  ]);
-  const cancel = useCallback(async () => {
-    chatRef.current.stop();
-    const activeRunId2 = runIdRef.current;
-    if (activeRunId2) {
-      try {
-        await client.cancelStream(activeRunId2);
-      } catch {
-      }
-    }
-  }, [
-    client
-  ]);
-  const approve = useCallback(async ({ toolCallId }) => {
-    await client.approveToolCall({
-      toolCallId
-    });
-  }, [
-    client
-  ]);
-  const reject = useCallback(async ({ toolCallId, reason }) => {
-    await client.rejectToolCall({
-      toolCallId,
-      ...reason !== void 0 ? {
-        reason
-      } : {}
-    });
-  }, [
-    client
-  ]);
-  const regenerate = useCallback(() => {
-    regenerateNext.current = true;
-    void chatRef.current.regenerate();
-  }, []);
-  return {
-    ...chat,
-    addToolResult,
-    runId,
-    /** The `resume`-fetched thread's active run id, or `null` once resolved with none. */
-    activeRunId,
-    client,
-    threads,
-    loadThreads,
-    loadThread,
-    deleteThread,
-    forkThread,
-    renameThread,
-    promoteThread,
-    truncateFromMessage,
-    quota,
-    loadQuota,
-    cancel,
-    approve,
-    reject,
-    regenerate
-  };
-}
-__name(useAgentChat, "useAgentChat");
-async function mergeHeaders(options) {
-  const dynamic = await options.getHeaders?.() ?? {};
-  return {
-    ...options.headers,
-    ...dynamic
-  };
-}
-__name(mergeHeaders, "mergeHeaders");
-
-// src/components/chat-input.tsx
-import React, { useEffect as useEffect3, useState as useState3 } from "react";
-
-// src/components/use-speech-recognition.ts
-import { useCallback as useCallback2, useEffect as useEffect2, useMemo as useMemo2, useRef as useRef2, useState as useState2 } from "react";
-function getRecognitionCtor() {
-  if (typeof window === "undefined") return null;
-  const scope = window;
-  return scope.SpeechRecognition ?? scope.webkitSpeechRecognition ?? null;
-}
-__name(getRecognitionCtor, "getRecognitionCtor");
-function useSpeechRecognition({ lang = "en-US", onFinalTranscript, onInterimTranscript }) {
-  const recognitionRef = useRef2(null);
-  const [isListening, setIsListening] = useState2(false);
-  const ctor = useMemo2(() => getRecognitionCtor(), []);
-  const isSupported = ctor !== null;
-  const finalRef = useRef2(onFinalTranscript);
-  const interimRef = useRef2(onInterimTranscript);
-  finalRef.current = onFinalTranscript;
-  interimRef.current = onInterimTranscript;
-  useEffect2(() => {
-    if (!ctor) return;
-    const recognition = new ctor();
-    recognition.lang = lang;
-    recognition.continuous = false;
-    recognition.interimResults = true;
-    recognition.onresult = (event) => {
-      let interim = "";
-      for (let i = event.resultIndex; i < event.results.length; i++) {
-        const result = event.results[i];
-        if (!result) continue;
-        const text = result[0]?.transcript ?? "";
-        if (result.isFinal) {
-          finalRef.current(text);
-        } else {
-          interim += text;
-        }
-      }
-      if (interim && interimRef.current) interimRef.current(interim);
-    };
-    recognition.onerror = (event) => {
-      if (event.error !== "no-speech" && event.error !== "aborted") {
-        console.warn("SpeechRecognition error", event.error);
-      }
-      setIsListening(false);
-    };
-    recognition.onend = () => setIsListening(false);
-    recognitionRef.current = recognition;
-    return () => {
-      try {
-        recognition.stop();
-      } catch {
-      }
-      recognitionRef.current = null;
-    };
-  }, [
-    ctor,
-    lang
-  ]);
-  const start = useCallback2(() => {
-    const recognition = recognitionRef.current;
-    if (!recognition) return;
-    try {
-      recognition.start();
-      setIsListening(true);
-    } catch (error) {
-      console.warn("SpeechRecognition start failed", error);
+  const start = useCallback(() => {
+    const recognition = recognitionRef.current;
+    if (!recognition) return;
+    try {
+      recognition.start();
+      setIsListening(true);
+    } catch (error) {
+      console.warn("SpeechRecognition start failed", error);
     }
   }, []);
-  const stop = useCallback2(() => {
+  const stop = useCallback(() => {
     const recognition = recognitionRef.current;
     if (!recognition) return;
     try {
@@ -945,9 +742,9 @@ function useSpeechRecognition({ lang = "en-US", onFinalTranscript, onInterimTran
 __name(useSpeechRecognition, "useSpeechRecognition");
 
 // src/components/chat-input.tsx
-function ChatInput({ onSubmit, disabled, placeholder, rows = 2, enableSpeech = true, speechLang = "en-US", sendLabel = "Send", className, textareaClassName, sendButtonClassName, micButtonClassName, renderMic }) {
-  const [value, setValue] = useState3("");
-  const [interim, setInterim] = useState3("");
+function ChatInput({ onSubmit, disabled, placeholder, rows = 2, enableSpeech = true, speechLang = "en-US", sendLabel = "Send", onStop, isStreaming = false, stopLabel = "Stop generating", className, textareaClassName, sendButtonClassName, micButtonClassName, stopButtonClassName, renderMic }) {
+  const [value, setValue] = useState2("");
+  const [interim, setInterim] = useState2("");
   const speech = useSpeechRecognition({
     lang: speechLang,
     onFinalTranscript: /* @__PURE__ */ __name((text) => {
@@ -958,7 +755,7 @@ function ChatInput({ onSubmit, disabled, placeholder, rows = 2, enableSpeech = t
     }, "onFinalTranscript"),
     onInterimTranscript: /* @__PURE__ */ __name((text) => setInterim(text), "onInterimTranscript")
   });
-  useEffect3(() => {
+  useEffect2(() => {
     if (!speech.isListening) setInterim("");
   }, [
     speech.isListening
@@ -985,9 +782,10 @@ function ChatInput({ onSubmit, disabled, placeholder, rows = 2, enableSpeech = t
   __name(toggleMic, "toggleMic");
   const displayValue = speech.isListening && interim ? `${value}${value && !value.endsWith(" ") ? " " : ""}${interim}` : value;
   const showMic = enableSpeech && speech.isSupported;
-  return /* @__PURE__ */ React.createElement("div", {
+  const showStop = isStreaming && onStop !== void 0;
+  return /* @__PURE__ */ React2.createElement("div", {
     className
-  }, /* @__PURE__ */ React.createElement("textarea", {
+  }, /* @__PURE__ */ React2.createElement("textarea", {
     className: textareaClassName,
     rows,
     value: displayValue,
@@ -998,12 +796,17 @@ function ChatInput({ onSubmit, disabled, placeholder, rows = 2, enableSpeech = t
     }, "onChange"),
     onKeyDown: handleKeyDown,
     placeholder: placeholder ?? "Ask something (Enter to send, Shift+Enter for newline)"
-  }), /* @__PURE__ */ React.createElement("button", {
+  }), /* @__PURE__ */ React2.createElement("button", {
     type: "button",
     className: sendButtonClassName,
     onClick: submit,
     disabled: disabled || !value.trim()
-  }, sendLabel), showMic ? /* @__PURE__ */ React.createElement("button", {
+  }, sendLabel), showStop ? /* @__PURE__ */ React2.createElement("button", {
+    type: "button",
+    className: stopButtonClassName,
+    onClick: /* @__PURE__ */ __name(() => void onStop(), "onClick"),
+    "aria-label": "Stop generating"
+  }, stopLabel) : null, showMic ? /* @__PURE__ */ React2.createElement("button", {
     type: "button",
     className: micButtonClassName,
     onClick: toggleMic,
@@ -1016,223 +819,393 @@ function ChatInput({ onSubmit, disabled, placeholder, rows = 2, enableSpeech = t
 __name(ChatInput, "ChatInput");
 
 // src/components/message-item.tsx
-import { isTextUIPart, isToolUIPart } from "ai";
-import React2, { useEffect as useEffect4, useRef as useRef3, useState as useState4 } from "react";
-function MessageItem({ message, renderToolPart, renderToolGroup, renderText, classNames, isStreaming = false, editable, onEditSubmit, regeneratable, onRegenerate, onFork, usage, createdAt }) {
-  const isUser = message.role === "user";
-  const parts = message.parts ?? [];
-  const copyableText = extractText2(parts);
-  const actionRow = /* @__PURE__ */ React2.createElement("div", {
-    className: classNames?.actions,
-    "data-actions-for": message.role
-  }, copyableText ? /* @__PURE__ */ React2.createElement(CopyButton, {
-    text: copyableText,
-    className: classNames?.actionButton
-  }) : null, onFork ? /* @__PURE__ */ React2.createElement("button", {
-    type: "button",
-    onClick: /* @__PURE__ */ __name(() => void onFork(message.id), "onClick"),
-    className: classNames?.actionButton,
-    title: "Fork thread from this message"
-  }, "Fork") : null, !isUser && regeneratable && onRegenerate ? /* @__PURE__ */ React2.createElement("button", {
-    type: "button",
-    onClick: /* @__PURE__ */ __name(() => void onRegenerate(), "onClick"),
-    className: classNames?.actionButton,
-    title: "Regenerate response"
-  }, "Regenerate") : null, !isUser && usage ? /* @__PURE__ */ React2.createElement(UsageInline, {
-    usage,
-    className: classNames?.usage
-  }) : null, createdAt ? /* @__PURE__ */ React2.createElement(TimestampInline, {
-    createdAt,
-    className: classNames?.timestamp
-  }) : null);
-  if (isUser && editable && onEditSubmit) {
-    return /* @__PURE__ */ React2.createElement(EditableUserBubble, {
-      message,
-      onSubmit: onEditSubmit,
-      renderText,
-      classNames,
-      actions: actionRow
-    });
-  }
-  const className = [
-    classNames?.root,
-    classNames?.byRole?.[message.role]
-  ].filter((entry) => entry).join(" ");
-  return /* @__PURE__ */ React2.createElement("div", {
-    className: className === "" ? void 0 : className,
-    "data-role": message.role,
-    "data-streaming": isStreaming ? "true" : void 0
-  }, /* @__PURE__ */ React2.createElement("div", null, renderParts(message, parts, {
-    renderText,
-    renderToolPart,
-    renderToolGroup,
-    classNames,
-    isStreaming
-  })), actionRow);
-}
-__name(MessageItem, "MessageItem");
-function renderParts(message, parts, ctx) {
+import React3 from "react";
+
+// src/transcript/use-chat-transcript.ts
+import { useCallback as useCallback3, useEffect as useEffect4, useRef as useRef3, useState as useState4 } from "react";
+
+// src/transcript/model.ts
+import { getToolName, isFileUIPart, isReasoningUIPart, isTextUIPart, isToolUIPart } from "ai";
+function buildTranscriptBlocks(message, options) {
   const blocks = [];
   let toolBuffer = [];
-  let toolGroupCounter = 0;
+  let retrievalBuffer = [];
+  let fileBuffer = [];
+  let toolCounter = 0;
   let textCounter = 0;
+  let fileCounter = 0;
+  let reasoningCounter = 0;
+  let sourcesCounter = 0;
+  let elicitationCounter = 0;
   function flushTools() {
     if (toolBuffer.length === 0) {
       return;
     }
-    const key = `${message.id}-tools-${toolGroupCounter++}`;
-    if (ctx.renderToolGroup) {
-      blocks.push(/* @__PURE__ */ React2.createElement(React2.Fragment, {
-        key
-      }, ctx.renderToolGroup(toolBuffer, key)));
-    } else if (ctx.renderToolPart) {
-      for (const part of toolBuffer) {
-        const partKey = `${message.id}-${part.toolCallId}`;
-        blocks.push(/* @__PURE__ */ React2.createElement(React2.Fragment, {
-          key: partKey
-        }, ctx.renderToolPart(part, partKey)));
-      }
-    }
+    blocks.push({
+      kind: "tools",
+      key: `${message.id}-tools-${toolCounter++}`,
+      parts: toolBuffer,
+      calls: toolBuffer.map((part) => buildToolCall(part, options.approval))
+    });
     toolBuffer = [];
   }
   __name(flushTools, "flushTools");
-  for (const part of parts) {
+  function flushSources() {
+    if (retrievalBuffer.length === 0) {
+      return;
+    }
+    blocks.push(buildSourcesBlock(`${message.id}-sources-${sourcesCounter++}`, retrievalBuffer));
+    retrievalBuffer = [];
+  }
+  __name(flushSources, "flushSources");
+  function flushFiles() {
+    if (fileBuffer.length === 0) {
+      return;
+    }
+    blocks.push({
+      kind: "files",
+      key: `${message.id}-files-${fileCounter++}`,
+      files: fileBuffer.map((part) => ({
+        url: part.url,
+        mediaType: part.mediaType,
+        filename: part.filename ?? null,
+        isImage: part.mediaType.startsWith("image/")
+      }))
+    });
+    fileBuffer = [];
+  }
+  __name(flushFiles, "flushFiles");
+  function flushAll() {
+    flushTools();
+    flushSources();
+    flushFiles();
+  }
+  __name(flushAll, "flushAll");
+  for (const part of message.parts ?? []) {
     if (isToolUIPart(part)) {
+      const elicitation = options.elicitation;
+      if (elicitation !== void 0) {
+        const request = readElicitationRequest(part);
+        if (request !== null) {
+          flushAll();
+          blocks.push(buildElicitationBlock(`${message.id}-elicitation-${elicitationCounter++}`, part, request, elicitation));
+          continue;
+        }
+      }
+      if (options.sources === true && readPassages(part) !== null) {
+        flushTools();
+        retrievalBuffer.push(part);
+        continue;
+      }
+      flushSources();
+      flushFiles();
       toolBuffer.push(part);
       continue;
     }
-    flushTools();
+    if (isFileUIPart(part)) {
+      flushTools();
+      flushSources();
+      fileBuffer.push(part);
+      continue;
+    }
+    flushAll();
     if (isTextUIPart(part)) {
-      const key = `${message.id}-text-${textCounter++}`;
-      blocks.push(/* @__PURE__ */ React2.createElement("div", {
+      blocks.push({
+        kind: "text",
+        key: `${message.id}-text-${textCounter++}`,
+        text: part.text,
+        isStreaming: part.state === "streaming"
+      });
+      continue;
+    }
+    if (isReasoningUIPart(part)) {
+      const key = `${message.id}-reasoning-${reasoningCounter++}`;
+      const isStreaming = part.state === "streaming";
+      blocks.push({
+        kind: "reasoning",
         key,
-        className: ctx.classNames?.text
-      }, ctx.renderText ? ctx.renderText(part.text, {
-        isStreaming: ctx.isStreaming
-      }) : part.text));
+        text: part.text,
+        isStreaming,
+        isOpen: options.isReasoningOpen(key, isStreaming),
+        toggle: /* @__PURE__ */ __name((open) => options.toggleReasoning(key, open), "toggle")
+      });
     }
   }
-  flushTools();
+  flushAll();
   return blocks;
 }
-__name(renderParts, "renderParts");
-function EditableUserBubble({ message, onSubmit, renderText, classNames, actions }) {
-  const initialText = extractText2(message.parts ?? []);
-  const [isEditing, setIsEditing] = useState4(false);
-  const [draft, setDraft] = useState4(initialText);
-  const textareaRef = useRef3(null);
-  useEffect4(() => {
-    if (isEditing && textareaRef.current) {
-      const el = textareaRef.current;
-      el.focus();
-      el.setSelectionRange(el.value.length, el.value.length);
-    }
-  }, [
-    isEditing
-  ]);
-  async function handleSave() {
-    const next = draft.trim();
-    if (!next) {
-      return;
+__name(buildTranscriptBlocks, "buildTranscriptBlocks");
+function buildSourcesBlock(key, parts) {
+  const byId = /* @__PURE__ */ new Map();
+  let query = null;
+  let passageCount = 0;
+  for (const part of parts) {
+    query ??= readQuery(part);
+    for (const passage of readPassages(part) ?? []) {
+      passageCount++;
+      const id = passage.source ?? passage.id;
+      const existing = byId.get(id);
+      if (existing) {
+        existing.passageCount++;
+        existing.topScore = Math.max(existing.topScore, passage.score);
+        existing.passages.push(passage);
+        continue;
+      }
+      byId.set(id, {
+        id,
+        label: passage.source ?? passage.id,
+        passageCount: 1,
+        topScore: passage.score,
+        passages: [
+          passage
+        ]
+      });
     }
-    setIsEditing(false);
-    await onSubmit(next);
-  }
-  __name(handleSave, "handleSave");
-  if (!isEditing) {
-    const rootClass = [
-      classNames?.root,
-      classNames?.byRole?.user
-    ].filter((entry) => entry).join(" ");
-    return /* @__PURE__ */ React2.createElement("div", {
-      className: rootClass === "" ? void 0 : rootClass,
-      "data-role": "user"
-    }, /* @__PURE__ */ React2.createElement("div", {
-      className: classNames?.text
-    }, renderText ? renderText(initialText, {
-      isStreaming: false
-    }) : initialText), /* @__PURE__ */ React2.createElement("button", {
-      type: "button",
-      onClick: /* @__PURE__ */ __name(() => {
-        setDraft(initialText);
-        setIsEditing(true);
-      }, "onClick"),
-      className: classNames?.actionButton,
-      title: "Edit & resubmit"
-    }, "Edit"), actions);
   }
-  return /* @__PURE__ */ React2.createElement("div", {
-    "data-editing": "true"
-  }, /* @__PURE__ */ React2.createElement("textarea", {
-    ref: textareaRef,
-    value: draft,
-    onChange: /* @__PURE__ */ __name((event) => setDraft(event.target.value), "onChange"),
-    onKeyDown: /* @__PURE__ */ __name((event) => {
-      if (event.key === "Enter" && !event.shiftKey) {
-        event.preventDefault();
-        void handleSave();
-      }
-      if (event.key === "Escape") {
-        event.preventDefault();
-        setIsEditing(false);
+  return {
+    kind: "sources",
+    key,
+    query,
+    sources: [
+      ...byId.values()
+    ],
+    passageCount
+  };
+}
+__name(buildSourcesBlock, "buildSourcesBlock");
+function isSettled(state) {
+  return state === "output-available" || state === "output-error" || state === "output-denied";
+}
+__name(isSettled, "isSettled");
+function toolKind(part) {
+  const metadata = part.toolMetadata;
+  return isRecord(metadata) && typeof metadata.toolKind === "string" ? metadata.toolKind : void 0;
+}
+__name(toolKind, "toolKind");
+function isAwaitingApproval(part) {
+  if (part.state === "approval-requested") {
+    return true;
+  }
+  if (part.state !== "input-available") {
+    return false;
+  }
+  return toolKind(part) === "action" && readElicitationRequest(part) === null;
+}
+__name(isAwaitingApproval, "isAwaitingApproval");
+function buildToolCall(part, options) {
+  const toolCallId = part.toolCallId;
+  const awaiting = isAwaitingApproval(part);
+  const isSubmitting = awaiting && options?.isSubmitting(toolCallId) === true;
+  return {
+    part,
+    toolCallId,
+    name: getToolName(part),
+    isAwaitingApproval: awaiting,
+    approve: {
+      available: awaiting && options?.canApprove === true,
+      isSubmitting,
+      run: /* @__PURE__ */ __name(() => options?.approve(toolCallId), "run")
+    },
+    reject: {
+      available: awaiting && options?.canReject === true,
+      isSubmitting,
+      run: /* @__PURE__ */ __name(() => options?.reject(toolCallId), "run")
+    },
+    error: options?.errorOf(toolCallId) ?? null
+  };
+}
+__name(buildToolCall, "buildToolCall");
+function readElicitationRequest(part) {
+  const input = part.input;
+  if (!isRecord(input) || !Array.isArray(input.questions) || input.questions.length === 0) {
+    return null;
+  }
+  const questions = [];
+  for (const candidate of input.questions) {
+    if (!isRecord(candidate) || typeof candidate.id !== "string" || typeof candidate.prompt !== "string" || !Array.isArray(candidate.options) || candidate.options.length === 0) {
+      return null;
+    }
+    const options = [];
+    for (const option of candidate.options) {
+      if (!isRecord(option) || typeof option.value !== "string" || typeof option.label !== "string") {
+        return null;
       }
-    }, "onKeyDown"),
-    rows: Math.min(8, draft.split("\n").length + 1),
-    className: classNames?.editTextarea
-  }), /* @__PURE__ */ React2.createElement("div", {
-    className: classNames?.editActions
-  }, /* @__PURE__ */ React2.createElement("button", {
-    type: "button",
-    onClick: /* @__PURE__ */ __name(() => setIsEditing(false), "onClick")
-  }, "Cancel"), /* @__PURE__ */ React2.createElement("button", {
-    type: "button",
-    onClick: /* @__PURE__ */ __name(() => void handleSave(), "onClick"),
-    disabled: !draft.trim()
-  }, "Resend")));
+      options.push({
+        value: option.value,
+        label: option.label,
+        hotkey: typeof option.hotkey === "string" ? option.hotkey : null
+      });
+    }
+    questions.push({
+      id: candidate.id,
+      prompt: candidate.prompt,
+      multiple: candidate.multiple === true,
+      defaults: Array.isArray(candidate.defaults) ? candidate.defaults.filter((value) => typeof value === "string") : [],
+      options
+    });
+  }
+  return {
+    preamble: typeof input.preamble === "string" ? input.preamble : null,
+    questions
+  };
 }
-__name(EditableUserBubble, "EditableUserBubble");
-function CopyButton({ text, className }) {
-  const [copied, setCopied] = useState4(false);
-  async function handleCopy() {
-    try {
-      await navigator.clipboard.writeText(text);
-      setCopied(true);
-      setTimeout(() => setCopied(false), 1500);
-    } catch {
+__name(readElicitationRequest, "readElicitationRequest");
+function readElicitationOutcome(part) {
+  const output = part.output;
+  if (!isRecord(output) || !isRecord(output.answers) || typeof output.skipped !== "boolean") {
+    return null;
+  }
+  const answers = {};
+  for (const [id, values] of Object.entries(output.answers)) {
+    answers[id] = Array.isArray(values) ? values.filter((value) => typeof value === "string") : [];
+  }
+  return {
+    answers,
+    skipped: output.skipped,
+    defaulted: Array.isArray(output.defaulted) ? output.defaulted.filter((id) => typeof id === "string") : [],
+    summary: typeof output.summary === "string" ? output.summary : null
+  };
+}
+__name(readElicitationOutcome, "readElicitationOutcome");
+function buildElicitationBlock(key, part, request, options) {
+  const toolCallId = part.toolCallId;
+  const isPending = !isSettled(part.state);
+  const outcome = isPending ? null : readElicitationOutcome(part);
+  const questions = request.questions.map((question, index) => {
+    const picked = isPending ? options.picked(toolCallId, question.id) : void 0;
+    const selected = picked ?? outcome?.answers[question.id] ?? question.defaults;
+    const pick = /* @__PURE__ */ __name((values) => options.pick(toolCallId, question.id, values), "pick");
+    return {
+      id: question.id,
+      prompt: question.prompt,
+      multiple: question.multiple,
+      position: index + 1,
+      selected,
+      isPristine: isPending ? picked === void 0 : outcome?.defaulted.includes(question.id) ?? true,
+      options: question.options.map((option) => ({
+        value: option.value,
+        label: option.label,
+        hotkey: option.hotkey,
+        isSelected: selected.includes(option.value),
+        isDefault: question.defaults.includes(option.value),
+        select: /* @__PURE__ */ __name(() => {
+          if (!isPending) {
+            return;
+          }
+          if (!question.multiple) {
+            pick([
+              option.value
+            ]);
+            return;
+          }
+          pick(selected.includes(option.value) ? selected.filter((value) => value !== option.value) : [
+            ...selected,
+            option.value
+          ]);
+        }, "select")
+      }))
+    };
+  });
+  const isSubmitting = isPending && options.isSubmitting(toolCallId);
+  return {
+    kind: "elicitation",
+    key,
+    toolCallId,
+    preamble: request.preamble,
+    questions,
+    questionCount: questions.length,
+    isPending,
+    outcome,
+    error: options.errorOf(toolCallId),
+    answer: {
+      available: isPending && options.canAnswer,
+      isSubmitting,
+      run: /* @__PURE__ */ __name(() => options.answer(toolCallId), "run")
+    },
+    skip: {
+      available: isPending && options.canSkip,
+      isSubmitting,
+      run: /* @__PURE__ */ __name(() => options.skip(toolCallId), "run")
     }
+  };
+}
+__name(buildElicitationBlock, "buildElicitationBlock");
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+__name(isRecord, "isRecord");
+function readQuery(part) {
+  const input = part.input;
+  if (!isRecord(input) || typeof input.query !== "string") {
+    return null;
   }
-  __name(handleCopy, "handleCopy");
-  return /* @__PURE__ */ React2.createElement("button", {
-    type: "button",
-    onClick: /* @__PURE__ */ __name(() => void handleCopy(), "onClick"),
-    className,
-    title: copied ? "Copied!" : "Copy message text"
-  }, copied ? "Copied" : "Copy");
+  return input.query;
 }
-__name(CopyButton, "CopyButton");
-function UsageInline({ usage, className }) {
-  const total = usage.inputTokens + usage.outputTokens;
-  return /* @__PURE__ */ React2.createElement("span", {
-    className,
-    title: `Input ${usage.inputTokens.toLocaleString()} \xB7 Output ${usage.outputTokens.toLocaleString()} tokens`
-  }, formatCostUsd(usage.costUsd), " \xB7 ", formatTokensShort(total));
+__name(readQuery, "readQuery");
+function readPassages(part) {
+  const output = part.output;
+  if (!isRecord(output) || !Array.isArray(output.passages) || output.passages.length === 0) {
+    return null;
+  }
+  const passages = [];
+  for (const candidate of output.passages) {
+    if (!isRecord(candidate) || typeof candidate.id !== "string" || typeof candidate.text !== "string") {
+      return null;
+    }
+    passages.push({
+      id: candidate.id,
+      text: candidate.text,
+      score: typeof candidate.score === "number" ? candidate.score : 0,
+      ...typeof candidate.source === "string" ? {
+        source: candidate.source
+      } : {},
+      ...isRecord(candidate.metadata) ? {
+        metadata: candidate.metadata
+      } : {}
+    });
+  }
+  return passages;
 }
-__name(UsageInline, "UsageInline");
-function TimestampInline({ createdAt, className }) {
-  const parsed = new Date(createdAt);
-  if (Number.isNaN(parsed.getTime())) {
+__name(readPassages, "readPassages");
+function extractMessageText(parts) {
+  const out = [];
+  for (const part of parts ?? []) {
+    if (isTextUIPart(part)) {
+      out.push(part.text);
+    }
+  }
+  return out.join("\n\n").trim();
+}
+__name(extractMessageText, "extractMessageText");
+function describeUsage(usage) {
+  const totalTokens = usage.inputTokens + usage.outputTokens;
+  return {
+    ...usage,
+    totalTokens,
+    costLabel: formatCostUsd(usage.costUsd),
+    tokensLabel: formatTokensShort(totalTokens)
+  };
+}
+__name(describeUsage, "describeUsage");
+function describeTimestamp(createdAt) {
+  if (createdAt == null) {
     return null;
   }
-  const absolute = parsed.toLocaleString(void 0, {
-    dateStyle: "medium",
-    timeStyle: "short"
-  });
-  return /* @__PURE__ */ React2.createElement("span", {
-    className,
-    title: absolute
-  }, formatRelativeTime(parsed));
+  const date = new Date(createdAt);
+  if (Number.isNaN(date.getTime())) {
+    return null;
+  }
+  return {
+    iso: createdAt,
+    date,
+    relative: formatRelativeTime(date),
+    absolute: date.toLocaleString(void 0, {
+      dateStyle: "medium",
+      timeStyle: "short"
+    })
+  };
 }
-__name(TimestampInline, "TimestampInline");
+__name(describeTimestamp, "describeTimestamp");
 var RELATIVE_TIME = new Intl.RelativeTimeFormat(void 0, {
   numeric: "auto",
   style: "narrow"
@@ -1271,6 +1244,9 @@ function formatTokensShort(n) {
 }
 __name(formatTokensShort, "formatTokensShort");
 function formatCostUsd(cost) {
+  if (cost === null) {
+    return "\u2014";
+  }
   if (cost === 0) {
     return "$0";
   }
@@ -1283,142 +1259,799 @@ function formatCostUsd(cost) {
   return `$${cost.toFixed(2)}`;
 }
 __name(formatCostUsd, "formatCostUsd");
-function extractText2(parts) {
-  const out = [];
-  for (const part of parts) {
-    if (isTextUIPart(part)) {
-      out.push(part.text);
+
+// src/transcript/use-stick-to-bottom.ts
+import { useCallback as useCallback2, useEffect as useEffect3, useRef as useRef2, useState as useState3 } from "react";
+function useStickToBottom({ contentKey, threshold = 32 }) {
+  const containerRef = useRef2(null);
+  const [isAtBottom, setIsAtBottom] = useState3(true);
+  const measure = useCallback2(() => {
+    const element = containerRef.current;
+    if (!element) {
+      return;
     }
-  }
-  return out.join("\n\n").trim();
+    const distance = element.scrollHeight - element.scrollTop - element.clientHeight;
+    setIsAtBottom(distance <= threshold);
+  }, [
+    threshold
+  ]);
+  const scrollToBottom = useCallback2(() => {
+    const element = containerRef.current;
+    if (!element) {
+      return;
+    }
+    element.scrollTop = element.scrollHeight;
+    setIsAtBottom(true);
+  }, []);
+  const setContainer = useCallback2((element) => {
+    containerRef.current = element;
+    if (element) {
+      measure();
+    }
+  }, [
+    measure
+  ]);
+  useEffect3(() => {
+    if (isAtBottom) {
+      scrollToBottom();
+    }
+  }, [
+    contentKey,
+    isAtBottom,
+    scrollToBottom
+  ]);
+  const getContainerProps = useCallback2(() => ({
+    ref: setContainer,
+    onScroll: measure
+  }), [
+    setContainer,
+    measure
+  ]);
+  return {
+    isAtBottom,
+    showJumpToLatest: !isAtBottom,
+    scrollToBottom,
+    getContainerProps
+  };
 }
-__name(extractText2, "extractText");
+__name(useStickToBottom, "useStickToBottom");
 
-// src/components/message-list.tsx
-import React3, { useState as useState5 } from "react";
+// src/transcript/use-chat-transcript.ts
 var DEFAULT_VISIBLE_COUNT = 50;
-var LOAD_EARLIER_STEP = 50;
-function MessageList({ messages, status, renderToolPart, renderToolGroup, renderText, onFork, editable, onEditSubmit, regeneratable, onRegenerate, getUsage, getCreatedAt, emptyState, typingIndicator, followUps, onFollowUpClick, error, onRetry, classNames }) {
-  const [visibleCount, setVisibleCount] = useState5(DEFAULT_VISIBLE_COUNT);
-  if (messages.length === 0 && status === "ready") {
-    return /* @__PURE__ */ React3.createElement("div", {
-      className: classNames?.empty
-    }, emptyState);
-  }
+var DEFAULT_LOAD_EARLIER_STEP = 50;
+var DEFAULT_COPY_RESET_MS = 1500;
+function useChatTranscript(options) {
+  const { messages, status, initialVisibleCount = DEFAULT_VISIBLE_COUNT, loadEarlierStep = DEFAULT_LOAD_EARLIER_STEP, followUps, stickToBottomThreshold } = options;
+  const latest = useRef3(options);
+  latest.current = options;
+  const [visibleCount, setVisibleCount] = useState4(initialVisibleCount);
+  const [stopRequested, setStopRequested] = useState4(false);
+  const isStreaming = status === "streaming";
+  const isBusy = status === "submitted" || isStreaming;
+  const isEmpty = messages.length === 0;
+  useEffect4(() => {
+    if (!isBusy) {
+      setStopRequested(false);
+    }
+  }, [
+    isBusy
+  ]);
   const lastMessage = messages.at(-1);
-  const showTypingBubble = (status === "submitted" || status === "streaming") && lastMessage?.role !== "assistant";
-  const showFollowUps = status === "ready" && !showTypingBubble && lastMessage?.role === "assistant" && onFollowUpClick !== void 0 && !!followUps && followUps.length > 0;
+  const lastAssistant = findLastAssistant(messages);
+  const streamingMessageId = isStreaming ? lastAssistant?.id ?? null : null;
   const visibleStart = Math.max(0, messages.length - visibleCount);
-  const visibleMessages = messages.slice(visibleStart);
-  const hiddenCount = visibleStart;
-  let lastAssistantIndex = -1;
-  for (let i = messages.length - 1; i >= 0; i--) {
-    if (messages[i]?.role === "assistant") {
-      lastAssistantIndex = i;
-      break;
+  const items = useTranscriptItems({
+    messages,
+    visibleStart,
+    streamingMessageId,
+    options
+  });
+  const stop = useCallback3(() => {
+    const current = latest.current;
+    if (current.status !== "submitted" && current.status !== "streaming") {
+      return;
+    }
+    setStopRequested(true);
+    void current.onStop?.();
+  }, []);
+  const loadEarlier = useCallback3(() => setVisibleCount((count) => count + (latest.current.loadEarlierStep ?? DEFAULT_LOAD_EARLIER_STEP)), []);
+  const showAll = useCallback3(() => setVisibleCount(latest.current.messages.length), []);
+  const scroll = useStickToBottom({
+    contentKey: contentSignature(messages),
+    ...stickToBottomThreshold !== void 0 ? {
+      threshold: stickToBottomThreshold
+    } : {}
+  });
+  const showTypingIndicator = isBusy && lastMessage?.role !== "assistant";
+  return {
+    items,
+    status,
+    isEmpty,
+    isBusy,
+    isStreaming,
+    showEmptyState: isEmpty && status === "ready",
+    showTypingIndicator,
+    showFollowUps: status === "ready" && !showTypingIndicator && lastMessage?.role === "assistant" && !!followUps && followUps.length > 0,
+    lastAssistantId: lastAssistant?.id ?? null,
+    window: {
+      visibleCount,
+      hiddenCount: visibleStart,
+      canLoadEarlier: visibleStart > 0,
+      loadEarlier,
+      showAll
+    },
+    scroll,
+    stop: {
+      available: isBusy && options.onStop !== void 0,
+      isStopping: stopRequested,
+      stop
     }
+  };
+}
+__name(useChatTranscript, "useChatTranscript");
+function useTranscriptItem(options) {
+  const { message, isStreaming = false } = options;
+  const messagesRef = useRef3([
+    message
+  ]);
+  if (messagesRef.current[0] !== message) {
+    messagesRef.current = [
+      message
+    ];
   }
-  return /* @__PURE__ */ React3.createElement("div", {
-    className: classNames?.root
-  }, hiddenCount > 0 ? /* @__PURE__ */ React3.createElement("button", {
-    type: "button",
-    className: classNames?.loadEarlier,
-    onClick: /* @__PURE__ */ __name(() => setVisibleCount((count) => count + LOAD_EARLIER_STEP), "onClick")
-  }, "Load earlier (", hiddenCount, " more)") : null, visibleMessages.map((message, index) => {
-    const absoluteIndex = visibleStart + index;
-    const isLastAssistant = absoluteIndex === lastAssistantIndex;
-    const usage = getUsage?.(message) ?? null;
-    const createdAt = getCreatedAt?.(message) ?? null;
-    return /* @__PURE__ */ React3.createElement(MessageItem, {
-      key: message.id,
+  const items = useTranscriptItems({
+    messages: messagesRef.current,
+    visibleStart: 0,
+    streamingMessageId: isStreaming ? message.id : null,
+    options
+  });
+  return items[0];
+}
+__name(useTranscriptItem, "useTranscriptItem");
+function useTranscriptItems({ messages, visibleStart, streamingMessageId, options }) {
+  const [drafts, setDrafts] = useState4(() => /* @__PURE__ */ new Map());
+  const [copied, setCopied] = useState4(() => /* @__PURE__ */ new Set());
+  const [openReasoning, setOpenReasoning] = useState4(() => /* @__PURE__ */ new Map());
+  const [picks, setPicks] = useState4(() => /* @__PURE__ */ new Map());
+  const [settling, setSettling] = useState4(() => /* @__PURE__ */ new Set());
+  const [settleErrors, setSettleErrors] = useState4(() => /* @__PURE__ */ new Map());
+  const latest = useRef3({
+    options,
+    drafts,
+    picks,
+    messages
+  });
+  latest.current = {
+    options,
+    drafts,
+    picks,
+    messages
+  };
+  const copyTimers = useRef3(/* @__PURE__ */ new Map());
+  useEffect4(() => () => {
+    for (const timer of copyTimers.current.values()) {
+      clearTimeout(timer);
+    }
+    copyTimers.current.clear();
+  }, []);
+  const callbackCache = useRef3(/* @__PURE__ */ new Map());
+  const reasoningToggleCache = useRef3(/* @__PURE__ */ new Map());
+  const toggleReasoning = useCallback3((key, open) => {
+    setOpenReasoning((current) => {
+      const next = new Map(current);
+      next.set(key, open ?? !(current.get(key) ?? false));
+      return next;
+    });
+  }, []);
+  const stableToggle = useCallback3((key) => {
+    let cached = reasoningToggleCache.current.get(key);
+    if (!cached) {
+      cached = /* @__PURE__ */ __name((open) => toggleReasoning(key, open), "cached");
+      reasoningToggleCache.current.set(key, cached);
+    }
+    return cached;
+  }, [
+    toggleReasoning
+  ]);
+  const pick = useCallback3((toolCallId, questionId, values) => {
+    setPicks((current) => new Map(current).set(pickKey(toolCallId, questionId), values));
+  }, []);
+  const settle = useCallback3((toolCallId, send) => {
+    setSettleErrors((current) => {
+      if (!current.has(toolCallId)) {
+        return current;
+      }
+      const next = new Map(current);
+      next.delete(toolCallId);
+      return next;
+    });
+    setSettling((current) => new Set(current).add(toolCallId));
+    const failed = /* @__PURE__ */ __name((error) => {
+      setSettling((current) => {
+        const next = new Set(current);
+        next.delete(toolCallId);
+        return next;
+      });
+      setSettleErrors((current) => new Map(current).set(toolCallId, error instanceof Error ? error.message : "Could not settle this"));
+    }, "failed");
+    try {
+      void Promise.resolve(send()).catch(failed);
+    } catch (error) {
+      failed(error);
+    }
+  }, []);
+  const answer = useCallback3((toolCallId) => {
+    const current = latest.current;
+    const onAnswer = current.options.onAnswer;
+    if (!onAnswer) {
+      return;
+    }
+    settle(toolCallId, () => onAnswer(toolCallId, answersFor(current.picks, toolCallId)));
+  }, [
+    settle
+  ]);
+  const skip = useCallback3((toolCallId) => {
+    const onSkip = latest.current.options.onSkip;
+    if (onSkip) {
+      settle(toolCallId, () => onSkip(toolCallId));
+    }
+  }, [
+    settle
+  ]);
+  const approve = useCallback3((toolCallId) => {
+    const onApprove = latest.current.options.onApprove;
+    if (onApprove) {
+      settle(toolCallId, () => onApprove(toolCallId));
+    }
+  }, [
+    settle
+  ]);
+  const reject = useCallback3((toolCallId) => {
+    const onReject = latest.current.options.onReject;
+    if (onReject) {
+      settle(toolCallId, () => onReject(toolCallId));
+    }
+  }, [
+    settle
+  ]);
+  const callbacksFor = useCallback3((id) => {
+    const cached = callbackCache.current.get(id);
+    if (cached) {
+      return cached;
+    }
+    const textFor = /* @__PURE__ */ __name(() => extractMessageText(latest.current.messages.find((message) => message.id === id)?.parts), "textFor");
+    const created = {
+      copy: /* @__PURE__ */ __name(() => {
+        const text = textFor();
+        if (!text) {
+          return;
+        }
+        const write = latest.current.options.writeClipboard ?? ((value) => navigator.clipboard.writeText(value));
+        void Promise.resolve().then(() => write(text)).then(() => {
+          setCopied((current) => new Set(current).add(id));
+          const existing = copyTimers.current.get(id);
+          if (existing) {
+            clearTimeout(existing);
+          }
+          copyTimers.current.set(id, setTimeout(() => {
+            copyTimers.current.delete(id);
+            setCopied((current) => {
+              const next = new Set(current);
+              next.delete(id);
+              return next;
+            });
+          }, latest.current.options.copyResetMs ?? DEFAULT_COPY_RESET_MS));
+        }).catch(() => {
+        });
+      }, "copy"),
+      startEdit: /* @__PURE__ */ __name(() => {
+        const text = textFor();
+        setDrafts((current) => new Map(current).set(id, text));
+      }, "startEdit"),
+      cancelEdit: /* @__PURE__ */ __name(() => {
+        setDrafts((current) => {
+          const next = new Map(current);
+          next.delete(id);
+          return next;
+        });
+      }, "cancelEdit"),
+      setDraft: /* @__PURE__ */ __name((value) => {
+        setDrafts((current) => new Map(current).set(id, value));
+      }, "setDraft"),
+      save: /* @__PURE__ */ __name(() => {
+        const next = (latest.current.drafts.get(id) ?? "").trim();
+        if (!next) {
+          return;
+        }
+        created.cancelEdit();
+        void latest.current.options.onEditSubmit?.(id, next);
+      }, "save"),
+      fork: /* @__PURE__ */ __name(() => {
+        void latest.current.options.onFork?.(id);
+      }, "fork"),
+      regenerate: /* @__PURE__ */ __name(() => {
+        void latest.current.options.onRegenerate?.(id);
+      }, "regenerate"),
+      textareaRef: /* @__PURE__ */ __name((element) => {
+        if (!element) {
+          return;
+        }
+        element.focus();
+        element.setSelectionRange(element.value.length, element.value.length);
+      }, "textareaRef"),
+      onTextareaChange: /* @__PURE__ */ __name((event) => {
+        created.setDraft(event.target.value);
+      }, "onTextareaChange"),
+      onTextareaKeyDown: /* @__PURE__ */ __name((event) => {
+        if (event.key === "Enter" && !event.shiftKey) {
+          event.preventDefault();
+          created.save();
+        }
+        if (event.key === "Escape") {
+          event.preventDefault();
+          created.cancelEdit();
+        }
+      }, "onTextareaKeyDown")
+    };
+    callbackCache.current.set(id, created);
+    return created;
+  }, []);
+  const lastAssistantId = findLastAssistant(messages)?.id ?? null;
+  const items = [];
+  for (let index = visibleStart; index < messages.length; index++) {
+    const message = messages[index];
+    if (!message) {
+      continue;
+    }
+    const callbacks = callbacksFor(message.id);
+    const draft = drafts.get(message.id);
+    const isEditing = draft !== void 0;
+    const text = extractMessageText(message.parts);
+    const usage = options.getUsage?.(message) ?? null;
+    const isUser = message.role === "user";
+    const isAssistant = message.role === "assistant";
+    const isLastAssistant = isAssistant && message.id === lastAssistantId;
+    items.push({
+      id: message.id,
       message,
-      ...renderToolPart ? {
-        renderToolPart
-      } : {},
-      ...renderToolGroup ? {
-        renderToolGroup
-      } : {},
-      ...renderText ? {
-        renderText
-      } : {},
-      ...classNames?.message ? {
-        classNames: classNames.message
-      } : {},
-      ...onFork ? {
-        onFork
-      } : {},
-      ...editable ? {
-        editable
-      } : {},
-      ...onEditSubmit ? {
-        onEditSubmit: /* @__PURE__ */ __name((text) => onEditSubmit(message.id, text), "onEditSubmit")
-      } : {},
-      ...regeneratable && isLastAssistant ? {
-        regeneratable
-      } : {},
-      ...onRegenerate ? {
-        onRegenerate: /* @__PURE__ */ __name(() => onRegenerate(message.id), "onRegenerate")
-      } : {},
-      ...usage !== null ? {
-        usage
-      } : {},
-      ...createdAt !== null ? {
-        createdAt
-      } : {},
-      isStreaming: status === "streaming" && isLastAssistant
+      role: message.role,
+      index,
+      isUser,
+      isAssistant,
+      isLastAssistant,
+      isStreaming: message.id === streamingMessageId,
+      blocks: buildTranscriptBlocks(message, {
+        isReasoningOpen: /* @__PURE__ */ __name((key, isStreamingRun) => openReasoning.get(key) ?? isStreamingRun, "isReasoningOpen"),
+        toggleReasoning: /* @__PURE__ */ __name((key, open) => stableToggle(key)(open), "toggleReasoning"),
+        ...options.sources !== void 0 ? {
+          sources: options.sources
+        } : {},
+        ...options.onAnswer !== void 0 ? {
+          elicitation: {
+            picked: /* @__PURE__ */ __name((toolCallId, questionId) => picks.get(pickKey(toolCallId, questionId)), "picked"),
+            pick,
+            canAnswer: true,
+            canSkip: options.onSkip !== void 0,
+            answer,
+            skip,
+            isSubmitting: /* @__PURE__ */ __name((toolCallId) => settling.has(toolCallId), "isSubmitting"),
+            errorOf: /* @__PURE__ */ __name((toolCallId) => settleErrors.get(toolCallId) ?? null, "errorOf")
+          }
+        } : {},
+        ...options.onApprove !== void 0 || options.onReject !== void 0 ? {
+          approval: {
+            canApprove: options.onApprove !== void 0,
+            canReject: options.onReject !== void 0,
+            approve,
+            reject,
+            isSubmitting: /* @__PURE__ */ __name((toolCallId) => settling.has(toolCallId), "isSubmitting"),
+            errorOf: /* @__PURE__ */ __name((toolCallId) => settleErrors.get(toolCallId) ?? null, "errorOf")
+          }
+        } : {}
+      }),
+      text,
+      usage: usage ? describeUsage(usage) : null,
+      timestamp: describeTimestamp(options.getCreatedAt?.(message)),
+      copy: {
+        available: text.length > 0,
+        copied: copied.has(message.id),
+        copy: callbacks.copy
+      },
+      edit: {
+        available: isUser && options.editable === true && options.onEditSubmit !== void 0,
+        isEditing,
+        draft: draft ?? text,
+        canSave: (draft ?? "").trim().length > 0,
+        start: callbacks.startEdit,
+        cancel: callbacks.cancelEdit,
+        setDraft: callbacks.setDraft,
+        save: callbacks.save,
+        getTextareaProps: /* @__PURE__ */ __name(() => ({
+          ref: callbacks.textareaRef,
+          value: draft ?? text,
+          onChange: callbacks.onTextareaChange,
+          onKeyDown: callbacks.onTextareaKeyDown
+        }), "getTextareaProps")
+      },
+      fork: {
+        available: options.onFork !== void 0,
+        run: callbacks.fork
+      },
+      regenerate: {
+        available: isLastAssistant && options.regeneratable === true && options.onRegenerate !== void 0,
+        run: callbacks.regenerate
+      }
     });
-  }), showTypingBubble ? /* @__PURE__ */ React3.createElement("div", {
-    className: classNames?.typing
-  }, typingIndicator ?? "Thinking\u2026") : null, error && onRetry ? /* @__PURE__ */ React3.createElement("div", {
-    className: classNames?.error
-  }, /* @__PURE__ */ React3.createElement("span", null, error.message || "The assistant didn't respond."), /* @__PURE__ */ React3.createElement("button", {
-    type: "button",
-    className: classNames?.errorRetry,
-    onClick: /* @__PURE__ */ __name(() => void onRetry(), "onClick")
-  }, "Retry")) : null, showFollowUps ? /* @__PURE__ */ React3.createElement("div", {
-    className: classNames?.followUps
-  }, followUps.map((text) => /* @__PURE__ */ React3.createElement("button", {
-    key: text,
-    type: "button",
-    className: classNames?.followUpChip,
-    onClick: /* @__PURE__ */ __name(() => onFollowUpClick(text), "onClick")
-  }, text))) : null);
+  }
+  return items;
 }
-__name(MessageList, "MessageList");
-
-// src/components/speech-languages.ts
-var DEFAULT_SPEECH_LANG = "en-US";
-var SPEECH_LANGUAGES = [
-  {
-    tag: "en-US",
-    label: "English (US)"
-  },
-  {
-    tag: "en-GB",
-    label: "English (UK)"
-  },
-  {
-    tag: "pt-BR",
-    label: "Portuguese (Brazil)"
-  },
-  {
-    tag: "es-ES",
-    label: "Spanish (Spain)"
+__name(useTranscriptItems, "useTranscriptItems");
+function pickKey(toolCallId, questionId) {
+  return `${toolCallId}|${questionId}`;
+}
+__name(pickKey, "pickKey");
+function answersFor(picks, toolCallId) {
+  const prefix = `${toolCallId}|`;
+  const answers = {};
+  for (const [key, values] of picks) {
+    if (key.startsWith(prefix)) {
+      answers[key.slice(prefix.length)] = values;
+    }
   }
-];
-var STORAGE_KEY = "nestjs-agent-chat-speech-lang";
-function loadStoredSpeechLang() {
-  if (typeof window === "undefined") return DEFAULT_SPEECH_LANG;
-  try {
-    const raw = window.localStorage.getItem(STORAGE_KEY);
-    if (raw && SPEECH_LANGUAGES.some((language) => language.tag === raw)) {
-      return raw;
+  return answers;
+}
+__name(answersFor, "answersFor");
+function findLastAssistant(messages) {
+  for (let index = messages.length - 1; index >= 0; index--) {
+    const message = messages[index];
+    if (message?.role === "assistant") {
+      return message;
     }
-  } catch {
   }
-  return DEFAULT_SPEECH_LANG;
+  return void 0;
 }
-__name(loadStoredSpeechLang, "loadStoredSpeechLang");
+__name(findLastAssistant, "findLastAssistant");
+function contentSignature(messages) {
+  const last = messages.at(-1);
+  if (!last) {
+    return "0";
+  }
+  let length = 0;
+  for (const part of last.parts ?? []) {
+    if ("text" in part && typeof part.text === "string") {
+      length += part.text.length;
+    }
+  }
+  return `${messages.length}|${last.id}|${last.parts?.length ?? 0}|${length}`;
+}
+__name(contentSignature, "contentSignature");
+
+// src/components/message-item.tsx
+function MessageItem({ message, isStreaming = false, editable, onEditSubmit, regeneratable, onRegenerate, onFork, usage, createdAt, ...slots }) {
+  const item = useTranscriptItem({
+    message,
+    isStreaming,
+    ...editable !== void 0 ? {
+      editable
+    } : {},
+    ...onEditSubmit ? {
+      onEditSubmit: /* @__PURE__ */ __name((_id, next) => onEditSubmit(next), "onEditSubmit")
+    } : {},
+    ...onFork ? {
+      onFork
+    } : {},
+    ...regeneratable !== void 0 ? {
+      regeneratable
+    } : {},
+    ...onRegenerate ? {
+      onRegenerate: /* @__PURE__ */ __name(() => onRegenerate(), "onRegenerate")
+    } : {},
+    ...usage != null ? {
+      getUsage: /* @__PURE__ */ __name(() => usage, "getUsage")
+    } : {},
+    ...createdAt != null ? {
+      getCreatedAt: /* @__PURE__ */ __name(() => createdAt, "getCreatedAt")
+    } : {}
+  });
+  return /* @__PURE__ */ React3.createElement(MessageItemView, {
+    item,
+    ...slots
+  });
+}
+__name(MessageItem, "MessageItem");
+function MessageItemView({ item, ...slots }) {
+  const { classNames } = slots;
+  const actionRow = /* @__PURE__ */ React3.createElement("div", {
+    className: classNames?.actions,
+    "data-actions-for": item.role
+  }, item.copy.available ? /* @__PURE__ */ React3.createElement("button", {
+    type: "button",
+    onClick: item.copy.copy,
+    className: classNames?.actionButton,
+    title: item.copy.copied ? "Copied!" : "Copy message text"
+  }, item.copy.copied ? "Copied" : "Copy") : null, item.fork.available ? /* @__PURE__ */ React3.createElement("button", {
+    type: "button",
+    onClick: item.fork.run,
+    className: classNames?.actionButton,
+    title: "Fork thread from this message"
+  }, "Fork") : null, item.regenerate.available ? /* @__PURE__ */ React3.createElement("button", {
+    type: "button",
+    onClick: item.regenerate.run,
+    className: classNames?.actionButton,
+    title: "Regenerate response"
+  }, "Regenerate") : null, slots.meta, !item.isUser && item.usage ? /* @__PURE__ */ React3.createElement("span", {
+    className: classNames?.usage,
+    title: `Input ${item.usage.inputTokens.toLocaleString()} \xB7 Output ${item.usage.outputTokens.toLocaleString()} tokens`
+  }, item.usage.costLabel, " \xB7 ", item.usage.tokensLabel) : null, item.timestamp ? /* @__PURE__ */ React3.createElement("span", {
+    className: classNames?.timestamp,
+    title: item.timestamp.absolute
+  }, item.timestamp.relative) : null);
+  if (item.edit.available) {
+    return /* @__PURE__ */ React3.createElement(EditableUserBubble, {
+      item,
+      slots,
+      actions: actionRow
+    });
+  }
+  const className = joinClasses(classNames?.root, classNames?.byRole?.[item.role]);
+  return /* @__PURE__ */ React3.createElement("div", {
+    className,
+    "data-role": item.role,
+    "data-streaming": item.isStreaming ? "true" : void 0
+  }, /* @__PURE__ */ React3.createElement("div", null, renderBlocks(item, slots)), actionRow);
+}
+__name(MessageItemView, "MessageItemView");
+function renderBlocks(item, slots) {
+  const nodes = [];
+  for (const block of item.blocks) {
+    if (block.kind === "text") {
+      nodes.push(/* @__PURE__ */ React3.createElement("div", {
+        key: block.key,
+        className: slots.classNames?.text
+      }, slots.renderText ? slots.renderText(block.text, {
+        isStreaming: item.isStreaming
+      }) : block.text));
+      continue;
+    }
+    if (block.kind === "reasoning") {
+      nodes.push(renderReasoningBlock(block, slots));
+      continue;
+    }
+    if (block.kind === "files") {
+      nodes.push(renderFilesBlock(block, slots));
+      continue;
+    }
+    if (block.kind === "tools") {
+      nodes.push(...renderToolBlock(item, block, slots));
+    }
+  }
+  return nodes;
+}
+__name(renderBlocks, "renderBlocks");
+function renderFilesBlock(block, slots) {
+  return /* @__PURE__ */ React3.createElement("div", {
+    key: block.key,
+    className: slots.classNames?.files,
+    "data-files": "true"
+  }, slots.renderFiles ? slots.renderFiles(block.files) : block.files.map((file) => /* @__PURE__ */ React3.createElement("a", {
+    key: file.url,
+    href: file.url,
+    target: "_blank",
+    rel: "noreferrer",
+    className: slots.classNames?.file,
+    title: file.filename ?? file.mediaType
+  }, file.isImage ? /* @__PURE__ */ React3.createElement("img", {
+    src: file.url,
+    alt: file.filename ?? "image",
+    className: slots.classNames?.fileImage
+  }) : file.filename ?? file.mediaType)));
+}
+__name(renderFilesBlock, "renderFilesBlock");
+function renderReasoningBlock(block, slots) {
+  return /* @__PURE__ */ React3.createElement("div", {
+    key: block.key,
+    className: slots.classNames?.reasoning,
+    "data-reasoning": "true",
+    "data-streaming": block.isStreaming ? "true" : void 0
+  }, /* @__PURE__ */ React3.createElement("button", {
+    type: "button",
+    className: slots.classNames?.reasoningToggle,
+    onClick: /* @__PURE__ */ __name(() => block.toggle(), "onClick"),
+    "aria-expanded": block.isOpen
+  }, slots.reasoningLabel ?? "Reasoning"), block.isOpen ? /* @__PURE__ */ React3.createElement("div", {
+    className: slots.classNames?.reasoningText
+  }, slots.renderReasoning ? slots.renderReasoning(block.text, {
+    isStreaming: block.isStreaming,
+    isOpen: block.isOpen
+  }) : block.text) : null);
+}
+__name(renderReasoningBlock, "renderReasoningBlock");
+function renderToolBlock(item, block, slots) {
+  if (slots.renderToolGroup) {
+    return [
+      /* @__PURE__ */ React3.createElement(React3.Fragment, {
+        key: block.key
+      }, slots.renderToolGroup(block.parts, block.key))
+    ];
+  }
+  if (!slots.renderToolPart) {
+    return [];
+  }
+  const renderToolPart = slots.renderToolPart;
+  return block.parts.map((part) => {
+    const partKey = `${item.id}-${part.toolCallId}`;
+    return /* @__PURE__ */ React3.createElement(React3.Fragment, {
+      key: partKey
+    }, renderToolPart(part, partKey));
+  });
+}
+__name(renderToolBlock, "renderToolBlock");
+function EditableUserBubble({ item, slots, actions }) {
+  const { classNames } = slots;
+  const { edit } = item;
+  if (!edit.isEditing) {
+    return /* @__PURE__ */ React3.createElement("div", {
+      className: joinClasses(classNames?.root, classNames?.byRole?.user),
+      "data-role": "user"
+    }, /* @__PURE__ */ React3.createElement("div", {
+      className: classNames?.text
+    }, slots.renderText ? slots.renderText(item.text, {
+      isStreaming: false
+    }) : item.text), /* @__PURE__ */ React3.createElement("button", {
+      type: "button",
+      onClick: edit.start,
+      className: classNames?.actionButton,
+      title: "Edit & resubmit"
+    }, "Edit"), actions);
+  }
+  const textareaProps = edit.getTextareaProps();
+  return /* @__PURE__ */ React3.createElement("div", {
+    "data-editing": "true"
+  }, /* @__PURE__ */ React3.createElement("textarea", {
+    ...textareaProps,
+    rows: Math.min(8, edit.draft.split("\n").length + 1),
+    className: classNames?.editTextarea
+  }), /* @__PURE__ */ React3.createElement("div", {
+    className: classNames?.editActions
+  }, /* @__PURE__ */ React3.createElement("button", {
+    type: "button",
+    onClick: edit.cancel
+  }, "Cancel"), /* @__PURE__ */ React3.createElement("button", {
+    type: "button",
+    onClick: edit.save,
+    disabled: !edit.canSave
+  }, "Resend")));
+}
+__name(EditableUserBubble, "EditableUserBubble");
+function joinClasses(...entries) {
+  const joined = entries.filter((entry) => entry).join(" ");
+  return joined === "" ? void 0 : joined;
+}
+__name(joinClasses, "joinClasses");
+
+// src/components/message-list.tsx
+function MessageList({ messages, status, renderToolPart, renderToolGroup, renderText, renderReasoning, renderFiles, reasoningLabel, getMeta, onFork, editable, onEditSubmit, regeneratable, onRegenerate, getUsage, getCreatedAt, emptyState, typingIndicator, followUps, onFollowUpClick, error, onRetry, classNames }) {
+  const transcript = useChatTranscript({
+    messages,
+    status,
+    ...onFork ? {
+      onFork
+    } : {},
+    ...editable !== void 0 ? {
+      editable
+    } : {},
+    ...onEditSubmit ? {
+      onEditSubmit
+    } : {},
+    ...regeneratable !== void 0 ? {
+      regeneratable
+    } : {},
+    ...onRegenerate ? {
+      onRegenerate
+    } : {},
+    ...getUsage ? {
+      getUsage
+    } : {},
+    ...getCreatedAt ? {
+      getCreatedAt
+    } : {},
+    ...followUps !== void 0 ? {
+      followUps
+    } : {}
+  });
+  if (transcript.showEmptyState) {
+    return /* @__PURE__ */ React.createElement("div", {
+      className: classNames?.empty
+    }, emptyState);
+  }
+  const slots = {
+    ...renderToolPart ? {
+      renderToolPart
+    } : {},
+    ...renderToolGroup ? {
+      renderToolGroup
+    } : {},
+    ...renderText ? {
+      renderText
+    } : {},
+    ...renderReasoning ? {
+      renderReasoning
+    } : {},
+    ...renderFiles ? {
+      renderFiles
+    } : {},
+    ...reasoningLabel !== void 0 ? {
+      reasoningLabel
+    } : {},
+    ...classNames?.message ? {
+      classNames: classNames.message
+    } : {}
+  };
+  return /* @__PURE__ */ React.createElement("div", {
+    className: classNames?.root
+  }, transcript.window.canLoadEarlier ? /* @__PURE__ */ React.createElement("button", {
+    type: "button",
+    className: classNames?.loadEarlier,
+    onClick: transcript.window.loadEarlier
+  }, "Load earlier (", transcript.window.hiddenCount, " more)") : null, transcript.items.map((item) => /* @__PURE__ */ React.createElement(MessageItemView, {
+    key: item.id,
+    item,
+    ...slots,
+    ...getMeta ? {
+      meta: getMeta(item.message)
+    } : {}
+  })), transcript.showTypingIndicator ? /* @__PURE__ */ React.createElement("div", {
+    className: classNames?.typing
+  }, typingIndicator ?? "Thinking\u2026") : null, error && onRetry ? /* @__PURE__ */ React.createElement("div", {
+    className: classNames?.error
+  }, /* @__PURE__ */ React.createElement("span", null, error.message || "The assistant didn't respond."), /* @__PURE__ */ React.createElement("button", {
+    type: "button",
+    className: classNames?.errorRetry,
+    onClick: /* @__PURE__ */ __name(() => void onRetry(), "onClick")
+  }, "Retry")) : null, transcript.showFollowUps && onFollowUpClick && followUps ? /* @__PURE__ */ React.createElement("div", {
+    className: classNames?.followUps
+  }, followUps.map((text) => /* @__PURE__ */ React.createElement("button", {
+    key: text,
+    type: "button",
+    className: classNames?.followUpChip,
+    onClick: /* @__PURE__ */ __name(() => onFollowUpClick(text), "onClick")
+  }, text))) : null);
+}
+__name(MessageList, "MessageList");
+
+// src/components/speech-languages.ts
+var DEFAULT_SPEECH_LANG = "en-US";
+var SPEECH_LANGUAGES = [
+  {
+    tag: "en-US",
+    label: "English (US)"
+  },
+  {
+    tag: "en-GB",
+    label: "English (UK)"
+  },
+  {
+    tag: "pt-BR",
+    label: "Portuguese (Brazil)"
+  },
+  {
+    tag: "es-ES",
+    label: "Spanish (Spain)"
+  }
+];
+var STORAGE_KEY = "nestjs-agent-chat-speech-lang";
+function loadStoredSpeechLang() {
+  if (typeof window === "undefined") return DEFAULT_SPEECH_LANG;
+  try {
+    const raw = window.localStorage.getItem(STORAGE_KEY);
+    if (raw && SPEECH_LANGUAGES.some((language) => language.tag === raw)) {
+      return raw;
+    }
+  } catch {
+  }
+  return DEFAULT_SPEECH_LANG;
+}
+__name(loadStoredSpeechLang, "loadStoredSpeechLang");
 function persistSpeechLang(tag) {
   if (typeof window === "undefined") return;
   try {
@@ -1427,6 +2060,776 @@ function persistSpeechLang(tag) {
   }
 }
 __name(persistSpeechLang, "persistSpeechLang");
+
+// src/composer/model.ts
+var WHITESPACE = /\s/;
+function findActiveTrigger(text, caret, sources) {
+  const end = Math.max(0, Math.min(caret, text.length));
+  for (let index = end - 1; index >= 0; index--) {
+    const char = text[index];
+    if (char === void 0 || WHITESPACE.test(char)) {
+      return null;
+    }
+    const source = sources.find((candidate) => candidate.trigger === char);
+    if (source && isAllowedAt(text, index, source.position)) {
+      return {
+        source,
+        index,
+        query: text.slice(index + 1, end)
+      };
+    }
+  }
+  return null;
+}
+__name(findActiveTrigger, "findActiveTrigger");
+function isAllowedAt(text, index, position) {
+  if (index === 0) {
+    return true;
+  }
+  if (position === "start") {
+    return false;
+  }
+  const previous = text[index - 1];
+  return previous !== void 0 && WHITESPACE.test(previous);
+}
+__name(isAllowedAt, "isAllowedAt");
+function filterAutocompleteItems(items, query) {
+  const needle = query.trim().toLowerCase();
+  return items.filter((item) => item.label.toLowerCase().includes(needle) || (item.description?.toLowerCase().includes(needle) ?? false));
+}
+__name(filterAutocompleteItems, "filterAutocompleteItems");
+function applyCompletion(text, caret, match, item) {
+  const end = Math.max(match.index, Math.min(caret, text.length));
+  const inserted = `${match.source.trigger}${item.value ?? item.label}${match.source.insertSuffix ?? " "}`;
+  return {
+    text: text.slice(0, match.index) + inserted + text.slice(end),
+    caret: match.index + inserted.length
+  };
+}
+__name(applyCompletion, "applyCompletion");
+
+// src/composer/skills-source.ts
+function createSkillsSource(options) {
+  const byThread = /* @__PURE__ */ new Map();
+  return {
+    id: "skills",
+    label: options.label ?? "Skills",
+    trigger: options.trigger ?? "/",
+    position: "start",
+    getItems: /* @__PURE__ */ __name(() => {
+      const threadId = options.getThreadId?.();
+      const key = threadId ?? "";
+      const cached = byThread.get(key);
+      if (cached) {
+        return cached;
+      }
+      const pending = options.client.listSkills(threadId).then((entries) => entries.map(toItem)).catch((error) => {
+        byThread.delete(key);
+        throw error;
+      });
+      byThread.set(key, pending);
+      return pending;
+    }, "getItems")
+  };
+}
+__name(createSkillsSource, "createSkillsSource");
+function toItem(entry) {
+  const data = {
+    scope: entry.scope,
+    ...entry.shadows !== void 0 ? {
+      shadows: entry.shadows
+    } : {}
+  };
+  return {
+    id: entry.name,
+    label: entry.name,
+    description: entry.description,
+    // `shadows` is present only on a conflict, so saying "overrides" is never noise: without it a
+    // user cannot tell "there is no org default" from "there is one and mine wins".
+    hint: entry.shadows === void 0 ? entry.scope : `${entry.scope} \xB7 overrides ${entry.shadows.join(", ")}`,
+    data
+  };
+}
+__name(toItem, "toItem");
+
+// src/composer/use-composer-autocomplete.ts
+import { useCallback as useCallback4, useEffect as useEffect5, useId, useLayoutEffect, useMemo as useMemo2, useRef as useRef4, useState as useState5 } from "react";
+function useComposerAutocomplete(options) {
+  const { value, sources, acceptOnTab = true } = options;
+  const latest = useRef4(options);
+  latest.current = options;
+  const inputRef = useRef4(null);
+  const [caret, setCaret] = useState5(value.length);
+  const [items, setItems] = useState5([]);
+  const [isLoading, setLoading] = useState5(false);
+  const [error, setError] = useState5(null);
+  const [activeIndex, setActiveIndex] = useState5(0);
+  const [dismissedIndex, setDismissedIndex] = useState5(null);
+  const safeCaret = Math.min(caret, value.length);
+  const match = useMemo2(() => findActiveTrigger(value, safeCaret, sources), [
+    value,
+    safeCaret,
+    sources
+  ]);
+  const isActive = match !== null && dismissedIndex !== match.index;
+  const matchRef = useRef4(match);
+  matchRef.current = match;
+  const caretRef = useRef4(safeCaret);
+  caretRef.current = safeCaret;
+  const itemsRef = useRef4(items);
+  itemsRef.current = items;
+  const activeIndexRef = useRef4(activeIndex);
+  activeIndexRef.current = activeIndex;
+  const requestKey = isActive && match ? `${match.source.id}\0${match.query}` : null;
+  useEffect5(() => {
+    const current = matchRef.current;
+    if (requestKey === null || current === null) {
+      setItems([]);
+      setLoading(false);
+      setError(null);
+      return;
+    }
+    const { source, query } = current;
+    const controller = new AbortController();
+    let superseded = false;
+    const settle = /* @__PURE__ */ __name((next) => {
+      if (superseded) return;
+      setItems((source.filter ?? filterAutocompleteItems)(next, query));
+      setActiveIndex(0);
+      setLoading(false);
+      setError(null);
+    }, "settle");
+    const failed = /* @__PURE__ */ __name((cause) => {
+      if (superseded) return;
+      setItems([]);
+      setLoading(false);
+      setError(cause instanceof Error ? cause.message : "Could not load suggestions");
+      latest.current.onError?.(cause, source);
+    }, "failed");
+    let result;
+    try {
+      result = source.getItems(query, controller.signal);
+    } catch (cause) {
+      failed(cause);
+      return;
+    }
+    if (!isPromise(result)) {
+      settle(result);
+      return;
+    }
+    setLoading(true);
+    setError(null);
+    result.then(settle, failed);
+    return () => {
+      superseded = true;
+      controller.abort();
+    };
+  }, [
+    requestKey
+  ]);
+  const isOpen = isActive;
+  const activeItem = isOpen ? items[activeIndex] ?? null : null;
+  const reactId = useId();
+  const listboxId = options.id ?? `agent-autocomplete-${reactId}`;
+  const optionId = useCallback4((index) => `${listboxId}-option-${index}`, [
+    listboxId
+  ]);
+  const highlight = useCallback4((index) => {
+    const total = itemsRef.current.length;
+    if (total === 0) return;
+    setActiveIndex((index % total + total) % total);
+  }, []);
+  const moveHighlight = useCallback4((delta) => highlight(activeIndexRef.current + delta), [
+    highlight
+  ]);
+  const dismiss = useCallback4(() => {
+    const current = matchRef.current;
+    if (current) setDismissedIndex(current.index);
+  }, []);
+  const pendingCaret = useRef4(null);
+  const accept = useCallback4((item) => {
+    const current = matchRef.current;
+    if (!current) return;
+    const chosen = item ?? itemsRef.current[activeIndexRef.current];
+    if (!chosen) return;
+    const edit = applyCompletion(latest.current.value, caretRef.current, current, chosen);
+    latest.current.onValueChange(edit.text);
+    setCaret(edit.caret);
+    setDismissedIndex(null);
+    pendingCaret.current = edit.caret;
+  }, []);
+  useLayoutEffect(() => {
+    const position = pendingCaret.current;
+    if (position === null) return;
+    pendingCaret.current = null;
+    inputRef.current?.setSelectionRange(position, position);
+  });
+  const readCaret = useCallback4((element) => {
+    setCaret(element.selectionStart ?? element.value.length);
+  }, []);
+  const onKeyDown = useCallback4((event) => {
+    if (!isOpen) return;
+    const hasItems = itemsRef.current.length > 0;
+    switch (event.key) {
+      case "ArrowDown":
+        if (!hasItems) return;
+        event.preventDefault();
+        moveHighlight(1);
+        return;
+      case "ArrowUp":
+        if (!hasItems) return;
+        event.preventDefault();
+        moveHighlight(-1);
+        return;
+      case "Enter":
+        if (!hasItems) return;
+        event.preventDefault();
+        accept();
+        return;
+      case "Tab":
+        if (!acceptOnTab || event.shiftKey || !hasItems) return;
+        event.preventDefault();
+        accept();
+        return;
+      case "Escape":
+        event.preventDefault();
+        dismiss();
+        return;
+      default:
+        return;
+    }
+  }, [
+    isOpen,
+    acceptOnTab,
+    accept,
+    dismiss,
+    moveHighlight
+  ]);
+  const onChange = useCallback4((event) => {
+    readCaret(event.target);
+    const next = findActiveTrigger(event.target.value, event.target.selectionStart ?? event.target.value.length, latest.current.sources);
+    setDismissedIndex((current) => current !== null && next?.index === current ? current : null);
+  }, [
+    readCaret
+  ]);
+  const onSelect = useCallback4((event) => readCaret(event.currentTarget), [
+    readCaret
+  ]);
+  const onClick = useCallback4((event) => readCaret(event.currentTarget), [
+    readCaret
+  ]);
+  const setInput = useCallback4((element) => {
+    inputRef.current = element;
+  }, []);
+  const getInputProps = useCallback4(() => ({
+    ref: setInput,
+    onChange,
+    onKeyDown,
+    onSelect,
+    onClick,
+    role: "combobox",
+    "aria-expanded": isOpen,
+    "aria-autocomplete": "list",
+    "aria-haspopup": "listbox",
+    ...isOpen ? {
+      "aria-controls": listboxId
+    } : {},
+    ...activeItem ? {
+      "aria-activedescendant": optionId(activeIndex)
+    } : {}
+  }), [
+    setInput,
+    onChange,
+    onKeyDown,
+    onSelect,
+    onClick,
+    isOpen,
+    listboxId,
+    activeItem,
+    activeIndex,
+    optionId
+  ]);
+  const getListboxProps = useCallback4(() => ({
+    id: listboxId,
+    role: "listbox",
+    "aria-label": match?.source.label ?? match?.source.id ?? "Suggestions"
+  }), [
+    listboxId,
+    match
+  ]);
+  const getOptionProps = useCallback4((index) => ({
+    id: optionId(index),
+    role: "option",
+    "aria-selected": index === activeIndex
+  }), [
+    optionId,
+    activeIndex
+  ]);
+  return {
+    isOpen,
+    source: isOpen && match ? match.source : null,
+    trigger: isOpen && match ? match.source.trigger : null,
+    query: match?.query ?? "",
+    items,
+    activeIndex,
+    activeItem,
+    isLoading,
+    error,
+    highlight,
+    moveHighlight,
+    accept,
+    dismiss,
+    getInputProps,
+    getListboxProps,
+    getOptionProps
+  };
+}
+__name(useComposerAutocomplete, "useComposerAutocomplete");
+function isPromise(value) {
+  return typeof value.then === "function";
+}
+__name(isPromise, "isPromise");
+
+// src/stored-message-to-ui-message.ts
+function storedMessageToUiMessage(message) {
+  const parts = [];
+  if (message.content) {
+    parts.push({
+      type: "text",
+      text: message.content
+    });
+  }
+  for (const attachment of message.attachments ?? []) {
+    parts.push({
+      type: "file",
+      mediaType: attachment.contentType,
+      filename: attachment.name,
+      url: attachment.url
+    });
+  }
+  for (const call of message.toolCalls ?? []) {
+    const result = message.toolResults?.find((candidate) => candidate.id === call.id);
+    const toolKind2 = call.kind;
+    parts.push({
+      type: `tool-${call.name}`,
+      toolCallId: call.id,
+      ...toolKind2 !== void 0 ? {
+        toolMetadata: {
+          toolKind: toolKind2
+        }
+      } : {},
+      ...result !== void 0 ? {
+        state: "output-available",
+        input: call.input,
+        output: result.output
+      } : {
+        state: "input-available",
+        input: call.input
+      }
+    });
+  }
+  return {
+    id: message.id,
+    role: message.role,
+    parts
+  };
+}
+__name(storedMessageToUiMessage, "storedMessageToUiMessage");
+
+// src/stored-thread-to-ui-messages.ts
+function storedThreadToUiMessages(messages) {
+  const turns = [];
+  for (const message of messages) {
+    const currentTurn = turns.at(-1);
+    const previousRow = currentTurn?.at(-1);
+    if (message.role === "assistant" && previousRow?.role === "assistant" && currentTurn && sameRun(previousRow, message)) {
+      currentTurn.push(message);
+    } else {
+      turns.push([
+        message
+      ]);
+    }
+  }
+  return turns.map(mergeTurn);
+}
+__name(storedThreadToUiMessages, "storedThreadToUiMessages");
+function sameRun(previous, next) {
+  return previous.runId === void 0 || next.runId === void 0 || previous.runId === next.runId;
+}
+__name(sameRun, "sameRun");
+function mergeTurn(rows) {
+  const lastRow = rows.at(-1);
+  if (lastRow === void 0) {
+    throw new Error("storedThreadToUiMessages: encountered an empty turn");
+  }
+  if (rows.length === 1) {
+    return storedMessageToUiMessage(lastRow);
+  }
+  const parts = rows.flatMap((row) => storedMessageToUiMessage(row).parts);
+  const usage = sumUsage(rows);
+  return {
+    id: lastRow.id,
+    role: lastRow.role,
+    parts,
+    ...usage !== void 0 ? {
+      metadata: {
+        usage
+      }
+    } : {}
+  };
+}
+__name(mergeTurn, "mergeTurn");
+function sumUsage(rows) {
+  const usages = rows.map((row) => row.usage).filter((usage) => usage !== void 0);
+  if (usages.length === 0) {
+    return void 0;
+  }
+  const allCostsUnknown = usages.every((usage) => usage.costUsd === null || usage.costUsd === void 0);
+  return {
+    inputTokens: usages.reduce((sum, usage) => sum + usage.inputTokens, 0),
+    outputTokens: usages.reduce((sum, usage) => sum + usage.outputTokens, 0),
+    costUsd: allCostsUnknown ? null : usages.reduce((sum, usage) => sum + (usage.costUsd ?? 0), 0)
+  };
+}
+__name(sumUsage, "sumUsage");
+
+// src/use-agent-chat.ts
+import { useChat } from "@ai-sdk/react";
+import { useCallback as useCallback5, useEffect as useEffect6, useMemo as useMemo3, useRef as useRef5, useState as useState6 } from "react";
+function useAgentChat(options) {
+  const latest = useRef5(options);
+  latest.current = options;
+  const [runId, setRunId] = useState6(options.resumeRunId);
+  const runIdRef = useRef5(runId);
+  runIdRef.current = runId;
+  const settlingRunIdRef = useRef5(void 0);
+  const autoResumeRunIdRef = useRef5(void 0);
+  const [autoResume, setAutoResume] = useState6(false);
+  const [activeRunId, setActiveRunId] = useState6(null);
+  const regenerateNext = useRef5(false);
+  const createdThreadId = useRef5(void 0);
+  const client = useMemo3(() => {
+    if (options.client) return options.client;
+    return new AgentClient({
+      ...options.baseUrl !== void 0 ? {
+        baseUrl: options.baseUrl
+      } : {},
+      ...options.credentials !== void 0 ? {
+        credentials: options.credentials
+      } : {},
+      ...options.fetch !== void 0 ? {
+        fetch: options.fetch
+      } : {},
+      getHeaders: /* @__PURE__ */ __name(async () => mergeHeaders(latest.current), "getHeaders")
+    });
+  }, []);
+  useEffect6(() => {
+    if (!options.resume || options.threadId === void 0) return;
+    let cancelled = false;
+    const threadId = options.threadId;
+    void client.getThread(threadId).then((thread) => {
+      if (cancelled) return;
+      setActiveRunId(thread.activeRunId ?? null);
+      if (thread.activeRunId != null) {
+        autoResumeRunIdRef.current = thread.activeRunId;
+        setAutoResume(true);
+      }
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [
+    client,
+    options.resume,
+    options.threadId
+  ]);
+  const transport = useMemo3(() => {
+    function onMeta(meta) {
+      settlingRunIdRef.current = meta.runId;
+      setRunId(meta.runId);
+      if (latest.current.threadId === void 0 && meta.threadId && createdThreadId.current !== meta.threadId) {
+        createdThreadId.current = meta.threadId;
+        latest.current.onThreadCreated?.(meta.threadId);
+      }
+    }
+    __name(onMeta, "onMeta");
+    return new AgentChatTransport({
+      ...options.baseUrl !== void 0 ? {
+        baseUrl: options.baseUrl
+      } : {},
+      ...options.credentials !== void 0 ? {
+        credentials: options.credentials
+      } : {},
+      ...options.fetch !== void 0 ? {
+        fetch: options.fetch
+      } : {},
+      ...options.agent !== void 0 ? {
+        agent: options.agent
+      } : {},
+      getHeaders: /* @__PURE__ */ __name(async () => mergeHeaders(latest.current), "getHeaders"),
+      getBody: /* @__PURE__ */ __name(() => {
+        const current = latest.current;
+        const pageContext = current.getPageContext?.() ?? null;
+        const regenerate2 = regenerateNext.current;
+        regenerateNext.current = false;
+        const threadId = current.threadId ?? createdThreadId.current;
+        return {
+          ...threadId !== void 0 ? {
+            threadId
+          } : {},
+          ...pageContext ? {
+            pageContext
+          } : {},
+          ...regenerate2 ? {
+            regenerate: true
+          } : {}
+        };
+      }, "getBody"),
+      getResumeRunId: /* @__PURE__ */ __name(() => latest.current.resumeRunId ?? autoResumeRunIdRef.current, "getResumeRunId"),
+      onMeta,
+      onAttemptStart: /* @__PURE__ */ __name(() => {
+        settlingRunIdRef.current = void 0;
+      }, "onAttemptStart")
+    });
+  }, []);
+  const backgroundRef = useRef5(() => Promise.resolve());
+  const chat = useChat({
+    transport,
+    resume: options.resumeRunId !== void 0 || autoResume,
+    ...options.threadId !== void 0 ? {
+      id: options.threadId
+    } : {},
+    ...options.initialMessages !== void 0 ? {
+      messages: options.initialMessages
+    } : {},
+    onFinish: /* @__PURE__ */ __name(({ isError }) => {
+      latest.current.onFinish?.();
+      if (latest.current.background === true) {
+        void backgroundRef.current();
+      }
+      const settledRunId = settlingRunIdRef.current;
+      if (settledRunId !== void 0) {
+        latest.current.onRunSettled?.({
+          runId: settledRunId,
+          status: isError ? "failed" : "completed"
+        });
+      }
+    }, "onFinish")
+  });
+  const chatRef = useRef5(chat);
+  chatRef.current = chat;
+  const turnInFlight = useRef5(false);
+  const isTurnInFlight = useCallback5(() => turnInFlight.current || transport.isAttemptLive, [
+    transport
+  ]);
+  const sendMessage = useCallback5(async (...args) => {
+    if (isTurnInFlight()) return;
+    turnInFlight.current = true;
+    try {
+      await chatRef.current.sendMessage(...args);
+    } finally {
+      turnInFlight.current = false;
+    }
+  }, [
+    isTurnInFlight
+  ]);
+  const addToolResult = useCallback5(({ tool, toolCallId, output }) => chatRef.current.addToolResult({
+    tool,
+    toolCallId,
+    output
+  }), []);
+  const [threads, setThreads] = useState6([]);
+  const [quota, setQuota] = useState6(null);
+  const [backgroundRuns, setBackgroundRuns] = useState6([]);
+  const refreshBackground = useCallback5(async () => {
+    const threadId = latest.current.threadId ?? createdThreadId.current;
+    if (threadId === void 0) {
+      return;
+    }
+    const thread = await client.getThread(threadId);
+    const runs = backgroundRunsFromThread(thread.messages);
+    setBackgroundRuns(runs);
+    const landed = runs.map((run) => run.message).filter((message) => message !== void 0);
+    if (landed.length === 0) {
+      return;
+    }
+    chatRef.current.setMessages((current) => {
+      const known = new Set(current.map((message) => message.id));
+      const missing = landed.filter((message) => !known.has(message.id));
+      return missing.length === 0 ? current : [
+        ...current,
+        ...missing.map((message) => storedMessageToUiMessage(message))
+      ];
+    });
+  }, [
+    client
+  ]);
+  backgroundRef.current = refreshBackground;
+  const isWorking = backgroundRuns.some((run) => run.status === "running");
+  useEffect6(() => {
+    if (options.background !== true || options.threadId === void 0) {
+      return;
+    }
+    void refreshBackground();
+  }, [
+    options.background,
+    options.threadId,
+    refreshBackground
+  ]);
+  useEffect6(() => {
+    const every = latest.current.backgroundPollMs ?? 5e3;
+    if (latest.current.background !== true || !isWorking || every <= 0) {
+      return;
+    }
+    const timer = setInterval(() => void refreshBackground(), every);
+    return () => clearInterval(timer);
+  }, [
+    isWorking,
+    refreshBackground
+  ]);
+  const loadThreads = useCallback5(async () => {
+    const list = await client.listThreads();
+    setThreads(list);
+    return list;
+  }, [
+    client
+  ]);
+  const loadThread = useCallback5((id) => client.getThread(id), [
+    client
+  ]);
+  const deleteThread = useCallback5(async (id) => {
+    await client.deleteThread(id);
+    setThreads((current) => current.filter((thread) => thread.id !== id));
+  }, [
+    client
+  ]);
+  const forkThread = useCallback5((threadId, messageId) => client.forkFromMessage(threadId, messageId), [
+    client
+  ]);
+  const renameThread = useCallback5(async (id, title) => {
+    await client.renameThread(id, title);
+    setThreads((current) => current.map((thread) => thread.id === id ? {
+      ...thread,
+      title
+    } : thread));
+  }, [
+    client
+  ]);
+  const promoteThread = useCallback5(async (id) => {
+    await client.promoteThread(id);
+    await loadThreads();
+  }, [
+    client,
+    loadThreads
+  ]);
+  const truncateFromMessage = useCallback5((threadId, messageId) => client.truncateFromMessage(threadId, messageId).then(() => void 0), [
+    client
+  ]);
+  const loadQuota = useCallback5(async () => {
+    const today = await client.getQuotaToday();
+    setQuota(today);
+    return today;
+  }, [
+    client
+  ]);
+  const cancel = useCallback5(async () => {
+    chatRef.current.stop();
+    const activeRunId2 = runIdRef.current;
+    if (activeRunId2) {
+      try {
+        await client.cancelStream(activeRunId2);
+      } catch {
+      }
+    }
+  }, [
+    client
+  ]);
+  const approve = useCallback5(async ({ toolCallId }) => {
+    await client.approveToolCall({
+      toolCallId
+    });
+  }, [
+    client
+  ]);
+  const reject = useCallback5(async ({ toolCallId, reason }) => {
+    await client.rejectToolCall({
+      toolCallId,
+      ...reason !== void 0 ? {
+        reason
+      } : {}
+    });
+  }, [
+    client
+  ]);
+  const answer = useCallback5(async ({ toolCallId, answers }) => {
+    await client.answerToolCall({
+      toolCallId,
+      ...answers !== void 0 ? {
+        answers
+      } : {}
+    });
+  }, [
+    client
+  ]);
+  const skip = useCallback5(async ({ toolCallId }) => {
+    await client.skipToolCall({
+      toolCallId
+    });
+  }, [
+    client
+  ]);
+  const regenerate = useCallback5(() => {
+    if (isTurnInFlight()) return;
+    regenerateNext.current = true;
+    turnInFlight.current = true;
+    void chatRef.current.regenerate().finally(() => {
+      turnInFlight.current = false;
+    });
+  }, [
+    isTurnInFlight
+  ]);
+  const background = {
+    runs: backgroundRuns,
+    isWorking,
+    refresh: refreshBackground
+  };
+  return {
+    ...chat,
+    sendMessage,
+    addToolResult,
+    /** Sub-agents this conversation started and did not wait for. */
+    background,
+    runId,
+    /** The `resume`-fetched thread's active run id, or `null` once resolved with none. */
+    activeRunId,
+    client,
+    threads,
+    loadThreads,
+    loadThread,
+    deleteThread,
+    forkThread,
+    renameThread,
+    promoteThread,
+    truncateFromMessage,
+    quota,
+    loadQuota,
+    cancel,
+    approve,
+    reject,
+    answer,
+    skip,
+    regenerate
+  };
+}
+__name(useAgentChat, "useAgentChat");
+async function mergeHeaders(options) {
+  const dynamic = await options.getHeaders?.() ?? {};
+  return {
+    ...options.headers,
+    ...dynamic
+  };
+}
+__name(mergeHeaders, "mergeHeaders");
 export {
   AgentChatTransport,
   AgentClient,
@@ -1434,14 +2837,28 @@ export {
   ChatInput,
   DEFAULT_SPEECH_LANG,
   MessageItem,
+  MessageItemView,
   MessageList,
   SPEECH_LANGUAGES,
+  applyCompletion,
+  backgroundRunsFromThread,
+  buildTranscriptBlocks,
+  createSkillsSource,
+  describeTimestamp,
+  describeUsage,
+  extractMessageText,
+  filterAutocompleteItems,
+  findActiveTrigger,
   formatRelativeTime,
   loadStoredSpeechLang,
   persistSpeechLang,
   storedMessageToUiMessage,
   storedThreadToUiMessages,
   useAgentChat,
-  useSpeechRecognition
+  useChatTranscript,
+  useComposerAutocomplete,
+  useSpeechRecognition,
+  useStickToBottom,
+  useTranscriptItem
 };
 //# sourceMappingURL=index.js.map