@deuz-sdk/react 2.1.0 → 2.3.0

package/dist/index.js

@@ -1,5 +1,5 @@
 import { useState, useRef, useCallback, useEffect } from 'react';
-import { filesToImageParts, uiFromMessages, createAssistantTurn, sealAssistantTurn, assistantMessageFromTurn, applyUIPart, clientToolResultMessage, userMessageFromInput, dropTrailingAssistant, branchBeforeUserMessage, canonicalFromUI } from '@deuz-sdk/core/chat';
+import { filesToImageParts, uiFromMessages, applyUIPart, clientToolResultMessage, assistantMessageFromTurn, createAssistantTurn, sealAssistantTurn, userMessageFromInput, dropTrailingAssistant, branchBeforeUserMessage, canonicalFromUI } from '@deuz-sdk/core/chat';
 import { readDeuzStream, connectDeuzStream } from '@deuz-sdk/core/ui';
 import { jsx, Fragment, jsxs } from 'react/jsx-runtime';
 
@@ -16,6 +16,126 @@ function foldPart(turn, part) {
   }
   return next;
 }
+function sameTarget(a, b) {
+  return a.approvalId === b.approvalId && a.token === b.token;
+}
+function answersRequest(verdict, request) {
+  return verdict.approvalId === request.approvalId && (verdict.token === void 0 || verdict.token === request.token);
+}
+function sameRequest(a, b) {
+  return sameTarget(a, b) && a.toolCallId === b.toolCallId && (a.agentPath ?? []).join("\0") === (b.agentPath ?? []).join("\0");
+}
+var newLedger = (cursor) => ({
+  answeredApprovals: /* @__PURE__ */ new Set(),
+  legs: /* @__PURE__ */ new Map(),
+  openLeg: /* @__PURE__ */ new Set(),
+  cursor
+});
+function recordPart(ledger, turn, part) {
+  switch (part.type) {
+    case "tool-result":
+      turn.approvals.forEach((request, index) => {
+        if (request.toolCallId === part.toolCallId) ledger.answeredApprovals.add(index);
+      });
+      return;
+    case "tool-call":
+      ledger.openLeg.add(invocationKey(part.toolCallId, part.toolName, part.input));
+      return;
+    case "finish":
+      for (const key of ledger.openLeg) ledger.legs.set(key, (ledger.legs.get(key) ?? 0) + 1);
+      ledger.openLeg.clear();
+      return;
+  }
+}
+var deliveries = (ledger, key) => Math.max(1, (ledger.legs.get(key) ?? 0) + (ledger.openLeg.has(key) ? 1 : 0));
+function isLaterId(id, cursor) {
+  return cursor !== void 0 && /^\d+$/.test(id) && /^\d+$/.test(cursor) && Number(id) > Number(cursor);
+}
+var NO_INDEXES = /* @__PURE__ */ new Set();
+function openApprovals(turn, answered) {
+  const open = [];
+  turn.approvals.forEach((request, index) => {
+    if (answered.has(index)) return;
+    const seen = open.findIndex((entry) => sameRequest(entry, request));
+    if (seen === -1) open.push(request);
+    else open[seen] = request;
+  });
+  return open;
+}
+function sortedKeys(_key, value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return value;
+  return Object.fromEntries(
+    Object.entries(value).sort(
+      ([a], [b]) => a < b ? -1 : a > b ? 1 : 0
+    )
+  );
+}
+function invocationKey(toolCallId, toolName, input) {
+  try {
+    return JSON.stringify([toolCallId, toolName, input ?? null], sortedKeys);
+  } catch {
+    return JSON.stringify([toolCallId, toolName]);
+  }
+}
+var keyOfCall = (call) => invocationKey(call.toolCallId, call.toolName, call.input);
+function answeredInvocations(history, behind) {
+  const answered = /* @__PURE__ */ new Map();
+  const results = /* @__PURE__ */ new Set();
+  for (let i = history.length - 1; i >= 0; i--) {
+    const message = history[i];
+    if (message.role === "user") break;
+    if (!Array.isArray(message.content)) continue;
+    for (const part of message.content) {
+      if (part.type === "tool_result") results.add(part.toolUseId);
+    }
+    if (message.role !== "assistant") continue;
+    for (const part of message.content) {
+      if (part.type === "tool_use" && results.delete(part.id) && !behind?.has(message)) {
+        const key = invocationKey(part.id, part.name, part.input);
+        answered.set(key, (answered.get(key) ?? 0) + 1);
+      }
+    }
+  }
+  return answered;
+}
+function asClientToolResult(answer) {
+  return {
+    toolCallId: answer.toolCallId,
+    output: answer.result,
+    ...answer.isError ? { isError: true } : {}
+  };
+}
+function nativeSuspension(turn) {
+  const agent = turn.agent;
+  if (agent?.status !== "suspended" || agent.runId === void 0) return void 0;
+  const cards = turn.message.toolCalls ?? [];
+  return {
+    runId: agent.runId,
+    approvals: agent.pendingApprovals,
+    clientCalls: agent.pendingClientCalls.map(
+      (call) => cards.find((card) => card.toolCallId === call.toolCallId && card.input !== void 0) ?? {
+        toolCallId: call.toolCallId,
+        toolName: call.toolName,
+        input: call.input,
+        state: "call"
+      }
+    )
+  };
+}
+function unansweredCalls(history) {
+  const results = /* @__PURE__ */ new Set();
+  const open = /* @__PURE__ */ new Set();
+  for (let i = history.length - 1; i >= 0; i--) {
+    const message = history[i];
+    if (message.role === "user") break;
+    if (!Array.isArray(message.content)) continue;
+    for (const part of message.content) {
+      if (part.type === "tool_result") results.add(part.toolUseId);
+      if (part.type === "tool_use" && !results.has(part.id)) open.add(part.id);
+    }
+  }
+  return open;
+}
 var defaultGenerateId = () => typeof crypto !== "undefined" && typeof crypto.randomUUID === "function" ? crypto.randomUUID() : `deuz-ui-${Math.random().toString(36).slice(2)}`;
 async function partsFromFiles(files) {
   if (!files) return [];
@@ -61,8 +181,18 @@ function useChat(options) {
   );
   const approvalsRef = useRef([]);
   const verdictsRef = useRef([]);
+  const nativeGateRef = useRef(void 0);
+  const parkedNativeRef = useRef(void 0);
+  const gateGenerationRef = useRef(0);
+  const priorResultsRef = useRef(
+    []
+  );
+  const executingRef = useRef(/* @__PURE__ */ new Set());
   const abortRef = useRef(null);
   const lastEventIdRef = useRef(options.resume?.lastEventId);
+  const cursorTurnRef = useRef(void 0);
+  const cursorLedgerRef = useRef(newLedger());
+  const behindCursorRef = useRef([]);
   const placedIdRef = useRef(void 0);
   const throttleMs = options.throttleMs ?? 0;
   const flushTimerRef = useRef(void 0);
@@ -104,7 +234,15 @@ function useChat(options) {
       const previous = snapshotRef.current;
       const placed = placedIdRef.current;
       const ui = previous.history.ui;
-      const index = placed === void 0 ? -1 : ui.findIndex((m) => m.id === placed);
+      let index = -1;
+      if (placed !== void 0) {
+        for (let i = ui.length - 1; i >= 0; i--) {
+          if (ui[i].id === placed) {
+            index = i;
+            break;
+          }
+        }
+      }
       placedIdRef.current = turn.message.id;
       commit({
         ...previous,
@@ -131,7 +269,9 @@ function useChat(options) {
         subAgents: turn.subAgents,
         steps: turn.steps,
         usage: turn.usage,
-        finishReason: turn.finishReason
+        finishReason: turn.finishReason,
+        stopDetails: turn.stopDetails,
+        agent: turn.agent
       });
     },
     [commit]
@@ -150,8 +290,11 @@ function useChat(options) {
     [commit]
   );
   const clearGates = useCallback(() => {
+    gateGenerationRef.current++;
     approvalsRef.current = [];
     verdictsRef.current = [];
+    nativeGateRef.current = void 0;
+    parkedNativeRef.current = void 0;
     clientToolsRef.current = [];
     toolResultsRef.current = [];
     parkedTurnRef.current = void 0;
@@ -162,7 +305,8 @@ function useChat(options) {
     (turn, part) => {
       const next = foldPart(turn, part);
       const onData = options.onData;
-      if (onData && typeof part.type === "string" && part.type.startsWith("data-")) {
+      const agentFrame = part.type === "data-agent" && next.dataParts === turn.dataParts;
+      if (onData && !agentFrame && typeof part.type === "string" && part.type.startsWith("data-")) {
         const data = part;
         try {
           onData({
@@ -173,6 +317,18 @@ function useChat(options) {
         } catch {
         }
       }
+      if (part.type === "tool-result" && !(turn.message.toolCalls ?? []).some(
+        (call) => call.toolCallId === part.toolCallId && call.input !== void 0
+      )) {
+        priorResultsRef.current = [
+          ...priorResultsRef.current,
+          {
+            toolCallId: part.toolCallId,
+            result: part.output,
+            ...part.isError ? { isError: true } : {}
+          }
+        ];
+      }
       return next;
     },
     [options.onData]
@@ -180,13 +336,123 @@ function useChat(options) {
   const stop = useCallback(() => {
     abortRef.current?.abort();
   }, []);
+  const settleClientCalls = useCallback(
+    async (settled, pending, native) => {
+      let turn = settled;
+      if (pending.length === 0) {
+        return native?.approvalResponses?.length ? { ...native } : void 0;
+      }
+      if (!options.onToolCall) {
+        parkedTurnRef.current = turn;
+        parkedNativeRef.current = native;
+        clientToolsRef.current = pending;
+        toolResultsRef.current = [];
+        setPendingToolCalls(pending);
+        return void 0;
+      }
+      const generation = gateGenerationRef.current;
+      const running = pending.map(keyOfCall);
+      for (const key of running) executingRef.current.add(key);
+      try {
+        const results = [];
+        for (const call of pending) {
+          let answer;
+          try {
+            const out = await options.onToolCall({
+              toolCallId: call.toolCallId,
+              toolName: call.toolName,
+              input: call.input
+            });
+            answer = { toolCallId: call.toolCallId, result: out };
+          } catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            answer = { toolCallId: call.toolCallId, result: message, isError: true };
+          }
+          if (gateGenerationRef.current !== generation) return void 0;
+          results.push(answer);
+          turn = applyUIPart(turn, {
+            type: "tool-result",
+            toolCallId: call.toolCallId,
+            toolName: call.toolName,
+            output: answer.result,
+            ...answer.isError ? { isError: true } : {}
+          });
+          placedIdRef.current = turn.message.id;
+          syncTurn(turn);
+        }
+        appendCanonical(clientToolResultMessage(results));
+        return native ? { ...native, clientToolResults: results.map(asClientToolResult) } : {};
+      } finally {
+        for (const key of running) executingRef.current.delete(key);
+      }
+    },
+    [options.onToolCall, appendCanonical, syncTurn]
+  );
+  const settleTurn = useCallback(
+    async (settled, replay, cursorRead = false) => {
+      const turn = settled;
+      const history = snapshotRef.current.history.canonical;
+      const behind = replay?.ledger.afterCursor ? new Set(behindCursorRef.current) : void 0;
+      const open = unansweredCalls(history);
+      const answers = priorResultsRef.current.filter(
+        (entry, index, all) => open.has(entry.toolCallId) && all.findIndex((other) => other.toolCallId === entry.toolCallId) === index
+      );
+      priorResultsRef.current = [];
+      if (answers.length > 0) appendCanonical(clientToolResultMessage(answers));
+      appendCanonical(assistantMessageFromTurn(turn));
+      const ran = (turn.message.toolCalls ?? []).filter(
+        (call) => call.input !== void 0 && call.state === "result"
+      );
+      if (ran.length > 0) {
+        appendCanonical(
+          clientToolResultMessage(
+            ran.map((call) => ({
+              toolCallId: call.toolCallId,
+              result: call.output,
+              ...call.isError ? { isError: true } : {}
+            }))
+          )
+        );
+      }
+      turnRef.current = void 0;
+      if (replay || cursorRead) behindCursorRef.current = snapshotRef.current.history.canonical;
+      const native = nativeSuspension(turn);
+      if (!native && turn.agent !== void 0) return void 0;
+      const answered = replay ? answeredInvocations(history, behind) : void 0;
+      const parked = new Set(clientToolsRef.current.map(keyOfCall));
+      const candidates = native ? native.clientCalls : (turn.message.toolCalls ?? []).filter(
+        // A card without input is a call of an earlier leg, never one to run.
+        (call) => call.state === "call" && call.input !== void 0
+      );
+      const clientPending = candidates.filter((call) => {
+        if (!replay || !answered) return true;
+        const key = keyOfCall(call);
+        return deliveries(replay.ledger, key) > (answered.get(key) ?? 0) && !parked.has(key) && !executingRef.current.has(key);
+      });
+      const gate = native ? native.approvals : openApprovals(turn, replay?.ledger.answeredApprovals ?? NO_INDEXES);
+      if (gate.length > 0) {
+        approvalsRef.current = gate;
+        verdictsRef.current = [];
+        nativeGateRef.current = native ? { runId: native.runId, turn, clientCalls: clientPending } : void 0;
+        setPendingApprovals(gate);
+        return void 0;
+      }
+      return settleClientCalls(turn, clientPending, native ? { runId: native.runId } : void 0);
+    },
+    [appendCanonical, settleClientCalls]
+  );
   const run = useCallback(
-    async (approvalResponses) => {
+    async (initial, gate) => {
       const controller = new AbortController();
       abortRef.current = controller;
       setStatus("streaming");
       setError(void 0);
+      let continuation = initial;
       try {
+        if (gate) {
+          continuation = await settleClientCalls(gate.turn, gate.clientCalls, gate.resume);
+          if (!continuation || controller.signal.aborted) return;
+        }
         for (; ; ) {
           const doFetch = options.fetch ?? fetch;
           const res = await doFetch(options.api, {
@@ -195,80 +461,55 @@ function useChat(options) {
             body: JSON.stringify({
               messages: snapshotRef.current.history.canonical,
               ...options.chatId !== void 0 ? { chatId: options.chatId } : {},
-              ...approvalResponses?.length ? { approvalResponses } : {},
+              ...continuation?.approvalResponses?.length ? { approvalResponses: continuation.approvalResponses } : {},
+              // A native run's resume (2.3); a chat route never gets these.
+              ...continuation?.runId !== void 0 ? { runId: continuation.runId } : {},
+              ...continuation?.clientToolResults?.length ? { clientToolResults: continuation.clientToolResults } : {},
               ...options.body
             }),
             signal: controller.signal
           });
-          approvalResponses = void 0;
+          continuation = void 0;
           let turn = createAssistantTurn(genId());
           turnRef.current = turn;
+          priorResultsRef.current = [];
           placedIdRef.current = void 0;
           syncTurn(turn);
           flush();
+          const resume = options.resume;
+          let cursorRead = false;
+          const ledger = newLedger(lastEventIdRef.current);
+          ledger.afterCursor = true;
           for await (const part of readDeuzStream(res, {
-            ...options.onHttpError ? { onHttpError: options.onHttpError } : {}
+            ...options.onHttpError ? { onHttpError: options.onHttpError } : {},
+            ...resume ? {
+              onEventId: (id) => {
+                lastEventIdRef.current = id;
+                cursorRead = true;
+              }
+            } : {}
           })) {
+            if (resume) recordPart(ledger, turn, part);
             turn = fold(turn, part);
             turnRef.current = turn;
+            if (cursorRead) {
+              cursorTurnRef.current = turn;
+              cursorLedgerRef.current = ledger;
+            }
             syncTurn(turn);
           }
           const sealed = sealAssistantTurn(turn);
           if (sealed !== turn) {
             turn = sealed;
             turnRef.current = turn;
+            if (cursorRead) cursorTurnRef.current = turn;
             syncTurn(turn);
           }
           flush();
           if (turn.error !== void 0) throw new Error(turn.error);
-          appendCanonical(assistantMessageFromTurn(turn));
-          turnRef.current = void 0;
-          if (turn.approvals.length > 0) {
-            approvalsRef.current = turn.approvals;
-            verdictsRef.current = [];
-            setPendingApprovals(turn.approvals);
-            return;
-          }
-          const toolCalls = turn.message.toolCalls ?? [];
-          const serverResults = new Set(turn.serverResults);
-          const clientPending = toolCalls.filter((t) => !serverResults.has(t.toolCallId));
-          if (clientPending.length === 0) return;
-          if (!options.onToolCall) {
-            parkedTurnRef.current = turn;
-            clientToolsRef.current = clientPending;
-            toolResultsRef.current = [];
-            setPendingToolCalls(clientPending);
-            return;
-          }
-          const results = [];
-          for (const call of clientPending) {
-            try {
-              const out = await options.onToolCall({
-                toolCallId: call.toolCallId,
-                toolName: call.toolName,
-                input: call.input
-              });
-              results.push({ toolCallId: call.toolCallId, result: out });
-              turn = applyUIPart(turn, {
-                type: "tool-result",
-                toolCallId: call.toolCallId,
-                toolName: call.toolName,
-                output: out
-              });
-            } catch (err) {
-              const message = err instanceof Error ? err.message : String(err);
-              results.push({ toolCallId: call.toolCallId, result: message, isError: true });
-              turn = applyUIPart(turn, {
-                type: "tool-result",
-                toolCallId: call.toolCallId,
-                toolName: call.toolName,
-                output: message,
-                isError: true
-              });
-            }
-            syncTurn(turn);
-          }
-          appendCanonical(clientToolResultMessage(results));
+          const next = await settleTurn(turn, void 0, cursorRead);
+          if (!next) return;
+          continuation = next;
         }
       } catch (err) {
         if (controller.signal.aborted) {
@@ -276,6 +517,7 @@ function useChat(options) {
           if (open) {
             const sealed = sealAssistantTurn(open);
             turnRef.current = sealed;
+            if (cursorTurnRef.current === open) cursorTurnRef.current = sealed;
             if (sealed !== open) syncTurn(sealed);
           }
           return;
@@ -286,7 +528,7 @@ function useChat(options) {
         options.onError?.(e);
         return;
       } finally {
-        setStatus((s) => s === "error" ? s : "idle");
+        if (abortRef.current === controller) setStatus((s) => s === "error" ? s : "idle");
         flush();
       }
     },
@@ -297,12 +539,13 @@ function useChat(options) {
       options.body,
       options.chatId,
       options.generateId,
-      options.onToolCall,
       options.onError,
       options.onHttpError,
-      appendCanonical,
+      options.resume,
       fold,
       flush,
+      settleClientCalls,
+      settleTurn,
       syncTurn
     ]
   );
@@ -352,6 +595,10 @@ function useChat(options) {
         history: { ui: [...next.ui], canonical: [...next.canonical] }
       });
       clearGates();
+      lastEventIdRef.current = void 0;
+      cursorTurnRef.current = void 0;
+      cursorLedgerRef.current = newLedger();
+      behindCursorRef.current = [];
       flush();
     },
     [commit, clearGates, flush]
@@ -392,37 +639,55 @@ function useChat(options) {
           ...result.isError ? { isError: true } : {}
         });
         parkedTurnRef.current = next;
+        placedIdRef.current = next.message.id;
         syncTurn(next);
         flush();
       }
       const answered = toolResultsRef.current;
       if (!parked.every((c) => answered.some((r) => r.toolCallId === c.toolCallId))) return;
+      const native = parkedNativeRef.current;
       clientToolsRef.current = [];
       toolResultsRef.current = [];
       parkedTurnRef.current = void 0;
+      parkedNativeRef.current = void 0;
       setPendingToolCalls([]);
       appendCanonical(clientToolResultMessage(answered));
-      await run();
+      await run(
+        native ? { ...native, clientToolResults: answered.map(asClientToolResult) } : void 0
+      );
     },
     [run, appendCanonical, syncTurn, flush]
   );
   const addToolApprovalResponse = useCallback(
     async (response) => {
-      const request = approvalsRef.current.find((p) => p.approvalId === response.approvalId);
-      const verdict = response.token === void 0 && request?.token !== void 0 ? { ...response, token: request.token } : response;
+      const gate = approvalsRef.current;
+      const targets = gate.filter((request) => answersRequest(response, request));
+      if (targets.length === 0) return;
+      const recorded = [];
+      for (const request of targets) {
+        const verdict = response.token === void 0 && request.token !== void 0 ? { ...response, token: request.token } : response;
+        if (!recorded.some((v) => sameTarget(v, verdict))) recorded.push(verdict);
+      }
       verdictsRef.current = [
-        ...verdictsRef.current.filter((v) => v.approvalId !== verdict.approvalId),
-        verdict
+        ...verdictsRef.current.filter((v) => !recorded.some((r) => sameTarget(r, v))),
+        ...recorded
       ];
       const verdicts = verdictsRef.current;
-      const allSettled = approvalsRef.current.every(
-        (p) => verdicts.some((v) => v.approvalId === p.approvalId)
-      );
-      if (!allSettled) return;
+      if (!gate.every((request) => verdicts.some((v) => sameTarget(v, request)))) return;
       approvalsRef.current = [];
       verdictsRef.current = [];
       setPendingApprovals([]);
-      await run(verdicts);
+      const native = nativeGateRef.current;
+      nativeGateRef.current = void 0;
+      if (native) {
+        await run(void 0, {
+          turn: native.turn,
+          clientCalls: native.clientCalls,
+          resume: { runId: native.runId, approvalResponses: verdicts }
+        });
+        return;
+      }
+      await run({ approvalResponses: verdicts });
     },
     [run]
   );
@@ -438,15 +703,18 @@ function useChat(options) {
       try {
         const cursor = lastEventIdRef.current ?? loadCursor(resume);
         const inFlight = turnRef.current;
-        let turn = inFlight;
-        if (turn === void 0 || cursor === void 0) {
-          if (inFlight === void 0) placedIdRef.current = void 0;
-          turn = createAssistantTurn(genId());
-        }
+        const continuing = inFlight !== void 0 && cursor !== void 0 && cursorTurnRef.current === inFlight;
+        if (inFlight === void 0) placedIdRef.current = void 0;
+        let turn = continuing && inFlight ? inFlight : createAssistantTurn(genId());
         turnRef.current = turn;
+        cursorTurnRef.current = turn;
+        if (!continuing) priorResultsRef.current = [];
+        const ledger = continuing ? cursorLedgerRef.current : newLedger(cursor);
+        cursorLedgerRef.current = ledger;
         const parts = connectDeuzStream(resume.endpoint, {
           ...cursor !== void 0 ? { lastEventId: cursor } : {},
           onCursor: (id) => {
+            ledger.afterCursor ??= isLaterId(id, ledger.cursor);
             lastEventIdRef.current = id;
             saveCursor(resume, id);
           },
@@ -456,12 +724,23 @@ function useChat(options) {
         });
         for await (const part of parts) {
           folded++;
+          recordPart(ledger, turn, part);
           turn = fold(turn, part);
           turnRef.current = turn;
+          cursorTurnRef.current = turn;
           syncTurn(turn);
         }
         if (folded === 0) {
-          turnRef.current = inFlight === void 0 ? void 0 : sealAssistantTurn(inFlight);
+          const kept = inFlight === void 0 ? void 0 : sealAssistantTurn(inFlight);
+          turnRef.current = kept;
+          cursorTurnRef.current = continuing ? kept : void 0;
+          return;
+        }
+        if (controller.signal.aborted) {
+          const stopped = sealAssistantTurn(turn);
+          turnRef.current = stopped;
+          cursorTurnRef.current = stopped;
+          if (stopped !== turn) syncTurn(stopped);
           return;
         }
         const sealed = sealAssistantTurn(turn);
@@ -470,14 +749,10 @@ function useChat(options) {
           syncTurn(turn);
         }
         turnRef.current = turn;
+        cursorTurnRef.current = turn;
         if (turn.error !== void 0) throw new Error(turn.error);
-        appendCanonical(assistantMessageFromTurn(turn));
-        turnRef.current = void 0;
-        if (turn.approvals.length > 0) {
-          approvalsRef.current = turn.approvals;
-          verdictsRef.current = [];
-          setPendingApprovals(turn.approvals);
-        }
+        const next = await settleTurn(turn, { ledger });
+        if (next && !controller.signal.aborted) await run(next);
       } catch (err) {
         if (controller.signal.aborted) return;
         if (silent) return;
@@ -497,9 +772,10 @@ function useChat(options) {
       options.headers,
       options.generateId,
       options.onError,
-      appendCanonical,
       fold,
       flush,
+      run,
+      settleTurn,
       syncTurn
     ]
   );
@@ -530,6 +806,8 @@ function useChat(options) {
     ...snapshot.steps !== void 0 ? { steps: snapshot.steps } : {},
     ...snapshot.usage !== void 0 ? { usage: snapshot.usage } : {},
     ...snapshot.finishReason !== void 0 ? { finishReason: snapshot.finishReason } : {},
+    ...snapshot.stopDetails !== void 0 ? { stopDetails: snapshot.stopDetails } : {},
+    ...snapshot.agent !== void 0 ? { agent: snapshot.agent } : {},
     sendMessage,
     stop,
     regenerate,