@dudousxd/nestjs-agent-react 0.31.5 → 0.33.0

package/dist/index.js

@@ -9,9 +9,9 @@ function readErrorAnswer(text) {
   }
   if (body === null || typeof body !== "object")
     return { body, message: void 0, code: void 0 };
-  const record = body;
-  const message = typeof record.message === "string" && record.message !== "" ? record.message : Array.isArray(record.message) && record.message.length > 0 && record.message.every((each) => typeof each === "string") ? record.message.join("; ") : void 0;
-  const code = typeof record.code === "string" && record.code !== "" ? record.code : void 0;
+  const record2 = body;
+  const message = typeof record2.message === "string" && record2.message !== "" ? record2.message : Array.isArray(record2.message) && record2.message.length > 0 && record2.message.every((each) => typeof each === "string") ? record2.message.join("; ") : void 0;
+  const code = typeof record2.code === "string" && record2.code !== "" ? record2.code : void 0;
   return { body, message, code };
 }
 async function readErrorResponse(response) {
@@ -88,6 +88,12 @@ var AgentClient = class {
     if (response.status === 202) {
       return { body: emptyStream(), queued: await response.json() };
     }
+    if (response.ok && response.headers.get("content-type")?.includes("application/json")) {
+      const decision = await response.json();
+      if (decision.proposalDecision !== void 0 && typeof decision.threadId === "string")
+        return { body: emptyStream(), threadId: decision.threadId, proposalDecision: decision };
+      throw new Error("Unexpected JSON chat response");
+    }
     if (!response.ok || !response.body) {
       throw await this.failure(response, "POST", `${this.agentPath()}/chat`);
     }
@@ -320,6 +326,54 @@ var AgentClient = class {
    * `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).
    */
+  async listActionProposals({ threadId }) {
+    const proposals = /* @__PURE__ */ new Map();
+    let after;
+    for (; ; ) {
+      const route = `/threads/${encodeURIComponent(threadId)}/action-proposals${after === void 0 ? "" : `?after=${encodeURIComponent(JSON.stringify(after))}`}`;
+      const response = await this.requestResponse("GET", route);
+      const page = await this.handleResponse(
+        response,
+        "GET",
+        `${this.agentPath()}${route}`
+      );
+      if (!Array.isArray(page)) throw new TypeError("Invalid action proposal page");
+      for (const proposal of page) proposals.set(proposal.id, proposal);
+      const header = response.headers.get("X-Action-Proposals-Next");
+      if (header === null) return [...proposals.values()];
+      let next;
+      try {
+        next = JSON.parse(decodeURIComponent(header));
+      } catch {
+        throw new TypeError("Invalid action proposal cursor");
+      }
+      if (typeof next !== "object" || next === null || !("createdAt" in next) || typeof next.createdAt !== "number" || !Number.isSafeInteger(next.createdAt) || !("id" in next) || typeof next.id !== "string" || next.id.length === 0 || next.id.length > 255 || after !== void 0 && (next.createdAt < after.createdAt || next.createdAt === after.createdAt && next.id <= after.id))
+        throw new TypeError("Invalid or non-advancing action proposal cursor");
+      after = { createdAt: next.createdAt, id: next.id };
+    }
+  }
+  approveActionProposal({
+    threadId,
+    proposalId,
+    remember
+  }) {
+    return this.request(
+      "POST",
+      `/threads/${encodeURIComponent(threadId)}/action-proposals/${encodeURIComponent(proposalId)}/approve`,
+      remember === void 0 ? {} : { remember }
+    );
+  }
+  rejectActionProposal({
+    threadId,
+    proposalId,
+    reason
+  }) {
+    return this.request(
+      "POST",
+      `/threads/${encodeURIComponent(threadId)}/action-proposals/${encodeURIComponent(proposalId)}/reject`,
+      reason === void 0 ? {} : { reason }
+    );
+  }
   approveToolCall(input) {
     return this.request("POST", "/tool-call/approve", input);
   }
@@ -376,6 +430,10 @@ var AgentClient = class {
     return this.options.credentials !== void 0 ? { credentials: this.options.credentials } : {};
   }
   async request(method, route, body) {
+    const response = await this.requestResponse(method, route, body);
+    return this.handleResponse(response, method, `${this.agentPath()}${route}`);
+  }
+  async requestResponse(method, route, body) {
     const path = `${this.agentPath()}${route}`;
     const response = await this.fetchImpl()(`${this.baseUrl()}${path}`, {
       method,
@@ -387,7 +445,7 @@ var AgentClient = class {
       ...body !== void 0 ? { body: JSON.stringify(body) } : {},
       ...this.credentials()
     });
-    return this.handleResponse(response, method, path);
+    return response;
   }
   /** The error for a refused `response`, already reported to `onHttpError`. */
   async failure(response, method, path) {
@@ -527,6 +585,7 @@ var AgentChatTransport = class {
       const message = lastMessage ? extractText(lastMessage) : "";
       const body = {
         ...this.options.agent !== void 0 ? { agent: this.options.agent } : {},
+        ...this.options.persona !== void 0 ? { persona: this.options.persona } : {},
         ...this.options.getBody?.() ?? {},
         ...options.body ?? {},
         message
@@ -542,6 +601,10 @@ var AgentChatTransport = class {
         return queuedChunkStream(response.queued);
       }
       this.captureHeaderMeta(response);
+      if (response.proposalDecision !== void 0) {
+        this.attemptLive = false;
+        return proposalDecisionChunkStream(response.proposalDecision);
+      }
       return this.toChunkStream(response, {
         ...headers !== void 0 ? { headers } : {},
         ...options.abortSignal ? { signal: options.abortSignal } : {}
@@ -668,7 +731,7 @@ var AgentChatTransport = class {
     let reasoningSeq = 0;
     const announced = /* @__PURE__ */ new Set();
     const toolMetadata = /* @__PURE__ */ new Map();
-    const record = (meta) => {
+    const record2 = (meta) => {
       streamRunId = meta.runId;
       this.recordMeta(meta);
     };
@@ -956,7 +1019,7 @@ var AgentChatTransport = class {
               }
               if (frame.event === "meta") {
                 const meta = parseMeta(frame.data);
-                if (meta) record(meta);
+                if (meta) record2(meta);
               } else if (frame.data) {
                 const event = parseEvent(frame.data);
                 if (event) emit(event);
@@ -1024,10 +1087,10 @@ function parseErrorFrame(data) {
   try {
     const parsed = JSON.parse(data);
     if (parsed !== null && typeof parsed === "object") {
-      const record = parsed;
+      const record2 = parsed;
       return {
-        code: typeof record.code === "string" && record.code !== "" ? record.code : void 0,
-        message: typeof record.message === "string" && record.message !== "" ? record.message : fallback2.message
+        code: typeof record2.code === "string" && record2.code !== "" ? record2.code : void 0,
+        message: typeof record2.message === "string" && record2.message !== "" ? record2.message : fallback2.message
       };
     }
   } catch {
@@ -1067,6 +1130,21 @@ function delay(ms, signal) {
     signal?.addEventListener("abort", done, { once: true });
   });
 }
+function proposalDecisionChunkStream(decision) {
+  return new ReadableStream({
+    start(controller) {
+      controller.enqueue({ type: "start", messageId: `decision:${crypto.randomUUID()}` });
+      controller.enqueue({ type: "data-proposal-decision", data: decision, transient: true });
+      if (decision.text !== void 0 && decision.text.length > 0) {
+        controller.enqueue({ type: "text-start", id: "decision" });
+        controller.enqueue({ type: "text-delta", id: "decision", delta: decision.text });
+        controller.enqueue({ type: "text-end", id: "decision" });
+      }
+      controller.enqueue({ type: "finish", finishReason: "stop" });
+      controller.close();
+    }
+  });
+}
 
 // src/attachments/files.ts
 function fileKind(mediaType) {
@@ -1205,6 +1283,10 @@ function toGenerativeUIItem(part) {
   return {
     id,
     component: source.component,
+    ...isRecord(source.componentVersions) && Object.values(source.componentVersions).every(
+      (version) => typeof version === "number" && Number.isSafeInteger(version) && version > 0
+    ) ? { componentVersions: { ...source.componentVersions } } : {},
+    ...typeof source.fallbackText === "string" ? { fallbackText: source.fallbackText } : {},
     props: isRecord(source.props) ? source.props : {},
     version: typeof source.version === "number" ? source.version : null,
     toolCallId: typeof source.toolCallId === "string" ? source.toolCallId : null
@@ -1310,20 +1392,29 @@ function useValidatedProps(catalog, name, props) {
 function useGenerativeUIState(part, options, fallbackTree) {
   const item = useMemo(() => toGenerativeUIItem(part), [part]);
   const name = item?.component ?? "";
+  const definition = options.catalog?.get?.(name);
+  const incompatible = item?.fallbackText !== void 0 && item.version !== null && definition !== void 0 && item.version !== (definition.version ?? 1);
   const resolution = useResolvedComponent(
     name,
     item?.version ?? null,
-    options.registry,
+    incompatible ? {} : options.registry,
     item === null ? void 0 : options.resolveComponent,
     fallbackTree
   );
   const empty = useMemo(() => ({}), []);
   const validation = useValidatedProps(
-    item === null || name === GENUI_TREE_COMPONENT ? void 0 : options.catalog,
+    item === null || name === GENUI_TREE_COMPONENT || incompatible ? void 0 : options.catalog,
     name,
     item?.props ?? empty
   );
   if (item === null) return null;
+  if (name === GENUI_TREE_COMPONENT && item.fallbackText !== void 0 && (!isRecord(item.props.root) || typeof item.props.root.type !== "string"))
+    return {
+      status: "problem",
+      reason: "invalid",
+      item,
+      issues: [{ path: ["root"], message: "Invalid UI tree root" }]
+    };
   if (resolution.status === "loading") return { status: "loading", item };
   if (resolution.status === "unknown") return { status: "problem", reason: "unknown", item };
   if (resolution.status === "error") {
@@ -1341,7 +1432,8 @@ import { jsx } from "react/jsx-runtime";
 var TreeScopeContext = createContext2(null);
 function renderFallback(fallback2, problem) {
   if (typeof fallback2 === "function") return fallback2(problem);
-  return fallback2 ?? null;
+  if (fallback2 !== void 0) return fallback2;
+  return problem.item.fallbackText !== void 0 ? /* @__PURE__ */ jsx("span", { style: { whiteSpace: "pre-wrap" }, children: problem.item.fallbackText }) : null;
 }
 var ItemBoundary = class extends Component {
   state = { error: void 0, failed: false };
@@ -1373,28 +1465,42 @@ function nodeItem(node, id) {
 function TreeNode({ node, id }) {
   const scope = useContext2(TreeScopeContext);
   const item = useMemo2(() => nodeItem(node, id), [node, id]);
+  const storedVersion = scope?.componentVersions?.[node.type];
+  const definition = scope?.options.catalog?.get?.(node.type);
+  const incompatible = storedVersion !== void 0 && definition !== void 0 && storedVersion !== (definition.version ?? 1);
   const resolution = useResolvedComponent(
     node.type,
-    null,
-    scope?.options.registry ?? {},
+    storedVersion ?? null,
+    incompatible ? {} : scope?.options.registry ?? {},
     scope?.options.resolveComponent
   );
-  const validation = useValidatedProps(scope?.options.catalog, node.type, item.props);
+  const validation = useValidatedProps(
+    incompatible ? void 0 : 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") {
+    if (scope.fallback === void 0 && scope.fallbackText !== void 0)
+      throw new Error("Unknown tree component");
     return renderFallback(scope.fallback, { reason: "unknown", item });
   }
   if (resolution.status === "error") {
+    if (scope.fallback === void 0 && scope.fallbackText !== void 0) throw resolution.error;
     return renderFallback(scope.fallback, { reason: "error", item, error: resolution.error });
   }
   if (validation.status === "invalid") {
+    if (scope.fallback === void 0 && scope.fallbackText !== void 0)
+      throw new Error("Invalid tree component");
     return renderFallback(scope.fallback, { reason: "invalid", item, issues: validation.issues });
   }
   const Renderer = resolution.Component;
   const children = Array.isArray(node.children) ? node.children : [];
   return /* @__PURE__ */ jsx(Renderer, { ...validation.props, children: children.length > 0 ? children.map((child, index) => {
     const childId = `${id}.${index}`;
+    if (scope.fallback === void 0 && scope.fallbackText !== void 0)
+      return /* @__PURE__ */ jsx(TreeNode, { node: child, id: childId }, childId);
     return /* @__PURE__ */ jsx(
       ItemBoundary,
       {
@@ -1416,6 +1522,8 @@ function GenerativeUIScope({
   catalog,
   resolveComponent,
   fallback: fallback2,
+  fallbackText,
+  componentVersions,
   loading = null,
   onError,
   children
@@ -1428,10 +1536,21 @@ function GenerativeUIScope({
         ...resolveComponent !== void 0 ? { resolveComponent } : {}
       },
       fallback: fallback2,
+      ...componentVersions !== void 0 ? { componentVersions } : {},
+      ...fallbackText !== void 0 ? { fallbackText } : {},
       loading,
       onError
     }),
-    [registry, catalog, resolveComponent, fallback2, loading, onError]
+    [
+      registry,
+      catalog,
+      resolveComponent,
+      fallback2,
+      fallbackText,
+      componentVersions,
+      loading,
+      onError
+    ]
   );
   return /* @__PURE__ */ jsx(TreeScopeContext.Provider, { value: scope, children });
 }
@@ -1491,7 +1610,7 @@ function GenerativeUI({
   onError: ownOnError
 }) {
   const provided = useContext2(GenuiContext);
-  const fallback2 = ownFallback ?? provided?.fallback;
+  const fallback2 = ownFallback !== void 0 ? ownFallback : provided?.fallback;
   const loading = ownLoading ?? provided?.loading ?? null;
   const onError = ownOnError ?? provided?.onError;
   const options = useMergedOptions({
@@ -1516,6 +1635,8 @@ function GenerativeUI({
     GenerativeUIScope,
     {
       ...options,
+      ...state.item.componentVersions !== void 0 ? { componentVersions: state.item.componentVersions } : {},
+      ...state.item.fallbackText !== void 0 ? { fallbackText: state.item.fallbackText } : {},
       fallback: fallback2,
       loading,
       ...onError !== void 0 ? { onError } : {},
@@ -1531,6 +1652,7 @@ var AgentBackendContext = sharedContext(
 );
 function AgentProvider({
   backend,
+  uiCapabilities,
   baseUrl,
   path,
   headers,
@@ -1562,7 +1684,7 @@ function AgentProvider({
     [backend, baseUrl, path, credentials, fetch, upload]
   );
   const content = genui !== void 0 ? /* @__PURE__ */ jsx2(GenuiProvider, { ...genui, children }) : children;
-  return /* @__PURE__ */ jsx2(AgentBackendContext.Provider, { value, children: content });
+  return /* @__PURE__ */ jsx2(AgentUiCapabilitiesContext.Provider, { value: uiCapabilities ?? null, children: /* @__PURE__ */ jsx2(AgentBackendContext.Provider, { value, children: content }) });
 }
 var fallback;
 function defaultBackend() {
@@ -1573,6 +1695,12 @@ function useAgentBackend(own) {
   const provided = useContext3(AgentBackendContext);
   return own ?? provided ?? defaultBackend();
 }
+var AgentUiCapabilitiesContext = sharedContext(
+  "@dudousxd/nestjs-agent-react:ui-capabilities"
+);
+function useAgentUiCapabilities() {
+  return useContext3(AgentUiCapabilitiesContext) ?? void 0;
+}
 
 // src/config/use-agent-config.ts
 var shared = /* @__PURE__ */ new WeakMap();
@@ -1838,7 +1966,7 @@ async function defaultRefusal(response) {
 }
 function defaultForwardedProps(body) {
   const out = {};
-  for (const key of ["pageContext", "agent", "model"]) {
+  for (const key of ["pageContext", "agent", "model", "persona", "uiCapabilities"]) {
     if (body[key] !== void 0 && body[key] !== null) out[key] = body[key];
   }
   return Object.keys(out).length > 0 ? out : void 0;
@@ -2155,7 +2283,7 @@ function applyPatch(target, patch) {
 }
 
 // src/catalog/use-agents.ts
-import { useMemo as useMemo5 } from "react";
+import { useCallback as useCallback4, useMemo as useMemo5 } from "react";
 
 // src/catalog/use-resource.ts
 import { useCallback as useCallback3, useEffect as useEffect5, useRef as useRef4, useState as useState5 } from "react";
@@ -2197,16 +2325,24 @@ function useAgents(options = {}) {
     "",
     enabled
   );
+  const find = useCallback4(
+    (name) => (data ?? []).find(
+      (agent) => name === void 0 ? agent.isDefault === true : agent.name === name
+    ),
+    [data]
+  );
   return useMemo5(() => {
     const agents = data ?? [];
     return {
       agents,
       defaultAgent: agents.find((agent) => agent.isDefault === true)?.name ?? null,
+      personasOf: (agent) => find(agent)?.personas ?? [],
+      defaultPersonaOf: (agent) => find(agent)?.defaultPersona ?? null,
       isLoading,
       error,
       refresh
     };
-  }, [data, isLoading, error, refresh]);
+  }, [data, find, isLoading, error, refresh]);
 }
 
 // src/catalog/use-models.ts
@@ -2304,7 +2440,7 @@ function useQuota(options = {}) {
 }
 
 // src/feedback/use-message-feedback.ts
-import { useCallback as useCallback4, useRef as useRef5, useState as useState6 } from "react";
+import { useCallback as useCallback5, useRef as useRef5, useState as useState6 } from "react";
 function useMessageFeedback(options = {}) {
   const backend = useAgentBackend(options.backend);
   const latest = useRef5({ ...options, backend });
@@ -2315,7 +2451,7 @@ function useMessageFeedback(options = {}) {
   const localRef = useRef5(local);
   localRef.current = local;
   const resolved = useRef5(/* @__PURE__ */ new Map());
-  const feedbackOf = useCallback4(
+  const feedbackOf = useCallback5(
     (message) => {
       const mine = local.get(message.id);
       if (mine !== void 0) return mine.feedback;
@@ -2323,8 +2459,8 @@ function useMessageFeedback(options = {}) {
     },
     [local]
   );
-  const isPending = useCallback4((message) => pending.has(message.id), [pending]);
-  const storedIdFor = useCallback4(async (message) => {
+  const isPending = useCallback5((message) => pending.has(message.id), [pending]);
+  const storedIdFor = useCallback5(async (message) => {
     const runId = metadataOf(message).runId;
     if (runId === void 0) return message.id;
     const known = resolved.current.get(message.id);
@@ -2342,7 +2478,7 @@ function useMessageFeedback(options = {}) {
     resolved.current.set(message.id, row.id);
     return row.id;
   }, []);
-  const rate = useCallback4(
+  const rate = useCallback5(
     async (message, value, comment) => {
       const setFeedback = requireBackendMethod(latest.current.backend, "setMessageFeedback");
       const had = localRef.current.get(message.id);
@@ -2381,7 +2517,7 @@ function useMessageFeedback(options = {}) {
     },
     [storedIdFor]
   );
-  const toggle = useCallback4(
+  const toggle = useCallback5(
     (message, value) => {
       const mine = localRef.current.get(message.id);
       const current = mine !== void 0 ? mine.feedback : metadataOf(message).feedback ?? null;
@@ -2397,7 +2533,7 @@ function metadataOf(message) {
 }
 
 // src/threads/use-threads.ts
-import { useCallback as useCallback5, useEffect as useEffect7, useRef as useRef6, useState as useState7 } from "react";
+import { useCallback as useCallback6, useEffect as useEffect7, useRef as useRef6, useState as useState7 } from "react";
 function useThreads(options = {}) {
   const { enabled = true } = options;
   const backend = useAgentBackend(options.backend);
@@ -2407,7 +2543,7 @@ function useThreads(options = {}) {
   const threadsRef = useRef6(threads);
   threadsRef.current = threads;
   const generation = useRef6(0);
-  const refresh = useCallback5(async () => {
+  const refresh = useCallback6(async () => {
     const mine = ++generation.current;
     setIsLoading(true);
     try {
@@ -2439,7 +2575,7 @@ function useThreads(options = {}) {
       }
     });
   }, [backend, enabled, refresh]);
-  const rename = useCallback5(
+  const rename = useCallback6(
     async (id, title) => {
       const before = threadsRef.current;
       setThreads(
@@ -2455,7 +2591,7 @@ function useThreads(options = {}) {
     },
     [backend]
   );
-  const remove = useCallback5(
+  const remove = useCallback6(
     async (id) => {
       const before = threadsRef.current;
       setThreads((current) => current.filter((thread) => thread.id !== id));
@@ -2514,7 +2650,7 @@ function backgroundRunsFromThread(messages) {
 import { useEffect as useEffect9, useState as useState9 } from "react";
 
 // src/components/use-speech-recognition.ts
-import { useCallback as useCallback6, useEffect as useEffect8, useMemo as useMemo8, useRef as useRef7, useState as useState8 } from "react";
+import { useCallback as useCallback7, useEffect as useEffect8, useMemo as useMemo8, useRef as useRef7, useState as useState8 } from "react";
 function getRecognitionCtor() {
   if (typeof window === "undefined") return null;
   const scope = window;
@@ -2569,7 +2705,7 @@ function useSpeechRecognition({
       recognitionRef.current = null;
     };
   }, [ctor, lang]);
-  const start = useCallback6(() => {
+  const start = useCallback7(() => {
     const recognition = recognitionRef.current;
     if (!recognition) return;
     try {
@@ -2579,7 +2715,7 @@ function useSpeechRecognition({
       console.warn("SpeechRecognition start failed", error);
     }
   }, []);
-  const stop = useCallback6(() => {
+  const stop = useCallback7(() => {
     const recognition = recognitionRef.current;
     if (!recognition) return;
     try {
@@ -2699,7 +2835,7 @@ function ChatInput({
 import React2 from "react";
 
 // src/transcript/use-chat-transcript.ts
-import { useCallback as useCallback8, useEffect as useEffect11, useRef as useRef9, useState as useState11 } from "react";
+import { useCallback as useCallback9, useEffect as useEffect11, useRef as useRef9, useState as useState11 } from "react";
 
 // src/transcript/model.ts
 import {
@@ -2879,6 +3015,15 @@ function isActionCall(part) {
 }
 function toolCallState(part) {
   const output = "output" in part ? part.output : void 0;
+  if (output !== null && typeof output === "object" && "proposalId" in output && "executed" in output && output.executed === false)
+    return {
+      status: "awaiting-approval",
+      isSettled: false,
+      isFailed: false,
+      isDenied: false,
+      output,
+      error: null
+    };
   const errorText = "errorText" in part ? part.errorText : void 0;
   const outputError = output !== null && typeof output === "object" && "error" in output ? String(output.error) : void 0;
   const isDenied = part.state === "output-denied";
@@ -2923,7 +3068,11 @@ function describeToolCall(part, catalog, options = {}) {
     icon: presentation?.icon ?? null,
     tone: presentation?.tone ?? "neutral",
     detail: presentation?.detail ?? null,
-    confirm: confirm === void 0 ? null : {
+    confirm: options.confirmation !== void 0 ? {
+      title: options.confirmation.title,
+      verb: options.confirmation.verb,
+      detail: options.confirmation.detail ?? null
+    } : confirm === void 0 ? null : {
       title: fillTemplate(confirm.title, input),
       verb: confirm.verb,
       detail: confirm.detail !== void 0 ? fillTemplate(confirm.detail, input) : null
@@ -2937,6 +3086,9 @@ function describeToolCall(part, catalog, options = {}) {
 }
 var STATUS_WEIGHT = {
   running: 4,
+  queued: 4,
+  executing: 4,
+  succeeded: 0,
   "awaiting-approval": 3,
   failed: 2,
   denied: 1,
@@ -2956,7 +3108,7 @@ function groupToolActivity(calls, options = {}) {
     if (corrected.has(call.toolCallId)) continue;
     const presentation = options.catalog?.[call.name];
     const key = options.keyOf?.(call, presentation) ?? presentation?.label ?? call.name;
-    const status = toolCallState(call.part).status;
+    const status = call.description.status;
     const phrase = phraseFor(
       presentation,
       call.part.input,
@@ -3198,7 +3350,7 @@ function isAncestor(call, candidate, byId) {
 }
 function buildToolCall(part, options, approval, catalog) {
   const toolCallId = part.toolCallId;
-  const awaiting = isAwaitingApproval(part);
+  const awaiting = approval?.target?.kind === "proposal" ? approval.status === "pending" : isAwaitingApproval(part);
   const sending = awaiting ? options?.submitting(toolCallId) ?? null : null;
   return {
     part,
@@ -3208,19 +3360,30 @@ function buildToolCall(part, options, approval, catalog) {
     parentId: toolParentId(part),
     children: [],
     approval,
-    description: describeToolCall(part, catalog),
+    description: proposalDescription(
+      describeToolCall(
+        part,
+        catalog,
+        approval?.confirmation === void 0 ? {} : { confirmation: approval.confirmation }
+      ),
+      approval
+    ),
     isAwaitingApproval: awaiting,
     approve: {
       available: awaiting && options?.canApprove === true,
       isSubmitting: sending === "approve",
       // Read by field, not passed through: `onClick={call.approve.run}` hands this a click event,
       // and a host's handler must not receive that as its options.
-      run: (approveOptions) => approveOptions?.remember === true ? options?.approve(toolCallId, { remember: true }) : options?.approve(toolCallId)
+      run: (approveOptions) => approval?.target === void 0 ? approveOptions?.remember === true ? options?.approve(toolCallId, { remember: true }) : options?.approve(toolCallId) : options?.approve(
+        toolCallId,
+        approveOptions?.remember === true ? { remember: true } : void 0,
+        approval.target
+      )
     },
     reject: {
       available: awaiting && options?.canReject === true,
       isSubmitting: sending === "reject",
-      run: () => options?.reject(toolCallId)
+      run: () => approval?.target === void 0 ? options?.reject(toolCallId) : options?.reject(toolCallId, approval.target)
     },
     error: options?.errorOf(toolCallId) ?? null,
     errorCode: options?.errorCodeOf?.(toolCallId) ?? null
@@ -3370,7 +3533,7 @@ function buildElicitationBlock(key, part, request, options) {
 var UI_PART = "data-ui";
 var APPROVAL_PART = "data-approval-requested";
 var SETTLED_PART = "data-approval-settled";
-var SETTLED_STATUSES = ["approved", "rejected", "expired"];
+var SETTLED_STATUSES = ["approved", "rejected", "expired", "superseded"];
 function readApprovals(parts) {
   const out = /* @__PURE__ */ new Map();
   const entry = (id) => {
@@ -3391,7 +3554,7 @@ function readApprovals(parts) {
     return found;
   };
   for (const part of parts) {
-    if (part.type !== APPROVAL_PART && part.type !== SETTLED_PART) {
+    if (part.type !== APPROVAL_PART && part.type !== SETTLED_PART && part.type !== "data-action-proposal") {
       continue;
     }
     const data = part.data;
@@ -3399,12 +3562,35 @@ function readApprovals(parts) {
       continue;
     }
     const approval = entry(data.id);
-    if (part.type === APPROVAL_PART) {
+    if (part.type === APPROVAL_PART || part.type === "data-action-proposal") {
+      if (isRecord4(data.target) && data.target.kind === "proposal" && typeof data.target.proposalId === "string") {
+        approval.target = {
+          kind: "proposal",
+          proposalId: data.target.proposalId,
+          ...typeof data.target.threadId === "string" ? { threadId: data.target.threadId } : {}
+        };
+      }
+      if (part.type === "data-action-proposal") {
+        if (typeof data.status === "string" && ["pending", "approved", "rejected", "expired", "superseded"].includes(data.status))
+          approval.status = data.status === "pending" ? null : data.status;
+        if (data.executionStatus === null || data.executionStatus === "queued" || data.executionStatus === "executing" || data.executionStatus === "succeeded" || data.executionStatus === "failed")
+          approval.executionStatus = data.executionStatus;
+        approval.remember = data.remember === true;
+        approval.decidedBy = typeof data.decidedBy === "string" ? data.decidedBy : null;
+        approval.decidedVia = typeof data.decidedVia === "string" ? data.decidedVia : null;
+      }
       if (typeof data.approver !== "string") {
         continue;
       }
       approval.approver = data.approver;
       approval.expiresAt = typeof data.expiresAt === "string" ? data.expiresAt : null;
+      if (isRecord4(data.confirmation) && typeof data.confirmation.title === "string" && typeof data.confirmation.verb === "string" && (data.confirmation.detail === void 0 || typeof data.confirmation.detail === "string")) {
+        approval.confirmation = {
+          title: data.confirmation.title,
+          verb: data.confirmation.verb,
+          ...typeof data.confirmation.detail === "string" ? { detail: data.confirmation.detail } : {}
+        };
+      }
       approval.reason = typeof data.reason === "string" ? data.reason : null;
       continue;
     }
@@ -3428,9 +3614,12 @@ function approvalOf(parts, call) {
   }
   return {
     approver: parts.approver,
+    ...parts.target === void 0 ? {} : { target: parts.target },
+    ...parts.executionStatus === void 0 ? {} : { executionStatus: parts.executionStatus },
+    ...parts.confirmation !== void 0 ? { confirmation: parts.confirmation } : {},
     expiresAt: parts.expiresAt,
     reason: parts.reason,
-    status: parts.status ?? statusFromPart(call),
+    status: parts.status ?? (parts.target?.kind === "proposal" ? "pending" : statusFromPart(call)),
     remember: parts.remember,
     decidedBy: parts.decidedBy,
     decidedVia: parts.decidedVia,
@@ -3460,6 +3649,10 @@ function readUiComponent(part) {
     component: data.component,
     props: isRecord4(data.props) ? data.props : {},
     version: typeof data.version === "number" ? data.version : null,
+    ...isRecord4(data.componentVersions) && Object.values(data.componentVersions).every(
+      (version) => typeof version === "number" && Number.isSafeInteger(version) && version > 0
+    ) ? { componentVersions: { ...data.componentVersions } } : {},
+    ...typeof data.fallbackText === "string" ? { fallbackText: data.fallbackText } : {},
     toolCallId: typeof data.toolCallId === "string" ? data.toolCallId : null
   };
 }
@@ -3570,16 +3763,22 @@ function formatCostUsd(cost) {
   }
   return `$${cost.toFixed(2)}`;
 }
+function proposalDescription(description, approval) {
+  if (approval?.target?.kind !== "proposal") return description;
+  const status = approval.status === "pending" ? "awaiting-approval" : approval.status === "approved" ? approval.executionStatus ?? "queued" : "denied";
+  const phrase = status === "awaiting-approval" ? "Awaiting approval" : status === "queued" ? "Queued" : status === "executing" ? "Executing" : status === "succeeded" ? "Succeeded" : status === "failed" ? "Failed" : approval.status === "expired" ? "Expired" : approval.status === "superseded" ? "Replaced" : "Rejected";
+  return { ...description, status, phrase, result: null };
+}
 
 // src/transcript/use-stick-to-bottom.ts
-import { useCallback as useCallback7, useEffect as useEffect10, useRef as useRef8, useState as useState10 } from "react";
+import { useCallback as useCallback8, useEffect as useEffect10, useRef as useRef8, useState as useState10 } from "react";
 function useStickToBottom({
   contentKey,
   threshold = 32
 }) {
   const containerRef = useRef8(null);
   const [isAtBottom, setIsAtBottom] = useState10(true);
-  const measure = useCallback7(() => {
+  const measure = useCallback8(() => {
     const element = containerRef.current;
     if (!element) {
       return;
@@ -3587,7 +3786,7 @@ function useStickToBottom({
     const distance = element.scrollHeight - element.scrollTop - element.clientHeight;
     setIsAtBottom(distance <= threshold);
   }, [threshold]);
-  const scrollToBottom = useCallback7(() => {
+  const scrollToBottom = useCallback8(() => {
     const element = containerRef.current;
     if (!element) {
       return;
@@ -3595,7 +3794,7 @@ function useStickToBottom({
     element.scrollTop = element.scrollHeight;
     setIsAtBottom(true);
   }, []);
-  const setContainer = useCallback7(
+  const setContainer = useCallback8(
     (element) => {
       containerRef.current = element;
       if (element) {
@@ -3609,7 +3808,7 @@ function useStickToBottom({
       scrollToBottom();
     }
   }, [contentKey, isAtBottom, scrollToBottom]);
-  const getContainerProps = useCallback7(
+  const getContainerProps = useCallback8(
     () => ({ ref: setContainer, onScroll: measure }),
     [setContainer, measure]
   );
@@ -3656,7 +3855,7 @@ function useChatTranscript(options) {
     streamingMessageId,
     options
   });
-  const stop = useCallback8(() => {
+  const stop = useCallback9(() => {
     const current = latest.current;
     if (current.status !== "submitted" && current.status !== "streaming" && current.status !== "reconnecting") {
       return;
@@ -3664,13 +3863,13 @@ function useChatTranscript(options) {
     setStopRequested(true);
     void current.onStop?.();
   }, []);
-  const loadEarlier = useCallback8(
+  const loadEarlier = useCallback9(
     () => setVisibleCount(
       (count) => count + (latest.current.loadEarlierStep ?? DEFAULT_LOAD_EARLIER_STEP)
     ),
     []
   );
-  const showAll = useCallback8(() => setVisibleCount(latest.current.messages.length), []);
+  const showAll = useCallback9(() => setVisibleCount(latest.current.messages.length), []);
   const scroll = useStickToBottom({
     contentKey: contentSignature(messages),
     ...stickToBottomThreshold !== void 0 ? { threshold: stickToBottomThreshold } : {}
@@ -3708,7 +3907,7 @@ function useQueuedItems(queue, readOnly) {
   const latestQueue = useRef9(queue);
   latestQueue.current = queue;
   const removers = useRef9(/* @__PURE__ */ new Map());
-  const removerFor = useCallback8((id) => {
+  const removerFor = useCallback9((id) => {
     let remover = removers.current.get(id);
     if (remover === void 0) {
       remover = () => {
@@ -3784,14 +3983,14 @@ function useTranscriptItems({
   );
   const callbackCache = useRef9(/* @__PURE__ */ new Map());
   const reasoningToggleCache = useRef9(/* @__PURE__ */ new Map());
-  const toggleReasoning = useCallback8((key, open) => {
+  const toggleReasoning = useCallback9((key, open) => {
     setOpenReasoning((current) => {
       const next = new Map(current);
       next.set(key, open ?? !(current.get(key) ?? false));
       return next;
     });
   }, []);
-  const stableToggle = useCallback8(
+  const stableToggle = useCallback9(
     (key) => {
       let cached = reasoningToggleCache.current.get(key);
       if (!cached) {
@@ -3802,10 +4001,10 @@ function useTranscriptItems({
     },
     [toggleReasoning]
   );
-  const pick = useCallback8((toolCallId, questionId, values) => {
+  const pick = useCallback9((toolCallId, questionId, values) => {
     setPicks((current) => new Map(current).set(pickKey(toolCallId, questionId), values));
   }, []);
-  const settle = useCallback8(
+  const settle = useCallback9(
     (toolCallId, action, send) => {
       setSettleErrors((current) => {
         if (!current.has(toolCallId)) {
@@ -3837,7 +4036,7 @@ function useTranscriptItems({
     },
     []
   );
-  const answer = useCallback8(
+  const answer = useCallback9(
     (toolCallId) => {
       const current = latest.current;
       const onAnswer = current.handlers.onAnswer;
@@ -3852,7 +4051,7 @@ function useTranscriptItems({
     },
     [settle]
   );
-  const skip = useCallback8(
+  const skip = useCallback9(
     (toolCallId) => {
       const onSkip = latest.current.handlers.onSkip;
       if (onSkip) {
@@ -3861,29 +4060,37 @@ function useTranscriptItems({
     },
     [settle]
   );
-  const approve = useCallback8(
-    (toolCallId, options2) => {
+  const approve = useCallback9(
+    (toolCallId, options2, target) => {
       const onApprove = latest.current.handlers.onApprove;
       if (onApprove) {
         settle(
           toolCallId,
           "approve",
-          () => onApprove({ toolCallId, ...options2?.remember === true ? { remember: true } : {} })
+          () => onApprove({
+            toolCallId,
+            ...target === void 0 ? {} : { target },
+            ...options2?.remember === true ? { remember: true } : {}
+          })
         );
       }
     },
     [settle]
   );
-  const reject = useCallback8(
-    (toolCallId) => {
+  const reject = useCallback9(
+    (toolCallId, target) => {
       const onReject = latest.current.handlers.onReject;
       if (onReject) {
-        settle(toolCallId, "reject", () => onReject({ toolCallId }));
+        settle(
+          toolCallId,
+          "reject",
+          () => onReject({ toolCallId, ...target === void 0 ? {} : { target } })
+        );
       }
     },
     [settle]
   );
-  const callbacksFor = useCallback8((id) => {
+  const callbacksFor = useCallback9((id) => {
     const cached = callbackCache.current.get(id);
     if (cached) {
       return cached;
@@ -4076,14 +4283,36 @@ function settleHandlers(options, backend) {
     ),
     onApprove: pick(
       options.onApprove,
-      backend.approveToolCall ? async (input) => {
-        await backend.approveToolCall?.(input);
+      backend.approveToolCall || backend.approveActionProposal ? async (input) => {
+        if (input.target?.kind === "proposal") {
+          if (input.target.threadId === void 0)
+            throw new Error("A proposal decision requires its thread scope");
+          await requireBackendMethod(
+            backend,
+            "approveActionProposal"
+          )({
+            threadId: input.target.threadId,
+            proposalId: input.target.proposalId,
+            ...input.remember === void 0 ? {} : { remember: input.remember }
+          });
+        } else await requireBackendMethod(backend, "approveToolCall")(input);
       } : void 0
     ),
     onReject: pick(
       options.onReject,
-      backend.rejectToolCall ? async (input) => {
-        await backend.rejectToolCall?.(input);
+      backend.rejectToolCall || backend.rejectActionProposal ? async (input) => {
+        if (input.target?.kind === "proposal") {
+          if (input.target.threadId === void 0)
+            throw new Error("A proposal decision requires its thread scope");
+          await requireBackendMethod(
+            backend,
+            "rejectActionProposal"
+          )({
+            threadId: input.target.threadId,
+            proposalId: input.target.proposalId,
+            ...input.reason === void 0 ? {} : { reason: input.reason }
+          });
+        } else await requireBackendMethod(backend, "rejectToolCall")(input);
       } : void 0
     )
   };
@@ -4608,7 +4837,7 @@ function toItem(entry) {
 }
 
 // src/composer/use-composer-autocomplete.ts
-import { useCallback as useCallback9, useEffect as useEffect12, useId, useLayoutEffect, useMemo as useMemo9, useRef as useRef10, useState as useState12 } from "react";
+import { useCallback as useCallback10, useEffect as useEffect12, useId, useLayoutEffect, useMemo as useMemo9, useRef as useRef10, useState as useState12 } from "react";
 function useComposerAutocomplete(options) {
   const { value, sources, acceptOnTab = true } = options;
   const latest = useRef10(options);
@@ -4683,22 +4912,22 @@ function useComposerAutocomplete(options) {
   const activeItem = isOpen ? items[activeIndex] ?? null : null;
   const reactId = useId();
   const listboxId = options.id ?? `agent-autocomplete-${reactId}`;
-  const optionId = useCallback9((index) => `${listboxId}-option-${index}`, [listboxId]);
-  const highlight = useCallback9((index) => {
+  const optionId = useCallback10((index) => `${listboxId}-option-${index}`, [listboxId]);
+  const highlight = useCallback10((index) => {
     const total = itemsRef.current.length;
     if (total === 0) return;
     setActiveIndex((index % total + total) % total);
   }, []);
-  const moveHighlight = useCallback9(
+  const moveHighlight = useCallback10(
     (delta) => highlight(activeIndexRef.current + delta),
     [highlight]
   );
-  const dismiss = useCallback9(() => {
+  const dismiss = useCallback10(() => {
     const current = matchRef.current;
     if (current) setDismissedIndex(current.index);
   }, []);
   const pendingCaret = useRef10(null);
-  const accept = useCallback9((item) => {
+  const accept = useCallback10((item) => {
     const current = matchRef.current;
     if (!current) return;
     const chosen = item ?? itemsRef.current[activeIndexRef.current];
@@ -4715,10 +4944,10 @@ function useComposerAutocomplete(options) {
     pendingCaret.current = null;
     inputRef.current?.setSelectionRange(position, position);
   });
-  const readCaret = useCallback9((element) => {
+  const readCaret = useCallback10((element) => {
     setCaret(element.selectionStart ?? element.value.length);
   }, []);
-  const onKeyDown = useCallback9(
+  const onKeyDown = useCallback10(
     (event) => {
       if (!isOpen) return;
       const hasItems = itemsRef.current.length > 0;
@@ -4753,7 +4982,7 @@ function useComposerAutocomplete(options) {
     },
     [isOpen, acceptOnTab, accept, dismiss, moveHighlight]
   );
-  const onChange = useCallback9(
+  const onChange = useCallback10(
     (event) => {
       readCaret(event.target);
       const next = findActiveTrigger(
@@ -4767,18 +4996,18 @@ function useComposerAutocomplete(options) {
     },
     [readCaret]
   );
-  const onSelect = useCallback9(
+  const onSelect = useCallback10(
     (event) => readCaret(event.currentTarget),
     [readCaret]
   );
-  const onClick = useCallback9(
+  const onClick = useCallback10(
     (event) => readCaret(event.currentTarget),
     [readCaret]
   );
-  const setInput = useCallback9((element) => {
+  const setInput = useCallback10((element) => {
     inputRef.current = element;
   }, []);
-  const getInputProps = useCallback9(
+  const getInputProps = useCallback10(
     () => ({
       ref: setInput,
       onChange,
@@ -4805,7 +5034,7 @@ function useComposerAutocomplete(options) {
       optionId
     ]
   );
-  const getListboxProps = useCallback9(
+  const getListboxProps = useCallback10(
     () => ({
       id: listboxId,
       role: "listbox",
@@ -4813,7 +5042,7 @@ function useComposerAutocomplete(options) {
     }),
     [listboxId, match]
   );
-  const getOptionProps = useCallback9(
+  const getOptionProps = useCallback10(
     (index) => ({
       id: optionId(index),
       role: "option",
@@ -4846,7 +5075,7 @@ function isPromise(value) {
 
 // src/presentation/use-tool-catalog.ts
 import { ALL_AGENTS } from "@dudousxd/nestjs-agent-core";
-import { useCallback as useCallback10, useEffect as useEffect13, useMemo as useMemo10, useState as useState13 } from "react";
+import { useCallback as useCallback11, useEffect as useEffect13, useMemo as useMemo10, useState as useState13 } from "react";
 var shared2 = /* @__PURE__ */ new WeakMap();
 function load2(client, agent) {
   let byAgent = shared2.get(client);
@@ -4898,7 +5127,7 @@ function useToolCatalog(options = {}) {
       cancelled = true;
     };
   }, [client, agent, enabled, generation]);
-  const refresh = useCallback10(() => {
+  const refresh = useCallback11(() => {
     shared2.get(client)?.delete(agent ?? "");
     setGeneration((current) => current + 1);
   }, [client, agent]);
@@ -4988,6 +5217,8 @@ function storedMessageToUiMessage(message) {
         id: component.id,
         component: component.component,
         props: component.props,
+        ...component.componentVersions !== void 0 ? { componentVersions: component.componentVersions } : {},
+        ...component.fallbackText !== void 0 ? { fallbackText: component.fallbackText } : {},
         ...component.version !== void 0 ? { version: component.version } : {},
         ...component.toolCallId !== void 0 ? { toolCallId: component.toolCallId } : {}
       }
@@ -5007,6 +5238,8 @@ function storedMessageToUiMessage(message) {
       data: {
         id: approval.toolCallId,
         approver: approval.approver,
+        ...approval.target !== void 0 ? { target: approval.target } : approval.proposalId !== void 0 ? { target: { kind: "proposal", proposalId: approval.proposalId } } : {},
+        ...approval.confirmation !== void 0 ? { confirmation: approval.confirmation } : {},
         ...approval.expiresAt !== void 0 ? { expiresAt: approval.expiresAt } : {}
       }
     });
@@ -5063,8 +5296,11 @@ function storedMessageToUiMessage(message) {
   const metadata = {
     // The host's own facts first: the library's keys win on a clash.
     ...message.metadata,
+    ...message.actionProposalOutcome === void 0 ? {} : { actionProposalOutcomeId: message.actionProposalOutcome.id },
     ...message.feedback !== void 0 ? { feedback: message.feedback } : {},
     ...message.createdAt ? { createdAt: message.createdAt } : {},
+    ...message.agentName !== void 0 ? { agentName: message.agentName } : {},
+    ...message.persona !== void 0 ? { persona: message.persona } : {},
     ...message.usage !== void 0 ? {
       usage: {
         inputTokens: message.usage.inputTokens,
@@ -5096,6 +5332,8 @@ function storedThreadToUiMessages(messages) {
   return turns.map(mergeTurn);
 }
 function sameRun(previous, next) {
+  if (previous.actionProposalOutcome !== void 0 || next.actionProposalOutcome !== void 0)
+    return false;
   return previous.runId === void 0 || next.runId === void 0 || previous.runId === next.runId;
 }
 function mergeTurn(rows) {
@@ -5115,7 +5353,9 @@ function mergeTurn(rows) {
     ...Object.assign({}, ...rows.map((row) => row.metadata ?? {})),
     ...usage !== void 0 ? { usage } : {},
     ...feedback !== void 0 ? { feedback } : {},
-    ...createdAt ? { createdAt } : {}
+    ...createdAt ? { createdAt } : {},
+    ...lastRow.agentName !== void 0 ? { agentName: lastRow.agentName } : {},
+    ...lastRow.persona !== void 0 ? { persona: lastRow.persona } : {}
   };
   return {
     id: lastRow.id,
@@ -5141,7 +5381,162 @@ function sumUsage(rows) {
 
 // src/use-agent-chat.ts
 import { useChat } from "@ai-sdk/react";
-import { useCallback as useCallback11, useEffect as useEffect15, useMemo as useMemo11, useRef as useRef12, useState as useState15 } from "react";
+import { useCallback as useCallback13, useEffect as useEffect16, useMemo as useMemo11, useRef as useRef13, useState as useState16 } from "react";
+
+// src/approvals/use-action-proposals.ts
+import { useCallback as useCallback12, useEffect as useEffect15, useRef as useRef12, useState as useState15 } from "react";
+
+// src/approvals/proposals.ts
+function proposalNeedsPolling(proposal) {
+  return proposal.decision === "pending" || proposal.execution?.status === "queued" || proposal.execution?.status === "executing" || proposal.outcomeDelivery?.status === "pending";
+}
+function reconcileProposalMessages(current, proposals, facts) {
+  const messages = current.map((message) => {
+    const relevant = proposals.filter(
+      (proposal) => message.parts.some((part) => {
+        if ("data" in part && record(part.data) && record(part.data.target) && part.data.target.kind === "proposal")
+          return part.data.target.proposalId === proposal.id;
+        if ("toolCallId" in part && part.toolCallId === proposal.originToolCallId) {
+          if ("output" in part && record(part.output) && typeof part.output.proposalId === "string")
+            return part.output.proposalId === proposal.id;
+          return record(message.metadata) && message.metadata.runId === proposal.originRunId;
+        }
+        return false;
+      })
+    );
+    if (relevant.length === 0) return message;
+    const ids = new Set(relevant.map((proposal) => proposal.originToolCallId));
+    const parts = message.parts.filter(
+      (part) => !(part.type === "data-action-proposal" && "id" in part && typeof part.id === "string" && ids.has(part.id))
+    );
+    for (const proposal of relevant)
+      parts.push({
+        type: "data-action-proposal",
+        id: proposal.originToolCallId,
+        data: {
+          id: proposal.originToolCallId,
+          target: { kind: "proposal", proposalId: proposal.id, threadId: proposal.threadId },
+          approver: proposal.approver,
+          confirmation: proposal.confirmation,
+          expiresAt: proposal.expiresAt === null ? null : Math.abs(proposal.expiresAt) <= 864e13 ? new Date(proposal.expiresAt).toISOString() : null,
+          status: proposal.decision,
+          executionStatus: proposal.execution?.status ?? null,
+          remember: proposal.decisionAudit?.remember === true,
+          decidedBy: proposal.decisionAudit?.actorRef ?? null,
+          decidedVia: proposal.decisionAudit?.via ?? null,
+          reason: proposal.decisionAudit?.reason ?? null
+        }
+      });
+    return { ...message, parts };
+  });
+  const knownMessages = new Set(messages.map((message) => message.id));
+  const knownOutcomes = new Set(
+    messages.map((message) => outcomeId(message.metadata)).filter(Boolean)
+  );
+  for (const fact of facts) {
+    const id = fact.actionProposalOutcome?.id;
+    if (id === void 0 || knownMessages.has(fact.id) || knownOutcomes.has(id)) continue;
+    const message = storedMessageToUiMessage(fact);
+    messages.push({
+      ...message,
+      metadata: {
+        ...record(message.metadata) ? message.metadata : {},
+        actionProposalOutcomeId: id
+      }
+    });
+    knownMessages.add(fact.id);
+    knownOutcomes.add(id);
+  }
+  return messages;
+}
+function record(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function outcomeId(value) {
+  return record(value) && typeof value.actionProposalOutcomeId === "string" ? value.actionProposalOutcomeId : void 0;
+}
+
+// src/approvals/use-action-proposals.ts
+function useActionProposals(backend, threadId, setMessages, refreshKey, pollMs = 1e3) {
+  const [items, setItems] = useState15([]);
+  const [error, setError] = useState15(null);
+  const latest = useRef12({ threadId, setMessages });
+  latest.current = { threadId, setMessages };
+  const mounted = useRef12(true);
+  const requests = useRef12(/* @__PURE__ */ new Map());
+  useEffect15(() => {
+    mounted.current = true;
+    return () => {
+      mounted.current = false;
+    };
+  }, []);
+  const refresh = useCallback12(async () => {
+    if (threadId === void 0 || backend.listActionProposals === void 0) return;
+    const pending = requests.current.get(threadId);
+    if (pending) return pending;
+    const request = (async () => {
+      try {
+        const proposals = await backend.listActionProposals?.({ threadId });
+        if (!mounted.current || latest.current.threadId !== threadId || !Array.isArray(proposals))
+          return;
+        const admitted = proposals.some(
+          (proposal) => proposal.outcomeDelivery?.status === "admitted"
+        );
+        const facts = admitted ? (await backend.getThread(threadId)).messages.filter(
+          (message) => message.actionProposalOutcome !== void 0
+        ) : [];
+        if (!mounted.current || latest.current.threadId !== threadId) return;
+        setItems(proposals);
+        setError(null);
+        latest.current.setMessages(
+          (current) => reconcileProposalMessages(current, proposals, facts)
+        );
+      } catch (cause) {
+        if (mounted.current && latest.current.threadId === threadId)
+          setError(cause instanceof Error ? cause : new Error(String(cause)));
+      }
+    })();
+    requests.current.set(threadId, request);
+    try {
+      await request;
+    } finally {
+      requests.current.delete(threadId);
+    }
+  }, [backend, threadId]);
+  useEffect15(() => {
+    setItems([]);
+    setError(null);
+  }, [threadId]);
+  useEffect15(() => {
+    void refresh();
+  }, [refresh, refreshKey]);
+  useEffect15(() => {
+    if (!items.some(proposalNeedsPolling) || pollMs <= 0) return;
+    const timer = setInterval(() => {
+      void refresh();
+    }, pollMs);
+    return () => clearInterval(timer);
+  }, [items, pollMs, refresh]);
+  useEffect15(() => {
+    const refetch = () => {
+      void refresh();
+    };
+    const visible = () => {
+      if (document.visibilityState === "visible") refetch();
+    };
+    window.addEventListener("focus", refetch);
+    window.addEventListener("online", refetch);
+    document.addEventListener("visibilitychange", visible);
+    return () => {
+      window.removeEventListener("focus", refetch);
+      window.removeEventListener("online", refetch);
+      document.removeEventListener("visibilitychange", visible);
+    };
+  }, [refresh]);
+  return { items, error, refresh };
+}
+
+// src/use-agent-chat.ts
 var EMPTY_QUEUE = { items: [], paused: null };
 var localQueueSequence = 0;
 function queuedUserMessage(turn) {
@@ -5196,13 +5591,16 @@ function localChatId() {
   return `local-chat-${localChatSequence}`;
 }
 function useAgentChat(options = {}) {
-  const latest = useRef12(options);
+  const providerCapabilities = useAgentUiCapabilities();
+  const capabilitiesRef = useRef13(providerCapabilities);
+  capabilitiesRef.current = providerCapabilities;
+  const latest = useRef13(options);
   latest.current = options;
   const resolved = useAgentBackend(options.backend);
-  const client = useRef12(resolved).current;
-  const createdThreadId = useRef12(void 0);
-  const chatIdRef = useRef12(options.threadId ?? localChatId());
-  const boundThreadRef = useRef12(options.threadId);
+  const client = useRef13(resolved).current;
+  const createdThreadId = useRef13(void 0);
+  const chatIdRef = useRef13(options.threadId ?? localChatId());
+  const boundThreadRef = useRef13(options.threadId);
   if (options.threadId !== boundThreadRef.current) {
     boundThreadRef.current = options.threadId;
     const adopting = options.threadId !== void 0 && options.threadId === createdThreadId.current;
@@ -5212,39 +5610,43 @@ function useAgentChat(options = {}) {
     }
   }
   const chatId = chatIdRef.current;
-  const [runId, setRunId] = useState15(options.resumeRunId);
-  const runIdRef = useRef12(runId);
+  const [runId, setRunId] = useState16(options.resumeRunId);
+  const runIdRef = useRef13(runId);
   runIdRef.current = runId;
-  const settlingRunIdRef = useRef12(void 0);
-  const autoResumeRunIdRef = useRef12(void 0);
-  const [activeRunId, setActiveRunId] = useState15(null);
-  const [historyFor, setHistoryFor] = useState15(void 0);
-  const [historyError, setHistoryError] = useState15(null);
-  const [runError, setRunError] = useState15(null);
-  const [threadModel, setThreadModel] = useState15(null);
-  const [pickedModel, setPickedModel] = useState15(void 0);
-  const pickedModelRef = useRef12(pickedModel);
+  const settlingRunIdRef = useRef13(void 0);
+  const autoResumeRunIdRef = useRef13(void 0);
+  const [activeRunId, setActiveRunId] = useState16(null);
+  const [historyFor, setHistoryFor] = useState16(void 0);
+  const [historyError, setHistoryError] = useState16(null);
+  const [runError, setRunError] = useState16(null);
+  const [threadModel, setThreadModel] = useState16(null);
+  const [threadPersona, setThreadPersona] = useState16(null);
+  const [pickedModel, setPickedModel] = useState16(void 0);
+  const pickedModelRef = useRef13(pickedModel);
   pickedModelRef.current = pickedModel;
-  const lockedRef = useRef12(false);
-  const pendingPin = useRef12(void 0);
-  const regenerateNext = useRef12(false);
-  const currentThreadId = useCallback11(
+  const lockedRef = useRef13(false);
+  const pendingPin = useRef13(void 0);
+  const regenerateNext = useRef13(false);
+  const currentThreadId = useCallback13(
     () => latest.current.threadId ?? createdThreadId.current,
     []
   );
-  const [queueState, setQueueState] = useState15(EMPTY_QUEUE);
-  const queueStateRef = useRef12(queueState);
-  const applyQueue = useCallback11((next) => {
+  const [queueState, setQueueState] = useState16(EMPTY_QUEUE);
+  const queueStateRef = useRef13(queueState);
+  const applyQueue = useCallback13((next) => {
     queueStateRef.current = next;
     setQueueState(next);
   }, []);
-  const [pendingSends, setPendingSends] = useState15([]);
-  const [queueError, setQueueError] = useState15(null);
-  const handoff = useRef12(void 0);
-  const queuedSend = useRef12(void 0);
-  const threadWaiters = useRef12([]);
-  const turnBody = useCallback11(() => {
+  const [pendingSends, setPendingSends] = useState16([]);
+  const [queueError, setQueueError] = useState16(null);
+  const handoff = useRef13(void 0);
+  const queuedSend = useRef13(void 0);
+  const proposalRefreshRef = useRef13(async () => {
+  });
+  const threadWaiters = useRef13([]);
+  const turnBody = useCallback13(() => {
     const current = latest.current;
+    if (current.persona !== void 0) setThreadPersona(current.persona);
     const pageContext = current.getPageContext?.() ?? null;
     const threadId = currentThreadId();
     const model = current.model ?? (lockedRef.current ? void 0 : pickedModelRef.current);
@@ -5252,13 +5654,15 @@ function useAgentChat(options = {}) {
       // Read per send: a host that switches agents before the first message (a picker on a new
       // chat) sends the one picked now, not the one this chat mounted with.
       ...current.agent !== void 0 ? { agent: current.agent } : {},
+      ...current.persona !== void 0 ? { persona: current.persona } : {},
       ...threadId !== void 0 ? { threadId } : {},
       ...model !== void 0 ? { model } : {},
-      ...pageContext ? { pageContext } : {}
+      ...pageContext ? { pageContext } : {},
+      ...(current.uiCapabilities ?? capabilitiesRef.current) === void 0 ? {} : { uiCapabilities: current.uiCapabilities ?? capabilitiesRef.current }
     };
   }, [currentThreadId]);
-  const [connection, setConnection] = useState15({ status: "live" });
-  const resyncAfterSettle = useRef12(false);
+  const [connection, setConnection] = useState16({ status: "live" });
+  const resyncAfterSettle = useRef13(false);
   const transport = useMemo11(() => {
     function onMeta(meta) {
       settlingRunIdRef.current = meta.runId;
@@ -5311,7 +5715,7 @@ function useAgentChat(options = {}) {
       }
     });
   }, []);
-  const backgroundRef = useRef12(() => Promise.resolve());
+  const backgroundRef = useRef13(() => Promise.resolve());
   const chat = useChat({
     transport,
     id: chatId,
@@ -5319,6 +5723,7 @@ function useAgentChat(options = {}) {
     ...options.initialMessages !== void 0 ? { messages: options.initialMessages } : {},
     onData: (part) => {
       latest.current.onData?.(part);
+      if (part.type === "data-proposal-decision") void proposalRefreshRef.current();
       if (part.type === "data-queue") {
         onQueueData(part.data);
       }
@@ -5365,7 +5770,7 @@ function useAgentChat(options = {}) {
       }
     }
   });
-  const chatRef = useRef12(chat);
+  const chatRef = useRef13(chat);
   chatRef.current = chat;
   function onQueueData(data) {
     const frame = data ?? {};
@@ -5413,13 +5818,14 @@ function useAgentChat(options = {}) {
     } catch {
     }
   }
-  const firstChatId = useRef12(chatId);
-  useEffect15(() => {
+  const firstChatId = useRef13(chatId);
+  useEffect16(() => {
     if (chatId === firstChatId.current) return;
     firstChatId.current = chatId;
     setRunId(void 0);
     setActiveRunId(null);
     setThreadModel(null);
+    setThreadPersona(null);
     setPickedModel(void 0);
     setBackgroundRuns([]);
     setHistoryError(null);
@@ -5432,7 +5838,7 @@ function useAgentChat(options = {}) {
     handoff.current = void 0;
     queuedSend.current = void 0;
   }, [chatId]);
-  useEffect15(() => {
+  useEffect16(() => {
     const threadId = options.threadId;
     if (threadId === void 0) return;
     if (threadId === createdThreadId.current) return;
@@ -5448,6 +5854,7 @@ function useAgentChat(options = {}) {
         const stored = Array.isArray(thread.messages) ? thread.messages : [];
         setActiveRunId(active);
         setThreadModel(thread.model ?? null);
+        setThreadPersona(thread.persona ?? null);
         setHistoryError(null);
         const queue2 = thread.queue ?? EMPTY_QUEUE;
         applyQueue(queue2);
@@ -5478,8 +5885,8 @@ function useAgentChat(options = {}) {
     };
   }, [client, chatId, options.threadId]);
   const isLoadingHistory = options.threadId !== void 0 && options.threadId !== createdThreadId.current && options.history !== false && options.initialMessages === void 0 && historyFor !== options.threadId;
-  const turnInFlight = useRef12(false);
-  const isTurnInFlight = useCallback11(
+  const turnInFlight = useRef13(false);
+  const isTurnInFlight = useCallback13(
     () => turnInFlight.current || transport.isAttemptLive,
     [transport]
   );
@@ -5488,20 +5895,20 @@ function useAgentChat(options = {}) {
     enabled: options.quota !== false && typeof client.getQuota === "function"
   });
   const blocked = options.blocked !== void 0 ? options.blocked : quota.blocked;
-  const blockedRef = useRef12(blocked);
+  const blockedRef = useRef13(blocked);
   blockedRef.current = blocked;
   const whileRunning = typeof client.enqueueMessage === "function" ? options.whileRunning ?? "queue" : "block";
-  const whileRunningRef = useRef12(whileRunning);
+  const whileRunningRef = useRef13(whileRunning);
   whileRunningRef.current = whileRunning;
-  const canQueueRef = useRef12(false);
+  const canQueueRef = useRef13(false);
   canQueueRef.current = typeof client.enqueueMessage === "function";
-  const threadForQueue = useCallback11(async () => {
+  const threadForQueue = useCallback13(async () => {
     const known = currentThreadId();
     if (known !== void 0) return known;
     if (!isTurnInFlight()) throw new Error("queue: this chat has no thread yet");
     return new Promise((resolve) => threadWaiters.current.push(resolve));
   }, [currentThreadId, isTurnInFlight]);
-  const queueCall = useCallback11(async (run) => {
+  const queueCall = useCallback13(async (run) => {
     try {
       const result = await run();
       setQueueError(null);
@@ -5511,7 +5918,7 @@ function useAgentChat(options = {}) {
       throw error;
     }
   }, []);
-  const enqueue = useCallback11(
+  const enqueue = useCallback13(
     async (text2, {
       attachments = [],
       mode = "queue"
@@ -5559,7 +5966,7 @@ function useAgentChat(options = {}) {
     },
     [client, queueCall, threadForQueue, turnBody, applyQueue, isTurnInFlight]
   );
-  const sendMessage = useCallback11(
+  const sendMessage = useCallback13(
     async (message, options2) => {
       const block = blockedRef.current;
       if (block != null) throw new QuotaBlockedError(block);
@@ -5583,7 +5990,7 @@ function useAgentChat(options = {}) {
     },
     [isTurnInFlight, enqueue]
   );
-  const removeQueued = useCallback11(
+  const removeQueued = useCallback13(
     async (id) => {
       const previous = queueStateRef.current;
       applyQueue({ ...previous, items: previous.items.filter((item) => item.id !== id) });
@@ -5596,7 +6003,7 @@ function useAgentChat(options = {}) {
     },
     [client, queueCall, applyQueue]
   );
-  const interruptQueued = useCallback11(
+  const interruptQueued = useCallback13(
     async (id) => {
       const previous = queueStateRef.current;
       const moving = previous.items.find((item) => item.id === id);
@@ -5631,7 +6038,7 @@ function useAgentChat(options = {}) {
     },
     [client, queueCall, applyQueue, isTurnInFlight]
   );
-  const editQueued = useCallback11(
+  const editQueued = useCallback13(
     async (id, text2) => {
       applyQueue(
         await queueCall(
@@ -5641,7 +6048,7 @@ function useAgentChat(options = {}) {
     },
     [client, queueCall, applyQueue]
   );
-  const moveQueued = useCallback11(
+  const moveQueued = useCallback13(
     async (id, index) => {
       const previous = queueStateRef.current;
       const moving = previous.items.find((item) => item.id === id);
@@ -5663,12 +6070,12 @@ function useAgentChat(options = {}) {
     },
     [client, queueCall, applyQueue]
   );
-  const clearQueue = useCallback11(async () => {
+  const clearQueue = useCallback13(async () => {
     const threadId = currentThreadId();
     if (threadId === void 0) return;
     applyQueue(await queueCall(() => requireBackendMethod(client, "clearQueue")(threadId)));
   }, [client, queueCall, currentThreadId, applyQueue]);
-  const resumeQueue = useCallback11(async () => {
+  const resumeQueue = useCallback13(async () => {
     const threadId = currentThreadId();
     if (threadId === void 0) return;
     const before = queueStateRef.current;
@@ -5686,7 +6093,7 @@ function useAgentChat(options = {}) {
       else attachTo(turn);
     }
   }, [client, queueCall, currentThreadId, applyQueue, isTurnInFlight]);
-  const resumeQueueRef = useRef12(resumeQueue);
+  const resumeQueueRef = useRef13(resumeQueue);
   resumeQueueRef.current = resumeQueue;
   const queuedItems = [
     ...pendingSends.filter((item) => item.interrupt),
@@ -5716,7 +6123,7 @@ function useAgentChat(options = {}) {
     resume: resumeQueue,
     error: queueError
   };
-  const addToolResult = useCallback11(
+  const addToolResult = useCallback13(
     ({ tool, toolCallId, output }) => chatRef.current.addToolResult({
       tool,
       toolCallId,
@@ -5724,8 +6131,8 @@ function useAgentChat(options = {}) {
     }),
     []
   );
-  const [backgroundRuns, setBackgroundRuns] = useState15([]);
-  const refreshBackground = useCallback11(async () => {
+  const [backgroundRuns, setBackgroundRuns] = useState16([]);
+  const refreshBackground = useCallback13(async () => {
     const threadId = currentThreadId();
     if (threadId === void 0) {
       return;
@@ -5745,13 +6152,13 @@ function useAgentChat(options = {}) {
   }, [client, currentThreadId]);
   backgroundRef.current = refreshBackground;
   const isWorking = backgroundRuns.some((run) => run.status === "running");
-  useEffect15(() => {
+  useEffect16(() => {
     if (options.background !== true || options.threadId === void 0) {
       return;
     }
     void refreshBackground();
   }, [options.background, options.threadId, chatId, refreshBackground]);
-  useEffect15(() => {
+  useEffect16(() => {
     const every = latest.current.backgroundPollMs ?? 5e3;
     if (latest.current.background !== true || !isWorking || every <= 0) {
       return;
@@ -5759,7 +6166,15 @@ function useAgentChat(options = {}) {
     const timer = setInterval(() => void refreshBackground(), every);
     return () => clearInterval(timer);
   }, [isWorking, refreshBackground]);
-  const cancel = useCallback11(async () => {
+  const proposals = useActionProposals(
+    client,
+    options.proposals === false || options.proposals !== true && options.history === false && options.resume === false ? void 0 : currentThreadId(),
+    (update) => chatRef.current.setMessages(update),
+    `${chat.status}:${connection.status}`,
+    options.proposalPollMs
+  );
+  proposalRefreshRef.current = proposals.refresh;
+  const cancel = useCallback13(async () => {
     chatRef.current.stop();
     const active = runIdRef.current;
     if (active) {
@@ -5776,8 +6191,23 @@ function useAgentChat(options = {}) {
       }
     }
   }, [client, currentThreadId, applyQueue]);
-  const approve = useCallback11(
-    async ({ toolCallId, remember, via }) => {
+  const approve = useCallback13(
+    async ({ toolCallId, target, remember, via }) => {
+      if (target?.kind === "proposal") {
+        const threadId = target.threadId ?? currentThreadId();
+        if (threadId === void 0)
+          throw new Error("A proposal decision requires its thread scope");
+        await requireBackendMethod(
+          client,
+          "approveActionProposal"
+        )({
+          threadId,
+          proposalId: target.proposalId,
+          ...remember === true ? { remember: true } : {}
+        });
+        await proposals.refresh();
+        return;
+      }
       await requireBackendMethod(
         client,
         "approveToolCall"
@@ -5787,10 +6217,25 @@ function useAgentChat(options = {}) {
         ...via !== void 0 ? { via } : {}
       });
     },
-    [client]
+    [client, currentThreadId, proposals.refresh]
   );
-  const reject = useCallback11(
-    async ({ toolCallId, reason, via }) => {
+  const reject = useCallback13(
+    async ({ toolCallId, target, reason, via }) => {
+      if (target?.kind === "proposal") {
+        const threadId = target.threadId ?? currentThreadId();
+        if (threadId === void 0)
+          throw new Error("A proposal decision requires its thread scope");
+        await requireBackendMethod(
+          client,
+          "rejectActionProposal"
+        )({
+          threadId,
+          proposalId: target.proposalId,
+          ...reason === void 0 ? {} : { reason }
+        });
+        await proposals.refresh();
+        return;
+      }
       await requireBackendMethod(
         client,
         "rejectToolCall"
@@ -5800,9 +6245,9 @@ function useAgentChat(options = {}) {
         ...via !== void 0 ? { via } : {}
       });
     },
-    [client]
+    [client, currentThreadId, proposals.refresh]
   );
-  const answer = useCallback11(
+  const answer = useCallback13(
     async ({ toolCallId, answers, via }) => {
       await requireBackendMethod(
         client,
@@ -5815,7 +6260,7 @@ function useAgentChat(options = {}) {
     },
     [client]
   );
-  const skip = useCallback11(
+  const skip = useCallback13(
     async ({ toolCallId, via }) => {
       await requireBackendMethod(
         client,
@@ -5824,7 +6269,7 @@ function useAgentChat(options = {}) {
     },
     [client]
   );
-  const regenerate = useCallback11(
+  const regenerate = useCallback13(
     (_input) => {
       const block = blockedRef.current;
       if (block != null) throw new QuotaBlockedError(block);
@@ -5837,7 +6282,7 @@ function useAgentChat(options = {}) {
     },
     [isTurnInFlight]
   );
-  const storedIdOf = useCallback11(
+  const storedIdOf = useCallback13(
     async (messageId, threadId) => {
       const message = chatRef.current.messages.find((candidate) => candidate.id === messageId);
       const runOf = message?.metadata?.runId;
@@ -5848,7 +6293,7 @@ function useAgentChat(options = {}) {
     },
     [client]
   );
-  const fork = useCallback11(
+  const fork = useCallback13(
     async ({
       messageId,
       threadId
@@ -5863,7 +6308,7 @@ function useAgentChat(options = {}) {
     },
     [client, currentThreadId, storedIdOf]
   );
-  const truncateFrom = useCallback11(
+  const truncateFrom = useCallback13(
     async ({ messageId, threadId }) => {
       const target = threadId ?? currentThreadId();
       if (target === void 0) throw new Error("truncateFrom: this chat has no thread yet");
@@ -5872,7 +6317,7 @@ function useAgentChat(options = {}) {
     },
     [client, currentThreadId, storedIdOf]
   );
-  const promote = useCallback11(
+  const promote = useCallback13(
     async ({ threadId } = {}) => {
       const target = threadId ?? currentThreadId();
       if (target === void 0) throw new Error("promote: this chat has no thread yet");
@@ -5881,24 +6326,24 @@ function useAgentChat(options = {}) {
     },
     [client, currentThreadId]
   );
-  const [modelsWanted, setModelsWanted] = useState15(false);
-  const modelsWantedRef = useRef12(modelsWanted);
+  const [modelsWanted, setModelsWanted] = useState16(false);
+  const modelsWantedRef = useRef13(modelsWanted);
   modelsWantedRef.current = modelsWanted;
   const catalog = useModels({
     backend: client,
     ...options.agent !== void 0 ? { agent: options.agent } : {},
     enabled: modelsWanted && typeof client.listModels === "function"
   });
-  const wantModels = useCallback11(() => {
+  const wantModels = useCallback13(() => {
     if (modelsWantedRef.current) return;
     modelsWantedRef.current = true;
     queueMicrotask(() => setModelsWanted(true));
   }, []);
   lockedRef.current = catalog.locked !== null;
-  const selectModel = useCallback11((id) => {
+  const selectModel = useCallback13((id) => {
     if (!lockedRef.current) setPickedModel(id);
   }, []);
-  const pinToThread = useCallback11(
+  const pinToThread = useCallback13(
     async (model) => {
       const threadId = currentThreadId();
       setThreadModel(model);
@@ -5938,14 +6383,14 @@ function useAgentChat(options = {}) {
   };
   const status = connection.status === "reconnecting" ? "reconnecting" : chat.status;
   const isBusy = status === "submitted" || status === "streaming" || status === "reconnecting";
-  const isBusyRef = useRef12(isBusy);
+  const isBusyRef = useRef13(isBusy);
   isBusyRef.current = isBusy;
   const files = useAttachments({ ...options.composer, backend: client });
-  const [text, setText] = useState15("");
+  const [text, setText] = useState16("");
   const blockedBy = blocked != null ? "quota" : files.isUploading ? "uploading" : isBusy && whileRunning === "block" ? "busy" : text.trim().length === 0 && files.refs.length === 0 ? "empty" : null;
-  const composerRef = useRef12({ text, files, blockedBy });
+  const composerRef = useRef13({ text, files, blockedBy });
   composerRef.current = { text, files, blockedBy };
-  const submit = useCallback11(
+  const submit = useCallback13(
     async (options2) => {
       const current = composerRef.current;
       const asked = canQueueRef.current ? options2?.mode : void 0;
@@ -6027,6 +6472,7 @@ function useAgentChat(options = {}) {
     addToolResult,
     /** Sub-agents this conversation started and did not wait for. */
     background,
+    proposals,
     runId,
     /** The loaded thread's running turn, or `null` once read with none. */
     activeRunId,
@@ -6059,6 +6505,11 @@ function useAgentChat(options = {}) {
     queue,
     /** The model picker: `list`, `selected`, `select(id)`, `pinToThread(id)`. */
     models,
+    /**
+     * The persona pinned on this thread (`ThreadSummary.persona`), or `null` when none is — what a
+     * persona picker on a reopened thread starts from (`?? agent.defaultPersona`).
+     */
+    threadPersona,
     /** The caller's budget (`GET <base>/quota`); `quota.blocked` gates sends. */
     quota,
     /** The window blocking sends right now (the `blocked` option, else the quota report's). */
@@ -6145,8 +6596,10 @@ export {
   onThreadsEvent,
   persistSpeechLang,
   phraseFor,
+  proposalNeedsPolling,
   readPath,
   readReasoningMs,
+  reconcileProposalMessages,
   reframeAgUiStream,
   requireBackendMethod,
   resolveResultView,
@@ -6154,6 +6607,7 @@ export {
   storedThreadToUiMessages,
   toolCallState,
   toolCatalogFrom,
+  useActionProposals,
   useAgentBackend,
   useAgentChat,
   useAgentConfig,