@dudousxd/nestjs-agent-react 0.21.0 → 0.22.1

package/dist/index.cjs

@@ -217,11 +217,6 @@ var AgentClient = class {
   forkFromMessage(threadId, messageId) {
     return this.request("POST", `/threads/${encodeURIComponent(threadId)}/fork-from/${encodeURIComponent(messageId)}`);
   }
-  renameThread(id, title) {
-    return this.updateThread(id, {
-      title
-    });
-  }
   /** General `PATCH <path>/threads/:threadId` — title and/or the thread's pinned default agent. */
   updateThread(id, patch) {
     return this.request("PATCH", `/threads/${encodeURIComponent(id)}`, patch);
@@ -314,9 +309,6 @@ var AgentClient = class {
   getQuota() {
     return this.request("GET", "/quota");
   }
-  getQuotaToday() {
-    return this.request("GET", "/quota/today");
-  }
   cancelStream(runId) {
     return this.request("POST", `/chat/${encodeURIComponent(runId)}/cancel`);
   }
@@ -728,13 +720,14 @@ var AgentChatTransport = class {
         function ensureStarted() {
           if (started) return;
           started = true;
-          controller.enqueue(streamRunId !== void 0 ? {
+          controller.enqueue({
             type: "start",
             messageMetadata: {
-              runId: streamRunId
+              ...streamRunId !== void 0 ? {
+                runId: streamRunId
+              } : {},
+              createdAt: (/* @__PURE__ */ new Date()).toISOString()
             }
-          } : {
-            type: "start"
           });
         }
         __name(ensureStarted, "ensureStarted");
@@ -3764,14 +3757,18 @@ function useTranscriptItems({ messages, visibleStart, streamingMessageId, option
   const [picks, setPicks] = (0, import_react16.useState)(() => /* @__PURE__ */ new Map());
   const [settling, setSettling] = (0, import_react16.useState)(() => /* @__PURE__ */ new Map());
   const [settleErrors, setSettleErrors] = (0, import_react16.useState)(() => /* @__PURE__ */ new Map());
+  const backend = useAgentBackend();
+  const handlers = settleHandlers(options, backend);
   const latest = (0, import_react16.useRef)({
     options,
+    handlers,
     drafts,
     picks,
     messages
   });
   latest.current = {
     options,
+    handlers,
     drafts,
     picks,
     messages
@@ -3831,34 +3828,46 @@ function useTranscriptItems({ messages, visibleStart, streamingMessageId, option
   }, []);
   const answer = (0, import_react16.useCallback)((toolCallId) => {
     const current = latest.current;
-    const onAnswer = current.options.onAnswer;
+    const onAnswer = current.handlers.onAnswer;
     if (!onAnswer) {
       return;
     }
-    settle(toolCallId, "answer", () => onAnswer(toolCallId, answersFor(current.picks, toolCallId)));
+    settle(toolCallId, "answer", () => onAnswer({
+      toolCallId,
+      answers: answersFor(current.picks, toolCallId)
+    }));
   }, [
     settle
   ]);
   const skip = (0, import_react16.useCallback)((toolCallId) => {
-    const onSkip = latest.current.options.onSkip;
+    const onSkip = latest.current.handlers.onSkip;
     if (onSkip) {
-      settle(toolCallId, "skip", () => onSkip(toolCallId));
+      settle(toolCallId, "skip", () => onSkip({
+        toolCallId
+      }));
     }
   }, [
     settle
   ]);
   const approve = (0, import_react16.useCallback)((toolCallId, options2) => {
-    const onApprove = latest.current.options.onApprove;
+    const onApprove = latest.current.handlers.onApprove;
     if (onApprove) {
-      settle(toolCallId, "approve", () => options2 === void 0 ? onApprove(toolCallId) : onApprove(toolCallId, options2));
+      settle(toolCallId, "approve", () => onApprove({
+        toolCallId,
+        ...options2?.remember === true ? {
+          remember: true
+        } : {}
+      }));
     }
   }, [
     settle
   ]);
   const reject = (0, import_react16.useCallback)((toolCallId) => {
-    const onReject = latest.current.options.onReject;
+    const onReject = latest.current.handlers.onReject;
     if (onReject) {
-      settle(toolCallId, "reject", () => onReject(toolCallId));
+      settle(toolCallId, "reject", () => onReject({
+        toolCallId
+      }));
     }
   }, [
     settle
@@ -3913,13 +3922,20 @@ function useTranscriptItems({ messages, visibleStart, streamingMessageId, option
           return;
         }
         created.cancelEdit();
-        void latest.current.options.onEditSubmit?.(id, next);
+        void latest.current.options.onEditSubmit?.({
+          messageId: id,
+          text: next
+        });
       }, "save"),
       fork: /* @__PURE__ */ __name(() => {
-        void latest.current.options.onFork?.(id);
+        void latest.current.options.onFork?.({
+          messageId: id
+        });
       }, "fork"),
       regenerate: /* @__PURE__ */ __name(() => {
-        void latest.current.options.onRegenerate?.(id);
+        void latest.current.options.onRegenerate?.({
+          messageId: id
+        });
       }, "regenerate"),
       textareaRef: /* @__PURE__ */ __name((element) => {
         if (!element) {
@@ -3956,7 +3972,7 @@ function useTranscriptItems({ messages, visibleStart, streamingMessageId, option
     const draft = drafts.get(message.id);
     const isEditing = draft !== void 0;
     const text = extractMessageText(message.parts);
-    const usage = options.getUsage?.(message) ?? null;
+    const usage = (options.getUsage ?? usageFromMetadata)(message);
     const isUser = message.role === "user";
     const isAssistant = message.role === "assistant";
     const isLastAssistant = isAssistant && message.id === lastAssistantId;
@@ -3978,22 +3994,22 @@ function useTranscriptItems({ messages, visibleStart, streamingMessageId, option
         ...options.toolCatalog !== void 0 ? {
           toolCatalog: options.toolCatalog
         } : {},
-        ...options.onAnswer !== void 0 ? {
+        ...handlers.onAnswer !== void 0 ? {
           elicitation: {
             picked: /* @__PURE__ */ __name((toolCallId, questionId) => picks.get(pickKey(toolCallId, questionId)), "picked"),
             pick,
             canAnswer: true,
-            canSkip: options.onSkip !== void 0,
+            canSkip: handlers.onSkip !== void 0,
             answer,
             skip,
             submitting: /* @__PURE__ */ __name((toolCallId) => settling.get(toolCallId) ?? null, "submitting"),
             errorOf: /* @__PURE__ */ __name((toolCallId) => settleErrors.get(toolCallId) ?? null, "errorOf")
           }
         } : {},
-        ...options.onApprove !== void 0 || options.onReject !== void 0 ? {
+        ...handlers.onApprove !== void 0 || handlers.onReject !== void 0 ? {
           approval: {
-            canApprove: options.onApprove !== void 0,
-            canReject: options.onReject !== void 0,
+            canApprove: handlers.onApprove !== void 0,
+            canReject: handlers.onReject !== void 0,
             approve,
             reject,
             submitting: /* @__PURE__ */ __name((toolCallId) => settling.get(toolCallId) ?? null, "submitting"),
@@ -4003,7 +4019,7 @@ function useTranscriptItems({ messages, visibleStart, streamingMessageId, option
       }),
       text,
       usage: usage ? describeUsage(usage) : null,
-      timestamp: describeTimestamp(options.getCreatedAt?.(message)),
+      timestamp: describeTimestamp((options.getCreatedAt ?? createdAtFromMetadata)(message)),
       copy: {
         available: text.length > 0,
         copied: copied.has(message.id),
@@ -4038,6 +4054,43 @@ function useTranscriptItems({ messages, visibleStart, streamingMessageId, option
   return items;
 }
 __name(useTranscriptItems, "useTranscriptItems");
+function settleHandlers(options, backend) {
+  const pick = /* @__PURE__ */ __name((own, fallback2) => own === null ? void 0 : own ?? fallback2, "pick");
+  return {
+    onAnswer: pick(options.onAnswer, backend.answerToolCall ? async (input) => {
+      await backend.answerToolCall?.(input);
+    } : void 0),
+    onSkip: pick(options.onSkip, backend.skipToolCall ? async (input) => {
+      await backend.skipToolCall?.(input);
+    } : void 0),
+    onApprove: pick(options.onApprove, backend.approveToolCall ? async (input) => {
+      await backend.approveToolCall?.(input);
+    } : void 0),
+    onReject: pick(options.onReject, backend.rejectToolCall ? async (input) => {
+      await backend.rejectToolCall?.(input);
+    } : void 0)
+  };
+}
+__name(settleHandlers, "settleHandlers");
+function metadataOf2(message) {
+  const metadata = message.metadata;
+  return metadata !== null && typeof metadata === "object" ? metadata : {};
+}
+__name(metadataOf2, "metadataOf");
+function usageFromMetadata(message) {
+  const usage = metadataOf2(message).usage;
+  if (usage === void 0) return null;
+  return {
+    inputTokens: usage.inputTokens,
+    outputTokens: usage.outputTokens,
+    costUsd: usage.costUsd ?? null
+  };
+}
+__name(usageFromMetadata, "usageFromMetadata");
+function createdAtFromMetadata(message) {
+  return metadataOf2(message).createdAt ?? null;
+}
+__name(createdAtFromMetadata, "createdAtFromMetadata");
 function pickKey(toolCallId, questionId) {
   return `${toolCallId}|${questionId}`;
 }
@@ -4087,7 +4140,7 @@ function MessageItem({ message, isStreaming = false, editable, onEditSubmit, reg
       editable
     } : {},
     ...onEditSubmit ? {
-      onEditSubmit: /* @__PURE__ */ __name((_id, next) => onEditSubmit(next), "onEditSubmit")
+      onEditSubmit
     } : {},
     ...onFork ? {
       onFork
@@ -4096,7 +4149,7 @@ function MessageItem({ message, isStreaming = false, editable, onEditSubmit, reg
       regeneratable
     } : {},
     ...onRegenerate ? {
-      onRegenerate: /* @__PURE__ */ __name(() => onRegenerate(), "onRegenerate")
+      onRegenerate
     } : {},
     ...usage != null ? {
       getUsage: /* @__PURE__ */ __name(() => usage, "getUsage")
@@ -4801,7 +4854,7 @@ function useToolCatalog(options = {}) {
     setLoading(true);
     load(client, agent).then((loaded) => {
       if (cancelled) return;
-      setEntries(loaded);
+      setEntries(Array.isArray(loaded) ? loaded : []);
       setError(null);
       setLoading(false);
     }, (failure) => {
@@ -5029,14 +5082,27 @@ function storedMessageToUiMessage(message) {
     });
     parts.push(...pushedByCall.get(call.id) ?? []);
   }
+  const metadata = {
+    ...message.feedback !== void 0 ? {
+      feedback: message.feedback
+    } : {},
+    ...message.createdAt ? {
+      createdAt: message.createdAt
+    } : {},
+    ...message.usage !== void 0 ? {
+      usage: {
+        inputTokens: message.usage.inputTokens,
+        outputTokens: message.usage.outputTokens,
+        costUsd: message.usage.costUsd ?? null
+      }
+    } : {}
+  };
   return {
     id: message.id,
     role: message.role,
     parts,
-    ...message.feedback !== void 0 ? {
-      metadata: {
-        feedback: message.feedback
-      }
+    ...Object.keys(metadata).length > 0 ? {
+      metadata
     } : {}
   };
 }
@@ -5074,12 +5140,16 @@ function mergeTurn(rows) {
   const parts = rows.flatMap((row) => storedMessageToUiMessage(row).parts);
   const usage = sumUsage(rows);
   const feedback = lastRow.feedback;
+  const createdAt = rows[0]?.createdAt;
   const metadata = {
     ...usage !== void 0 ? {
       usage
     } : {},
     ...feedback !== void 0 ? {
       feedback
+    } : {},
+    ...createdAt ? {
+      createdAt
     } : {}
   };
   return {
@@ -5109,50 +5179,61 @@ __name(sumUsage, "sumUsage");
 // src/use-agent-chat.ts
 var import_react21 = require("@ai-sdk/react");
 var import_react22 = require("react");
+var localChatSequence = 0;
+function localChatId() {
+  localChatSequence += 1;
+  return `local-chat-${localChatSequence}`;
+}
+__name(localChatId, "localChatId");
 function useAgentChat(options = {}) {
   const latest = (0, import_react22.useRef)(options);
   latest.current = options;
+  const resolved = useAgentBackend(options.backend);
+  const client = (0, import_react22.useRef)(resolved).current;
+  const createdThreadId = (0, import_react22.useRef)(void 0);
+  const chatIdRef = (0, import_react22.useRef)(options.threadId ?? localChatId());
+  const boundThreadRef = (0, import_react22.useRef)(options.threadId);
+  if (options.threadId !== boundThreadRef.current) {
+    boundThreadRef.current = options.threadId;
+    const adopting = options.threadId !== void 0 && options.threadId === createdThreadId.current;
+    if (!adopting) {
+      chatIdRef.current = options.threadId ?? localChatId();
+      createdThreadId.current = void 0;
+    }
+  }
+  const chatId = chatIdRef.current;
   const [runId, setRunId] = (0, import_react22.useState)(options.resumeRunId);
   const runIdRef = (0, import_react22.useRef)(runId);
   runIdRef.current = runId;
   const settlingRunIdRef = (0, import_react22.useRef)(void 0);
   const autoResumeRunIdRef = (0, import_react22.useRef)(void 0);
-  const [autoResume, setAutoResume] = (0, import_react22.useState)(false);
   const [activeRunId, setActiveRunId] = (0, import_react22.useState)(null);
+  const [isLoadingHistory, setIsLoadingHistory] = (0, import_react22.useState)(false);
+  const [historyError, setHistoryError] = (0, import_react22.useState)(null);
+  const [threadModel, setThreadModel] = (0, import_react22.useState)(null);
+  const [pickedModel, setPickedModel] = (0, import_react22.useState)(void 0);
+  const pickedModelRef = (0, import_react22.useRef)(pickedModel);
+  pickedModelRef.current = pickedModel;
+  const pendingPin = (0, import_react22.useRef)(void 0);
   const regenerateNext = (0, import_react22.useRef)(false);
-  const createdThreadId = (0, import_react22.useRef)(void 0);
-  const resolved = useAgentBackend(options.backend);
-  const client = (0, import_react22.useRef)(resolved).current;
+  const currentThreadId = (0, import_react22.useCallback)(() => latest.current.threadId ?? createdThreadId.current, []);
   const [connection, setConnection] = (0, import_react22.useState)({
     status: "live"
   });
   const resyncAfterSettle = (0, import_react22.useRef)(false);
-  (0, import_react22.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);
-      }
-    });
-    return () => {
-      cancelled = true;
-    };
-  }, [
-    client,
-    options.resume,
-    options.threadId
-  ]);
   const transport = (0, import_react22.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;
+        const pin = pendingPin.current;
+        if (pin !== void 0) {
+          pendingPin.current = void 0;
+          void client.updateThread(meta.threadId, {
+            model: pin.model
+          }).catch(() => void 0);
+        }
         latest.current.onThreadCreated?.(meta.threadId);
         notifyThreads(client, {
           type: "changed"
@@ -5179,13 +5260,14 @@ function useAgentChat(options = {}) {
         const pageContext = current.getPageContext?.() ?? null;
         const regenerate2 = regenerateNext.current;
         regenerateNext.current = false;
-        const threadId = current.threadId ?? createdThreadId.current;
+        const threadId = currentThreadId();
+        const model = current.model ?? pickedModelRef.current;
         return {
           ...threadId !== void 0 ? {
             threadId
           } : {},
-          ...current.model !== void 0 ? {
-            model: current.model
+          ...model !== void 0 ? {
+            model
           } : {},
           ...pageContext ? {
             pageContext
@@ -5205,10 +5287,8 @@ function useAgentChat(options = {}) {
   const backgroundRef = (0, import_react22.useRef)(() => Promise.resolve());
   const chat = (0, import_react21.useChat)({
     transport,
-    resume: options.resumeRunId !== void 0 || autoResume,
-    ...options.threadId !== void 0 ? {
-      id: options.threadId
-    } : {},
+    id: chatId,
+    resume: options.resumeRunId !== void 0,
     ...options.initialMessages !== void 0 ? {
       messages: options.initialMessages
     } : {},
@@ -5218,7 +5298,7 @@ function useAgentChat(options = {}) {
         const title = part.data?.title;
         if (typeof title === "string") {
           latest.current.onTitle?.(title);
-          const threadId = latest.current.threadId ?? createdThreadId.current;
+          const threadId = currentThreadId();
           if (threadId !== void 0) notifyThreads(client, {
             type: "title",
             threadId,
@@ -5254,7 +5334,7 @@ function useAgentChat(options = {}) {
   const chatRef = (0, import_react22.useRef)(chat);
   chatRef.current = chat;
   async function resyncFromThread() {
-    const threadId = latest.current.threadId ?? createdThreadId.current;
+    const threadId = currentThreadId();
     if (threadId === void 0) return;
     try {
       const thread = await client.getThread(threadId);
@@ -5263,13 +5343,75 @@ function useAgentChat(options = {}) {
     }
   }
   __name(resyncFromThread, "resyncFromThread");
+  const firstChatId = (0, import_react22.useRef)(chatId);
+  (0, import_react22.useEffect)(() => {
+    if (chatId === firstChatId.current) return;
+    firstChatId.current = chatId;
+    setRunId(void 0);
+    setActiveRunId(null);
+    setThreadModel(null);
+    setBackgroundRuns([]);
+    setHistoryError(null);
+    autoResumeRunIdRef.current = void 0;
+    pendingPin.current = void 0;
+  }, [
+    chatId
+  ]);
+  (0, import_react22.useEffect)(() => {
+    const threadId = options.threadId;
+    if (threadId === void 0) return;
+    if (threadId === createdThreadId.current) return;
+    const current = latest.current;
+    const wantHistory = current.history !== false && current.initialMessages === void 0;
+    const wantResume = current.resume !== false && current.resumeRunId === void 0;
+    if (!wantHistory && !wantResume) return;
+    let cancelled = false;
+    if (wantHistory) setIsLoadingHistory(true);
+    client.getThread(threadId).then((thread) => {
+      if (cancelled || thread == null) return;
+      const active = thread.activeRunId ?? null;
+      const stored = Array.isArray(thread.messages) ? thread.messages : [];
+      setActiveRunId(active);
+      setThreadModel(thread.model ?? null);
+      setHistoryError(null);
+      const resuming = wantResume && active !== null;
+      if (wantHistory && chatRef.current.messages.length === 0) {
+        const rows = resuming ? stored.filter((message) => !(message.role === "assistant" && message.runId === active)) : stored;
+        chatRef.current.setMessages(storedThreadToUiMessages(rows));
+      }
+      if (resuming) {
+        autoResumeRunIdRef.current = active;
+        void chatRef.current.resumeStream();
+      }
+    }, (error) => {
+      if (cancelled) return;
+      setHistoryError(error instanceof Error ? error : new Error(String(error)));
+    }).finally(() => {
+      if (!cancelled) setIsLoadingHistory(false);
+    });
+    return () => {
+      cancelled = true;
+      setIsLoadingHistory(false);
+    };
+  }, [
+    client,
+    chatId,
+    options.threadId
+  ]);
   const turnInFlight = (0, import_react22.useRef)(false);
   const isTurnInFlight = (0, import_react22.useCallback)(() => turnInFlight.current || transport.isAttemptLive, [
     transport
   ]);
+  const quota = useQuota({
+    backend: client,
+    enabled: options.quota !== false && typeof client.getQuota === "function"
+  });
+  const blocked = options.blocked !== void 0 ? options.blocked : quota.blocked;
+  const blockedRef = (0, import_react22.useRef)(blocked);
+  blockedRef.current = blocked;
   const sendMessage = (0, import_react22.useCallback)(async (...args) => {
-    const blocked = latest.current.blocked;
-    if (blocked != null) throw new QuotaBlockedError(blocked);
+    const block = blockedRef.current;
+    if (block != null) throw new QuotaBlockedError(block);
     if (isTurnInFlight()) return;
     turnInFlight.current = true;
     try {
@@ -5285,11 +5427,9 @@ function useAgentChat(options = {}) {
     toolCallId,
     output
   }), []);
-  const [threads, setThreads] = (0, import_react22.useState)([]);
-  const [quota, setQuota] = (0, import_react22.useState)(null);
   const [backgroundRuns, setBackgroundRuns] = (0, import_react22.useState)([]);
   const refreshBackground = (0, import_react22.useCallback)(async () => {
-    const threadId = latest.current.threadId ?? createdThreadId.current;
+    const threadId = currentThreadId();
     if (threadId === void 0) {
       return;
     }
@@ -5309,7 +5449,8 @@ function useAgentChat(options = {}) {
       ];
     });
   }, [
-    client
+    client,
+    currentThreadId
   ]);
   backgroundRef.current = refreshBackground;
   const isWorking = backgroundRuns.some((run) => run.status === "running");
@@ -5321,6 +5462,7 @@ function useAgentChat(options = {}) {
   }, [
     options.background,
     options.threadId,
+    chatId,
     refreshBackground
   ]);
   (0, import_react22.useEffect)(() => {
@@ -5334,59 +5476,12 @@ function useAgentChat(options = {}) {
     isWorking,
     refreshBackground
   ]);
-  const loadThreads = (0, import_react22.useCallback)(async () => {
-    const list = await client.listThreads();
-    setThreads(list);
-    return list;
-  }, [
-    client
-  ]);
-  const loadThread = (0, import_react22.useCallback)((id) => client.getThread(id), [
-    client
-  ]);
-  const deleteThread = (0, import_react22.useCallback)(async (id) => {
-    await client.deleteThread(id);
-    setThreads((current) => current.filter((thread) => thread.id !== id));
-  }, [
-    client
-  ]);
-  const forkThread = (0, import_react22.useCallback)((threadId, messageId) => requireBackendMethod(client, "forkFromMessage")(threadId, messageId), [
-    client
-  ]);
-  const renameThread = (0, import_react22.useCallback)(async (id, title) => {
-    await client.updateThread(id, {
-      title
-    });
-    setThreads((current) => current.map((thread) => thread.id === id ? {
-      ...thread,
-      title
-    } : thread));
-  }, [
-    client
-  ]);
-  const promoteThread = (0, import_react22.useCallback)(async (id) => {
-    await requireBackendMethod(client, "promoteThread")(id);
-    await loadThreads();
-  }, [
-    client,
-    loadThreads
-  ]);
-  const truncateFromMessage = (0, import_react22.useCallback)((threadId, messageId) => requireBackendMethod(client, "truncateFromMessage")(threadId, messageId).then(() => void 0), [
-    client
-  ]);
-  const loadQuota = (0, import_react22.useCallback)(async () => {
-    const today = await requireBackendMethod(client, "getQuotaToday")();
-    setQuota(today);
-    return today;
-  }, [
-    client
-  ]);
   const cancel = (0, import_react22.useCallback)(async () => {
     chatRef.current.stop();
-    const activeRunId2 = runIdRef.current;
-    if (activeRunId2) {
+    const active = runIdRef.current;
+    if (active) {
       try {
-        await client.cancelStream(activeRunId2);
+        await client.cancelStream(active);
       } catch {
       }
     }
@@ -5436,9 +5531,9 @@ function useAgentChat(options = {}) {
   }, [
     client
   ]);
-  const regenerate = (0, import_react22.useCallback)(() => {
-    const blocked = latest.current.blocked;
-    if (blocked != null) throw new QuotaBlockedError(blocked);
+  const regenerate = (0, import_react22.useCallback)((_input) => {
+    const block = blockedRef.current;
+    if (block != null) throw new QuotaBlockedError(block);
     if (isTurnInFlight()) return;
     regenerateNext.current = true;
     turnInFlight.current = true;
@@ -5448,15 +5543,78 @@ function useAgentChat(options = {}) {
   }, [
     isTurnInFlight
   ]);
-  const background = {
-    runs: backgroundRuns,
-    isWorking,
-    refresh: refreshBackground
-  };
-  const setThreadModel = (0, import_react22.useCallback)(async (model) => {
-    const threadId = latest.current.threadId ?? createdThreadId.current;
+  const storedIdOf = (0, import_react22.useCallback)(async (messageId, threadId) => {
+    const message = chatRef.current.messages.find((candidate) => candidate.id === messageId);
+    const runOf = message?.metadata?.runId;
+    if (runOf === void 0) return messageId;
+    const thread = await client.getThread(threadId);
+    const row = [
+      ...thread.messages
+    ].reverse().find((candidate) => candidate.role === "assistant" && candidate.runId === runOf);
+    return row?.id ?? messageId;
+  }, [
+    client
+  ]);
+  const fork = (0, import_react22.useCallback)(async ({ messageId, threadId }) => {
+    const source = threadId ?? currentThreadId();
+    if (source === void 0) throw new Error("fork: this chat has no thread yet");
+    const stored = await storedIdOf(messageId, source);
+    const forked = await requireBackendMethod(client, "forkFromMessage")(source, stored);
+    notifyThreads(client, {
+      type: "changed"
+    });
+    latest.current.onThreadCreated?.(forked.id);
+    return forked;
+  }, [
+    client,
+    currentThreadId,
+    storedIdOf
+  ]);
+  const truncateFrom = (0, import_react22.useCallback)(async ({ messageId, threadId }) => {
+    const target = threadId ?? currentThreadId();
+    if (target === void 0) throw new Error("truncateFrom: this chat has no thread yet");
+    const stored = await storedIdOf(messageId, target);
+    await requireBackendMethod(client, "truncateFromMessage")(target, stored);
+  }, [
+    client,
+    currentThreadId,
+    storedIdOf
+  ]);
+  const promote = (0, import_react22.useCallback)(async ({ threadId } = {}) => {
+    const target = threadId ?? currentThreadId();
+    if (target === void 0) throw new Error("promote: this chat has no thread yet");
+    await requireBackendMethod(client, "promoteThread")(target);
+    notifyThreads(client, {
+      type: "changed"
+    });
+  }, [
+    client,
+    currentThreadId
+  ]);
+  const [modelsWanted, setModelsWanted] = (0, import_react22.useState)(false);
+  const modelsWantedRef = (0, import_react22.useRef)(modelsWanted);
+  modelsWantedRef.current = modelsWanted;
+  const catalog = useModels({
+    backend: client,
+    ...options.agent !== void 0 ? {
+      agent: options.agent
+    } : {},
+    enabled: modelsWanted && typeof client.listModels === "function"
+  });
+  const wantModels = (0, import_react22.useCallback)(() => {
+    if (modelsWantedRef.current) return;
+    modelsWantedRef.current = true;
+    queueMicrotask(() => setModelsWanted(true));
+  }, []);
+  const selectModel = (0, import_react22.useCallback)((id) => setPickedModel(id), []);
+  const pinToThread = (0, import_react22.useCallback)(async (model) => {
+    const threadId = currentThreadId();
+    setThreadModel(model);
     if (threadId === void 0) {
-      throw new Error("setThreadModel: this chat has no thread yet");
+      pendingPin.current = {
+        model
+      };
+      return;
     }
     await client.updateThread(threadId, {
       model
@@ -5465,10 +5623,99 @@ function useAgentChat(options = {}) {
       type: "changed"
     });
   }, [
-    client
+    client,
+    currentThreadId
   ]);
-  const getThreadId = (0, import_react22.useCallback)(() => latest.current.threadId ?? createdThreadId.current, []);
+  const models = {
+    get list() {
+      wantModels();
+      return catalog.models;
+    },
+    get providers() {
+      wantModels();
+      return catalog.providers;
+    },
+    selected: options.model ?? pickedModel ?? threadModel ?? catalog.defaultModel ?? null,
+    select: selectModel,
+    pinToThread,
+    isLoading: modelsWanted && catalog.isLoading,
+    error: catalog.error
+  };
   const status = connection.status === "reconnecting" ? "reconnecting" : chat.status;
+  const isBusy = status === "submitted" || status === "streaming" || status === "reconnecting";
+  const files = useAttachments({
+    ...options.composer,
+    backend: client
+  });
+  const [text, setText] = (0, import_react22.useState)("");
+  const blockedBy = blocked != null ? "quota" : files.isUploading ? "uploading" : isBusy ? "busy" : text.trim().length === 0 && files.attachments.length === 0 ? "empty" : null;
+  const composerRef = (0, import_react22.useRef)({
+    text,
+    files,
+    blockedBy
+  });
+  composerRef.current = {
+    text,
+    files,
+    blockedBy
+  };
+  const submit = (0, import_react22.useCallback)(async () => {
+    const current = composerRef.current;
+    if (current.blockedBy !== null) return;
+    const refs = current.files.refs;
+    const draft = current.text.trim();
+    setText("");
+    current.files.clear();
+    await sendMessage({
+      text: draft
+    }, refs.length > 0 ? {
+      body: {
+        attachments: refs
+      }
+    } : void 0);
+  }, [
+    sendMessage
+  ]);
+  const composer = {
+    text,
+    setText,
+    files,
+    canSend: blockedBy === null,
+    blockedBy,
+    submit
+  };
+  const ownCatalog = options.transcript?.toolCatalog;
+  const tools = useToolCatalog({
+    backend: client,
+    ...options.agent !== void 0 ? {
+      agent: options.agent
+    } : {},
+    enabled: ownCatalog === void 0 && typeof client.listTools === "function"
+  });
+  const canFork = typeof client.forkFromMessage === "function";
+  const transcript = useChatTranscript({
+    messages: chat.messages,
+    status,
+    onStop: cancel,
+    onApprove: approve,
+    onReject: reject,
+    onAnswer: answer,
+    onSkip: skip,
+    regeneratable: true,
+    onRegenerate: regenerate,
+    ...canFork ? {
+      onFork: /* @__PURE__ */ __name((input) => fork(input).then(() => void 0), "onFork")
+    } : {},
+    ...ownCatalog === void 0 ? {
+      toolCatalog: tools.catalog
+    } : {},
+    ...options.transcript
+  });
+  const background = {
+    runs: backgroundRuns,
+    isWorking,
+    refresh: refreshBackground
+  };
   return {
     ...chat,
     status,
@@ -5479,32 +5726,38 @@ function useAgentChat(options = {}) {
     /** 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. */
+    /** The loaded thread's running turn, or `null` once read with none. */
     activeRunId,
+    /** The thread's history is being read. */
+    isLoadingHistory,
+    /** Reading the thread's history failed. */
+    historyError,
     /**
     * The thread this chat is on right now: the `threadId` option, else the one the backend created
     * on the first send. A getter, because the created id is learned mid-stream.
     */
-    getThreadId,
-    setThreadModel,
+    getThreadId: currentThreadId,
     /** The backend this chat talks to — the same one every other hook under the provider uses. */
     backend: client,
-    threads,
-    loadThreads,
-    loadThread,
-    deleteThread,
-    forkThread,
-    renameThread,
-    promoteThread,
-    truncateFromMessage,
+    /** The transcript model, with every action already bound to this chat. */
+    transcript,
+    /** A headless composer: draft, files, send gate, `submit()`. */
+    composer,
+    /** The model picker: `list`, `selected`, `select(id)`, `pinToThread(id)`. */
+    models,
+    /** The caller's budget (`GET <base>/quota`); `quota.blocked` gates sends. */
     quota,
-    loadQuota,
+    /** The window blocking sends right now (the `blocked` option, else the quota report's). */
+    blocked,
     cancel,
     approve,
     reject,
     answer,
     skip,
-    regenerate
+    regenerate,
+    fork,
+    truncateFrom,
+    promote
   };
 }
 __name(useAgentChat, "useAgentChat");