@dudousxd/nestjs-agent-react 0.20.0 → 0.22.0

package/dist/index.cjs

@@ -35,6 +35,7 @@ __export(src_exports, {
   AgentChatTransport: () => AgentChatTransport,
   AgentClient: () => AgentClient,
   AgentHttpError: () => AgentHttpError,
+  AgentProvider: () => AgentProvider,
   AmbientRenderUiContext: () => AmbientRenderUiContext,
   ChatInput: () => ChatInput,
   DEFAULT_SPEECH_LANG: () => DEFAULT_SPEECH_LANG,
@@ -80,6 +81,7 @@ __export(src_exports, {
   storedThreadToUiMessages: () => storedThreadToUiMessages,
   toolCallState: () => toolCallState,
   toolCatalogFrom: () => toolCatalogFrom,
+  useAgentBackend: () => useAgentBackend,
   useAgentChat: () => useAgentChat,
   useAgents: () => useAgents,
   useAmbientRenderUi: () => useAmbientRenderUi,
@@ -114,6 +116,11 @@ var AgentHttpError = class extends Error {
     this.name = "AgentHttpError";
   }
 };
+function normalizeAgentPath(path) {
+  const trimmed = (path ?? "agent").replace(/^\/+|\/+$/g, "");
+  return trimmed === "" ? "" : `/${trimmed}`;
+}
+__name(normalizeAgentPath, "normalizeAgentPath");
 var HEADER_RUN_ID = "x-agent-run-id";
 var HEADER_THREAD_ID = "x-agent-thread-id";
 var AgentClient = class {
@@ -124,9 +131,9 @@ var AgentClient = class {
   constructor(options = {}) {
     this.options = options;
   }
-  /** `POST /agent/chat` → the turn's SSE stream. Throws {@link AgentHttpError} on a non-2xx. */
+  /** `POST <path>/chat` → the turn's SSE stream. Throws {@link AgentHttpError} on a non-2xx. */
   async openChatStream(request) {
-    const response = await this.fetchImpl()(`${this.baseUrl()}/agent/chat`, {
+    const response = await this.fetchImpl()(`${this.root()}/chat`, {
       method: "POST",
       headers: {
         "content-type": "application/json",
@@ -141,18 +148,18 @@ var AgentClient = class {
       } : {}
     });
     if (!response.ok || !response.body) {
-      throw new AgentHttpError(response.status, "POST", "/agent/chat", response.statusText);
+      throw new AgentHttpError(response.status, "POST", `${this.agentPath()}/chat`, response.statusText);
     }
     return streamResponse(response);
   }
   /**
-  * `GET /agent/chat/:runId/stream[?after=<seq>]` → the run's SSE stream, or `null` when nothing is
+  * `GET <path>/chat/:runId/stream[?after=<seq>]` → the run's SSE stream, or `null` when nothing is
   * streaming under that id (404).
   */
   async resumeChatStream(request) {
-    const path = `/agent/chat/${encodeURIComponent(request.runId)}/stream`;
+    const path = `/chat/${encodeURIComponent(request.runId)}/stream`;
     const query = request.after !== void 0 && request.after > 0 ? `?after=${request.after}` : "";
-    const response = await this.fetchImpl()(`${this.baseUrl()}${path}${query}`, {
+    const response = await this.fetchImpl()(`${this.root()}${path}${query}`, {
       method: "GET",
       headers: {
         accept: "text/event-stream",
@@ -168,7 +175,7 @@ var AgentClient = class {
       return null;
     }
     if (!response.ok || !response.body) {
-      throw new AgentHttpError(response.status, "GET", path, response.statusText);
+      throw new AgentHttpError(response.status, "GET", `${this.agentPath()}${path}`, response.statusText);
     }
     return streamResponse(response);
   }
@@ -177,10 +184,10 @@ var AgentClient = class {
   * the stored rating.
   */
   setMessageFeedback(messageId, input) {
-    return this.request("POST", `/agent/messages/${encodeURIComponent(messageId)}/feedback`, input);
+    return this.request("POST", `/messages/${encodeURIComponent(messageId)}/feedback`, input);
   }
   listThreads() {
-    return this.request("GET", "/agent/threads");
+    return this.request("GET", "/threads");
   }
   /**
   * The skills this caller can invoke right now, scope-resolved — the same list, built by the same
@@ -190,7 +197,7 @@ var AgentClient = class {
   */
   listSkills(threadId) {
     const query = threadId === void 0 ? "" : `?threadId=${encodeURIComponent(threadId)}`;
-    return this.request("GET", `/agent/skills${query}`);
+    return this.request("GET", `/skills${query}`);
   }
   /**
   * The tools this caller can reach through `agent` (the default agent when omitted), each with the
@@ -199,41 +206,37 @@ var AgentClient = class {
   */
   listTools(agent) {
     const query = agent === void 0 ? "" : `?agent=${encodeURIComponent(agent)}`;
-    return this.request("GET", `/agent/tools${query}`);
+    return this.request("GET", `/tools${query}`);
   }
   getThread(id) {
-    return this.request("GET", `/agent/threads/${encodeURIComponent(id)}`);
+    return this.request("GET", `/threads/${encodeURIComponent(id)}`);
   }
   deleteThread(id) {
-    return this.request("DELETE", `/agent/threads/${encodeURIComponent(id)}`);
+    return this.request("DELETE", `/threads/${encodeURIComponent(id)}`);
   }
   forkFromMessage(threadId, messageId) {
-    return this.request("POST", `/agent/threads/${encodeURIComponent(threadId)}/fork-from/${encodeURIComponent(messageId)}`);
-  }
-  renameThread(id, title) {
-    return this.updateThread(id, {
-      title
-    });
+    return this.request("POST", `/threads/${encodeURIComponent(threadId)}/fork-from/${encodeURIComponent(messageId)}`);
   }
-  /** General `PATCH /agent/threads/:threadId` — title and/or the thread's pinned default agent. */
+  /** General `PATCH <path>/threads/:threadId` — title and/or the thread's pinned default agent. */
   updateThread(id, patch) {
-    return this.request("PATCH", `/agent/threads/${encodeURIComponent(id)}`, patch);
+    return this.request("PATCH", `/threads/${encodeURIComponent(id)}`, patch);
   }
   /**
   * Uploads a file (image/PDF) for a vision-capable model turn. Multipart, field name `file` —
-  * mirrors the backend's `POST /agent/attachments`. The returned {@link MessageAttachment} is
+  * mirrors the backend's `POST <path>/attachments`. The returned {@link MessageAttachment} is
   * what a caller then rides on `sendMessage({ text }, { body: { attachments: [...] } })`.
   */
   async uploadAttachment(file, options = {}) {
-    if (this.options.attachments !== void 0) {
-      return this.options.attachments(file, options, this.connection());
+    const upload = this.options.attachments?.upload;
+    if (upload !== void 0) {
+      return upload(file, options, this.connection());
     }
     if (options.onProgress !== void 0 && this.options.fetch === void 0 && typeof XMLHttpRequest !== "undefined") {
       return this.uploadWithProgress(file, options);
     }
     const formData = new FormData();
     formData.append("file", file);
-    const response = await this.fetchImpl()(`${this.baseUrl()}/agent/attachments`, {
+    const response = await this.fetchImpl()(`${this.root()}/attachments`, {
       method: "POST",
       headers: {
         accept: "application/json",
@@ -245,7 +248,7 @@ var AgentClient = class {
         signal: options.signal
       } : {}
     });
-    const attachment = await this.handleResponse(response, "POST", "/agent/attachments");
+    const attachment = await this.handleResponse(response, "POST", `${this.agentPath()}/attachments`);
     options.onProgress?.(1);
     return attachment;
   }
@@ -254,7 +257,7 @@ var AgentClient = class {
       accept: "application/json",
       ...await this.resolveHeaders()
     };
-    const url = `${this.baseUrl()}/agent/attachments`;
+    const url = `${this.root()}/attachments`;
     return new Promise((resolve, reject) => {
       const xhr = new XMLHttpRequest();
       xhr.open("POST", url);
@@ -265,7 +268,7 @@ var AgentClient = class {
       };
       xhr.onload = () => {
         if (xhr.status < 200 || xhr.status >= 300) {
-          reject(new AgentHttpError(xhr.status, "POST", "/agent/attachments", xhr.statusText));
+          reject(new AgentHttpError(xhr.status, "POST", `${this.agentPath()}/attachments`, xhr.statusText));
           return;
         }
         onProgress?.(1);
@@ -288,39 +291,36 @@ var AgentClient = class {
     });
   }
   promoteThread(id) {
-    return this.request("POST", `/agent/threads/${encodeURIComponent(id)}/promote`);
+    return this.request("POST", `/threads/${encodeURIComponent(id)}/promote`);
   }
   truncateFromMessage(threadId, messageId) {
-    return this.request("DELETE", `/agent/threads/${encodeURIComponent(threadId)}/from/${encodeURIComponent(messageId)}`);
+    return this.request("DELETE", `/threads/${encodeURIComponent(threadId)}/from/${encodeURIComponent(messageId)}`);
   }
-  /** `GET /agent/models?agent=` — the models this caller may pick, grouped by provider. */
+  /** `GET <path>/models?agent=` — the models this caller may pick, grouped by provider. */
   listModels(agent) {
     const query = agent === void 0 ? "" : `?agent=${encodeURIComponent(agent)}`;
-    return this.request("GET", `/agent/models${query}`);
+    return this.request("GET", `/models${query}`);
   }
-  /** `GET /agent/agents` — the registered agents, the default one flagged. */
+  /** `GET <path>/agents` — the registered agents, the default one flagged. */
   listAgents() {
-    return this.request("GET", "/agent/agents");
+    return this.request("GET", "/agents");
   }
-  /** `GET /agent/quota` — the caller's budget windows and the one blocking sends, if any. */
+  /** `GET <path>/quota` — the caller's budget windows and the one blocking sends, if any. */
   getQuota() {
-    return this.request("GET", "/agent/quota");
-  }
-  getQuotaToday() {
-    return this.request("GET", "/agent/quota/today");
+    return this.request("GET", "/quota");
   }
   cancelStream(runId) {
-    return this.request("POST", `/agent/chat/${encodeURIComponent(runId)}/cancel`);
+    return this.request("POST", `/chat/${encodeURIComponent(runId)}/cancel`);
   }
   /**
   * `remember` approves later calls of the same tool in the same thread; `via` names the surface
   * the decision came through (the server records `'web'` when omitted).
   */
   approveToolCall(input) {
-    return this.request("POST", "/agent/tool-call/approve", input);
+    return this.request("POST", "/tool-call/approve", input);
   }
   rejectToolCall(input) {
-    return this.request("POST", "/agent/tool-call/reject", input);
+    return this.request("POST", "/tool-call/reject", input);
   }
   /**
   * Settle a parked question set. `answers` is questionId → chosen option values; a question left
@@ -329,7 +329,7 @@ var AgentClient = class {
   * answer — which is the point of the surface, so it is a valid submission rather than a blank.
   */
   answerToolCall(input) {
-    return this.request("POST", "/agent/tool-call/answer", input);
+    return this.request("POST", "/tool-call/answer", input);
   }
   /**
   * Decline to answer and let the agent proceed on its own pre-picked values. Lands on the same
@@ -337,7 +337,7 @@ var AgentClient = class {
   * evidence the user chose them.
   */
   skipToolCall(input) {
-    return this.request("POST", "/agent/tool-call/skip", input);
+    return this.request("POST", "/tool-call/skip", input);
   }
   fetchImpl() {
     return this.options.fetch ?? globalThis.fetch;
@@ -346,13 +346,21 @@ var AgentClient = class {
   connection() {
     return {
       baseUrl: this.baseUrl(),
+      path: this.agentPath(),
       headers: /* @__PURE__ */ __name(() => this.resolveHeaders(), "headers"),
       fetch: this.fetchImpl(),
       ...this.credentials()
     };
   }
   baseUrl() {
-    return (this.options.baseUrl ?? "").replace(/\/$/, "");
+    return (this.options.baseUrl ?? "").replace(/\/+$/, "");
+  }
+  agentPath() {
+    return normalizeAgentPath(this.options.path);
+  }
+  /** Origin + agent path: what every route hangs off. */
+  root() {
+    return `${this.baseUrl()}${this.agentPath()}`;
   }
   async resolveHeaders() {
     const dynamic = await this.options.getHeaders?.() ?? {};
@@ -366,7 +374,8 @@ var AgentClient = class {
       credentials: this.options.credentials
     } : {};
   }
-  async request(method, path, body) {
+  async request(method, route, body) {
+    const path = `${this.agentPath()}${route}`;
     const response = await this.fetchImpl()(`${this.baseUrl()}${path}`, {
       method,
       headers: {
@@ -497,6 +506,9 @@ var AgentChatTransport = class {
       ...options.baseUrl !== void 0 ? {
         baseUrl: options.baseUrl
       } : {},
+      ...options.path !== void 0 ? {
+        path: options.path
+      } : {},
       ...options.headers !== void 0 ? {
         headers: options.headers
       } : {},
@@ -708,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");
@@ -1202,7 +1215,7 @@ function dragHasFiles(data) {
 __name(dragHasFiles, "dragHasFiles");
 
 // src/attachments/use-attachments.ts
-var import_react2 = require("react");
+var import_react6 = require("react");
 
 // src/backend.ts
 var AgentBackendUnsupportedError = class extends Error {
@@ -1224,6 +1237,570 @@ function requireBackendMethod(backend, name) {
 }
 __name(requireBackendMethod, "requireBackendMethod");
 
+// src/provider.tsx
+var import_react5 = require("react");
+
+// src/components/ambient-ui.ts
+var import_react2 = require("react");
+function sharedContext(key) {
+  const symbol = Symbol.for(key);
+  const holder = globalThis;
+  const existing = holder[symbol];
+  if (existing !== void 0) return existing;
+  const created = (0, import_react2.createContext)(null);
+  holder[symbol] = created;
+  return created;
+}
+__name(sharedContext, "sharedContext");
+var AmbientRenderUiContext = sharedContext("@dudousxd/nestjs-agent-react:ambient-render-ui");
+function useAmbientRenderUi() {
+  return (0, import_react2.useContext)(AmbientRenderUiContext);
+}
+__name(useAmbientRenderUi, "useAmbientRenderUi");
+
+// src/genui/generative-ui.tsx
+var import_react4 = require("react");
+
+// src/genui/use-generative-ui.ts
+var import_react3 = require("react");
+
+// src/genui/types.ts
+var GENUI_TREE_COMPONENT = "genui:tree";
+
+// src/genui/use-generative-ui.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+__name(isRecord, "isRecord");
+function toGenerativeUIItem(part) {
+  if (!isRecord(part)) return null;
+  const source = part.type === "data-ui" && isRecord(part.data) ? part.data : part;
+  if (typeof source.component !== "string") return null;
+  const id = typeof source.id === "string" ? source.id : typeof part.id === "string" ? part.id : null;
+  if (id === null) return null;
+  return {
+    id,
+    component: source.component,
+    props: isRecord(source.props) ? source.props : {},
+    version: typeof source.version === "number" ? source.version : null,
+    toolCallId: typeof source.toolCallId === "string" ? source.toolCallId : null
+  };
+}
+__name(toGenerativeUIItem, "toGenerativeUIItem");
+var resolverCaches = /* @__PURE__ */ new WeakMap();
+function resolveCached(resolve, name, version) {
+  let cache = resolverCaches.get(resolve);
+  if (cache === void 0) {
+    cache = /* @__PURE__ */ new Map();
+    resolverCaches.set(resolve, cache);
+  }
+  const key = `${name}@${version ?? ""}`;
+  const hit = cache.get(key);
+  if (hit !== void 0) return hit;
+  let entry;
+  try {
+    const result = resolve(name, version);
+    if (result instanceof Promise) {
+      entry = {
+        resolution: {
+          status: "loading"
+        },
+        settled: null
+      };
+      entry.settled = result.then((Component2) => {
+        entry.resolution = Component2 ? {
+          status: "ready",
+          Component: Component2
+        } : {
+          status: "unknown"
+        };
+      }, (error) => {
+        entry.resolution = {
+          status: "error",
+          error
+        };
+      });
+    } else {
+      entry = {
+        resolution: result ? {
+          status: "ready",
+          Component: result
+        } : {
+          status: "unknown"
+        },
+        settled: null
+      };
+    }
+  } catch (error) {
+    entry = {
+      resolution: {
+        status: "error",
+        error
+      },
+      settled: null
+    };
+  }
+  cache.set(key, entry);
+  return entry;
+}
+__name(resolveCached, "resolveCached");
+function useResolvedComponent(name, version, registry, resolve, fallbackTree) {
+  const [, setTick] = (0, import_react3.useState)(0);
+  const own = registry[name];
+  const entry = own !== void 0 || resolve === void 0 ? null : resolveCached(resolve, name, version);
+  const pending = entry?.resolution.status === "loading" ? entry.settled : null;
+  (0, import_react3.useEffect)(() => {
+    if (pending === null) return;
+    let live = true;
+    void pending.then(() => {
+      if (live) setTick((tick) => tick + 1);
+    });
+    return () => {
+      live = false;
+    };
+  }, [
+    pending
+  ]);
+  if (own !== void 0) return {
+    status: "ready",
+    Component: own
+  };
+  if (entry !== null && entry.resolution.status !== "unknown") return entry.resolution;
+  if (name === GENUI_TREE_COMPONENT && fallbackTree !== void 0) {
+    return {
+      status: "ready",
+      Component: fallbackTree
+    };
+  }
+  return {
+    status: "unknown"
+  };
+}
+__name(useResolvedComponent, "useResolvedComponent");
+function useValidatedProps(catalog, name, props) {
+  const checked = catalog?.has(name) === true;
+  const immediate = (0, import_react3.useMemo)(() => {
+    if (!checked || catalog === void 0) return {
+      status: "ok",
+      props
+    };
+    const result = catalog.validateSync?.(name, props);
+    if (result === void 0) return null;
+    return result.ok ? {
+      status: "ok",
+      props: result.value
+    } : {
+      status: "invalid",
+      issues: result.issues
+    };
+  }, [
+    checked,
+    catalog,
+    name,
+    props
+  ]);
+  const [late, setLate] = (0, import_react3.useState)(null);
+  (0, import_react3.useEffect)(() => {
+    if (immediate !== null || catalog === void 0) return;
+    let live = true;
+    catalog.validate(name, props).then((result) => {
+      if (!live) return;
+      setLate({
+        props,
+        result: result.ok ? {
+          status: "ok",
+          props: result.value
+        } : {
+          status: "invalid",
+          issues: result.issues
+        }
+      });
+    }, (error) => {
+      if (!live) return;
+      setLate({
+        props,
+        result: {
+          status: "invalid",
+          issues: [
+            {
+              path: [],
+              message: error instanceof Error ? error.message : String(error)
+            }
+          ]
+        }
+      });
+    });
+    return () => {
+      live = false;
+    };
+  }, [
+    immediate,
+    catalog,
+    name,
+    props
+  ]);
+  if (immediate !== null) return immediate;
+  return late !== null && late.props === props ? late.result : {
+    status: "pending"
+  };
+}
+__name(useValidatedProps, "useValidatedProps");
+function useGenerativeUIState(part, options, fallbackTree) {
+  const item = (0, import_react3.useMemo)(() => toGenerativeUIItem(part), [
+    part
+  ]);
+  const name = item?.component ?? "";
+  const resolution = useResolvedComponent(name, item?.version ?? null, options.registry, item === null ? void 0 : options.resolveComponent, fallbackTree);
+  const empty = (0, import_react3.useMemo)(() => ({}), []);
+  const validation = useValidatedProps(item === null || name === GENUI_TREE_COMPONENT ? void 0 : options.catalog, name, item?.props ?? empty);
+  if (item === null) return null;
+  if (resolution.status === "loading") return {
+    status: "loading",
+    item
+  };
+  if (resolution.status === "unknown") return {
+    status: "problem",
+    reason: "unknown",
+    item
+  };
+  if (resolution.status === "error") {
+    return {
+      status: "problem",
+      reason: "error",
+      item,
+      error: resolution.error
+    };
+  }
+  if (validation.status === "pending") return {
+    status: "loading",
+    item
+  };
+  if (validation.status === "invalid") {
+    return {
+      status: "problem",
+      reason: "invalid",
+      item,
+      issues: validation.issues
+    };
+  }
+  return {
+    status: "ready",
+    item,
+    Component: resolution.Component,
+    props: validation.props
+  };
+}
+__name(useGenerativeUIState, "useGenerativeUIState");
+
+// src/genui/generative-ui.tsx
+var TreeScopeContext = /* @__PURE__ */ (0, import_react4.createContext)(null);
+function renderFallback(fallback2, problem) {
+  if (typeof fallback2 === "function") return fallback2(problem);
+  return fallback2 ?? null;
+}
+__name(renderFallback, "renderFallback");
+var ItemBoundary = class ItemBoundary2 extends import_react4.Component {
+  static {
+    __name(this, "ItemBoundary");
+  }
+  state = {
+    error: void 0,
+    failed: false
+  };
+  static getDerivedStateFromError(error) {
+    return {
+      error,
+      failed: true
+    };
+  }
+  componentDidCatch(error, _info) {
+    this.props.onError?.(error, this.props.item);
+  }
+  componentDidUpdate(previous) {
+    if (this.state.failed && previous.item !== this.props.item) {
+      this.setState({
+        error: void 0,
+        failed: false
+      });
+    }
+  }
+  render() {
+    if (this.state.failed) {
+      return renderFallback(this.props.fallback, {
+        reason: "error",
+        item: this.props.item,
+        error: this.state.error
+      });
+    }
+    return this.props.children;
+  }
+};
+function nodeItem(node, id) {
+  return {
+    id,
+    component: node.type,
+    props: node.props ?? {},
+    version: null,
+    toolCallId: null
+  };
+}
+__name(nodeItem, "nodeItem");
+function TreeNode({ node, id }) {
+  const scope = (0, import_react4.useContext)(TreeScopeContext);
+  const item = (0, import_react4.useMemo)(() => nodeItem(node, id), [
+    node,
+    id
+  ]);
+  const resolution = useResolvedComponent(node.type, null, scope?.options.registry ?? {}, scope?.options.resolveComponent);
+  const validation = useValidatedProps(scope?.options.catalog, node.type, item.props);
+  if (scope === null) return null;
+  if (resolution.status === "loading" || validation.status === "pending") return scope.loading;
+  if (resolution.status === "unknown") {
+    return renderFallback(scope.fallback, {
+      reason: "unknown",
+      item
+    });
+  }
+  if (resolution.status === "error") {
+    return renderFallback(scope.fallback, {
+      reason: "error",
+      item,
+      error: resolution.error
+    });
+  }
+  if (validation.status === "invalid") {
+    return renderFallback(scope.fallback, {
+      reason: "invalid",
+      item,
+      issues: validation.issues
+    });
+  }
+  const Renderer = resolution.Component;
+  const children = Array.isArray(node.children) ? node.children : [];
+  return /* @__PURE__ */ React.createElement(Renderer, validation.props, children.length > 0 ? children.map((child, index) => {
+    const childId = `${id}.${index}`;
+    return /* @__PURE__ */ React.createElement(ItemBoundary, {
+      key: childId,
+      item: nodeItem(child, childId),
+      fallback: scope.fallback,
+      onError: scope.onError
+    }, /* @__PURE__ */ React.createElement(TreeNode, {
+      node: child,
+      id: childId
+    }));
+  }) : void 0);
+}
+__name(TreeNode, "TreeNode");
+function GenuiTree({ root }) {
+  if (root === void 0 || root === null || typeof root.type !== "string") return null;
+  return /* @__PURE__ */ React.createElement(TreeNode, {
+    node: root,
+    id: "root"
+  });
+}
+__name(GenuiTree, "GenuiTree");
+function GenerativeUIScope({ registry, catalog, resolveComponent, fallback: fallback2, loading = null, onError, children }) {
+  const scope = (0, import_react4.useMemo)(() => ({
+    options: {
+      registry,
+      ...catalog !== void 0 ? {
+        catalog
+      } : {},
+      ...resolveComponent !== void 0 ? {
+        resolveComponent
+      } : {}
+    },
+    fallback: fallback2,
+    loading,
+    onError
+  }), [
+    registry,
+    catalog,
+    resolveComponent,
+    fallback2,
+    loading,
+    onError
+  ]);
+  return /* @__PURE__ */ React.createElement(TreeScopeContext.Provider, {
+    value: scope
+  }, children);
+}
+__name(GenerativeUIScope, "GenerativeUIScope");
+var GenuiContext = sharedContext("@dudousxd/nestjs-agent-react:genui-provider");
+function GenuiProvider({ registry, catalog, resolveComponent, treeRenderer, fallback: fallback2, loading, onError, children }) {
+  const value = (0, import_react4.useMemo)(() => ({
+    ...registry !== void 0 ? {
+      registry
+    } : {},
+    ...catalog !== void 0 ? {
+      catalog
+    } : {},
+    ...resolveComponent !== void 0 ? {
+      resolveComponent
+    } : {},
+    ...treeRenderer !== void 0 ? {
+      treeRenderer
+    } : {},
+    ...fallback2 !== void 0 ? {
+      fallback: fallback2
+    } : {},
+    ...loading !== void 0 ? {
+      loading
+    } : {},
+    ...onError !== void 0 ? {
+      onError
+    } : {}
+  }), [
+    registry,
+    catalog,
+    resolveComponent,
+    treeRenderer,
+    fallback2,
+    loading,
+    onError
+  ]);
+  const renderUi = (0, import_react4.useCallback)((block) => /* @__PURE__ */ React.createElement(GenerativeUI, {
+    part: block
+  }), []);
+  return /* @__PURE__ */ React.createElement(GenuiContext.Provider, {
+    value
+  }, /* @__PURE__ */ React.createElement(AmbientRenderUiContext.Provider, {
+    value: renderUi
+  }, children));
+}
+__name(GenuiProvider, "GenuiProvider");
+var NO_REGISTRY = {};
+function useMergedOptions(own) {
+  const provided = (0, import_react4.useContext)(GenuiContext);
+  const registry = own.registry ?? provided?.registry ?? NO_REGISTRY;
+  const catalog = own.catalog ?? provided?.catalog;
+  const resolveComponent = own.resolveComponent ?? provided?.resolveComponent;
+  const treeRenderer = own.treeRenderer ?? provided?.treeRenderer;
+  return (0, import_react4.useMemo)(() => ({
+    registry,
+    ...catalog !== void 0 ? {
+      catalog
+    } : {},
+    ...resolveComponent !== void 0 ? {
+      resolveComponent
+    } : {},
+    ...treeRenderer !== void 0 ? {
+      treeRenderer
+    } : {}
+  }), [
+    registry,
+    catalog,
+    resolveComponent,
+    treeRenderer
+  ]);
+}
+__name(useMergedOptions, "useMergedOptions");
+function GenerativeUI({ part, registry, catalog, resolveComponent, treeRenderer, fallback: ownFallback, loading: ownLoading, onError: ownOnError }) {
+  const provided = (0, import_react4.useContext)(GenuiContext);
+  const fallback2 = ownFallback ?? provided?.fallback;
+  const loading = ownLoading ?? provided?.loading ?? null;
+  const onError = ownOnError ?? provided?.onError;
+  const options = useMergedOptions({
+    ...registry !== void 0 ? {
+      registry
+    } : {},
+    ...catalog !== void 0 ? {
+      catalog
+    } : {},
+    ...resolveComponent !== void 0 ? {
+      resolveComponent
+    } : {},
+    ...treeRenderer !== void 0 ? {
+      treeRenderer
+    } : {}
+  });
+  const state = useGenerativeUIState(part, options, options.treeRenderer ?? GenuiTree);
+  if (state === null) return null;
+  if (state.status === "loading") return loading;
+  if (state.status === "problem") {
+    const { status: _status, ...problem } = state;
+    return renderFallback(fallback2, problem);
+  }
+  const Renderer = state.Component;
+  return /* @__PURE__ */ React.createElement(GenerativeUIScope, {
+    ...options,
+    fallback: fallback2,
+    loading,
+    ...onError !== void 0 ? {
+      onError
+    } : {}
+  }, /* @__PURE__ */ React.createElement(ItemBoundary, {
+    item: state.item,
+    fallback: fallback2,
+    onError
+  }, /* @__PURE__ */ React.createElement(Renderer, state.props)));
+}
+__name(GenerativeUI, "GenerativeUI");
+
+// src/provider.tsx
+var AgentBackendContext = sharedContext("@dudousxd/nestjs-agent-react:agent-backend");
+function AgentProvider({ backend, baseUrl, path, headers, getHeaders, credentials, fetch, attachments, genui, children }) {
+  const latestHeaders = (0, import_react5.useRef)({
+    headers,
+    getHeaders
+  });
+  latestHeaders.current = {
+    headers,
+    getHeaders
+  };
+  const upload = attachments?.upload;
+  const value = (0, import_react5.useMemo)(() => backend ?? new AgentClient({
+    ...baseUrl !== void 0 ? {
+      baseUrl
+    } : {},
+    ...path !== void 0 ? {
+      path
+    } : {},
+    ...credentials !== void 0 ? {
+      credentials
+    } : {},
+    ...fetch !== void 0 ? {
+      fetch
+    } : {},
+    ...upload !== void 0 ? {
+      attachments: {
+        upload
+      }
+    } : {},
+    getHeaders: /* @__PURE__ */ __name(async () => {
+      const current = latestHeaders.current;
+      const dynamic = await current.getHeaders?.() ?? {};
+      return {
+        ...current.headers,
+        ...dynamic
+      };
+    }, "getHeaders")
+  }), [
+    backend,
+    baseUrl,
+    path,
+    credentials,
+    fetch,
+    upload
+  ]);
+  const content = genui !== void 0 ? /* @__PURE__ */ React.createElement(GenuiProvider, genui, children) : children;
+  return /* @__PURE__ */ React.createElement(AgentBackendContext.Provider, {
+    value
+  }, content);
+}
+__name(AgentProvider, "AgentProvider");
+var fallback;
+function defaultBackend() {
+  fallback ??= new AgentClient();
+  return fallback;
+}
+__name(defaultBackend, "defaultBackend");
+function useAgentBackend(own) {
+  const provided = (0, import_react5.useContext)(AgentBackendContext);
+  return own ?? provided ?? defaultBackend();
+}
+__name(useAgentBackend, "useAgentBackend");
+
 // src/attachments/use-attachments.ts
 var DEFAULT_REJECTION = {
   type: /* @__PURE__ */ __name((file) => `${file.name} is not a supported file type`, "type"),
@@ -1231,23 +1808,30 @@ var DEFAULT_REJECTION = {
   count: /* @__PURE__ */ __name(() => "Too many files", "count")
 };
 var sequence = 0;
-function useAttachments(options) {
-  const latest = (0, import_react2.useRef)(options);
-  latest.current = options;
-  const [items, setItems] = (0, import_react2.useState)([]);
-  const itemsRef = (0, import_react2.useRef)(items);
+function useAttachments(options = {}) {
+  const backend = useAgentBackend(options.backend);
+  const latest = (0, import_react6.useRef)({
+    ...options,
+    backend
+  });
+  latest.current = {
+    ...options,
+    backend
+  };
+  const [items, setItems] = (0, import_react6.useState)([]);
+  const itemsRef = (0, import_react6.useRef)(items);
   itemsRef.current = items;
-  const controllers = (0, import_react2.useRef)(/* @__PURE__ */ new Map());
-  const [dragDepth, setDragDepth] = (0, import_react2.useState)(0);
-  const patch = (0, import_react2.useCallback)((id, change) => {
+  const controllers = (0, import_react6.useRef)(/* @__PURE__ */ new Map());
+  const [dragDepth, setDragDepth] = (0, import_react6.useState)(0);
+  const patch = (0, import_react6.useCallback)((id, change) => {
     setItems((current) => current.map((item) => item.id === id ? {
       ...item,
       ...change
     } : item));
   }, []);
-  const start = (0, import_react2.useCallback)((item) => {
-    const { upload, backend } = latest.current;
-    const run = upload ?? (backend?.uploadAttachment !== void 0 ? backend.uploadAttachment.bind(backend) : void 0);
+  const start = (0, import_react6.useCallback)((item) => {
+    const { upload, backend: backend2 } = latest.current;
+    const run = upload ?? (backend2.uploadAttachment !== void 0 ? backend2.uploadAttachment.bind(backend2) : void 0);
     if (run === void 0) {
       patch(item.id, {
         status: "error",
@@ -1281,7 +1865,7 @@ function useAttachments(options) {
   }, [
     patch
   ]);
-  const add = (0, import_react2.useCallback)((files) => {
+  const add = (0, import_react6.useCallback)((files) => {
     if (files == null) return;
     const { accept: accept2, maxBytes, maxFiles, describeRejection } = latest.current;
     const describe = /* @__PURE__ */ __name((reason, file) => describeRejection?.(reason, file) ?? DEFAULT_REJECTION[reason](file), "describe");
@@ -1327,7 +1911,7 @@ function useAttachments(options) {
   }, [
     start
   ]);
-  const release = (0, import_react2.useCallback)((item) => {
+  const release = (0, import_react6.useCallback)((item) => {
     if (item === void 0) return;
     controllers.current.get(item.id)?.abort();
     controllers.current.delete(item.id);
@@ -1335,19 +1919,19 @@ function useAttachments(options) {
       URL.revokeObjectURL(item.previewUrl);
     }
   }, []);
-  const remove = (0, import_react2.useCallback)((id) => {
+  const remove = (0, import_react6.useCallback)((id) => {
     release(itemsRef.current.find((item) => item.id === id));
     setItems((current) => current.filter((item) => item.id !== id));
   }, [
     release
   ]);
-  const clear = (0, import_react2.useCallback)(() => {
+  const clear = (0, import_react6.useCallback)(() => {
     for (const item of itemsRef.current) release(item);
     setItems([]);
   }, [
     release
   ]);
-  const retry = (0, import_react2.useCallback)((id) => {
+  const retry = (0, import_react6.useCallback)((id) => {
     const item = itemsRef.current.find((candidate) => candidate.id === id);
     if (item === void 0 || item.status !== "error") return;
     const { error: _previous, ...rest } = item;
@@ -1361,12 +1945,12 @@ function useAttachments(options) {
   }, [
     start
   ]);
-  (0, import_react2.useEffect)(() => () => {
+  (0, import_react6.useEffect)(() => () => {
     for (const item of itemsRef.current) release(item);
   }, [
     release
   ]);
-  const onPaste = (0, import_react2.useCallback)((event) => {
+  const onPaste = (0, import_react6.useCallback)((event) => {
     const files = filesFromClipboard(event.clipboardData);
     if (files.length === 0) return;
     event.preventDefault();
@@ -1374,7 +1958,7 @@ function useAttachments(options) {
   }, [
     add
   ]);
-  const dropZoneProps = (0, import_react2.useMemo)(() => ({
+  const dropZoneProps = (0, import_react6.useMemo)(() => ({
     onDragEnter: /* @__PURE__ */ __name((event) => {
       if (!dragHasFiles(event.dataTransfer)) return;
       event.preventDefault();
@@ -1397,7 +1981,7 @@ function useAttachments(options) {
     add
   ]);
   const accept = options.accept;
-  const inputProps = (0, import_react2.useMemo)(() => ({
+  const inputProps = (0, import_react6.useMemo)(() => ({
     type: "file",
     accept: typeof accept === "string" ? accept : accept?.join(","),
     multiple: options.maxFiles === void 0 || options.maxFiles > 1,
@@ -1411,7 +1995,7 @@ function useAttachments(options) {
     options.maxFiles,
     add
   ]);
-  return (0, import_react2.useMemo)(() => {
+  return (0, import_react6.useMemo)(() => {
     const ready = items.filter((item) => item.status === "ready" && item.attachment !== void 0);
     const attachments = ready.map((item) => item.attachment);
     return {
@@ -1445,18 +2029,18 @@ function useAttachments(options) {
 __name(useAttachments, "useAttachments");
 
 // src/catalog/use-agents.ts
-var import_react4 = require("react");
+var import_react8 = require("react");
 
 // src/catalog/use-resource.ts
-var import_react3 = require("react");
+var import_react7 = require("react");
 function useResource(load2, key, enabled) {
-  const [data, setData] = (0, import_react3.useState)(void 0);
-  const [isLoading, setIsLoading] = (0, import_react3.useState)(enabled);
-  const [error, setError] = (0, import_react3.useState)(null);
-  const loadRef = (0, import_react3.useRef)(load2);
+  const [data, setData] = (0, import_react7.useState)(void 0);
+  const [isLoading, setIsLoading] = (0, import_react7.useState)(enabled);
+  const [error, setError] = (0, import_react7.useState)(null);
+  const loadRef = (0, import_react7.useRef)(load2);
   loadRef.current = load2;
-  const generation = (0, import_react3.useRef)(0);
-  const refresh = (0, import_react3.useCallback)(async () => {
+  const generation = (0, import_react7.useRef)(0);
+  const refresh = (0, import_react7.useCallback)(async () => {
     const mine = ++generation.current;
     setIsLoading(true);
     try {
@@ -1471,7 +2055,7 @@ function useResource(load2, key, enabled) {
       if (mine === generation.current) setIsLoading(false);
     }
   }, []);
-  (0, import_react3.useEffect)(() => {
+  (0, import_react7.useEffect)(() => {
     if (!enabled) return;
     void refresh();
   }, [
@@ -1489,10 +2073,11 @@ function useResource(load2, key, enabled) {
 __name(useResource, "useResource");
 
 // src/catalog/use-agents.ts
-function useAgents(options) {
-  const { backend, enabled = true } = options;
+function useAgents(options = {}) {
+  const { enabled = true } = options;
+  const backend = useAgentBackend(options.backend);
   const { data, isLoading, error, refresh } = useResource(() => requireBackendMethod(backend, "listAgents")(), "", enabled);
-  return (0, import_react4.useMemo)(() => {
+  return (0, import_react8.useMemo)(() => {
     const agents = data ?? [];
     return {
       agents,
@@ -1511,11 +2096,12 @@ function useAgents(options) {
 __name(useAgents, "useAgents");
 
 // src/catalog/use-models.ts
-var import_react5 = require("react");
-function useModels(options) {
-  const { backend, agent, enabled = true } = options;
+var import_react9 = require("react");
+function useModels(options = {}) {
+  const { agent, enabled = true } = options;
+  const backend = useAgentBackend(options.backend);
   const { data, isLoading, error, refresh } = useResource(() => requireBackendMethod(backend, "listModels")(agent), `${agent ?? ""}`, enabled);
-  return (0, import_react5.useMemo)(() => {
+  return (0, import_react9.useMemo)(() => {
     const providers = data?.providers ?? [];
     const models = providers.flatMap((provider) => provider.models.map((model) => ({
       ...model,
@@ -1545,7 +2131,7 @@ function useModels(options) {
 __name(useModels, "useModels");
 
 // src/quota/use-quota.ts
-var import_react6 = require("react");
+var import_react10 = require("react");
 
 // src/threads/threads-events.ts
 var listeners = /* @__PURE__ */ new WeakMap();
@@ -1569,10 +2155,11 @@ function onThreadsEvent(backend, listener) {
 __name(onThreadsEvent, "onThreadsEvent");
 
 // src/quota/use-quota.ts
-function useQuota(options) {
-  const { backend, enabled = true, pollMs } = options;
+function useQuota(options = {}) {
+  const { enabled = true, pollMs } = options;
+  const backend = useAgentBackend(options.backend);
   const { data, isLoading, error, refresh } = useResource(() => requireBackendMethod(backend, "getQuota")(), "", enabled);
-  (0, import_react6.useEffect)(() => {
+  (0, import_react10.useEffect)(() => {
     if (!enabled) return;
     return onThreadsEvent(backend, (event) => {
       if (event.type === "changed") void refresh();
@@ -1582,7 +2169,7 @@ function useQuota(options) {
     enabled,
     refresh
   ]);
-  (0, import_react6.useEffect)(() => {
+  (0, import_react10.useEffect)(() => {
     if (!enabled || pollMs === void 0 || pollMs <= 0) return;
     const timer = setInterval(() => void refresh(), pollMs);
     return () => clearInterval(timer);
@@ -1591,7 +2178,7 @@ function useQuota(options) {
     pollMs,
     refresh
   ]);
-  return (0, import_react6.useMemo)(() => {
+  return (0, import_react10.useMemo)(() => {
     const windows = data?.windows ?? [];
     return {
       report: data,
@@ -1613,37 +2200,44 @@ function useQuota(options) {
 __name(useQuota, "useQuota");
 
 // src/feedback/use-message-feedback.ts
-var import_react7 = require("react");
-function useMessageFeedback(options) {
-  const latest = (0, import_react7.useRef)(options);
-  latest.current = options;
-  const [local, setLocal] = (0, import_react7.useState)(/* @__PURE__ */ new Map());
-  const [pending, setPending] = (0, import_react7.useState)(/* @__PURE__ */ new Set());
-  const [error, setError] = (0, import_react7.useState)(null);
-  const localRef = (0, import_react7.useRef)(local);
+var import_react11 = require("react");
+function useMessageFeedback(options = {}) {
+  const backend = useAgentBackend(options.backend);
+  const latest = (0, import_react11.useRef)({
+    ...options,
+    backend
+  });
+  latest.current = {
+    ...options,
+    backend
+  };
+  const [local, setLocal] = (0, import_react11.useState)(/* @__PURE__ */ new Map());
+  const [pending, setPending] = (0, import_react11.useState)(/* @__PURE__ */ new Set());
+  const [error, setError] = (0, import_react11.useState)(null);
+  const localRef = (0, import_react11.useRef)(local);
   localRef.current = local;
-  const resolved = (0, import_react7.useRef)(/* @__PURE__ */ new Map());
-  const feedbackOf = (0, import_react7.useCallback)((message) => {
+  const resolved = (0, import_react11.useRef)(/* @__PURE__ */ new Map());
+  const feedbackOf = (0, import_react11.useCallback)((message) => {
     const mine = local.get(message.id);
     if (mine !== void 0) return mine.feedback;
     return metadataOf(message).feedback ?? null;
   }, [
     local
   ]);
-  const isPending = (0, import_react7.useCallback)((message) => pending.has(message.id), [
+  const isPending = (0, import_react11.useCallback)((message) => pending.has(message.id), [
     pending
   ]);
-  const storedIdFor = (0, import_react7.useCallback)(async (message) => {
+  const storedIdFor = (0, import_react11.useCallback)(async (message) => {
     const runId = metadataOf(message).runId;
     if (runId === void 0) return message.id;
     const known = resolved.current.get(message.id);
     if (known !== void 0) return known;
-    const { backend, threadId } = latest.current;
+    const { backend: backend2, threadId } = latest.current;
     const thread = typeof threadId === "function" ? threadId() : threadId;
     if (thread === void 0) {
       throw new Error("useMessageFeedback: a streamed message needs `threadId` to be rated");
     }
-    const detail = await backend.getThread(thread);
+    const detail = await backend2.getThread(thread);
     const row = [
       ...detail.messages
     ].reverse().find((candidate) => candidate.role === "assistant" && candidate.runId === runId);
@@ -1653,7 +2247,7 @@ function useMessageFeedback(options) {
     resolved.current.set(message.id, row.id);
     return row.id;
   }, []);
-  const rate = (0, import_react7.useCallback)(async (message, value, comment) => {
+  const rate = (0, import_react11.useCallback)(async (message, value, comment) => {
     const setFeedback = requireBackendMethod(latest.current.backend, "setMessageFeedback");
     const had = localRef.current.get(message.id);
     const optimistic = value === null ? null : {
@@ -1699,7 +2293,7 @@ function useMessageFeedback(options) {
   }, [
     storedIdFor
   ]);
-  const toggle = (0, import_react7.useCallback)((message, value) => {
+  const toggle = (0, import_react11.useCallback)((message, value) => {
     const mine = localRef.current.get(message.id);
     const current = mine !== void 0 ? mine.feedback : metadataOf(message).feedback ?? null;
     return rate(message, current?.value === value ? null : value);
@@ -1722,16 +2316,17 @@ function metadataOf(message) {
 __name(metadataOf, "metadataOf");
 
 // src/threads/use-threads.ts
-var import_react8 = require("react");
-function useThreads(options) {
-  const { backend, enabled = true } = options;
-  const [threads, setThreads] = (0, import_react8.useState)([]);
-  const [isLoading, setIsLoading] = (0, import_react8.useState)(enabled);
-  const [error, setError] = (0, import_react8.useState)(null);
-  const threadsRef = (0, import_react8.useRef)(threads);
+var import_react12 = require("react");
+function useThreads(options = {}) {
+  const { enabled = true } = options;
+  const backend = useAgentBackend(options.backend);
+  const [threads, setThreads] = (0, import_react12.useState)([]);
+  const [isLoading, setIsLoading] = (0, import_react12.useState)(enabled);
+  const [error, setError] = (0, import_react12.useState)(null);
+  const threadsRef = (0, import_react12.useRef)(threads);
   threadsRef.current = threads;
-  const generation = (0, import_react8.useRef)(0);
-  const refresh = (0, import_react8.useCallback)(async () => {
+  const generation = (0, import_react12.useRef)(0);
+  const refresh = (0, import_react12.useCallback)(async () => {
     const mine = ++generation.current;
     setIsLoading(true);
     try {
@@ -1748,7 +2343,7 @@ function useThreads(options) {
   }, [
     backend
   ]);
-  (0, import_react8.useEffect)(() => {
+  (0, import_react12.useEffect)(() => {
     if (!enabled) return;
     void refresh();
     return onThreadsEvent(backend, (event) => {
@@ -1768,7 +2363,7 @@ function useThreads(options) {
     enabled,
     refresh
   ]);
-  const rename = (0, import_react8.useCallback)(async (id, title) => {
+  const rename = (0, import_react12.useCallback)(async (id, title) => {
     const before = threadsRef.current;
     setThreads((current) => current.map((thread) => thread.id === id ? {
       ...thread,
@@ -1790,7 +2385,7 @@ function useThreads(options) {
   }, [
     backend
   ]);
-  const remove = (0, import_react8.useCallback)(async (id) => {
+  const remove = (0, import_react12.useCallback)(async (id) => {
     const before = threadsRef.current;
     setThreads((current) => current.filter((thread) => thread.id !== id));
     try {
@@ -1864,29 +2459,11 @@ function backgroundRunsFromThread(messages) {
 }
 __name(backgroundRunsFromThread, "backgroundRunsFromThread");
 
-// src/components/ambient-ui.ts
-var import_react9 = require("react");
-function sharedContext(key) {
-  const symbol = Symbol.for(key);
-  const holder = globalThis;
-  const existing = holder[symbol];
-  if (existing !== void 0) return existing;
-  const created = (0, import_react9.createContext)(null);
-  holder[symbol] = created;
-  return created;
-}
-__name(sharedContext, "sharedContext");
-var AmbientRenderUiContext = sharedContext("@dudousxd/nestjs-agent-react:ambient-render-ui");
-function useAmbientRenderUi() {
-  return (0, import_react9.useContext)(AmbientRenderUiContext);
-}
-__name(useAmbientRenderUi, "useAmbientRenderUi");
-
 // src/components/chat-input.tsx
-var import_react11 = __toESM(require("react"), 1);
+var import_react14 = __toESM(require("react"), 1);
 
 // src/components/use-speech-recognition.ts
-var import_react10 = require("react");
+var import_react13 = require("react");
 function getRecognitionCtor() {
   if (typeof window === "undefined") return null;
   const scope = window;
@@ -1894,15 +2471,15 @@ function getRecognitionCtor() {
 }
 __name(getRecognitionCtor, "getRecognitionCtor");
 function useSpeechRecognition({ lang = "en-US", onFinalTranscript, onInterimTranscript }) {
-  const recognitionRef = (0, import_react10.useRef)(null);
-  const [isListening, setIsListening] = (0, import_react10.useState)(false);
-  const ctor = (0, import_react10.useMemo)(() => getRecognitionCtor(), []);
+  const recognitionRef = (0, import_react13.useRef)(null);
+  const [isListening, setIsListening] = (0, import_react13.useState)(false);
+  const ctor = (0, import_react13.useMemo)(() => getRecognitionCtor(), []);
   const isSupported = ctor !== null;
-  const finalRef = (0, import_react10.useRef)(onFinalTranscript);
-  const interimRef = (0, import_react10.useRef)(onInterimTranscript);
+  const finalRef = (0, import_react13.useRef)(onFinalTranscript);
+  const interimRef = (0, import_react13.useRef)(onInterimTranscript);
   finalRef.current = onFinalTranscript;
   interimRef.current = onInterimTranscript;
-  (0, import_react10.useEffect)(() => {
+  (0, import_react13.useEffect)(() => {
     if (!ctor) return;
     const recognition = new ctor();
     recognition.lang = lang;
@@ -1941,7 +2518,7 @@ function useSpeechRecognition({ lang = "en-US", onFinalTranscript, onInterimTran
     ctor,
     lang
   ]);
-  const start = (0, import_react10.useCallback)(() => {
+  const start = (0, import_react13.useCallback)(() => {
     const recognition = recognitionRef.current;
     if (!recognition) return;
     try {
@@ -1951,7 +2528,7 @@ function useSpeechRecognition({ lang = "en-US", onFinalTranscript, onInterimTran
       console.warn("SpeechRecognition start failed", error);
     }
   }, []);
-  const stop = (0, import_react10.useCallback)(() => {
+  const stop = (0, import_react13.useCallback)(() => {
     const recognition = recognitionRef.current;
     if (!recognition) return;
     try {
@@ -1970,8 +2547,8 @@ __name(useSpeechRecognition, "useSpeechRecognition");
 
 // src/components/chat-input.tsx
 function ChatInput({ onSubmit, disabled, placeholder, rows = 2, enableSpeech = true, speechLang = "en-US", sendLabel = "Send", onStop, isStreaming = false, stopLabel = "Stop generating", className, textareaClassName, sendButtonClassName, micButtonClassName, stopButtonClassName, renderMic }) {
-  const [value, setValue] = (0, import_react11.useState)("");
-  const [interim, setInterim] = (0, import_react11.useState)("");
+  const [value, setValue] = (0, import_react14.useState)("");
+  const [interim, setInterim] = (0, import_react14.useState)("");
   const speech = useSpeechRecognition({
     lang: speechLang,
     onFinalTranscript: /* @__PURE__ */ __name((text) => {
@@ -1982,7 +2559,7 @@ function ChatInput({ onSubmit, disabled, placeholder, rows = 2, enableSpeech = t
     }, "onFinalTranscript"),
     onInterimTranscript: /* @__PURE__ */ __name((text) => setInterim(text), "onInterimTranscript")
   });
-  (0, import_react11.useEffect)(() => {
+  (0, import_react14.useEffect)(() => {
     if (!speech.isListening) setInterim("");
   }, [
     speech.isListening
@@ -2010,9 +2587,9 @@ function ChatInput({ onSubmit, disabled, placeholder, rows = 2, enableSpeech = t
   const displayValue = speech.isListening && interim ? `${value}${value && !value.endsWith(" ") ? " " : ""}${interim}` : value;
   const showMic = enableSpeech && speech.isSupported;
   const showStop = isStreaming && onStop !== void 0;
-  return /* @__PURE__ */ import_react11.default.createElement("div", {
+  return /* @__PURE__ */ import_react14.default.createElement("div", {
     className
-  }, /* @__PURE__ */ import_react11.default.createElement("textarea", {
+  }, /* @__PURE__ */ import_react14.default.createElement("textarea", {
     className: textareaClassName,
     rows,
     value: displayValue,
@@ -2023,17 +2600,17 @@ function ChatInput({ onSubmit, disabled, placeholder, rows = 2, enableSpeech = t
     }, "onChange"),
     onKeyDown: handleKeyDown,
     placeholder: placeholder ?? "Ask something (Enter to send, Shift+Enter for newline)"
-  }), /* @__PURE__ */ import_react11.default.createElement("button", {
+  }), /* @__PURE__ */ import_react14.default.createElement("button", {
     type: "button",
     className: sendButtonClassName,
     onClick: submit,
     disabled: disabled || !value.trim()
-  }, sendLabel), showStop ? /* @__PURE__ */ import_react11.default.createElement("button", {
+  }, sendLabel), showStop ? /* @__PURE__ */ import_react14.default.createElement("button", {
     type: "button",
     className: stopButtonClassName,
     onClick: /* @__PURE__ */ __name(() => void onStop(), "onClick"),
     "aria-label": "Stop generating"
-  }, stopLabel) : null, showMic ? /* @__PURE__ */ import_react11.default.createElement("button", {
+  }, stopLabel) : null, showMic ? /* @__PURE__ */ import_react14.default.createElement("button", {
     type: "button",
     className: micButtonClassName,
     onClick: toggleMic,
@@ -2046,10 +2623,10 @@ function ChatInput({ onSubmit, disabled, placeholder, rows = 2, enableSpeech = t
 __name(ChatInput, "ChatInput");
 
 // src/components/message-item.tsx
-var import_react14 = __toESM(require("react"), 1);
+var import_react17 = __toESM(require("react"), 1);
 
 // src/transcript/use-chat-transcript.ts
-var import_react13 = require("react");
+var import_react16 = require("react");
 
 // src/transcript/model.ts
 var import_nestjs_agent_core2 = require("@dudousxd/nestjs-agent-core");
@@ -2146,21 +2723,21 @@ function fillTemplate(template, context) {
   }).replace(/\s{2,}/g, " ").trim();
 }
 __name(fillTemplate, "fillTemplate");
-function phraseFor(presentation, input, isSettled2, fallback = {
+function phraseFor(presentation, input, isSettled2, fallback2 = {
   running: "Working",
   done: "Done"
 }) {
-  if (presentation === void 0) return isSettled2 ? fallback.done : fallback.running;
+  if (presentation === void 0) return isSettled2 ? fallback2.done : fallback2.running;
   const filled = fillTemplate(isSettled2 ? presentation.done : presentation.running, input);
   return filled === "" ? presentation.label : filled;
 }
 __name(phraseFor, "phraseFor");
 
 // src/presentation/result-view.ts
-function isRecord(value) {
+function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-__name(isRecord, "isRecord");
+__name(isRecord2, "isRecord");
 function toText(value) {
   if (value === null || value === void 0) return "\u2014";
   if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
@@ -2171,7 +2748,7 @@ function toText(value) {
 }
 __name(toText, "toText");
 function inferResultView(output) {
-  if (!isRecord(output)) return void 0;
+  if (!isRecord2(output)) return void 0;
   for (const [key, value] of Object.entries(output)) {
     if (!Array.isArray(value) || value.length === 0) continue;
     if (value.every((entry) => typeof entry === "string")) {
@@ -2180,12 +2757,12 @@ function inferResultView(output) {
         lines: key
       };
     }
-    if (value.every(isRecord)) {
+    if (value.every(isRecord2)) {
       const first = value[0];
       return {
         kind: "table",
         rows: key,
-        columns: Object.keys(first).filter((column) => !isRecord(first[column])).map((column) => ({
+        columns: Object.keys(first).filter((column) => !isRecord2(first[column])).map((column) => ({
           path: column,
           label: column
         }))
@@ -2561,7 +3138,7 @@ function isSettled(state) {
 __name(isSettled, "isSettled");
 function toolKind(part) {
   const metadata = part.toolMetadata;
-  return isRecord2(metadata) && typeof metadata.toolKind === "string" ? metadata.toolKind : void 0;
+  return isRecord3(metadata) && typeof metadata.toolKind === "string" ? metadata.toolKind : void 0;
 }
 __name(toolKind, "toolKind");
 function isAwaitingApproval(part) {
@@ -2576,7 +3153,7 @@ function isAwaitingApproval(part) {
 __name(isAwaitingApproval, "isAwaitingApproval");
 function toolParentId(part) {
   const metadata = part.toolMetadata;
-  return isRecord2(metadata) && typeof metadata.parentId === "string" ? metadata.parentId : null;
+  return isRecord3(metadata) && typeof metadata.parentId === "string" ? metadata.parentId : null;
 }
 __name(toolParentId, "toolParentId");
 function nestToolCalls(calls) {
@@ -2643,12 +3220,12 @@ function buildToolCall(part, options, approval, catalog) {
 __name(buildToolCall, "buildToolCall");
 function readElicitationRequest(part) {
   const input = part.input;
-  if (!isRecord2(input) || !Array.isArray(input.questions) || input.questions.length === 0) {
+  if (!isRecord3(input) || !Array.isArray(input.questions) || input.questions.length === 0) {
     return null;
   }
   const questions = [];
   for (const candidate of input.questions) {
-    if (!isRecord2(candidate) || typeof candidate.id !== "string" || typeof candidate.prompt !== "string") {
+    if (!isRecord3(candidate) || typeof candidate.id !== "string" || typeof candidate.prompt !== "string") {
       return null;
     }
     const input2 = (0, import_nestjs_agent_core2.readElicitationInput)(candidate.input) ?? null;
@@ -2658,7 +3235,7 @@ function readElicitationRequest(part) {
     }
     const options = [];
     for (const option of rawOptions) {
-      if (!isRecord2(option) || typeof option.value !== "string" || typeof option.label !== "string") {
+      if (!isRecord3(option) || typeof option.value !== "string" || typeof option.label !== "string") {
         return null;
       }
       options.push({
@@ -2686,7 +3263,7 @@ function readElicitationRequest(part) {
 __name(readElicitationRequest, "readElicitationRequest");
 function readElicitationOutcome(part) {
   const output = part.output;
-  if (!isRecord2(output) || !isRecord2(output.answers) || typeof output.skipped !== "boolean") {
+  if (!isRecord3(output) || !isRecord3(output.answers) || typeof output.skipped !== "boolean") {
     return null;
   }
   const answers = {};
@@ -2823,7 +3400,7 @@ function readApprovals(parts) {
       continue;
     }
     const data = part.data;
-    if (!isRecord2(data) || typeof data.id !== "string") {
+    if (!isRecord3(data) || typeof data.id !== "string") {
       continue;
     }
     const approval = entry(data.id);
@@ -2879,7 +3456,7 @@ function statusFromPart(call) {
 __name(statusFromPart, "statusFromPart");
 function readUiComponent(part) {
   const data = part.data;
-  if (!isRecord2(data) || typeof data.component !== "string") {
+  if (!isRecord3(data) || typeof data.component !== "string") {
     return null;
   }
   const id = typeof data.id === "string" ? data.id : part.id;
@@ -2889,19 +3466,19 @@ function readUiComponent(part) {
   return {
     id,
     component: data.component,
-    props: isRecord2(data.props) ? data.props : {},
+    props: isRecord3(data.props) ? data.props : {},
     version: typeof data.version === "number" ? data.version : null,
     toolCallId: typeof data.toolCallId === "string" ? data.toolCallId : null
   };
 }
 __name(readUiComponent, "readUiComponent");
-function isRecord2(value) {
+function isRecord3(value) {
   return typeof value === "object" && value !== null;
 }
-__name(isRecord2, "isRecord");
+__name(isRecord3, "isRecord");
 function readQuery(part) {
   const input = part.input;
-  if (!isRecord2(input) || typeof input.query !== "string") {
+  if (!isRecord3(input) || typeof input.query !== "string") {
     return null;
   }
   return input.query;
@@ -2909,12 +3486,12 @@ function readQuery(part) {
 __name(readQuery, "readQuery");
 function readPassages(part) {
   const output = part.output;
-  if (!isRecord2(output) || !Array.isArray(output.passages) || output.passages.length === 0) {
+  if (!isRecord3(output) || !Array.isArray(output.passages) || output.passages.length === 0) {
     return null;
   }
   const passages = [];
   for (const candidate of output.passages) {
-    if (!isRecord2(candidate) || typeof candidate.id !== "string" || typeof candidate.text !== "string") {
+    if (!isRecord3(candidate) || typeof candidate.id !== "string" || typeof candidate.text !== "string") {
       return null;
     }
     passages.push({
@@ -2924,7 +3501,7 @@ function readPassages(part) {
       ...typeof candidate.source === "string" ? {
         source: candidate.source
       } : {},
-      ...isRecord2(candidate.metadata) ? {
+      ...isRecord3(candidate.metadata) ? {
         metadata: candidate.metadata
       } : {}
     });
@@ -3026,11 +3603,11 @@ function formatCostUsd(cost) {
 __name(formatCostUsd, "formatCostUsd");
 
 // src/transcript/use-stick-to-bottom.ts
-var import_react12 = require("react");
+var import_react15 = require("react");
 function useStickToBottom({ contentKey, threshold = 32 }) {
-  const containerRef = (0, import_react12.useRef)(null);
-  const [isAtBottom, setIsAtBottom] = (0, import_react12.useState)(true);
-  const measure = (0, import_react12.useCallback)(() => {
+  const containerRef = (0, import_react15.useRef)(null);
+  const [isAtBottom, setIsAtBottom] = (0, import_react15.useState)(true);
+  const measure = (0, import_react15.useCallback)(() => {
     const element = containerRef.current;
     if (!element) {
       return;
@@ -3040,7 +3617,7 @@ function useStickToBottom({ contentKey, threshold = 32 }) {
   }, [
     threshold
   ]);
-  const scrollToBottom = (0, import_react12.useCallback)(() => {
+  const scrollToBottom = (0, import_react15.useCallback)(() => {
     const element = containerRef.current;
     if (!element) {
       return;
@@ -3048,7 +3625,7 @@ function useStickToBottom({ contentKey, threshold = 32 }) {
     element.scrollTop = element.scrollHeight;
     setIsAtBottom(true);
   }, []);
-  const setContainer = (0, import_react12.useCallback)((element) => {
+  const setContainer = (0, import_react15.useCallback)((element) => {
     containerRef.current = element;
     if (element) {
       measure();
@@ -3056,7 +3633,7 @@ function useStickToBottom({ contentKey, threshold = 32 }) {
   }, [
     measure
   ]);
-  (0, import_react12.useEffect)(() => {
+  (0, import_react15.useEffect)(() => {
     if (isAtBottom) {
       scrollToBottom();
     }
@@ -3065,7 +3642,7 @@ function useStickToBottom({ contentKey, threshold = 32 }) {
     isAtBottom,
     scrollToBottom
   ]);
-  const getContainerProps = (0, import_react12.useCallback)(() => ({
+  const getContainerProps = (0, import_react15.useCallback)(() => ({
     ref: setContainer,
     onScroll: measure
   }), [
@@ -3087,14 +3664,14 @@ var DEFAULT_LOAD_EARLIER_STEP = 50;
 var DEFAULT_COPY_RESET_MS = 1500;
 function useChatTranscript(options) {
   const { messages, status, initialVisibleCount = DEFAULT_VISIBLE_COUNT, loadEarlierStep = DEFAULT_LOAD_EARLIER_STEP, followUps, stickToBottomThreshold } = options;
-  const latest = (0, import_react13.useRef)(options);
+  const latest = (0, import_react16.useRef)(options);
   latest.current = options;
-  const [visibleCount, setVisibleCount] = (0, import_react13.useState)(initialVisibleCount);
-  const [stopRequested, setStopRequested] = (0, import_react13.useState)(false);
+  const [visibleCount, setVisibleCount] = (0, import_react16.useState)(initialVisibleCount);
+  const [stopRequested, setStopRequested] = (0, import_react16.useState)(false);
   const isStreaming = status === "streaming" || status === "reconnecting";
   const isBusy = status === "submitted" || isStreaming;
   const isEmpty = messages.length === 0;
-  (0, import_react13.useEffect)(() => {
+  (0, import_react16.useEffect)(() => {
     if (!isBusy) {
       setStopRequested(false);
     }
@@ -3111,7 +3688,7 @@ function useChatTranscript(options) {
     streamingMessageId,
     options
   });
-  const stop = (0, import_react13.useCallback)(() => {
+  const stop = (0, import_react16.useCallback)(() => {
     const current = latest.current;
     if (current.status !== "submitted" && current.status !== "streaming" && current.status !== "reconnecting") {
       return;
@@ -3119,8 +3696,8 @@ function useChatTranscript(options) {
     setStopRequested(true);
     void current.onStop?.();
   }, []);
-  const loadEarlier = (0, import_react13.useCallback)(() => setVisibleCount((count) => count + (latest.current.loadEarlierStep ?? DEFAULT_LOAD_EARLIER_STEP)), []);
-  const showAll = (0, import_react13.useCallback)(() => setVisibleCount(latest.current.messages.length), []);
+  const loadEarlier = (0, import_react16.useCallback)(() => setVisibleCount((count) => count + (latest.current.loadEarlierStep ?? DEFAULT_LOAD_EARLIER_STEP)), []);
+  const showAll = (0, import_react16.useCallback)(() => setVisibleCount(latest.current.messages.length), []);
   const scroll = useStickToBottom({
     contentKey: contentSignature(messages),
     ...stickToBottomThreshold !== void 0 ? {
@@ -3156,7 +3733,7 @@ function useChatTranscript(options) {
 __name(useChatTranscript, "useChatTranscript");
 function useTranscriptItem(options) {
   const { message, isStreaming = false } = options;
-  const messagesRef = (0, import_react13.useRef)([
+  const messagesRef = (0, import_react16.useRef)([
     message
   ]);
   if (messagesRef.current[0] !== message) {
@@ -3174,41 +3751,45 @@ function useTranscriptItem(options) {
 }
 __name(useTranscriptItem, "useTranscriptItem");
 function useTranscriptItems({ messages, visibleStart, streamingMessageId, options }) {
-  const [drafts, setDrafts] = (0, import_react13.useState)(() => /* @__PURE__ */ new Map());
-  const [copied, setCopied] = (0, import_react13.useState)(() => /* @__PURE__ */ new Set());
-  const [openReasoning, setOpenReasoning] = (0, import_react13.useState)(() => /* @__PURE__ */ new Map());
-  const [picks, setPicks] = (0, import_react13.useState)(() => /* @__PURE__ */ new Map());
-  const [settling, setSettling] = (0, import_react13.useState)(() => /* @__PURE__ */ new Map());
-  const [settleErrors, setSettleErrors] = (0, import_react13.useState)(() => /* @__PURE__ */ new Map());
-  const latest = (0, import_react13.useRef)({
+  const [drafts, setDrafts] = (0, import_react16.useState)(() => /* @__PURE__ */ new Map());
+  const [copied, setCopied] = (0, import_react16.useState)(() => /* @__PURE__ */ new Set());
+  const [openReasoning, setOpenReasoning] = (0, import_react16.useState)(() => /* @__PURE__ */ new Map());
+  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
   };
-  const copyTimers = (0, import_react13.useRef)(/* @__PURE__ */ new Map());
-  (0, import_react13.useEffect)(() => () => {
+  const copyTimers = (0, import_react16.useRef)(/* @__PURE__ */ new Map());
+  (0, import_react16.useEffect)(() => () => {
     for (const timer of copyTimers.current.values()) {
       clearTimeout(timer);
     }
     copyTimers.current.clear();
   }, []);
-  const callbackCache = (0, import_react13.useRef)(/* @__PURE__ */ new Map());
-  const reasoningToggleCache = (0, import_react13.useRef)(/* @__PURE__ */ new Map());
-  const toggleReasoning = (0, import_react13.useCallback)((key, open) => {
+  const callbackCache = (0, import_react16.useRef)(/* @__PURE__ */ new Map());
+  const reasoningToggleCache = (0, import_react16.useRef)(/* @__PURE__ */ new Map());
+  const toggleReasoning = (0, import_react16.useCallback)((key, open) => {
     setOpenReasoning((current) => {
       const next = new Map(current);
       next.set(key, open ?? !(current.get(key) ?? false));
       return next;
     });
   }, []);
-  const stableToggle = (0, import_react13.useCallback)((key) => {
+  const stableToggle = (0, import_react16.useCallback)((key) => {
     let cached = reasoningToggleCache.current.get(key);
     if (!cached) {
       cached = /* @__PURE__ */ __name((open) => toggleReasoning(key, open), "cached");
@@ -3218,10 +3799,10 @@ function useTranscriptItems({ messages, visibleStart, streamingMessageId, option
   }, [
     toggleReasoning
   ]);
-  const pick = (0, import_react13.useCallback)((toolCallId, questionId, values) => {
+  const pick = (0, import_react16.useCallback)((toolCallId, questionId, values) => {
     setPicks((current) => new Map(current).set(pickKey(toolCallId, questionId), values));
   }, []);
-  const settle = (0, import_react13.useCallback)((toolCallId, action, send) => {
+  const settle = (0, import_react16.useCallback)((toolCallId, action, send) => {
     setSettleErrors((current) => {
       if (!current.has(toolCallId)) {
         return current;
@@ -3245,41 +3826,53 @@ function useTranscriptItems({ messages, visibleStart, streamingMessageId, option
       failed(error);
     }
   }, []);
-  const answer = (0, import_react13.useCallback)((toolCallId) => {
+  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_react13.useCallback)((toolCallId) => {
-    const onSkip = latest.current.options.onSkip;
+  const skip = (0, import_react16.useCallback)((toolCallId) => {
+    const onSkip = latest.current.handlers.onSkip;
     if (onSkip) {
-      settle(toolCallId, "skip", () => onSkip(toolCallId));
+      settle(toolCallId, "skip", () => onSkip({
+        toolCallId
+      }));
     }
   }, [
     settle
   ]);
-  const approve = (0, import_react13.useCallback)((toolCallId, options2) => {
-    const onApprove = latest.current.options.onApprove;
+  const approve = (0, import_react16.useCallback)((toolCallId, options2) => {
+    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_react13.useCallback)((toolCallId) => {
-    const onReject = latest.current.options.onReject;
+  const reject = (0, import_react16.useCallback)((toolCallId) => {
+    const onReject = latest.current.handlers.onReject;
     if (onReject) {
-      settle(toolCallId, "reject", () => onReject(toolCallId));
+      settle(toolCallId, "reject", () => onReject({
+        toolCallId
+      }));
     }
   }, [
     settle
   ]);
-  const callbacksFor = (0, import_react13.useCallback)((id) => {
+  const callbacksFor = (0, import_react16.useCallback)((id) => {
     const cached = callbackCache.current.get(id);
     if (cached) {
       return cached;
@@ -3329,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) {
@@ -3372,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;
@@ -3394,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"),
@@ -3419,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),
@@ -3454,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}`;
 }
@@ -3503,7 +4140,7 @@ function MessageItem({ message, isStreaming = false, editable, onEditSubmit, reg
       editable
     } : {},
     ...onEditSubmit ? {
-      onEditSubmit: /* @__PURE__ */ __name((_id, next) => onEditSubmit(next), "onEditSubmit")
+      onEditSubmit
     } : {},
     ...onFork ? {
       onFork
@@ -3512,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")
@@ -3521,7 +4158,7 @@ function MessageItem({ message, isStreaming = false, editable, onEditSubmit, reg
       getCreatedAt: /* @__PURE__ */ __name(() => createdAt, "getCreatedAt")
     } : {}
   });
-  return /* @__PURE__ */ import_react14.default.createElement(MessageItemView, {
+  return /* @__PURE__ */ import_react17.default.createElement(MessageItemView, {
     item,
     ...slots
   });
@@ -3534,51 +4171,51 @@ function MessageItemView({ item, ...given }) {
     renderUi: ambientRenderUi
   } : given;
   const { classNames } = slots;
-  const actionRow = /* @__PURE__ */ import_react14.default.createElement("div", {
+  const actionRow = /* @__PURE__ */ import_react17.default.createElement("div", {
     className: classNames?.actions,
     "data-actions-for": item.role
-  }, item.copy.available ? /* @__PURE__ */ import_react14.default.createElement("button", {
+  }, item.copy.available ? /* @__PURE__ */ import_react17.default.createElement("button", {
     type: "button",
     onClick: item.copy.copy,
     className: classNames?.actionButton,
     title: item.copy.copied ? "Copied!" : "Copy message text"
-  }, item.copy.copied ? "Copied" : "Copy") : null, item.fork.available ? /* @__PURE__ */ import_react14.default.createElement("button", {
+  }, item.copy.copied ? "Copied" : "Copy") : null, item.fork.available ? /* @__PURE__ */ import_react17.default.createElement("button", {
     type: "button",
     onClick: item.fork.run,
     className: classNames?.actionButton,
     title: "Fork thread from this message"
-  }, "Fork") : null, item.regenerate.available ? /* @__PURE__ */ import_react14.default.createElement("button", {
+  }, "Fork") : null, item.regenerate.available ? /* @__PURE__ */ import_react17.default.createElement("button", {
     type: "button",
     onClick: item.regenerate.run,
     className: classNames?.actionButton,
     title: "Regenerate response"
-  }, "Regenerate") : null, slots.meta, !item.isUser && item.usage ? /* @__PURE__ */ import_react14.default.createElement("span", {
+  }, "Regenerate") : null, slots.meta, !item.isUser && item.usage ? /* @__PURE__ */ import_react17.default.createElement("span", {
     className: classNames?.usage,
     title: `Input ${item.usage.inputTokens.toLocaleString()} \xB7 Output ${item.usage.outputTokens.toLocaleString()} tokens`
-  }, item.usage.costLabel, " \xB7 ", item.usage.tokensLabel) : null, item.timestamp ? /* @__PURE__ */ import_react14.default.createElement("span", {
+  }, item.usage.costLabel, " \xB7 ", item.usage.tokensLabel) : null, item.timestamp ? /* @__PURE__ */ import_react17.default.createElement("span", {
     className: classNames?.timestamp,
     title: item.timestamp.absolute
   }, item.timestamp.relative) : null);
   if (item.edit.available) {
-    return /* @__PURE__ */ import_react14.default.createElement(EditableUserBubble, {
+    return /* @__PURE__ */ import_react17.default.createElement(EditableUserBubble, {
       item,
       slots,
       actions: actionRow
     });
   }
   const className = joinClasses(classNames?.root, classNames?.byRole?.[item.role]);
-  return /* @__PURE__ */ import_react14.default.createElement("div", {
+  return /* @__PURE__ */ import_react17.default.createElement("div", {
     className,
     "data-role": item.role,
     "data-streaming": item.isStreaming ? "true" : void 0
-  }, /* @__PURE__ */ import_react14.default.createElement("div", null, renderBlocks(item, slots)), actionRow);
+  }, /* @__PURE__ */ import_react17.default.createElement("div", null, renderBlocks(item, slots)), actionRow);
 }
 __name(MessageItemView, "MessageItemView");
 function renderBlocks(item, slots) {
   const nodes = [];
   for (const block of item.blocks) {
     if (block.kind === "text") {
-      nodes.push(/* @__PURE__ */ import_react14.default.createElement("div", {
+      nodes.push(/* @__PURE__ */ import_react17.default.createElement("div", {
         key: block.key,
         className: slots.classNames?.text
       }, slots.renderText ? slots.renderText(block.text, {
@@ -3599,7 +4236,7 @@ function renderBlocks(item, slots) {
       continue;
     }
     if (block.kind === "ui" && slots.renderUi) {
-      nodes.push(/* @__PURE__ */ import_react14.default.createElement("div", {
+      nodes.push(/* @__PURE__ */ import_react17.default.createElement("div", {
         key: block.key,
         "data-slot": "ui",
         "data-component": block.component
@@ -3610,18 +4247,18 @@ function renderBlocks(item, slots) {
 }
 __name(renderBlocks, "renderBlocks");
 function renderFilesBlock(block, slots) {
-  return /* @__PURE__ */ import_react14.default.createElement("div", {
+  return /* @__PURE__ */ import_react17.default.createElement("div", {
     key: block.key,
     className: slots.classNames?.files,
     "data-files": "true"
-  }, slots.renderFiles ? slots.renderFiles(block.files) : block.files.map((file) => /* @__PURE__ */ import_react14.default.createElement("a", {
+  }, slots.renderFiles ? slots.renderFiles(block.files) : block.files.map((file) => /* @__PURE__ */ import_react17.default.createElement("a", {
     key: file.url,
     href: file.url,
     target: "_blank",
     rel: "noreferrer",
     className: slots.classNames?.file,
     title: file.filename ?? file.mediaType
-  }, file.isImage ? /* @__PURE__ */ import_react14.default.createElement("img", {
+  }, file.isImage ? /* @__PURE__ */ import_react17.default.createElement("img", {
     src: file.url,
     alt: file.filename ?? "image",
     className: slots.classNames?.fileImage
@@ -3629,17 +4266,17 @@ function renderFilesBlock(block, slots) {
 }
 __name(renderFilesBlock, "renderFilesBlock");
 function renderReasoningBlock(block, slots) {
-  return /* @__PURE__ */ import_react14.default.createElement("div", {
+  return /* @__PURE__ */ import_react17.default.createElement("div", {
     key: block.key,
     className: slots.classNames?.reasoning,
     "data-reasoning": "true",
     "data-streaming": block.isStreaming ? "true" : void 0
-  }, /* @__PURE__ */ import_react14.default.createElement("button", {
+  }, /* @__PURE__ */ import_react17.default.createElement("button", {
     type: "button",
     className: slots.classNames?.reasoningToggle,
     onClick: /* @__PURE__ */ __name(() => block.toggle(), "onClick"),
     "aria-expanded": block.isOpen
-  }, slots.reasoningLabel ?? "Reasoning"), block.isOpen ? /* @__PURE__ */ import_react14.default.createElement("div", {
+  }, slots.reasoningLabel ?? "Reasoning"), block.isOpen ? /* @__PURE__ */ import_react17.default.createElement("div", {
     className: slots.classNames?.reasoningText
   }, slots.renderReasoning ? slots.renderReasoning(block.text, {
     isStreaming: block.isStreaming,
@@ -3650,7 +4287,7 @@ __name(renderReasoningBlock, "renderReasoningBlock");
 function renderToolBlock(item, block, slots) {
   if (slots.renderToolGroup) {
     return [
-      /* @__PURE__ */ import_react14.default.createElement(import_react14.default.Fragment, {
+      /* @__PURE__ */ import_react17.default.createElement(import_react17.default.Fragment, {
         key: block.key
       }, slots.renderToolGroup(block.parts, block.key))
     ];
@@ -3661,7 +4298,7 @@ function renderToolBlock(item, block, slots) {
   const renderToolPart = slots.renderToolPart;
   return block.parts.map((part) => {
     const partKey = `${item.id}-${part.toolCallId}`;
-    return /* @__PURE__ */ import_react14.default.createElement(import_react14.default.Fragment, {
+    return /* @__PURE__ */ import_react17.default.createElement(import_react17.default.Fragment, {
       key: partKey
     }, renderToolPart(part, partKey));
   });
@@ -3671,14 +4308,14 @@ function EditableUserBubble({ item, slots, actions }) {
   const { classNames } = slots;
   const { edit } = item;
   if (!edit.isEditing) {
-    return /* @__PURE__ */ import_react14.default.createElement("div", {
+    return /* @__PURE__ */ import_react17.default.createElement("div", {
       className: joinClasses(classNames?.root, classNames?.byRole?.user),
       "data-role": "user"
-    }, /* @__PURE__ */ import_react14.default.createElement("div", {
+    }, /* @__PURE__ */ import_react17.default.createElement("div", {
       className: classNames?.text
     }, slots.renderText ? slots.renderText(item.text, {
       isStreaming: false
-    }) : item.text), /* @__PURE__ */ import_react14.default.createElement("button", {
+    }) : item.text), /* @__PURE__ */ import_react17.default.createElement("button", {
       type: "button",
       onClick: edit.start,
       className: classNames?.actionButton,
@@ -3686,18 +4323,18 @@ function EditableUserBubble({ item, slots, actions }) {
     }, "Edit"), actions);
   }
   const textareaProps = edit.getTextareaProps();
-  return /* @__PURE__ */ import_react14.default.createElement("div", {
+  return /* @__PURE__ */ import_react17.default.createElement("div", {
     "data-editing": "true"
-  }, /* @__PURE__ */ import_react14.default.createElement("textarea", {
+  }, /* @__PURE__ */ import_react17.default.createElement("textarea", {
     ...textareaProps,
     rows: Math.min(8, edit.draft.split("\n").length + 1),
     className: classNames?.editTextarea
-  }), /* @__PURE__ */ import_react14.default.createElement("div", {
+  }), /* @__PURE__ */ import_react17.default.createElement("div", {
     className: classNames?.editActions
-  }, /* @__PURE__ */ import_react14.default.createElement("button", {
+  }, /* @__PURE__ */ import_react17.default.createElement("button", {
     type: "button",
     onClick: edit.cancel
-  }, "Cancel"), /* @__PURE__ */ import_react14.default.createElement("button", {
+  }, "Cancel"), /* @__PURE__ */ import_react17.default.createElement("button", {
     type: "button",
     onClick: edit.save,
     disabled: !edit.canSave
@@ -3907,11 +4544,11 @@ function createSkillsSource(options) {
       if (cached) {
         return cached;
       }
-      const listSkills = options.client.listSkills;
+      const listSkills = options.backend.listSkills;
       if (listSkills === void 0) {
         return Promise.reject(new AgentBackendUnsupportedError("listSkills"));
       }
-      const pending = listSkills.call(options.client, threadId).then((entries) => entries.map(toItem)).catch((error) => {
+      const pending = listSkills.call(options.backend, threadId).then((entries) => entries.map(toItem)).catch((error) => {
         byThread.delete(key);
         throw error;
       });
@@ -3941,35 +4578,35 @@ function toItem(entry) {
 __name(toItem, "toItem");
 
 // src/composer/use-composer-autocomplete.ts
-var import_react15 = require("react");
+var import_react18 = require("react");
 function useComposerAutocomplete(options) {
   const { value, sources, acceptOnTab = true } = options;
-  const latest = (0, import_react15.useRef)(options);
+  const latest = (0, import_react18.useRef)(options);
   latest.current = options;
-  const inputRef = (0, import_react15.useRef)(null);
-  const [caret, setCaret] = (0, import_react15.useState)(value.length);
-  const [items, setItems] = (0, import_react15.useState)([]);
-  const [isLoading, setLoading] = (0, import_react15.useState)(false);
-  const [error, setError] = (0, import_react15.useState)(null);
-  const [activeIndex, setActiveIndex] = (0, import_react15.useState)(0);
-  const [dismissedIndex, setDismissedIndex] = (0, import_react15.useState)(null);
+  const inputRef = (0, import_react18.useRef)(null);
+  const [caret, setCaret] = (0, import_react18.useState)(value.length);
+  const [items, setItems] = (0, import_react18.useState)([]);
+  const [isLoading, setLoading] = (0, import_react18.useState)(false);
+  const [error, setError] = (0, import_react18.useState)(null);
+  const [activeIndex, setActiveIndex] = (0, import_react18.useState)(0);
+  const [dismissedIndex, setDismissedIndex] = (0, import_react18.useState)(null);
   const safeCaret = Math.min(caret, value.length);
-  const match = (0, import_react15.useMemo)(() => findActiveTrigger(value, safeCaret, sources), [
+  const match = (0, import_react18.useMemo)(() => findActiveTrigger(value, safeCaret, sources), [
     value,
     safeCaret,
     sources
   ]);
   const isActive = match !== null && dismissedIndex !== match.index;
-  const matchRef = (0, import_react15.useRef)(match);
+  const matchRef = (0, import_react18.useRef)(match);
   matchRef.current = match;
-  const caretRef = (0, import_react15.useRef)(safeCaret);
+  const caretRef = (0, import_react18.useRef)(safeCaret);
   caretRef.current = safeCaret;
-  const itemsRef = (0, import_react15.useRef)(items);
+  const itemsRef = (0, import_react18.useRef)(items);
   itemsRef.current = items;
-  const activeIndexRef = (0, import_react15.useRef)(activeIndex);
+  const activeIndexRef = (0, import_react18.useRef)(activeIndex);
   activeIndexRef.current = activeIndex;
   const requestKey = isActive && match ? `${match.source.id}\0${match.query}` : null;
-  (0, import_react15.useEffect)(() => {
+  (0, import_react18.useEffect)(() => {
     const current = matchRef.current;
     if (requestKey === null || current === null) {
       setItems([]);
@@ -4017,25 +4654,25 @@ function useComposerAutocomplete(options) {
   ]);
   const isOpen = isActive;
   const activeItem = isOpen ? items[activeIndex] ?? null : null;
-  const reactId = (0, import_react15.useId)();
+  const reactId = (0, import_react18.useId)();
   const listboxId = options.id ?? `agent-autocomplete-${reactId}`;
-  const optionId = (0, import_react15.useCallback)((index) => `${listboxId}-option-${index}`, [
+  const optionId = (0, import_react18.useCallback)((index) => `${listboxId}-option-${index}`, [
     listboxId
   ]);
-  const highlight = (0, import_react15.useCallback)((index) => {
+  const highlight = (0, import_react18.useCallback)((index) => {
     const total = itemsRef.current.length;
     if (total === 0) return;
     setActiveIndex((index % total + total) % total);
   }, []);
-  const moveHighlight = (0, import_react15.useCallback)((delta) => highlight(activeIndexRef.current + delta), [
+  const moveHighlight = (0, import_react18.useCallback)((delta) => highlight(activeIndexRef.current + delta), [
     highlight
   ]);
-  const dismiss = (0, import_react15.useCallback)(() => {
+  const dismiss = (0, import_react18.useCallback)(() => {
     const current = matchRef.current;
     if (current) setDismissedIndex(current.index);
   }, []);
-  const pendingCaret = (0, import_react15.useRef)(null);
-  const accept = (0, import_react15.useCallback)((item) => {
+  const pendingCaret = (0, import_react18.useRef)(null);
+  const accept = (0, import_react18.useCallback)((item) => {
     const current = matchRef.current;
     if (!current) return;
     const chosen = item ?? itemsRef.current[activeIndexRef.current];
@@ -4046,16 +4683,16 @@ function useComposerAutocomplete(options) {
     setDismissedIndex(null);
     pendingCaret.current = edit.caret;
   }, []);
-  (0, import_react15.useLayoutEffect)(() => {
+  (0, import_react18.useLayoutEffect)(() => {
     const position = pendingCaret.current;
     if (position === null) return;
     pendingCaret.current = null;
     inputRef.current?.setSelectionRange(position, position);
   });
-  const readCaret = (0, import_react15.useCallback)((element) => {
+  const readCaret = (0, import_react18.useCallback)((element) => {
     setCaret(element.selectionStart ?? element.value.length);
   }, []);
-  const onKeyDown = (0, import_react15.useCallback)((event) => {
+  const onKeyDown = (0, import_react18.useCallback)((event) => {
     if (!isOpen) return;
     const hasItems = itemsRef.current.length > 0;
     switch (event.key) {
@@ -4093,23 +4730,23 @@ function useComposerAutocomplete(options) {
     dismiss,
     moveHighlight
   ]);
-  const onChange = (0, import_react15.useCallback)((event) => {
+  const onChange = (0, import_react18.useCallback)((event) => {
     readCaret(event.target);
     const next = findActiveTrigger(event.target.value, event.target.selectionStart ?? event.target.value.length, latest.current.sources);
     setDismissedIndex((current) => current !== null && next?.index === current ? current : null);
   }, [
     readCaret
   ]);
-  const onSelect = (0, import_react15.useCallback)((event) => readCaret(event.currentTarget), [
+  const onSelect = (0, import_react18.useCallback)((event) => readCaret(event.currentTarget), [
     readCaret
   ]);
-  const onClick = (0, import_react15.useCallback)((event) => readCaret(event.currentTarget), [
+  const onClick = (0, import_react18.useCallback)((event) => readCaret(event.currentTarget), [
     readCaret
   ]);
-  const setInput = (0, import_react15.useCallback)((element) => {
+  const setInput = (0, import_react18.useCallback)((element) => {
     inputRef.current = element;
   }, []);
-  const getInputProps = (0, import_react15.useCallback)(() => ({
+  const getInputProps = (0, import_react18.useCallback)(() => ({
     ref: setInput,
     onChange,
     onKeyDown,
@@ -4137,7 +4774,7 @@ function useComposerAutocomplete(options) {
     activeIndex,
     optionId
   ]);
-  const getListboxProps = (0, import_react15.useCallback)(() => ({
+  const getListboxProps = (0, import_react18.useCallback)(() => ({
     id: listboxId,
     role: "listbox",
     "aria-label": match?.source.label ?? match?.source.id ?? "Suggestions"
@@ -4145,7 +4782,7 @@ function useComposerAutocomplete(options) {
     listboxId,
     match
   ]);
-  const getOptionProps = (0, import_react15.useCallback)((index) => ({
+  const getOptionProps = (0, import_react18.useCallback)((index) => ({
     id: optionId(index),
     role: "option",
     "aria-selected": index === activeIndex
@@ -4179,7 +4816,7 @@ function isPromise(value) {
 __name(isPromise, "isPromise");
 
 // src/presentation/use-tool-catalog.ts
-var import_react16 = require("react");
+var import_react19 = require("react");
 var shared = /* @__PURE__ */ new WeakMap();
 function load(client, agent) {
   let byAgent = shared.get(client);
@@ -4201,13 +4838,14 @@ function load(client, agent) {
   return request;
 }
 __name(load, "load");
-function useToolCatalog(options) {
-  const { client, agent, enabled = true } = options;
-  const [entries, setEntries] = (0, import_react16.useState)([]);
-  const [isLoading, setLoading] = (0, import_react16.useState)(enabled);
-  const [error, setError] = (0, import_react16.useState)(null);
-  const [generation, setGeneration] = (0, import_react16.useState)(0);
-  (0, import_react16.useEffect)(() => {
+function useToolCatalog(options = {}) {
+  const { agent, enabled = true } = options;
+  const client = useAgentBackend(options.backend);
+  const [entries, setEntries] = (0, import_react19.useState)([]);
+  const [isLoading, setLoading] = (0, import_react19.useState)(enabled);
+  const [error, setError] = (0, import_react19.useState)(null);
+  const [generation, setGeneration] = (0, import_react19.useState)(0);
+  (0, import_react19.useEffect)(() => {
     if (!enabled) {
       setLoading(false);
       return;
@@ -4216,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) => {
@@ -4233,14 +4871,14 @@ function useToolCatalog(options) {
     enabled,
     generation
   ]);
-  const refresh = (0, import_react16.useCallback)(() => {
+  const refresh = (0, import_react19.useCallback)(() => {
     shared.get(client)?.delete(agent ?? "");
     setGeneration((current) => current + 1);
   }, [
     client,
     agent
   ]);
-  const catalog = (0, import_react16.useMemo)(() => toolCatalogFrom(entries), [
+  const catalog = (0, import_react19.useMemo)(() => toolCatalogFrom(entries), [
     entries
   ]);
   return {
@@ -4254,7 +4892,7 @@ function useToolCatalog(options) {
 __name(useToolCatalog, "useToolCatalog");
 
 // src/approvals/countdown.ts
-var import_react17 = require("react");
+var import_react20 = require("react");
 function approvalCountdown(expiresAt, now = Date.now()) {
   const deadline = expiresAt == null ? Number.NaN : Date.parse(expiresAt);
   if (!Number.isFinite(deadline)) {
@@ -4272,10 +4910,10 @@ function approvalCountdown(expiresAt, now = Date.now()) {
 __name(approvalCountdown, "approvalCountdown");
 function useApprovalCountdown(expiresAt, options = {}) {
   const { intervalMs = 1e3 } = options;
-  const nowRef = (0, import_react17.useRef)(options.now ?? Date.now);
+  const nowRef = (0, import_react20.useRef)(options.now ?? Date.now);
   nowRef.current = options.now ?? Date.now;
-  const [state, setState] = (0, import_react17.useState)(() => approvalCountdown(expiresAt, nowRef.current()));
-  (0, import_react17.useEffect)(() => {
+  const [state, setState] = (0, import_react20.useState)(() => approvalCountdown(expiresAt, nowRef.current()));
+  (0, import_react20.useEffect)(() => {
     const read = /* @__PURE__ */ __name(() => approvalCountdown(expiresAt, nowRef.current()), "read");
     const first = read();
     setState(first);
@@ -4444,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
     } : {}
   };
 }
@@ -4489,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 {
@@ -4522,69 +5177,63 @@ function sumUsage(rows) {
 __name(sumUsage, "sumUsage");
 
 // src/use-agent-chat.ts
-var import_react18 = require("@ai-sdk/react");
-var import_react19 = require("react");
-function useAgentChat(options) {
-  const latest = (0, import_react19.useRef)(options);
+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 [runId, setRunId] = (0, import_react19.useState)(options.resumeRunId);
-  const runIdRef = (0, import_react19.useRef)(runId);
+  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_react19.useRef)(void 0);
-  const autoResumeRunIdRef = (0, import_react19.useRef)(void 0);
-  const [autoResume, setAutoResume] = (0, import_react19.useState)(false);
-  const [activeRunId, setActiveRunId] = (0, import_react19.useState)(null);
-  const regenerateNext = (0, import_react19.useRef)(false);
-  const createdThreadId = (0, import_react19.useRef)(void 0);
-  const client = (0, import_react19.useMemo)(() => {
-    if (options.backend) return options.backend;
-    if (options.client) return options.client;
-    return new AgentClient({
-      ...options.baseUrl !== void 0 ? {
-        baseUrl: options.baseUrl
-      } : {},
-      ...options.credentials !== void 0 ? {
-        credentials: options.credentials
-      } : {},
-      ...options.fetch !== void 0 ? {
-        fetch: options.fetch
-      } : {},
-      ...options.attachments !== void 0 ? {
-        attachments: options.attachments
-      } : {},
-      getHeaders: /* @__PURE__ */ __name(async () => mergeHeaders(latest.current), "getHeaders")
-    });
-  }, []);
-  const [connection, setConnection] = (0, import_react19.useState)({
+  const settlingRunIdRef = (0, import_react22.useRef)(void 0);
+  const autoResumeRunIdRef = (0, import_react22.useRef)(void 0);
+  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 currentThreadId = (0, import_react22.useCallback)(() => latest.current.threadId ?? createdThreadId.current, []);
+  const [connection, setConnection] = (0, import_react22.useState)({
     status: "live"
   });
-  const resyncAfterSettle = (0, import_react19.useRef)(false);
-  (0, import_react19.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_react19.useMemo)(() => {
+  const resyncAfterSettle = (0, import_react22.useRef)(false);
+  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"
@@ -4611,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
@@ -4634,13 +5284,11 @@ function useAgentChat(options) {
       }, "onAttemptStart")
     });
   }, []);
-  const backgroundRef = (0, import_react19.useRef)(() => Promise.resolve());
-  const chat = (0, import_react18.useChat)({
+  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
     } : {},
@@ -4650,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,
@@ -4683,10 +5331,10 @@ function useAgentChat(options) {
       }
     }, "onFinish")
   });
-  const chatRef = (0, import_react19.useRef)(chat);
+  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);
@@ -4695,13 +5343,75 @@ function useAgentChat(options) {
     }
   }
   __name(resyncFromThread, "resyncFromThread");
-  const turnInFlight = (0, import_react19.useRef)(false);
-  const isTurnInFlight = (0, import_react19.useCallback)(() => turnInFlight.current || transport.isAttemptLive, [
+  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 sendMessage = (0, import_react19.useCallback)(async (...args) => {
-    const blocked = latest.current.blocked;
-    if (blocked != null) throw new QuotaBlockedError(blocked);
+  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 block = blockedRef.current;
+    if (block != null) throw new QuotaBlockedError(block);
     if (isTurnInFlight()) return;
     turnInFlight.current = true;
     try {
@@ -4712,16 +5422,14 @@ function useAgentChat(options) {
   }, [
     isTurnInFlight
   ]);
-  const addToolResult = (0, import_react19.useCallback)(({ tool, toolCallId, output }) => chatRef.current.addToolResult({
+  const addToolResult = (0, import_react22.useCallback)(({ tool, toolCallId, output }) => chatRef.current.addToolResult({
     tool,
     toolCallId,
     output
   }), []);
-  const [threads, setThreads] = (0, import_react19.useState)([]);
-  const [quota, setQuota] = (0, import_react19.useState)(null);
-  const [backgroundRuns, setBackgroundRuns] = (0, import_react19.useState)([]);
-  const refreshBackground = (0, import_react19.useCallback)(async () => {
-    const threadId = latest.current.threadId ?? createdThreadId.current;
+  const [backgroundRuns, setBackgroundRuns] = (0, import_react22.useState)([]);
+  const refreshBackground = (0, import_react22.useCallback)(async () => {
+    const threadId = currentThreadId();
     if (threadId === void 0) {
       return;
     }
@@ -4741,11 +5449,12 @@ function useAgentChat(options) {
       ];
     });
   }, [
-    client
+    client,
+    currentThreadId
   ]);
   backgroundRef.current = refreshBackground;
   const isWorking = backgroundRuns.some((run) => run.status === "running");
-  (0, import_react19.useEffect)(() => {
+  (0, import_react22.useEffect)(() => {
     if (options.background !== true || options.threadId === void 0) {
       return;
     }
@@ -4753,9 +5462,10 @@ function useAgentChat(options) {
   }, [
     options.background,
     options.threadId,
+    chatId,
     refreshBackground
   ]);
-  (0, import_react19.useEffect)(() => {
+  (0, import_react22.useEffect)(() => {
     const every = latest.current.backgroundPollMs ?? 5e3;
     if (latest.current.background !== true || !isWorking || every <= 0) {
       return;
@@ -4766,66 +5476,19 @@ function useAgentChat(options) {
     isWorking,
     refreshBackground
   ]);
-  const loadThreads = (0, import_react19.useCallback)(async () => {
-    const list = await client.listThreads();
-    setThreads(list);
-    return list;
-  }, [
-    client
-  ]);
-  const loadThread = (0, import_react19.useCallback)((id) => client.getThread(id), [
-    client
-  ]);
-  const deleteThread = (0, import_react19.useCallback)(async (id) => {
-    await client.deleteThread(id);
-    setThreads((current) => current.filter((thread) => thread.id !== id));
-  }, [
-    client
-  ]);
-  const forkThread = (0, import_react19.useCallback)((threadId, messageId) => requireBackendMethod(client, "forkFromMessage")(threadId, messageId), [
-    client
-  ]);
-  const renameThread = (0, import_react19.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_react19.useCallback)(async (id) => {
-    await requireBackendMethod(client, "promoteThread")(id);
-    await loadThreads();
-  }, [
-    client,
-    loadThreads
-  ]);
-  const truncateFromMessage = (0, import_react19.useCallback)((threadId, messageId) => requireBackendMethod(client, "truncateFromMessage")(threadId, messageId).then(() => void 0), [
-    client
-  ]);
-  const loadQuota = (0, import_react19.useCallback)(async () => {
-    const today = await requireBackendMethod(client, "getQuotaToday")();
-    setQuota(today);
-    return today;
-  }, [
-    client
-  ]);
-  const cancel = (0, import_react19.useCallback)(async () => {
+  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 {
       }
     }
   }, [
     client
   ]);
-  const approve = (0, import_react19.useCallback)(async ({ toolCallId, remember, via }) => {
+  const approve = (0, import_react22.useCallback)(async ({ toolCallId, remember, via }) => {
     await requireBackendMethod(client, "approveToolCall")({
       toolCallId,
       ...remember === true ? {
@@ -4838,7 +5501,7 @@ function useAgentChat(options) {
   }, [
     client
   ]);
-  const reject = (0, import_react19.useCallback)(async ({ toolCallId, reason, via }) => {
+  const reject = (0, import_react22.useCallback)(async ({ toolCallId, reason, via }) => {
     await requireBackendMethod(client, "rejectToolCall")({
       toolCallId,
       ...reason !== void 0 ? {
@@ -4851,7 +5514,7 @@ function useAgentChat(options) {
   }, [
     client
   ]);
-  const answer = (0, import_react19.useCallback)(async ({ toolCallId, answers }) => {
+  const answer = (0, import_react22.useCallback)(async ({ toolCallId, answers }) => {
     await requireBackendMethod(client, "answerToolCall")({
       toolCallId,
       ...answers !== void 0 ? {
@@ -4861,16 +5524,16 @@ function useAgentChat(options) {
   }, [
     client
   ]);
-  const skip = (0, import_react19.useCallback)(async ({ toolCallId }) => {
+  const skip = (0, import_react22.useCallback)(async ({ toolCallId }) => {
     await requireBackendMethod(client, "skipToolCall")({
       toolCallId
     });
   }, [
     client
   ]);
-  const regenerate = (0, import_react19.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;
@@ -4880,15 +5543,78 @@ function useAgentChat(options) {
   }, [
     isTurnInFlight
   ]);
-  const background = {
-    runs: backgroundRuns,
-    isWorking,
-    refresh: refreshBackground
-  };
-  const setThreadModel = (0, import_react19.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
@@ -4897,10 +5623,99 @@ function useAgentChat(options) {
       type: "changed"
     });
   }, [
-    client
+    client,
+    currentThreadId
   ]);
-  const getThreadId = (0, import_react19.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,
@@ -4911,34 +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,
-    /** The backend this chat talks to — pass it to `useThreads`, `useMessageFeedback`, … */
+    getThreadId: currentThreadId,
+    /** The backend this chat talks to — the same one every other hook under the provider uses. */
     backend: client,
-    /** Same object as {@link backend}; kept for callers that read it under its old name. */
-    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");
@@ -4952,20 +5771,13 @@ var QuotaBlockedError = class extends Error {
     this.name = "QuotaBlockedError";
   }
 };
-async function mergeHeaders(options) {
-  const dynamic = await options.getHeaders?.() ?? {};
-  return {
-    ...options.headers,
-    ...dynamic
-  };
-}
-__name(mergeHeaders, "mergeHeaders");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AgentBackendUnsupportedError,
   AgentChatTransport,
   AgentClient,
   AgentHttpError,
+  AgentProvider,
   AmbientRenderUiContext,
   ChatInput,
   DEFAULT_SPEECH_LANG,
@@ -5011,6 +5823,7 @@ __name(mergeHeaders, "mergeHeaders");
   storedThreadToUiMessages,
   toolCallState,
   toolCatalogFrom,
+  useAgentBackend,
   useAgentChat,
   useAgents,
   useAmbientRenderUi,