@dudousxd/nestjs-agent-react 0.35.1 → 0.35.3

package/dist/index.js

@@ -1220,7 +1220,7 @@ function dragHasFiles(data) {
 }
 
 // src/attachments/use-attachments.ts
-import { useCallback as useCallback2, useEffect as useEffect4, useMemo as useMemo4, useRef as useRef3, useState as useState4 } from "react";
+import { useCallback as useCallback2, useEffect as useEffect4, useMemo as useMemo4, useRef as useRef4, useState as useState4 } from "react";
 
 // src/backend.ts
 var AgentBackendUnsupportedError = class extends Error {
@@ -1243,7 +1243,7 @@ function requireBackendMethod(backend, name) {
 import { useEffect as useEffect3, useState as useState3 } from "react";
 
 // src/provider.tsx
-import { useContext as useContext3, useMemo as useMemo3, useRef as useRef2 } from "react";
+import { useContext as useContext3, useMemo as useMemo3, useRef as useRef3 } from "react";
 
 // src/components/ambient-ui.ts
 import { createContext, useContext } from "react";
@@ -1265,11 +1265,46 @@ function useAmbientRenderUi() {
 import {
   Component,
   createContext as createContext2,
+  memo,
   useCallback,
   useContext as useContext2,
-  useMemo as useMemo2
+  useMemo as useMemo2,
+  useRef as useRef2
 } from "react";
 
+// src/genui/share-structure.ts
+function isPlainObject(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+function shareStructure(previous, next) {
+  if (Object.is(previous, next)) return next;
+  if (Array.isArray(next)) {
+    if (!Array.isArray(previous)) return next;
+    let same = previous.length === next.length;
+    const shared3 = next.map((value, index) => {
+      const kept = shareStructure(previous[index], value);
+      if (kept !== previous[index]) same = false;
+      return kept;
+    });
+    return same ? previous : shared3;
+  }
+  if (isPlainObject(next)) {
+    if (!isPlainObject(previous)) return next;
+    const keys = Object.keys(next);
+    let same = keys.length === Object.keys(previous).length;
+    const shared3 = {};
+    for (const key of keys) {
+      const kept = shareStructure(previous[key], next[key]);
+      if (kept !== previous[key] || !Object.hasOwn(previous, key)) same = false;
+      shared3[key] = kept;
+    }
+    return same ? previous : shared3;
+  }
+  return next;
+}
+
 // src/genui/use-generative-ui.ts
 import { useEffect as useEffect2, useMemo, useState as useState2 } from "react";
 
@@ -1441,10 +1476,10 @@ var TreeScopeContext = createContext2(null);
 var GenuiNodeContext = sharedContext(
   "@dudousxd/nestjs-agent-react:genui-node"
 );
-function renderPlaceholder(scope, node) {
-  const { placeholder } = scope;
+function renderPlaceholder(look, node) {
+  const { placeholder } = look;
   if (typeof placeholder === "function") return placeholder(node);
-  return placeholder !== void 0 ? placeholder : scope.loading;
+  return placeholder !== void 0 ? placeholder : look.loading;
 }
 function renderFallback(fallback2, problem) {
   if (typeof fallback2 === "function") return fallback2(problem);
@@ -1478,9 +1513,33 @@ var ItemBoundary = class extends Component {
 function nodeItem(node, id) {
   return { id, component: node.type, props: node.props ?? {}, version: null, toolCallId: null };
 }
-function TreeNode({ node, id }) {
+function failsWhole(scope) {
+  return !scope.hasFallback && scope.fallbackText !== void 0;
+}
+var TreeNode = memo(
+  function TreeNode2({ node, id, bounded }) {
+    const scope = useContext2(TreeScopeContext);
+    const item = useMemo2(() => nodeItem(node, id), [node, id]);
+    if (scope === null) return null;
+    if (!bounded || failsWhole(scope)) return /* @__PURE__ */ jsx(TreeNodeBody, { node, id, item });
+    return /* @__PURE__ */ jsx(
+      ItemBoundary,
+      {
+        item,
+        fallback: scope.look.current.fallback,
+        onError: scope.look.current.onError,
+        children: /* @__PURE__ */ jsx(TreeNodeBody, { node, id, item })
+      }
+    );
+  },
+  (previous, next) => previous.node === next.node && previous.id === next.id && previous.bounded === next.bounded
+);
+function TreeNodeBody({
+  node,
+  id,
+  item
+}) {
   const scope = useContext2(TreeScopeContext);
-  const item = useMemo2(() => nodeItem(node, id), [node, id]);
   const incomplete = node.incomplete === true;
   const held = node.held === true;
   const state = useMemo2(
@@ -1502,45 +1561,37 @@ function TreeNode({ node, id }) {
     item.props
   );
   if (scope === null) return null;
+  const look = scope.look.current;
   if (held) {
-    return /* @__PURE__ */ jsx(GenuiNodeContext.Provider, { value: state, children: renderPlaceholder(scope, state) });
+    return /* @__PURE__ */ jsx(GenuiNodeContext.Provider, { value: state, children: renderPlaceholder(look, state) });
   }
-  if (resolution.status === "loading" || validation.status === "pending") return scope.loading;
+  if (resolution.status === "loading" || validation.status === "pending") return look.loading;
   if (resolution.status === "unknown") {
-    if (scope.fallback === void 0 && scope.fallbackText !== void 0)
-      throw new Error("Unknown tree component");
-    return renderFallback(scope.fallback, { reason: "unknown", item });
+    if (failsWhole(scope)) throw new Error("Unknown tree component");
+    return renderFallback(look.fallback, { reason: "unknown", item });
   }
   if (resolution.status === "error") {
-    if (scope.fallback === void 0 && scope.fallbackText !== void 0) throw resolution.error;
-    return renderFallback(scope.fallback, { reason: "error", item, error: resolution.error });
+    if (failsWhole(scope)) throw resolution.error;
+    return renderFallback(look.fallback, { reason: "error", item, error: resolution.error });
   }
   if (validation.status === "invalid") {
-    if (scope.fallback === void 0 && scope.fallbackText !== void 0)
-      throw new Error("Invalid tree component");
-    return renderFallback(scope.fallback, { reason: "invalid", item, issues: validation.issues });
+    if (failsWhole(scope)) throw new Error("Invalid tree component");
+    return renderFallback(look.fallback, { reason: "invalid", item, issues: validation.issues });
   }
   const Renderer = resolution.Component;
   const children = Array.isArray(node.children) ? node.children : [];
   return /* @__PURE__ */ jsx(GenuiNodeContext.Provider, { value: state, children: /* @__PURE__ */ jsx(Renderer, { ...validation.props, children: children.length > 0 ? children.map((child, index) => {
     const childId = `${id}.${index}`;
-    if (scope.fallback === void 0 && scope.fallbackText !== void 0)
-      return /* @__PURE__ */ jsx(TreeNode, { node: child, id: childId }, childId);
-    return /* @__PURE__ */ jsx(
-      ItemBoundary,
-      {
-        item: nodeItem(child, childId),
-        fallback: scope.fallback,
-        onError: scope.onError,
-        children: /* @__PURE__ */ jsx(TreeNode, { node: child, id: childId })
-      },
-      childId
-    );
+    return /* @__PURE__ */ jsx(TreeNode, { node: child, id: childId, bounded: true }, childId);
   }) : void 0 }) });
 }
 function GenuiTree({ root }) {
-  if (root === void 0 || root === null || typeof root.type !== "string") return null;
-  return /* @__PURE__ */ jsx(TreeNode, { node: root, id: "root" });
+  const previous = useRef2(void 0);
+  const valid = root !== void 0 && root !== null && typeof root.type === "string";
+  const shared3 = valid ? shareStructure(previous.current, root) : void 0;
+  previous.current = shared3;
+  if (shared3 === void 0) return null;
+  return /* @__PURE__ */ jsx(TreeNode, { node: shared3, id: "root", bounded: false });
 }
 function GenerativeUIScope({
   registry,
@@ -1554,6 +1605,12 @@ function GenerativeUIScope({
   onError,
   children
 }) {
+  const versionsRef = useRef2(void 0);
+  const versions = shareStructure(versionsRef.current, componentVersions);
+  versionsRef.current = versions;
+  const look = useRef2({ fallback: fallback2, loading, placeholder, onError });
+  look.current = { fallback: fallback2, loading, placeholder, onError };
+  const hasFallback = fallback2 !== void 0;
   const scope = useMemo2(
     () => ({
       options: {
@@ -1561,24 +1618,12 @@ function GenerativeUIScope({
         ...catalog !== void 0 ? { catalog } : {},
         ...resolveComponent !== void 0 ? { resolveComponent } : {}
       },
-      fallback: fallback2,
-      ...componentVersions !== void 0 ? { componentVersions } : {},
+      hasFallback,
+      ...versions !== void 0 ? { componentVersions: versions } : {},
       ...fallbackText !== void 0 ? { fallbackText } : {},
-      loading,
-      placeholder,
-      onError
+      look
     }),
-    [
-      registry,
-      catalog,
-      resolveComponent,
-      fallback2,
-      fallbackText,
-      componentVersions,
-      loading,
-      placeholder,
-      onError
-    ]
+    [registry, catalog, resolveComponent, hasFallback, fallbackText, versions]
   );
   return /* @__PURE__ */ jsx(TreeScopeContext.Provider, { value: scope, children });
 }
@@ -1697,7 +1742,7 @@ function AgentProvider({
   genui,
   children
 }) {
-  const latestHeaders = useRef2({ headers, getHeaders, onHttpError });
+  const latestHeaders = useRef3({ headers, getHeaders, onHttpError });
   latestHeaders.current = { headers, getHeaders, onHttpError };
   const upload = attachments?.upload;
   const value = useMemo3(
@@ -1803,12 +1848,12 @@ function useAttachments(options = {}) {
     ...maxBytes !== void 0 ? { maxBytes } : {},
     ...maxFiles !== void 0 ? { maxFiles } : {}
   };
-  const latest = useRef3(effective);
+  const latest = useRef4(effective);
   latest.current = effective;
   const [items, setItems] = useState4([]);
-  const itemsRef = useRef3(items);
+  const itemsRef = useRef4(items);
   itemsRef.current = items;
-  const controllers = useRef3(/* @__PURE__ */ new Map());
+  const controllers = useRef4(/* @__PURE__ */ new Map());
   const [dragDepth, setDragDepth] = useState4(0);
   const patch = useCallback2((id, change) => {
     setItems((current) => current.map((item) => item.id === id ? { ...item, ...change } : item));
@@ -2443,14 +2488,14 @@ function applyPatch(target, patch) {
 import { useCallback as useCallback4, useMemo as useMemo5 } from "react";
 
 // src/catalog/use-resource.ts
-import { useCallback as useCallback3, useEffect as useEffect5, useRef as useRef4, useState as useState5 } from "react";
+import { useCallback as useCallback3, useEffect as useEffect5, useRef as useRef5, useState as useState5 } from "react";
 function useResource(load3, key, enabled) {
   const [data, setData] = useState5(void 0);
   const [isLoading, setIsLoading] = useState5(enabled);
   const [error, setError] = useState5(null);
-  const loadRef = useRef4(load3);
+  const loadRef = useRef5(load3);
   loadRef.current = load3;
-  const generation = useRef4(0);
+  const generation = useRef5(0);
   const refresh = useCallback3(async () => {
     const mine = ++generation.current;
     setIsLoading(true);
@@ -2597,17 +2642,17 @@ function useQuota(options = {}) {
 }
 
 // src/feedback/use-message-feedback.ts
-import { useCallback as useCallback5, useRef as useRef5, useState as useState6 } from "react";
+import { useCallback as useCallback5, useRef as useRef6, useState as useState6 } from "react";
 function useMessageFeedback(options = {}) {
   const backend = useAgentBackend(options.backend);
-  const latest = useRef5({ ...options, backend });
+  const latest = useRef6({ ...options, backend });
   latest.current = { ...options, backend };
   const [local, setLocal] = useState6(/* @__PURE__ */ new Map());
   const [pending, setPending] = useState6(/* @__PURE__ */ new Set());
   const [error, setError] = useState6(null);
-  const localRef = useRef5(local);
+  const localRef = useRef6(local);
   localRef.current = local;
-  const resolved = useRef5(/* @__PURE__ */ new Map());
+  const resolved = useRef6(/* @__PURE__ */ new Map());
   const feedbackOf = useCallback5(
     (message) => {
       const mine = local.get(message.id);
@@ -2690,16 +2735,16 @@ function metadataOf(message) {
 }
 
 // src/threads/use-threads.ts
-import { useCallback as useCallback6, useEffect as useEffect7, useRef as useRef6, useState as useState7 } from "react";
+import { useCallback as useCallback6, useEffect as useEffect7, useRef as useRef7, useState as useState7 } from "react";
 function useThreads(options = {}) {
   const { enabled = true } = options;
   const backend = useAgentBackend(options.backend);
   const [threads, setThreads] = useState7([]);
   const [isLoading, setIsLoading] = useState7(enabled);
   const [error, setError] = useState7(null);
-  const threadsRef = useRef6(threads);
+  const threadsRef = useRef7(threads);
   threadsRef.current = threads;
-  const generation = useRef6(0);
+  const generation = useRef7(0);
   const refresh = useCallback6(async () => {
     const mine = ++generation.current;
     setIsLoading(true);
@@ -2807,7 +2852,7 @@ function backgroundRunsFromThread(messages) {
 import { useEffect as useEffect9, useState as useState9 } from "react";
 
 // src/components/use-speech-recognition.ts
-import { useCallback as useCallback7, useEffect as useEffect8, useMemo as useMemo8, useRef as useRef7, useState as useState8 } from "react";
+import { useCallback as useCallback7, useEffect as useEffect8, useMemo as useMemo8, useRef as useRef8, useState as useState8 } from "react";
 function getRecognitionCtor() {
   if (typeof window === "undefined") return null;
   const scope = window;
@@ -2818,12 +2863,12 @@ function useSpeechRecognition({
   onFinalTranscript,
   onInterimTranscript
 }) {
-  const recognitionRef = useRef7(null);
+  const recognitionRef = useRef8(null);
   const [isListening, setIsListening] = useState8(false);
   const ctor = useMemo8(() => getRecognitionCtor(), []);
   const isSupported = ctor !== null;
-  const finalRef = useRef7(onFinalTranscript);
-  const interimRef = useRef7(onInterimTranscript);
+  const finalRef = useRef8(onFinalTranscript);
+  const interimRef = useRef8(onInterimTranscript);
   finalRef.current = onFinalTranscript;
   interimRef.current = onInterimTranscript;
   useEffect8(() => {
@@ -2992,7 +3037,7 @@ function ChatInput({
 import React2 from "react";
 
 // src/transcript/use-chat-transcript.ts
-import { useCallback as useCallback9, useEffect as useEffect11, useRef as useRef9, useState as useState11 } from "react";
+import { useCallback as useCallback9, useEffect as useEffect11, useRef as useRef10, useState as useState11 } from "react";
 
 // src/transcript/model.ts
 import {
@@ -3938,12 +3983,12 @@ function proposalDescription(description, approval) {
 }
 
 // src/transcript/use-stick-to-bottom.ts
-import { useCallback as useCallback8, useEffect as useEffect10, useRef as useRef8, useState as useState10 } from "react";
+import { useCallback as useCallback8, useEffect as useEffect10, useRef as useRef9, useState as useState10 } from "react";
 function useStickToBottom({
   contentKey,
   threshold = 32
 }) {
-  const containerRef = useRef8(null);
+  const containerRef = useRef9(null);
   const [isAtBottom, setIsAtBottom] = useState10(true);
   const measure = useCallback8(() => {
     const element = containerRef.current;
@@ -4000,7 +4045,7 @@ function useChatTranscript(options) {
     followUps,
     stickToBottomThreshold
   } = options;
-  const latest = useRef9(options);
+  const latest = useRef10(options);
   latest.current = options;
   const [visibleCount, setVisibleCount] = useState11(initialVisibleCount);
   const [stopRequested, setStopRequested] = useState11(false);
@@ -4071,9 +4116,9 @@ function useChatTranscript(options) {
   };
 }
 function useQueuedItems(queue, readOnly) {
-  const latestQueue = useRef9(queue);
+  const latestQueue = useRef10(queue);
   latestQueue.current = queue;
-  const removers = useRef9(/* @__PURE__ */ new Map());
+  const removers = useRef10(/* @__PURE__ */ new Map());
   const removerFor = useCallback9((id) => {
     let remover = removers.current.get(id);
     if (remover === void 0) {
@@ -4110,7 +4155,7 @@ function useQueuedItems(queue, readOnly) {
 }
 function useTranscriptItem(options) {
   const { message, isStreaming = false } = options;
-  const messagesRef = useRef9([message]);
+  const messagesRef = useRef10([message]);
   if (messagesRef.current[0] !== message) {
     messagesRef.current = [message];
   }
@@ -4136,9 +4181,9 @@ function useTranscriptItems({
   const [settleErrors, setSettleErrors] = useState11(() => /* @__PURE__ */ new Map());
   const backend = useAgentBackend();
   const handlers = settleHandlers(options, backend);
-  const latest = useRef9({ options, handlers, drafts, picks, messages });
+  const latest = useRef10({ options, handlers, drafts, picks, messages });
   latest.current = { options, handlers, drafts, picks, messages };
-  const copyTimers = useRef9(/* @__PURE__ */ new Map());
+  const copyTimers = useRef10(/* @__PURE__ */ new Map());
   useEffect11(
     () => () => {
       for (const timer of copyTimers.current.values()) {
@@ -4148,8 +4193,9 @@ function useTranscriptItems({
     },
     []
   );
-  const callbackCache = useRef9(/* @__PURE__ */ new Map());
-  const reasoningToggleCache = useRef9(/* @__PURE__ */ new Map());
+  const callbackCache = useRef10(/* @__PURE__ */ new Map());
+  const reasoningToggleCache = useRef10(/* @__PURE__ */ new Map());
+  const uiBlocks = useRef10(/* @__PURE__ */ new Map());
   const toggleReasoning = useCallback9((key, open) => {
     setOpenReasoning((current) => {
       const next = new Map(current);
@@ -4344,6 +4390,14 @@ function useTranscriptItems({
   }, []);
   const lastAssistantId = findLastAssistant(messages)?.id ?? null;
   const items = [];
+  const previousUi = uiBlocks.current;
+  const keptUi = /* @__PURE__ */ new Map();
+  const keepUiIdentity = (blocks) => blocks.map((block) => {
+    if (block.kind !== "ui") return block;
+    const kept = shareStructure(previousUi.get(block.key), block);
+    keptUi.set(block.key, kept);
+    return kept;
+  });
   for (let index = visibleStart; index < messages.length; index++) {
     const message = messages[index];
     if (!message) {
@@ -4366,37 +4420,39 @@ function useTranscriptItems({
       isAssistant,
       isLastAssistant,
       isStreaming: message.id === streamingMessageId,
-      blocks: buildTranscriptBlocks(message, {
-        isReasoningOpen: (key, isStreamingRun) => openReasoning.get(key) ?? isStreamingRun,
-        toggleReasoning: (key, open) => stableToggle(key)(open),
-        ...options.sources !== void 0 ? { sources: options.sources } : {},
-        ...options.toolCatalog !== void 0 ? { toolCatalog: options.toolCatalog } : {},
-        // Read-only still lifts question sets into their block, so the outcome shows.
-        ...handlers.onAnswer !== void 0 || options.readOnly === true && options.onAnswer !== null ? {
-          elicitation: {
-            picked: (toolCallId, questionId) => picks.get(pickKey(toolCallId, questionId)),
-            pick,
-            canAnswer: handlers.onAnswer !== void 0,
-            canSkip: handlers.onSkip !== void 0,
-            answer,
-            skip,
-            submitting: (toolCallId) => settling.get(toolCallId) ?? null,
-            errorOf: (toolCallId) => settleErrors.get(toolCallId)?.message ?? null,
-            errorCodeOf: (toolCallId) => settleErrors.get(toolCallId)?.code ?? null
-          }
-        } : {},
-        ...handlers.onApprove !== void 0 || handlers.onReject !== void 0 ? {
-          approval: {
-            canApprove: handlers.onApprove !== void 0,
-            canReject: handlers.onReject !== void 0,
-            approve,
-            reject,
-            submitting: (toolCallId) => settling.get(toolCallId) ?? null,
-            errorOf: (toolCallId) => settleErrors.get(toolCallId)?.message ?? null,
-            errorCodeOf: (toolCallId) => settleErrors.get(toolCallId)?.code ?? null
-          }
-        } : {}
-      }),
+      blocks: keepUiIdentity(
+        buildTranscriptBlocks(message, {
+          isReasoningOpen: (key, isStreamingRun) => openReasoning.get(key) ?? isStreamingRun,
+          toggleReasoning: (key, open) => stableToggle(key)(open),
+          ...options.sources !== void 0 ? { sources: options.sources } : {},
+          ...options.toolCatalog !== void 0 ? { toolCatalog: options.toolCatalog } : {},
+          // Read-only still lifts question sets into their block, so the outcome shows.
+          ...handlers.onAnswer !== void 0 || options.readOnly === true && options.onAnswer !== null ? {
+            elicitation: {
+              picked: (toolCallId, questionId) => picks.get(pickKey(toolCallId, questionId)),
+              pick,
+              canAnswer: handlers.onAnswer !== void 0,
+              canSkip: handlers.onSkip !== void 0,
+              answer,
+              skip,
+              submitting: (toolCallId) => settling.get(toolCallId) ?? null,
+              errorOf: (toolCallId) => settleErrors.get(toolCallId)?.message ?? null,
+              errorCodeOf: (toolCallId) => settleErrors.get(toolCallId)?.code ?? null
+            }
+          } : {},
+          ...handlers.onApprove !== void 0 || handlers.onReject !== void 0 ? {
+            approval: {
+              canApprove: handlers.onApprove !== void 0,
+              canReject: handlers.onReject !== void 0,
+              approve,
+              reject,
+              submitting: (toolCallId) => settling.get(toolCallId) ?? null,
+              errorOf: (toolCallId) => settleErrors.get(toolCallId)?.message ?? null,
+              errorCodeOf: (toolCallId) => settleErrors.get(toolCallId)?.code ?? null
+            }
+          } : {}
+        })
+      ),
       text,
       usage: usage ? describeUsage(usage) : null,
       timestamp: describeTimestamp((options.getCreatedAt ?? createdAtFromMetadata)(message)),
@@ -4431,6 +4487,7 @@ function useTranscriptItems({
       }
     });
   }
+  uiBlocks.current = keptUi;
   return items;
 }
 function settleHandlers(options, backend) {
@@ -5004,12 +5061,12 @@ function toItem(entry) {
 }
 
 // src/composer/use-composer-autocomplete.ts
-import { useCallback as useCallback10, useEffect as useEffect12, useId, useLayoutEffect, useMemo as useMemo9, useRef as useRef10, useState as useState12 } from "react";
+import { useCallback as useCallback10, useEffect as useEffect12, useId, useLayoutEffect, useMemo as useMemo9, useRef as useRef11, useState as useState12 } from "react";
 function useComposerAutocomplete(options) {
   const { value, sources, acceptOnTab = true } = options;
-  const latest = useRef10(options);
+  const latest = useRef11(options);
   latest.current = options;
-  const inputRef = useRef10(null);
+  const inputRef = useRef11(null);
   const [caret, setCaret] = useState12(value.length);
   const [items, setItems] = useState12([]);
   const [isLoading, setLoading] = useState12(false);
@@ -5022,13 +5079,13 @@ function useComposerAutocomplete(options) {
     [value, safeCaret, sources]
   );
   const isActive = match !== null && dismissedIndex !== match.index;
-  const matchRef = useRef10(match);
+  const matchRef = useRef11(match);
   matchRef.current = match;
-  const caretRef = useRef10(safeCaret);
+  const caretRef = useRef11(safeCaret);
   caretRef.current = safeCaret;
-  const itemsRef = useRef10(items);
+  const itemsRef = useRef11(items);
   itemsRef.current = items;
-  const activeIndexRef = useRef10(activeIndex);
+  const activeIndexRef = useRef11(activeIndex);
   activeIndexRef.current = activeIndex;
   const requestKey = isActive && match ? `${match.source.id}\0${match.query}` : null;
   useEffect12(() => {
@@ -5093,7 +5150,7 @@ function useComposerAutocomplete(options) {
     const current = matchRef.current;
     if (current) setDismissedIndex(current.index);
   }, []);
-  const pendingCaret = useRef10(null);
+  const pendingCaret = useRef11(null);
   const accept = useCallback10((item) => {
     const current = matchRef.current;
     if (!current) return;
@@ -5303,7 +5360,7 @@ function useToolCatalog(options = {}) {
 }
 
 // src/approvals/countdown.ts
-import { useEffect as useEffect14, useRef as useRef11, useState as useState14 } from "react";
+import { useEffect as useEffect14, useRef as useRef12, useState as useState14 } from "react";
 function approvalCountdown(expiresAt, now = Date.now()) {
   const deadline = expiresAt == null ? Number.NaN : Date.parse(expiresAt);
   if (!Number.isFinite(deadline)) {
@@ -5314,7 +5371,7 @@ function approvalCountdown(expiresAt, now = Date.now()) {
 }
 function useApprovalCountdown(expiresAt, options = {}) {
   const { intervalMs = 1e3 } = options;
-  const nowRef = useRef11(options.now ?? Date.now);
+  const nowRef = useRef12(options.now ?? Date.now);
   nowRef.current = options.now ?? Date.now;
   const [state, setState] = useState14(() => approvalCountdown(expiresAt, nowRef.current()));
   useEffect14(() => {
@@ -5548,10 +5605,10 @@ function sumUsage(rows) {
 
 // src/use-agent-chat.ts
 import { useChat } from "@ai-sdk/react";
-import { useCallback as useCallback13, useEffect as useEffect16, useMemo as useMemo11, useRef as useRef13, useState as useState16 } from "react";
+import { useCallback as useCallback13, useEffect as useEffect16, useMemo as useMemo11, useRef as useRef14, useState as useState16 } from "react";
 
 // src/approvals/use-action-proposals.ts
-import { useCallback as useCallback12, useEffect as useEffect15, useRef as useRef12, useState as useState15 } from "react";
+import { useCallback as useCallback12, useEffect as useEffect15, useRef as useRef13, useState as useState15 } from "react";
 
 // src/approvals/proposals.ts
 function proposalNeedsPolling(proposal) {
@@ -5624,13 +5681,28 @@ function outcomeId(value) {
 }
 
 // src/approvals/use-action-proposals.ts
+var UNSUPPORTED_STATUSES = /* @__PURE__ */ new Set([404, 405, 501]);
+var UNKNOWN_THREAD = /* @__PURE__ */ new Set(["Thread not found", "Unknown thread"]);
+var MAX_BACKOFF_MS = 3e4;
+var unsupportedBackends = /* @__PURE__ */ new WeakSet();
+function statusOf(cause) {
+  const status = cause?.status;
+  return typeof status === "number" ? status : void 0;
+}
+function isProposalsUnsupported(cause) {
+  const status = statusOf(cause);
+  if (status === void 0 || !UNSUPPORTED_STATUSES.has(status)) return false;
+  return !(status === 404 && cause instanceof Error && UNKNOWN_THREAD.has(cause.message));
+}
 function useActionProposals(backend, threadId, setMessages, refreshKey, pollMs = 1e3) {
   const [items, setItems] = useState15([]);
   const [error, setError] = useState15(null);
-  const latest = useRef12({ threadId, setMessages });
+  const [unsupported, setUnsupported] = useState15(() => unsupportedBackends.has(backend));
+  const [failures, setFailures] = useState15(0);
+  const latest = useRef13({ threadId, setMessages });
   latest.current = { threadId, setMessages };
-  const mounted = useRef12(true);
-  const requests = useRef12(/* @__PURE__ */ new Map());
+  const mounted = useRef13(true);
+  const requests = useRef13(/* @__PURE__ */ new Map());
   useEffect15(() => {
     mounted.current = true;
     return () => {
@@ -5639,6 +5711,7 @@ function useActionProposals(backend, threadId, setMessages, refreshKey, pollMs =
   }, []);
   const refresh = useCallback12(async () => {
     if (threadId === void 0 || backend.listActionProposals === void 0) return;
+    if (unsupportedBackends.has(backend)) return;
     const pending = requests.current.get(threadId);
     if (pending) return pending;
     const request = (async () => {
@@ -5655,12 +5728,23 @@ function useActionProposals(backend, threadId, setMessages, refreshKey, pollMs =
         if (!mounted.current || latest.current.threadId !== threadId) return;
         setItems(proposals);
         setError(null);
+        setFailures(0);
         latest.current.setMessages(
           (current) => reconcileProposalMessages(current, proposals, facts)
         );
       } catch (cause) {
-        if (mounted.current && latest.current.threadId === threadId)
+        if (isProposalsUnsupported(cause)) {
+          unsupportedBackends.add(backend);
+          if (mounted.current) {
+            setUnsupported(true);
+            setError(null);
+          }
+          return;
+        }
+        if (mounted.current && latest.current.threadId === threadId) {
           setError(cause instanceof Error ? cause : new Error(String(cause)));
+          setFailures((count) => count + 1);
+        }
       }
     })();
     requests.current.set(threadId, request);
@@ -5673,18 +5757,24 @@ function useActionProposals(backend, threadId, setMessages, refreshKey, pollMs =
   useEffect15(() => {
     setItems([]);
     setError(null);
+    setFailures(0);
   }, [threadId]);
+  useEffect15(() => {
+    setUnsupported(unsupportedBackends.has(backend));
+  }, [backend]);
   useEffect15(() => {
     void refresh();
   }, [refresh, refreshKey]);
   useEffect15(() => {
-    if (!items.some(proposalNeedsPolling) || pollMs <= 0) return;
-    const timer = setInterval(() => {
+    if (unsupported || !items.some(proposalNeedsPolling) || pollMs <= 0) return;
+    const wait = failures === 0 ? pollMs : Math.min(pollMs * 2 ** failures, MAX_BACKOFF_MS);
+    const timer = setTimeout(() => {
       void refresh();
-    }, pollMs);
-    return () => clearInterval(timer);
-  }, [items, pollMs, refresh]);
+    }, wait);
+    return () => clearTimeout(timer);
+  }, [items, failures, unsupported, pollMs, refresh]);
   useEffect15(() => {
+    if (unsupported) return;
     const refetch = () => {
       void refresh();
     };
@@ -5699,8 +5789,8 @@ function useActionProposals(backend, threadId, setMessages, refreshKey, pollMs =
       window.removeEventListener("online", refetch);
       document.removeEventListener("visibilitychange", visible);
     };
-  }, [refresh]);
-  return { items, error, refresh };
+  }, [refresh, unsupported]);
+  return { items, error, unsupported, refresh };
 }
 
 // src/use-agent-chat.ts
@@ -5759,15 +5849,15 @@ function localChatId() {
 }
 function useAgentChat(options = {}) {
   const providerCapabilities = useAgentUiCapabilities();
-  const capabilitiesRef = useRef13(providerCapabilities);
+  const capabilitiesRef = useRef14(providerCapabilities);
   capabilitiesRef.current = providerCapabilities;
-  const latest = useRef13(options);
+  const latest = useRef14(options);
   latest.current = options;
   const resolved = useAgentBackend(options.backend);
-  const client = useRef13(resolved).current;
-  const createdThreadId = useRef13(void 0);
-  const chatIdRef = useRef13(options.threadId ?? localChatId());
-  const boundThreadRef = useRef13(options.threadId);
+  const client = useRef14(resolved).current;
+  const createdThreadId = useRef14(void 0);
+  const chatIdRef = useRef14(options.threadId ?? localChatId());
+  const boundThreadRef = useRef14(options.threadId);
   if (options.threadId !== boundThreadRef.current) {
     boundThreadRef.current = options.threadId;
     const adopting = options.threadId !== void 0 && options.threadId === createdThreadId.current;
@@ -5778,10 +5868,10 @@ function useAgentChat(options = {}) {
   }
   const chatId = chatIdRef.current;
   const [runId, setRunId] = useState16(options.resumeRunId);
-  const runIdRef = useRef13(runId);
+  const runIdRef = useRef14(runId);
   runIdRef.current = runId;
-  const settlingRunIdRef = useRef13(void 0);
-  const autoResumeRunIdRef = useRef13(void 0);
+  const settlingRunIdRef = useRef14(void 0);
+  const autoResumeRunIdRef = useRef14(void 0);
   const [activeRunId, setActiveRunId] = useState16(null);
   const [historyFor, setHistoryFor] = useState16(void 0);
   const [historyError, setHistoryError] = useState16(null);
@@ -5789,28 +5879,28 @@ function useAgentChat(options = {}) {
   const [threadModel, setThreadModel] = useState16(null);
   const [threadPersona, setThreadPersona] = useState16(null);
   const [pickedModel, setPickedModel] = useState16(void 0);
-  const pickedModelRef = useRef13(pickedModel);
+  const pickedModelRef = useRef14(pickedModel);
   pickedModelRef.current = pickedModel;
-  const lockedRef = useRef13(false);
-  const pendingPin = useRef13(void 0);
-  const regenerateNext = useRef13(false);
+  const lockedRef = useRef14(false);
+  const pendingPin = useRef14(void 0);
+  const regenerateNext = useRef14(false);
   const currentThreadId = useCallback13(
     () => latest.current.threadId ?? createdThreadId.current,
     []
   );
   const [queueState, setQueueState] = useState16(EMPTY_QUEUE);
-  const queueStateRef = useRef13(queueState);
+  const queueStateRef = useRef14(queueState);
   const applyQueue = useCallback13((next) => {
     queueStateRef.current = next;
     setQueueState(next);
   }, []);
   const [pendingSends, setPendingSends] = useState16([]);
   const [queueError, setQueueError] = useState16(null);
-  const handoff = useRef13(void 0);
-  const queuedSend = useRef13(void 0);
-  const proposalRefreshRef = useRef13(async () => {
+  const handoff = useRef14(void 0);
+  const queuedSend = useRef14(void 0);
+  const proposalRefreshRef = useRef14(async () => {
   });
-  const threadWaiters = useRef13([]);
+  const threadWaiters = useRef14([]);
   const turnBody = useCallback13(() => {
     const current = latest.current;
     if (current.persona !== void 0) setThreadPersona(current.persona);
@@ -5829,7 +5919,7 @@ function useAgentChat(options = {}) {
     };
   }, [currentThreadId]);
   const [connection, setConnection] = useState16({ status: "live" });
-  const resyncAfterSettle = useRef13(false);
+  const resyncAfterSettle = useRef14(false);
   const transport = useMemo11(() => {
     function onMeta(meta) {
       settlingRunIdRef.current = meta.runId;
@@ -5882,7 +5972,7 @@ function useAgentChat(options = {}) {
       }
     });
   }, []);
-  const backgroundRef = useRef13(() => Promise.resolve());
+  const backgroundRef = useRef14(() => Promise.resolve());
   const chat = useChat({
     transport,
     id: chatId,
@@ -5937,7 +6027,7 @@ function useAgentChat(options = {}) {
       }
     }
   });
-  const chatRef = useRef13(chat);
+  const chatRef = useRef14(chat);
   chatRef.current = chat;
   function onQueueData(data) {
     const frame = data ?? {};
@@ -5985,7 +6075,7 @@ function useAgentChat(options = {}) {
     } catch {
     }
   }
-  const firstChatId = useRef13(chatId);
+  const firstChatId = useRef14(chatId);
   useEffect16(() => {
     if (chatId === firstChatId.current) return;
     firstChatId.current = chatId;
@@ -6052,7 +6142,7 @@ function useAgentChat(options = {}) {
     };
   }, [client, chatId, options.threadId]);
   const isLoadingHistory = options.threadId !== void 0 && options.threadId !== createdThreadId.current && options.history !== false && options.initialMessages === void 0 && historyFor !== options.threadId;
-  const turnInFlight = useRef13(false);
+  const turnInFlight = useRef14(false);
   const isTurnInFlight = useCallback13(
     () => turnInFlight.current || transport.isAttemptLive,
     [transport]
@@ -6062,12 +6152,12 @@ function useAgentChat(options = {}) {
     enabled: options.quota !== false && typeof client.getQuota === "function"
   });
   const blocked = options.blocked !== void 0 ? options.blocked : quota.blocked;
-  const blockedRef = useRef13(blocked);
+  const blockedRef = useRef14(blocked);
   blockedRef.current = blocked;
   const whileRunning = typeof client.enqueueMessage === "function" ? options.whileRunning ?? "queue" : "block";
-  const whileRunningRef = useRef13(whileRunning);
+  const whileRunningRef = useRef14(whileRunning);
   whileRunningRef.current = whileRunning;
-  const canQueueRef = useRef13(false);
+  const canQueueRef = useRef14(false);
   canQueueRef.current = typeof client.enqueueMessage === "function";
   const threadForQueue = useCallback13(async () => {
     const known = currentThreadId();
@@ -6260,7 +6350,7 @@ function useAgentChat(options = {}) {
       else attachTo(turn);
     }
   }, [client, queueCall, currentThreadId, applyQueue, isTurnInFlight]);
-  const resumeQueueRef = useRef13(resumeQueue);
+  const resumeQueueRef = useRef14(resumeQueue);
   resumeQueueRef.current = resumeQueue;
   const queuedItems = [
     ...pendingSends.filter((item) => item.interrupt),
@@ -6494,7 +6584,7 @@ function useAgentChat(options = {}) {
     [client, currentThreadId]
   );
   const [modelsWanted, setModelsWanted] = useState16(false);
-  const modelsWantedRef = useRef13(modelsWanted);
+  const modelsWantedRef = useRef14(modelsWanted);
   modelsWantedRef.current = modelsWanted;
   const catalog = useModels({
     backend: client,
@@ -6550,12 +6640,12 @@ function useAgentChat(options = {}) {
   };
   const status = connection.status === "reconnecting" ? "reconnecting" : chat.status;
   const isBusy = status === "submitted" || status === "streaming" || status === "reconnecting";
-  const isBusyRef = useRef13(isBusy);
+  const isBusyRef = useRef14(isBusy);
   isBusyRef.current = isBusy;
   const files = useAttachments({ ...options.composer, backend: client });
   const [text, setText] = useState16("");
   const blockedBy = blocked != null ? "quota" : files.isUploading ? "uploading" : isBusy && whileRunning === "block" ? "busy" : text.trim().length === 0 && files.refs.length === 0 ? "empty" : null;
-  const composerRef = useRef13({ text, files, blockedBy });
+  const composerRef = useRef14({ text, files, blockedBy });
   composerRef.current = { text, files, blockedBy };
   const submit = useCallback13(
     async (options2) => {