@deuz-sdk/react 1.8.0 → 1.9.0

package/dist/index.js

@@ -1,5 +1,5 @@
-import { useState, useRef, useCallback } from 'react';
-import { uiFromMessages, createAssistantTurn, assistantMessageFromTurn, applyUIPart, clientToolResultMessage, dropTrailingAssistant, branchBeforeUserMessage } from '@deuz-sdk/core/chat';
+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 { readDeuzStream, connectDeuzStream } from '@deuz-sdk/core/ui';
 import { jsx, Fragment, jsxs } from 'react/jsx-runtime';
 
@@ -17,50 +17,166 @@ function foldPart(turn, part) {
   return next;
 }
 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 [];
+  const list = Array.from(
+    files
+  );
+  return list.length === 0 ? [] : filesToImageParts(list);
+}
+function loadCursor(resume) {
+  try {
+    return resume.cursor?.load();
+  } catch {
+    return void 0;
+  }
+}
+function saveCursor(resume, id) {
+  try {
+    resume.cursor?.save(id);
+  } catch {
+  }
+}
 function useChat(options) {
   const genId = options.generateId ?? defaultGenerateId;
-  const [messages, setMessages] = useState(
-    () => uiFromMessages(options.initialMessages ?? [], genId)
-  );
+  const [snapshot, setSnapshot] = useState(() => ({
+    history: {
+      ui: uiFromMessages(options.initialMessages ?? [], genId),
+      canonical: options.initialMessages ? [...options.initialMessages] : []
+    },
+    dataParts: [],
+    citations: [],
+    activity: []
+  }));
   const [status, setStatus] = useState("idle");
   const [error, setError] = useState(void 0);
   const [pendingApprovals, setPendingApprovals] = useState([]);
-  const [cost, setCost] = useState(void 0);
-  const [budgetExceeded, setBudgetExceeded] = useState(
-    void 0
-  );
-  const [dataParts, setDataParts] = useState([]);
-  const [citations, setCitations] = useState([]);
-  const [plan, setPlan] = useState(void 0);
-  const [activity, setActivity] = useState([]);
-  const uiRef = useRef(messages);
-  const canonicalRef = useRef(
-    options.initialMessages ? [...options.initialMessages] : []
-  );
+  const [pendingToolCalls, setPendingToolCalls] = useState([]);
+  const snapshotRef = useRef(snapshot);
   const turnRef = useRef(void 0);
+  const parkedTurnRef = useRef(void 0);
+  const clientToolsRef = useRef([]);
+  const toolResultsRef = useRef(
+    []
+  );
   const approvalsRef = useRef([]);
   const verdictsRef = useRef([]);
   const abortRef = useRef(null);
   const lastEventIdRef = useRef(options.resume?.lastEventId);
-  const pushMessage = useCallback((message) => {
-    uiRef.current = [...uiRef.current, message];
-    setMessages(uiRef.current);
+  const placedIdRef = useRef(void 0);
+  const throttleMs = options.throttleMs ?? 0;
+  const flushTimerRef = useRef(void 0);
+  const dirtyRef = useRef(false);
+  const publish = useCallback(() => {
+    flushTimerRef.current = void 0;
+    dirtyRef.current = false;
+    setSnapshot(snapshotRef.current);
   }, []);
-  const syncTurn = useCallback((turn) => {
-    uiRef.current = [...uiRef.current.slice(0, -1), turn.message];
-    setMessages(uiRef.current);
-    if (turn.costUsd !== void 0) {
-      setCost({
-        costUsd: turn.costUsd,
-        ...turn.cacheSavingsUsd !== void 0 ? { cacheSavingsUsd: turn.cacheSavingsUsd } : {}
-      });
+  const commit = useCallback(
+    (next) => {
+      snapshotRef.current = next;
+      if (throttleMs <= 0) {
+        publish();
+        return;
+      }
+      dirtyRef.current = true;
+      if (flushTimerRef.current === void 0) {
+        flushTimerRef.current = setTimeout(publish, throttleMs);
+      }
+    },
+    [throttleMs, publish]
+  );
+  const flush = useCallback(() => {
+    if (flushTimerRef.current !== void 0) {
+      clearTimeout(flushTimerRef.current);
+      flushTimerRef.current = void 0;
     }
-    setBudgetExceeded(turn.budgetExceeded);
-    setDataParts(turn.dataParts);
-    setCitations(turn.citations);
-    setPlan(turn.plan);
-    setActivity(turn.activity);
+    if (dirtyRef.current) publish();
+  }, [publish]);
+  useEffect(
+    () => () => {
+      if (flushTimerRef.current !== void 0) clearTimeout(flushTimerRef.current);
+    },
+    []
+  );
+  const syncTurn = useCallback(
+    (turn) => {
+      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);
+      placedIdRef.current = turn.message.id;
+      commit({
+        ...previous,
+        history: {
+          // NEW array either way — the turn's message is never spliced in place.
+          ui: index === -1 ? [...ui, turn.message] : [...ui.slice(0, index), turn.message, ...ui.slice(index + 1)],
+          canonical: previous.history.canonical
+        },
+        // `cost` is CUMULATIVE for the chat, so an absent reading keeps the
+        // previous one (1.7 behaviour, verbatim); every other readout is
+        // turn-scoped and resets when the turn does.
+        cost: turn.costUsd !== void 0 ? {
+          costUsd: turn.costUsd,
+          ...turn.cacheSavingsUsd !== void 0 ? { cacheSavingsUsd: turn.cacheSavingsUsd } : {}
+        } : previous.cost,
+        budgetExceeded: turn.budgetExceeded,
+        dataParts: turn.dataParts,
+        citations: turn.citations,
+        plan: turn.plan,
+        activity: turn.activity,
+        verifications: turn.verifications,
+        warnings: turn.warnings,
+        falseFinishes: turn.falseFinishes,
+        subAgents: turn.subAgents,
+        steps: turn.steps,
+        usage: turn.usage,
+        finishReason: turn.finishReason
+      });
+    },
+    [commit]
+  );
+  const appendCanonical = useCallback(
+    (message) => {
+      const previous = snapshotRef.current;
+      commit({
+        ...previous,
+        history: {
+          ui: previous.history.ui,
+          canonical: [...previous.history.canonical, message]
+        }
+      });
+    },
+    [commit]
+  );
+  const clearGates = useCallback(() => {
+    approvalsRef.current = [];
+    verdictsRef.current = [];
+    clientToolsRef.current = [];
+    toolResultsRef.current = [];
+    parkedTurnRef.current = void 0;
+    setPendingApprovals([]);
+    setPendingToolCalls([]);
   }, []);
+  const fold = useCallback(
+    (turn, part) => {
+      const next = foldPart(turn, part);
+      const onData = options.onData;
+      if (onData && typeof part.type === "string" && part.type.startsWith("data-")) {
+        const data = part;
+        try {
+          onData({
+            name: data.type.slice("data-".length),
+            ...typeof data.id === "string" ? { id: data.id } : {},
+            payload: data.payload
+          });
+        } catch {
+        }
+      }
+      return next;
+    },
+    [options.onData]
+  );
   const stop = useCallback(() => {
     abortRef.current?.abort();
   }, []);
@@ -77,7 +193,7 @@ function useChat(options) {
             method: "POST",
             headers: { "content-type": "application/json", ...options.headers },
             body: JSON.stringify({
-              messages: canonicalRef.current,
+              messages: snapshotRef.current.history.canonical,
               ...options.chatId !== void 0 ? { chatId: options.chatId } : {},
               ...approvalResponses?.length ? { approvalResponses } : {},
               ...options.body
@@ -87,15 +203,25 @@ function useChat(options) {
           approvalResponses = void 0;
           let turn = createAssistantTurn(genId());
           turnRef.current = turn;
-          pushMessage(turn.message);
+          placedIdRef.current = void 0;
           syncTurn(turn);
-          for await (const part of readDeuzStream(res)) {
-            turn = foldPart(turn, part);
+          flush();
+          for await (const part of readDeuzStream(res, {
+            ...options.onHttpError ? { onHttpError: options.onHttpError } : {}
+          })) {
+            turn = fold(turn, part);
+            turnRef.current = turn;
+            syncTurn(turn);
+          }
+          const sealed = sealAssistantTurn(turn);
+          if (sealed !== turn) {
+            turn = sealed;
             turnRef.current = turn;
             syncTurn(turn);
           }
+          flush();
           if (turn.error !== void 0) throw new Error(turn.error);
-          canonicalRef.current = [...canonicalRef.current, assistantMessageFromTurn(turn)];
+          appendCanonical(assistantMessageFromTurn(turn));
           turnRef.current = void 0;
           if (turn.approvals.length > 0) {
             approvalsRef.current = turn.approvals;
@@ -106,7 +232,14 @@ function useChat(options) {
           const toolCalls = turn.message.toolCalls ?? [];
           const serverResults = new Set(turn.serverResults);
           const clientPending = toolCalls.filter((t) => !serverResults.has(t.toolCallId));
-          if (clientPending.length === 0 || !options.onToolCall) return;
+          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 {
@@ -135,10 +268,18 @@ function useChat(options) {
             }
             syncTurn(turn);
           }
-          canonicalRef.current = [...canonicalRef.current, clientToolResultMessage(results)];
+          appendCanonical(clientToolResultMessage(results));
         }
       } catch (err) {
-        if (controller.signal.aborted) return;
+        if (controller.signal.aborted) {
+          const open = turnRef.current;
+          if (open) {
+            const sealed = sealAssistantTurn(open);
+            turnRef.current = sealed;
+            if (sealed !== open) syncTurn(sealed);
+          }
+          return;
+        }
         const e = err instanceof Error ? err : new Error(String(err));
         setError(e);
         setStatus("error");
@@ -146,6 +287,7 @@ function useChat(options) {
         return;
       } finally {
         setStatus((s) => s === "error" ? s : "idle");
+        flush();
       }
     },
     [
@@ -157,47 +299,112 @@ function useChat(options) {
       options.generateId,
       options.onToolCall,
       options.onError,
-      pushMessage,
+      options.onHttpError,
+      appendCanonical,
+      fold,
+      flush,
       syncTurn
     ]
   );
   const sendMessage = useCallback(
-    async (text) => {
-      canonicalRef.current = [...canonicalRef.current, { role: "user", content: text }];
-      pushMessage({ id: genId(), role: "user", content: text });
-      approvalsRef.current = [];
-      verdictsRef.current = [];
-      setPendingApprovals([]);
+    async (input) => {
+      const message = userMessageFromInput(input);
+      const bubble = uiFromMessages([message], genId)[0];
+      const previous = snapshotRef.current;
+      commit({
+        ...previous,
+        history: {
+          ui: bubble ? [...previous.history.ui, bubble] : previous.history.ui,
+          canonical: [...previous.history.canonical, message]
+        }
+      });
+      clearGates();
+      flush();
       await run();
     },
-    [run, pushMessage, options.generateId]
+    [run, commit, clearGates, flush, options.generateId]
   );
   const regenerate = useCallback(async () => {
-    const cut = dropTrailingAssistant({ ui: uiRef.current, canonical: canonicalRef.current });
-    uiRef.current = cut.ui;
-    canonicalRef.current = cut.canonical;
-    setMessages(cut.ui);
-    approvalsRef.current = [];
-    verdictsRef.current = [];
-    setPendingApprovals([]);
+    const previous = snapshotRef.current;
+    commit({ ...previous, history: dropTrailingAssistant(previous.history) });
+    clearGates();
+    flush();
     await run();
-  }, [run]);
+  }, [run, commit, clearGates, flush]);
   const editAndResend = useCallback(
-    async (messageId, text) => {
-      const cut = branchBeforeUserMessage(
-        { ui: uiRef.current, canonical: canonicalRef.current },
-        messageId
-      );
+    async (messageId, input) => {
+      const previous = snapshotRef.current;
+      const cut = branchBeforeUserMessage(previous.history, messageId);
       if (!cut) return;
-      uiRef.current = cut.ui;
-      canonicalRef.current = cut.canonical;
-      setMessages(cut.ui);
-      approvalsRef.current = [];
-      verdictsRef.current = [];
-      setPendingApprovals([]);
-      await sendMessage(text);
+      commit({ ...previous, history: cut });
+      clearGates();
+      flush();
+      await sendMessage(input);
+    },
+    [sendMessage, commit, clearGates, flush]
+  );
+  const setHistory = useCallback(
+    (update) => {
+      const previous = snapshotRef.current;
+      const next = typeof update === "function" ? update(previous.history) : update;
+      commit({
+        ...previous,
+        history: { ui: [...next.ui], canonical: [...next.canonical] }
+      });
+      clearGates();
+      flush();
     },
-    [sendMessage]
+    [commit, clearGates, flush]
+  );
+  const setMessages = useCallback(
+    (update) => {
+      setHistory((prev) => {
+        const ui = typeof update === "function" ? update(prev.ui) : update;
+        return { ui, canonical: canonicalFromUI(ui) };
+      });
+    },
+    [setHistory]
+  );
+  const clearError = useCallback(() => {
+    setError(void 0);
+    setStatus((s) => s === "error" ? "idle" : s);
+  }, []);
+  const addToolResult = useCallback(
+    async (result) => {
+      const parked = clientToolsRef.current;
+      const call = parked.find((c) => c.toolCallId === result.toolCallId);
+      if (!call) return;
+      toolResultsRef.current = [
+        ...toolResultsRef.current.filter((r) => r.toolCallId !== result.toolCallId),
+        {
+          toolCallId: result.toolCallId,
+          result: result.output,
+          ...result.isError ? { isError: true } : {}
+        }
+      ];
+      const turn = parkedTurnRef.current;
+      if (turn) {
+        const next = applyUIPart(turn, {
+          type: "tool-result",
+          toolCallId: result.toolCallId,
+          toolName: call.toolName,
+          output: result.output,
+          ...result.isError ? { isError: true } : {}
+        });
+        parkedTurnRef.current = next;
+        syncTurn(next);
+        flush();
+      }
+      const answered = toolResultsRef.current;
+      if (!parked.every((c) => answered.some((r) => r.toolCallId === c.toolCallId))) return;
+      clientToolsRef.current = [];
+      toolResultsRef.current = [];
+      parkedTurnRef.current = void 0;
+      setPendingToolCalls([]);
+      appendCanonical(clientToolResultMessage(answered));
+      await run();
+    },
+    [run, appendCanonical, syncTurn, flush]
   );
   const addToolApprovalResponse = useCallback(
     async (response) => {
@@ -219,79 +426,118 @@ function useChat(options) {
     },
     [run]
   );
-  const reconnect = useCallback(async () => {
-    const resume = options.resume;
-    if (!resume) return;
-    const controller = new AbortController();
-    abortRef.current = controller;
-    setStatus("streaming");
-    setError(void 0);
-    try {
-      const cursor = lastEventIdRef.current;
-      let turn;
-      if (turnRef.current && cursor !== void 0) {
-        turn = turnRef.current;
-      } else {
-        turn = createAssistantTurn(genId());
-        if (!turnRef.current) pushMessage(turn.message);
-      }
-      turnRef.current = turn;
-      const parts = connectDeuzStream(resume.endpoint, {
-        ...cursor !== void 0 ? { lastEventId: cursor } : {},
-        onCursor: (id) => {
-          lastEventIdRef.current = id;
-        },
-        signal: controller.signal,
-        ...options.fetch ? { fetch: options.fetch } : {},
-        ...options.headers ? { headers: options.headers } : {}
-      });
-      for await (const part of parts) {
-        turn = foldPart(turn, part);
+  const runResume = useCallback(
+    async (silent) => {
+      const resume = options.resume;
+      if (!resume) return;
+      const controller = new AbortController();
+      abortRef.current = controller;
+      setStatus("streaming");
+      setError(void 0);
+      let folded = 0;
+      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());
+        }
         turnRef.current = turn;
-        syncTurn(turn);
-      }
-      if (turn.error !== void 0) throw new Error(turn.error);
-      canonicalRef.current = [...canonicalRef.current, assistantMessageFromTurn(turn)];
-      turnRef.current = void 0;
-      if (turn.approvals.length > 0) {
-        approvalsRef.current = turn.approvals;
-        verdictsRef.current = [];
-        setPendingApprovals(turn.approvals);
+        const parts = connectDeuzStream(resume.endpoint, {
+          ...cursor !== void 0 ? { lastEventId: cursor } : {},
+          onCursor: (id) => {
+            lastEventIdRef.current = id;
+            saveCursor(resume, id);
+          },
+          signal: controller.signal,
+          ...options.fetch ? { fetch: options.fetch } : {},
+          ...options.headers ? { headers: options.headers } : {}
+        });
+        for await (const part of parts) {
+          folded++;
+          turn = fold(turn, part);
+          turnRef.current = turn;
+          syncTurn(turn);
+        }
+        if (folded === 0) {
+          turnRef.current = inFlight === void 0 ? void 0 : sealAssistantTurn(inFlight);
+          return;
+        }
+        const sealed = sealAssistantTurn(turn);
+        if (sealed !== turn) {
+          turn = sealed;
+          syncTurn(turn);
+        }
+        turnRef.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);
+        }
+      } catch (err) {
+        if (controller.signal.aborted) return;
+        if (silent) return;
+        const e = err instanceof Error ? err : new Error(String(err));
+        setError(e);
+        setStatus("error");
+        options.onError?.(e);
+        return;
+      } finally {
+        setStatus((s) => s === "error" ? s : "idle");
+        flush();
       }
-    } catch (err) {
-      if (controller.signal.aborted) return;
-      const e = err instanceof Error ? err : new Error(String(err));
-      setError(e);
-      setStatus("error");
-      options.onError?.(e);
-      return;
-    } finally {
-      setStatus((s) => s === "error" ? s : "idle");
-    }
-  }, [
-    options.resume,
-    options.fetch,
-    options.headers,
-    options.generateId,
-    options.onError,
-    pushMessage,
-    syncTurn
-  ]);
+    },
+    [
+      options.resume,
+      options.fetch,
+      options.headers,
+      options.generateId,
+      options.onError,
+      appendCanonical,
+      fold,
+      flush,
+      syncTurn
+    ]
+  );
+  const reconnect = useCallback(() => runResume(false), [runResume]);
+  const autoResumedRef = useRef(false);
+  useEffect(() => {
+    if (options.resume?.auto !== true || autoResumedRef.current) return;
+    autoResumedRef.current = true;
+    void runResume(true);
+  }, [options.resume?.auto, runResume]);
   return {
-    messages,
+    messages: snapshot.history.ui,
+    history: snapshot.history,
     status,
     error,
     pendingApprovals,
-    ...cost !== void 0 ? { cost } : {},
-    ...budgetExceeded !== void 0 ? { budgetExceeded } : {},
-    dataParts,
-    citations,
-    ...plan !== void 0 ? { plan } : {},
-    activity,
+    pendingToolCalls,
+    ...snapshot.cost !== void 0 ? { cost: snapshot.cost } : {},
+    ...snapshot.budgetExceeded !== void 0 ? { budgetExceeded: snapshot.budgetExceeded } : {},
+    dataParts: snapshot.dataParts,
+    citations: snapshot.citations,
+    ...snapshot.plan !== void 0 ? { plan: snapshot.plan } : {},
+    activity: snapshot.activity,
+    ...snapshot.verifications !== void 0 ? { verifications: snapshot.verifications } : {},
+    ...snapshot.warnings !== void 0 ? { warnings: snapshot.warnings } : {},
+    ...snapshot.falseFinishes !== void 0 ? { falseFinishes: snapshot.falseFinishes } : {},
+    ...snapshot.subAgents !== void 0 ? { subAgents: snapshot.subAgents } : {},
+    ...snapshot.steps !== void 0 ? { steps: snapshot.steps } : {},
+    ...snapshot.usage !== void 0 ? { usage: snapshot.usage } : {},
+    ...snapshot.finishReason !== void 0 ? { finishReason: snapshot.finishReason } : {},
     sendMessage,
     stop,
     regenerate,
     editAndResend,
+    setHistory,
+    setMessages,
+    addToolResult,
+    clearError,
     addToolApprovalResponse,
     reconnect
   };
@@ -301,6 +547,40 @@ function useObject(options) {
   const [isLoading, setLoading] = useState(false);
   const [error, setError] = useState(void 0);
   const abortRef = useRef(null);
+  const throttleMs = options.throttleMs ?? 0;
+  const latestRef = useRef(void 0);
+  const timerRef = useRef(void 0);
+  const dirtyRef = useRef(false);
+  const publish = useCallback(() => {
+    timerRef.current = void 0;
+    dirtyRef.current = false;
+    setObject(latestRef.current);
+  }, []);
+  const commit = useCallback(
+    (next) => {
+      latestRef.current = next;
+      if (throttleMs <= 0) {
+        publish();
+        return;
+      }
+      dirtyRef.current = true;
+      if (timerRef.current === void 0) timerRef.current = setTimeout(publish, throttleMs);
+    },
+    [throttleMs, publish]
+  );
+  const flush = useCallback(() => {
+    if (timerRef.current !== void 0) {
+      clearTimeout(timerRef.current);
+      timerRef.current = void 0;
+    }
+    if (dirtyRef.current) publish();
+  }, [publish]);
+  useEffect(
+    () => () => {
+      if (timerRef.current !== void 0) clearTimeout(timerRef.current);
+    },
+    []
+  );
   const stop = useCallback(() => {
     abortRef.current?.abort();
   }, []);
@@ -311,7 +591,8 @@ function useObject(options) {
       abortRef.current = controller;
       setLoading(true);
       setError(void 0);
-      setObject(void 0);
+      commit(void 0);
+      flush();
       try {
         const doFetch = options.fetch ?? fetch;
         const res = await doFetch(options.api, {
@@ -320,9 +601,11 @@ function useObject(options) {
           body: JSON.stringify({ input }),
           signal: controller.signal
         });
-        for await (const part of readDeuzStream(res)) {
+        for await (const part of readDeuzStream(res, {
+          ...options.onHttpError ? { onHttpError: options.onHttpError } : {}
+        })) {
           if (part.type === "object-delta") {
-            setObject(part.object);
+            commit(part.object);
           } else if (part.type === "error") {
             setError(new Error(part.message));
             break;
@@ -334,9 +617,10 @@ function useObject(options) {
         }
       } finally {
         setLoading(false);
+        flush();
       }
     },
-    [options.api, options.fetch, options.headers]
+    [options.api, options.fetch, options.headers, options.onHttpError, commit, flush]
   );
   return { object, isLoading, error, submit, stop };
 }
@@ -364,6 +648,6 @@ function CostBadge({ cost, format }) {
   return /* @__PURE__ */ jsx("span", { "data-deuz": "cost-badge", children: `$${cost.costUsd.toFixed(4)}${saved}` });
 }
 
-export { CostBadge, ToolApprovalCard, useChat, useObject };
+export { CostBadge, ToolApprovalCard, partsFromFiles, useChat, useObject };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map