@dudousxd/nestjs-agent-react 0.9.0 → 0.11.0

package/dist/index.js

@@ -444,6 +444,10 @@ var AgentChatTransport = class {
                 });
               }
               break;
+            case "approval-settled":
+              ensureStep();
+              forwardAsData(event, false);
+              break;
             case "ui":
               ensureStep();
               closeRuns();
@@ -679,6 +683,15 @@ var AgentClient = class {
     const query = threadId === void 0 ? "" : `?threadId=${encodeURIComponent(threadId)}`;
     return this.request("GET", `/agent/skills${query}`);
   }
+  /**
+  * The tools this caller can reach through `agent` (the default agent when omitted), each with the
+  * server-declared `presentation` a chat narrates it by — the same list the model is offered.
+  * Prefer {@link useToolCatalog}, which fetches it once and shares it.
+  */
+  listTools(agent) {
+    const query = agent === void 0 ? "" : `?agent=${encodeURIComponent(agent)}`;
+    return this.request("GET", `/agent/tools${query}`);
+  }
   getThread(id) {
     return this.request("GET", `/agent/threads/${encodeURIComponent(id)}`);
   }
@@ -734,6 +747,10 @@ var AgentClient = class {
   cancelStream(runId) {
     return this.request("POST", `/agent/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);
   }
@@ -961,7 +978,280 @@ import React3 from "react";
 import { useCallback as useCallback3, useEffect as useEffect5, useRef as useRef4, useState as useState5 } from "react";
 
 // src/transcript/model.ts
-import { getToolName, isDataUIPart, isFileUIPart, isReasoningUIPart, isTextUIPart, isToolUIPart } from "ai";
+import { getToolName as getToolName2, isDataUIPart, isFileUIPart, isReasoningUIPart, isTextUIPart, isToolUIPart } from "ai";
+
+// src/presentation/tool-activity.ts
+import { getToolName } from "ai";
+
+// src/presentation/phrasing.ts
+function toolCatalogFrom(entries) {
+  const catalog = {};
+  for (const entry of entries) {
+    if (entry.presentation !== void 0) catalog[entry.name] = entry.presentation;
+  }
+  return catalog;
+}
+__name(toolCatalogFrom, "toolCatalogFrom");
+function readPath(value, path) {
+  return path.split(".").reduce((current, key) => {
+    if (current === null || typeof current !== "object") return void 0;
+    return current[key];
+  }, value);
+}
+__name(readPath, "readPath");
+function renderValue(value) {
+  if (value === null || value === void 0) return "";
+  if (typeof value === "string") return value;
+  if (typeof value === "number" || typeof value === "boolean") return String(value);
+  if (Array.isArray(value)) return value.map(renderValue).filter(Boolean).join(", ");
+  return "";
+}
+__name(renderValue, "renderValue");
+function fillTemplate(template, context) {
+  return template.replace(/(\s*)\{([\w.]+)\}/g, (_match, space, path) => {
+    const rendered = renderValue(readPath(context, path));
+    return rendered === "" ? "" : `${space}${rendered}`;
+  }).replace(/\s{2,}/g, " ").trim();
+}
+__name(fillTemplate, "fillTemplate");
+function phraseFor(presentation, input, isSettled2, fallback = {
+  running: "Working",
+  done: "Done"
+}) {
+  if (presentation === void 0) return isSettled2 ? fallback.done : fallback.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) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+__name(isRecord, "isRecord");
+function toText(value) {
+  if (value === null || value === void 0) return "\u2014";
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return String(value);
+  }
+  if (Array.isArray(value)) return value.map(toText).join(", ");
+  return "\u2014";
+}
+__name(toText, "toText");
+function inferResultView(output) {
+  if (!isRecord(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")) {
+      return {
+        kind: "log",
+        lines: key
+      };
+    }
+    if (value.every(isRecord)) {
+      const first = value[0];
+      return {
+        kind: "table",
+        rows: key,
+        columns: Object.keys(first).filter((column) => !isRecord(first[column])).map((column) => ({
+          path: column,
+          label: column
+        }))
+      };
+    }
+  }
+  const fields = Object.entries(output).filter(([, value]) => [
+    "string",
+    "number",
+    "boolean"
+  ].includes(typeof value)).map(([key]) => ({
+    path: key,
+    label: key
+  }));
+  return fields.length > 0 ? {
+    kind: "metrics",
+    fields
+  } : void 0;
+}
+__name(inferResultView, "inferResultView");
+function resolveResultView(output, view, options = {}) {
+  const resolved = view ?? (options.infer === true ? inferResultView(output) : void 0);
+  if (resolved === void 0 || resolved.kind === "elsewhere") return null;
+  switch (resolved.kind) {
+    case "note": {
+      const text = fillTemplate(resolved.text, output);
+      return text === "" ? null : {
+        kind: "note",
+        text
+      };
+    }
+    case "metrics": {
+      const readings = resolved.fields.map((field) => ({
+        field,
+        value: readPath(output, field.path)
+      })).filter((entry) => entry.value !== void 0 && entry.value !== null).map(({ field, value }) => ({
+        label: field.label,
+        value: toText(value),
+        unit: field.unit ?? null
+      }));
+      return readings.length === 0 ? null : {
+        kind: "metrics",
+        readings
+      };
+    }
+    case "log": {
+      const lines = readPath(output, resolved.lines);
+      if (!Array.isArray(lines) || lines.length === 0) return null;
+      return {
+        kind: "log",
+        lines: lines.map(toText)
+      };
+    }
+    case "table": {
+      const rows = readPath(output, resolved.rows);
+      if (!Array.isArray(rows)) return null;
+      return {
+        kind: "table",
+        columns: resolved.columns,
+        rows: rows.map((row) => resolved.columns.map((column) => toText(readPath(row, column.path)))),
+        empty: rows.length === 0 ? resolved.empty ?? null : null
+      };
+    }
+  }
+}
+__name(resolveResultView, "resolveResultView");
+
+// src/presentation/tool-activity.ts
+function isActionCall(part) {
+  const metadata = part.toolMetadata;
+  return typeof metadata === "object" && metadata !== null && metadata.toolKind === "action";
+}
+__name(isActionCall, "isActionCall");
+function toolCallState(part) {
+  const output = "output" in part ? part.output : void 0;
+  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";
+  const isFailed = part.state === "output-error" || outputError !== void 0 && !isDenied;
+  const isSettled2 = part.state === "output-available" || part.state === "output-error" || isDenied;
+  const isAwaiting = part.state === "approval-requested" || part.state === "input-available" && isActionCall(part);
+  const status = isDenied ? "denied" : isFailed ? "failed" : isSettled2 ? "done" : isAwaiting ? "awaiting-approval" : "running";
+  return {
+    status,
+    isSettled: isSettled2,
+    isFailed,
+    isDenied,
+    output,
+    error: errorText ?? outputError ?? null
+  };
+}
+__name(toolCallState, "toolCallState");
+function correctedCallIds(parts) {
+  const corrected = /* @__PURE__ */ new Set();
+  const lastSuccessByTool = /* @__PURE__ */ new Map();
+  parts.forEach((part, index) => {
+    if (part.state === "output-available" && !toolCallState(part).isFailed) {
+      lastSuccessByTool.set(getToolName(part), index);
+    }
+  });
+  parts.forEach((part, index) => {
+    const successAt = lastSuccessByTool.get(getToolName(part));
+    if (successAt !== void 0 && index < successAt && toolCallState(part).isFailed) {
+      corrected.add(part.toolCallId);
+    }
+  });
+  return corrected;
+}
+__name(correctedCallIds, "correctedCallIds");
+function describeToolCall(part, catalog, options = {}) {
+  const presentation = catalog?.[getToolName(part)];
+  const state = toolCallState(part);
+  const input = part.input;
+  const confirm = presentation?.confirm;
+  return {
+    status: state.status,
+    phrase: phraseFor(presentation, input, state.isSettled, options.fallback),
+    label: presentation?.label ?? null,
+    icon: presentation?.icon ?? null,
+    tone: presentation?.tone ?? "neutral",
+    detail: presentation?.detail ?? null,
+    confirm: confirm === void 0 ? null : {
+      title: fillTemplate(confirm.title, input),
+      verb: confirm.verb,
+      detail: confirm.detail !== void 0 ? fillTemplate(confirm.detail, input) : null
+    },
+    result: state.status === "done" ? resolveResultView(state.output, presentation?.result, {
+      ...options.inferResult !== void 0 ? {
+        infer: options.inferResult
+      } : {}
+    }) : null,
+    error: state.error,
+    presentation: presentation ?? null
+  };
+}
+__name(describeToolCall, "describeToolCall");
+var STATUS_WEIGHT = {
+  running: 4,
+  "awaiting-approval": 3,
+  failed: 2,
+  denied: 1,
+  done: 0
+};
+function descendants(call) {
+  return call.children.flatMap((child) => [
+    child,
+    ...descendants(child)
+  ]);
+}
+__name(descendants, "descendants");
+function leaves(call) {
+  return call.children.length === 0 ? [
+    call
+  ] : call.children.flatMap(leaves);
+}
+__name(leaves, "leaves");
+function groupToolActivity(calls, options = {}) {
+  const expanded = options.expandNested === true ? calls.flatMap(leaves) : [
+    ...calls
+  ];
+  const corrected = options.hideCorrected === true ? correctedCallIds(expanded.map((call) => call.part)) : /* @__PURE__ */ new Set();
+  const groups = /* @__PURE__ */ new Map();
+  for (const call of expanded) {
+    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 phrase = phraseFor(presentation, call.part.input, status !== "running" && status !== "awaiting-approval", options.fallback);
+    const inner = options.expandNested === true ? 0 : descendants(call).length;
+    const existing = groups.get(key);
+    if (existing === void 0) {
+      groups.set(key, {
+        key,
+        label: presentation?.label ?? null,
+        icon: presentation?.icon ?? null,
+        status,
+        count: 1,
+        phrase,
+        calls: [
+          call
+        ],
+        innerCount: inner
+      });
+      continue;
+    }
+    existing.count += 1;
+    existing.calls.push(call);
+    existing.phrase = phrase;
+    existing.innerCount += inner;
+    if (STATUS_WEIGHT[status] > STATUS_WEIGHT[existing.status]) existing.status = status;
+  }
+  return [
+    ...groups.values()
+  ];
+}
+__name(groupToolActivity, "groupToolActivity");
+
+// src/transcript/model.ts
 function buildTranscriptBlocks(message, options) {
   const blocks = [];
   let toolBuffer = [];
@@ -978,13 +1268,19 @@ function buildTranscriptBlocks(message, options) {
     if (toolBuffer.length === 0) {
       return;
     }
-    const calls = toolBuffer.map((part) => buildToolCall(part, options.approval, approvals.get(part.toolCallId) ?? null));
+    const calls = toolBuffer.map((part) => buildToolCall(part, options.approval, approvalOf(approvals.get(part.toolCallId), part), options.toolCatalog));
+    const roots = nestToolCalls(calls);
     blocks.push({
       kind: "tools",
       key: `${message.id}-tools-${toolCounter++}`,
       parts: toolBuffer,
       calls,
-      roots: nestToolCalls(calls)
+      roots,
+      activity: groupToolActivity(roots, {
+        ...options.toolCatalog !== void 0 ? {
+          catalog: options.toolCatalog
+        } : {}
+      })
     });
     toolBuffer = [];
   }
@@ -1047,7 +1343,7 @@ function buildTranscriptBlocks(message, options) {
       fileBuffer.push(part);
       continue;
     }
-    if (part.type === APPROVAL_PART) {
+    if (part.type === APPROVAL_PART || part.type === SETTLED_PART) {
       continue;
     }
     flushAll();
@@ -1133,7 +1429,7 @@ function isSettled(state) {
 __name(isSettled, "isSettled");
 function toolKind(part) {
   const metadata = part.toolMetadata;
-  return isRecord(metadata) && typeof metadata.toolKind === "string" ? metadata.toolKind : void 0;
+  return isRecord2(metadata) && typeof metadata.toolKind === "string" ? metadata.toolKind : void 0;
 }
 __name(toolKind, "toolKind");
 function isAwaitingApproval(part) {
@@ -1148,7 +1444,7 @@ function isAwaitingApproval(part) {
 __name(isAwaitingApproval, "isAwaitingApproval");
 function toolParentId(part) {
   const metadata = part.toolMetadata;
-  return isRecord(metadata) && typeof metadata.parentId === "string" ? metadata.parentId : null;
+  return isRecord2(metadata) && typeof metadata.parentId === "string" ? metadata.parentId : null;
 }
 __name(toolParentId, "toolParentId");
 function nestToolCalls(calls) {
@@ -1181,23 +1477,28 @@ function isAncestor(call, candidate, byId) {
   return false;
 }
 __name(isAncestor, "isAncestor");
-function buildToolCall(part, options, approval) {
+function buildToolCall(part, options, approval, catalog) {
   const toolCallId = part.toolCallId;
   const awaiting = isAwaitingApproval(part);
   const sending = awaiting ? options?.submitting(toolCallId) ?? null : null;
   return {
     part,
     toolCallId,
-    name: getToolName(part),
+    name: getToolName2(part),
     toolKind: toolKind(part) ?? null,
     parentId: toolParentId(part),
     children: [],
     approval,
+    description: describeToolCall(part, catalog),
     isAwaitingApproval: awaiting,
     approve: {
       available: awaiting && options?.canApprove === true,
       isSubmitting: sending === "approve",
-      run: /* @__PURE__ */ __name(() => options?.approve(toolCallId), "run")
+      // 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: /* @__PURE__ */ __name((approveOptions) => approveOptions?.remember === true ? options?.approve(toolCallId, {
+        remember: true
+      }) : options?.approve(toolCallId), "run")
     },
     reject: {
       available: awaiting && options?.canReject === true,
@@ -1210,17 +1511,17 @@ function buildToolCall(part, options, approval) {
 __name(buildToolCall, "buildToolCall");
 function readElicitationRequest(part) {
   const input = part.input;
-  if (!isRecord(input) || !Array.isArray(input.questions) || input.questions.length === 0) {
+  if (!isRecord2(input) || !Array.isArray(input.questions) || input.questions.length === 0) {
     return null;
   }
   const questions = [];
   for (const candidate of input.questions) {
-    if (!isRecord(candidate) || typeof candidate.id !== "string" || typeof candidate.prompt !== "string" || !Array.isArray(candidate.options) || candidate.options.length === 0) {
+    if (!isRecord2(candidate) || typeof candidate.id !== "string" || typeof candidate.prompt !== "string" || !Array.isArray(candidate.options) || candidate.options.length === 0) {
       return null;
     }
     const options = [];
     for (const option of candidate.options) {
-      if (!isRecord(option) || typeof option.value !== "string" || typeof option.label !== "string") {
+      if (!isRecord2(option) || typeof option.value !== "string" || typeof option.label !== "string") {
         return null;
       }
       options.push({
@@ -1245,7 +1546,7 @@ function readElicitationRequest(part) {
 __name(readElicitationRequest, "readElicitationRequest");
 function readElicitationOutcome(part) {
   const output = part.output;
-  if (!isRecord(output) || !isRecord(output.answers) || typeof output.skipped !== "boolean") {
+  if (!isRecord2(output) || !isRecord2(output.answers) || typeof output.skipped !== "boolean") {
     return null;
   }
   const answers = {};
@@ -1325,28 +1626,93 @@ function buildElicitationBlock(key, part, request, options) {
 __name(buildElicitationBlock, "buildElicitationBlock");
 var UI_PART = "data-ui";
 var APPROVAL_PART = "data-approval-requested";
+var SETTLED_PART = "data-approval-settled";
+var SETTLED_STATUSES = [
+  "approved",
+  "rejected",
+  "expired"
+];
 function readApprovals(parts) {
   const out = /* @__PURE__ */ new Map();
+  const entry = /* @__PURE__ */ __name((id) => {
+    let found = out.get(id);
+    if (found === void 0) {
+      found = {
+        approver: null,
+        expiresAt: null,
+        reason: null,
+        status: null,
+        remember: false,
+        decidedBy: null,
+        decidedVia: null,
+        decisionReason: null
+      };
+      out.set(id, found);
+    }
+    return found;
+  }, "entry");
   for (const part of parts) {
-    if (part.type !== APPROVAL_PART) {
+    if (part.type !== APPROVAL_PART && part.type !== SETTLED_PART) {
       continue;
     }
     const data = part.data;
-    if (!isRecord(data) || typeof data.id !== "string" || typeof data.approver !== "string") {
+    if (!isRecord2(data) || typeof data.id !== "string") {
       continue;
     }
-    out.set(data.id, {
-      approver: data.approver,
-      expiresAt: typeof data.expiresAt === "string" ? data.expiresAt : null,
-      reason: typeof data.reason === "string" ? data.reason : null
-    });
+    const approval = entry(data.id);
+    if (part.type === APPROVAL_PART) {
+      if (typeof data.approver !== "string") {
+        continue;
+      }
+      approval.approver = data.approver;
+      approval.expiresAt = typeof data.expiresAt === "string" ? data.expiresAt : null;
+      approval.reason = typeof data.reason === "string" ? data.reason : null;
+      continue;
+    }
+    if (typeof data.status !== "string" || !SETTLED_STATUSES.includes(data.status)) {
+      continue;
+    }
+    approval.status = data.status;
+    if (approval.approver === null && typeof data.approver === "string") {
+      approval.approver = data.approver;
+    }
+    approval.remember = data.remember === true;
+    approval.decidedBy = typeof data.decidedBy === "string" ? data.decidedBy : null;
+    approval.decidedVia = typeof data.decidedVia === "string" ? data.decidedVia : null;
+    approval.decisionReason = typeof data.reason === "string" ? data.reason : null;
   }
   return out;
 }
 __name(readApprovals, "readApprovals");
+function approvalOf(parts, call) {
+  if (parts === void 0 || parts.approver === null) {
+    return null;
+  }
+  return {
+    approver: parts.approver,
+    expiresAt: parts.expiresAt,
+    reason: parts.reason,
+    status: parts.status ?? statusFromPart(call),
+    remember: parts.remember,
+    decidedBy: parts.decidedBy,
+    decidedVia: parts.decidedVia,
+    decisionReason: parts.decisionReason
+  };
+}
+__name(approvalOf, "approvalOf");
+function statusFromPart(call) {
+  if (call.state === "output-denied") {
+    return "rejected";
+  }
+  if (call.state === "output-available" || call.state === "output-error") {
+    return "approved";
+  }
+  return "pending";
+}
+__name(statusFromPart, "statusFromPart");
 function readUiComponent(part) {
   const data = part.data;
-  if (!isRecord(data) || typeof data.component !== "string") {
+  if (!isRecord2(data) || typeof data.component !== "string") {
     return null;
   }
   const id = typeof data.id === "string" ? data.id : part.id;
@@ -1356,18 +1722,18 @@ function readUiComponent(part) {
   return {
     id,
     component: data.component,
-    props: isRecord(data.props) ? data.props : {},
+    props: isRecord2(data.props) ? data.props : {},
     version: typeof data.version === "number" ? data.version : null
   };
 }
 __name(readUiComponent, "readUiComponent");
-function isRecord(value) {
+function isRecord2(value) {
   return typeof value === "object" && value !== null;
 }
-__name(isRecord, "isRecord");
+__name(isRecord2, "isRecord");
 function readQuery(part) {
   const input = part.input;
-  if (!isRecord(input) || typeof input.query !== "string") {
+  if (!isRecord2(input) || typeof input.query !== "string") {
     return null;
   }
   return input.query;
@@ -1375,12 +1741,12 @@ function readQuery(part) {
 __name(readQuery, "readQuery");
 function readPassages(part) {
   const output = part.output;
-  if (!isRecord(output) || !Array.isArray(output.passages) || output.passages.length === 0) {
+  if (!isRecord2(output) || !Array.isArray(output.passages) || output.passages.length === 0) {
     return null;
   }
   const passages = [];
   for (const candidate of output.passages) {
-    if (!isRecord(candidate) || typeof candidate.id !== "string" || typeof candidate.text !== "string") {
+    if (!isRecord2(candidate) || typeof candidate.id !== "string" || typeof candidate.text !== "string") {
       return null;
     }
     passages.push({
@@ -1390,7 +1756,7 @@ function readPassages(part) {
       ...typeof candidate.source === "string" ? {
         source: candidate.source
       } : {},
-      ...isRecord(candidate.metadata) ? {
+      ...isRecord2(candidate.metadata) ? {
         metadata: candidate.metadata
       } : {}
     });
@@ -1729,10 +2095,10 @@ function useTranscriptItems({ messages, visibleStart, streamingMessageId, option
   }, [
     settle
   ]);
-  const approve = useCallback3((toolCallId) => {
+  const approve = useCallback3((toolCallId, options2) => {
     const onApprove = latest.current.options.onApprove;
     if (onApprove) {
-      settle(toolCallId, "approve", () => onApprove(toolCallId));
+      settle(toolCallId, "approve", () => options2 === void 0 ? onApprove(toolCallId) : onApprove(toolCallId, options2));
     }
   }, [
     settle
@@ -1857,6 +2223,9 @@ function useTranscriptItems({ messages, visibleStart, streamingMessageId, option
         ...options.sources !== void 0 ? {
           sources: options.sources
         } : {},
+        ...options.toolCatalog !== void 0 ? {
+          toolCatalog: options.toolCatalog
+        } : {},
         ...options.onAnswer !== void 0 ? {
           elicitation: {
             picked: /* @__PURE__ */ __name((toolCallId, questionId) => picks.get(pickKey(toolCallId, questionId)), "picked"),
@@ -2632,6 +3001,121 @@ function isPromise(value) {
 }
 __name(isPromise, "isPromise");
 
+// src/presentation/use-tool-catalog.ts
+import { useCallback as useCallback5, useEffect as useEffect7, useMemo as useMemo3, useState as useState7 } from "react";
+var shared = /* @__PURE__ */ new WeakMap();
+function load(client, agent) {
+  let byAgent = shared.get(client);
+  if (byAgent === void 0) {
+    byAgent = /* @__PURE__ */ new Map();
+    shared.set(client, byAgent);
+  }
+  const key = agent ?? "";
+  const cached = byAgent.get(key);
+  if (cached !== void 0) return cached;
+  const request = client.listTools(agent).catch((error) => {
+    byAgent.delete(key);
+    throw error;
+  });
+  byAgent.set(key, request);
+  return request;
+}
+__name(load, "load");
+function useToolCatalog(options) {
+  const { client, agent, enabled = true } = options;
+  const [entries, setEntries] = useState7([]);
+  const [isLoading, setLoading] = useState7(enabled);
+  const [error, setError] = useState7(null);
+  const [generation, setGeneration] = useState7(0);
+  useEffect7(() => {
+    if (!enabled) {
+      setLoading(false);
+      return;
+    }
+    let cancelled = false;
+    setLoading(true);
+    load(client, agent).then((loaded) => {
+      if (cancelled) return;
+      setEntries(loaded);
+      setError(null);
+      setLoading(false);
+    }, (failure) => {
+      if (cancelled) return;
+      setError(failure instanceof Error ? failure : new Error(String(failure)));
+      setLoading(false);
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [
+    client,
+    agent,
+    enabled,
+    generation
+  ]);
+  const refresh = useCallback5(() => {
+    shared.get(client)?.delete(agent ?? "");
+    setGeneration((current) => current + 1);
+  }, [
+    client,
+    agent
+  ]);
+  const catalog = useMemo3(() => toolCatalogFrom(entries), [
+    entries
+  ]);
+  return {
+    catalog,
+    entries,
+    isLoading,
+    error,
+    refresh
+  };
+}
+__name(useToolCatalog, "useToolCatalog");
+
+// src/approvals/countdown.ts
+import { useEffect as useEffect8, useRef as useRef6, useState as useState8 } from "react";
+function approvalCountdown(expiresAt, now = Date.now()) {
+  const deadline = expiresAt == null ? Number.NaN : Date.parse(expiresAt);
+  if (!Number.isFinite(deadline)) {
+    return {
+      remainingMs: null,
+      isExpired: false
+    };
+  }
+  const remainingMs = Math.max(0, deadline - now);
+  return {
+    remainingMs,
+    isExpired: remainingMs === 0
+  };
+}
+__name(approvalCountdown, "approvalCountdown");
+function useApprovalCountdown(expiresAt, options = {}) {
+  const { intervalMs = 1e3 } = options;
+  const nowRef = useRef6(options.now ?? Date.now);
+  nowRef.current = options.now ?? Date.now;
+  const [state, setState] = useState8(() => approvalCountdown(expiresAt, nowRef.current()));
+  useEffect8(() => {
+    const read = /* @__PURE__ */ __name(() => approvalCountdown(expiresAt, nowRef.current()), "read");
+    const first = read();
+    setState(first);
+    if (first.remainingMs === null || first.isExpired) {
+      return;
+    }
+    const timer = setInterval(() => {
+      const next = read();
+      setState(next);
+      if (next.isExpired) clearInterval(timer);
+    }, intervalMs);
+    return () => clearInterval(timer);
+  }, [
+    expiresAt,
+    intervalMs
+  ]);
+  return state;
+}
+__name(useApprovalCountdown, "useApprovalCountdown");
+
 // src/stored-message-to-ui-message.ts
 import { DEFAULT_REFUSAL_REASON } from "@dudousxd/nestjs-agent-core";
 function isRefusal(result) {
@@ -2691,6 +3175,41 @@ function storedMessageToUiMessage(message) {
       }
     });
   }
+  for (const approval of message.approvals ?? []) {
+    parts.push({
+      type: "data-approval-requested",
+      id: approval.toolCallId,
+      data: {
+        id: approval.toolCallId,
+        approver: approval.approver,
+        ...approval.expiresAt !== void 0 ? {
+          expiresAt: approval.expiresAt
+        } : {}
+      }
+    });
+    if (approval.status !== "pending") {
+      parts.push({
+        type: "data-approval-settled",
+        id: approval.toolCallId,
+        data: {
+          id: approval.toolCallId,
+          status: approval.status,
+          ...approval.decidedBy !== void 0 ? {
+            decidedBy: approval.decidedBy
+          } : {},
+          ...approval.decidedVia !== void 0 ? {
+            decidedVia: approval.decidedVia
+          } : {},
+          ...approval.remember === true ? {
+            remember: true
+          } : {},
+          ...approval.reason !== void 0 ? {
+            reason: approval.reason
+          } : {}
+        }
+      });
+    }
+  }
   for (const call of message.toolCalls ?? []) {
     const result = message.toolResults?.find((candidate) => candidate.id === call.id);
     const toolKind2 = call.kind;
@@ -2793,20 +3312,20 @@ __name(sumUsage, "sumUsage");
 
 // src/use-agent-chat.ts
 import { useChat } from "@ai-sdk/react";
-import { useCallback as useCallback5, useEffect as useEffect7, useMemo as useMemo3, useRef as useRef6, useState as useState7 } from "react";
+import { useCallback as useCallback6, useEffect as useEffect9, useMemo as useMemo4, useRef as useRef7, useState as useState9 } from "react";
 function useAgentChat(options) {
-  const latest = useRef6(options);
+  const latest = useRef7(options);
   latest.current = options;
-  const [runId, setRunId] = useState7(options.resumeRunId);
-  const runIdRef = useRef6(runId);
+  const [runId, setRunId] = useState9(options.resumeRunId);
+  const runIdRef = useRef7(runId);
   runIdRef.current = runId;
-  const settlingRunIdRef = useRef6(void 0);
-  const autoResumeRunIdRef = useRef6(void 0);
-  const [autoResume, setAutoResume] = useState7(false);
-  const [activeRunId, setActiveRunId] = useState7(null);
-  const regenerateNext = useRef6(false);
-  const createdThreadId = useRef6(void 0);
-  const client = useMemo3(() => {
+  const settlingRunIdRef = useRef7(void 0);
+  const autoResumeRunIdRef = useRef7(void 0);
+  const [autoResume, setAutoResume] = useState9(false);
+  const [activeRunId, setActiveRunId] = useState9(null);
+  const regenerateNext = useRef7(false);
+  const createdThreadId = useRef7(void 0);
+  const client = useMemo4(() => {
     if (options.client) return options.client;
     return new AgentClient({
       ...options.baseUrl !== void 0 ? {
@@ -2821,7 +3340,7 @@ function useAgentChat(options) {
       getHeaders: /* @__PURE__ */ __name(async () => mergeHeaders(latest.current), "getHeaders")
     });
   }, []);
-  useEffect7(() => {
+  useEffect9(() => {
     if (!options.resume || options.threadId === void 0) return;
     let cancelled = false;
     const threadId = options.threadId;
@@ -2841,7 +3360,7 @@ function useAgentChat(options) {
     options.resume,
     options.threadId
   ]);
-  const transport = useMemo3(() => {
+  const transport = useMemo4(() => {
     function onMeta(meta) {
       settlingRunIdRef.current = meta.runId;
       setRunId(meta.runId);
@@ -2890,7 +3409,7 @@ function useAgentChat(options) {
       }, "onAttemptStart")
     });
   }, []);
-  const backgroundRef = useRef6(() => Promise.resolve());
+  const backgroundRef = useRef7(() => Promise.resolve());
   const chat = useChat({
     transport,
     resume: options.resumeRunId !== void 0 || autoResume,
@@ -2921,13 +3440,13 @@ function useAgentChat(options) {
       }
     }, "onFinish")
   });
-  const chatRef = useRef6(chat);
+  const chatRef = useRef7(chat);
   chatRef.current = chat;
-  const turnInFlight = useRef6(false);
-  const isTurnInFlight = useCallback5(() => turnInFlight.current || transport.isAttemptLive, [
+  const turnInFlight = useRef7(false);
+  const isTurnInFlight = useCallback6(() => turnInFlight.current || transport.isAttemptLive, [
     transport
   ]);
-  const sendMessage = useCallback5(async (...args) => {
+  const sendMessage = useCallback6(async (...args) => {
     if (isTurnInFlight()) return;
     turnInFlight.current = true;
     try {
@@ -2938,15 +3457,15 @@ function useAgentChat(options) {
   }, [
     isTurnInFlight
   ]);
-  const addToolResult = useCallback5(({ tool, toolCallId, output }) => chatRef.current.addToolResult({
+  const addToolResult = useCallback6(({ tool, toolCallId, output }) => chatRef.current.addToolResult({
     tool,
     toolCallId,
     output
   }), []);
-  const [threads, setThreads] = useState7([]);
-  const [quota, setQuota] = useState7(null);
-  const [backgroundRuns, setBackgroundRuns] = useState7([]);
-  const refreshBackground = useCallback5(async () => {
+  const [threads, setThreads] = useState9([]);
+  const [quota, setQuota] = useState9(null);
+  const [backgroundRuns, setBackgroundRuns] = useState9([]);
+  const refreshBackground = useCallback6(async () => {
     const threadId = latest.current.threadId ?? createdThreadId.current;
     if (threadId === void 0) {
       return;
@@ -2971,7 +3490,7 @@ function useAgentChat(options) {
   ]);
   backgroundRef.current = refreshBackground;
   const isWorking = backgroundRuns.some((run) => run.status === "running");
-  useEffect7(() => {
+  useEffect9(() => {
     if (options.background !== true || options.threadId === void 0) {
       return;
     }
@@ -2981,7 +3500,7 @@ function useAgentChat(options) {
     options.threadId,
     refreshBackground
   ]);
-  useEffect7(() => {
+  useEffect9(() => {
     const every = latest.current.backgroundPollMs ?? 5e3;
     if (latest.current.background !== true || !isWorking || every <= 0) {
       return;
@@ -2992,26 +3511,26 @@ function useAgentChat(options) {
     isWorking,
     refreshBackground
   ]);
-  const loadThreads = useCallback5(async () => {
+  const loadThreads = useCallback6(async () => {
     const list = await client.listThreads();
     setThreads(list);
     return list;
   }, [
     client
   ]);
-  const loadThread = useCallback5((id) => client.getThread(id), [
+  const loadThread = useCallback6((id) => client.getThread(id), [
     client
   ]);
-  const deleteThread = useCallback5(async (id) => {
+  const deleteThread = useCallback6(async (id) => {
     await client.deleteThread(id);
     setThreads((current) => current.filter((thread) => thread.id !== id));
   }, [
     client
   ]);
-  const forkThread = useCallback5((threadId, messageId) => client.forkFromMessage(threadId, messageId), [
+  const forkThread = useCallback6((threadId, messageId) => client.forkFromMessage(threadId, messageId), [
     client
   ]);
-  const renameThread = useCallback5(async (id, title) => {
+  const renameThread = useCallback6(async (id, title) => {
     await client.renameThread(id, title);
     setThreads((current) => current.map((thread) => thread.id === id ? {
       ...thread,
@@ -3020,24 +3539,24 @@ function useAgentChat(options) {
   }, [
     client
   ]);
-  const promoteThread = useCallback5(async (id) => {
+  const promoteThread = useCallback6(async (id) => {
     await client.promoteThread(id);
     await loadThreads();
   }, [
     client,
     loadThreads
   ]);
-  const truncateFromMessage = useCallback5((threadId, messageId) => client.truncateFromMessage(threadId, messageId).then(() => void 0), [
+  const truncateFromMessage = useCallback6((threadId, messageId) => client.truncateFromMessage(threadId, messageId).then(() => void 0), [
     client
   ]);
-  const loadQuota = useCallback5(async () => {
+  const loadQuota = useCallback6(async () => {
     const today = await client.getQuotaToday();
     setQuota(today);
     return today;
   }, [
     client
   ]);
-  const cancel = useCallback5(async () => {
+  const cancel = useCallback6(async () => {
     chatRef.current.stop();
     const activeRunId2 = runIdRef.current;
     if (activeRunId2) {
@@ -3049,24 +3568,33 @@ function useAgentChat(options) {
   }, [
     client
   ]);
-  const approve = useCallback5(async ({ toolCallId }) => {
+  const approve = useCallback6(async ({ toolCallId, remember, via }) => {
     await client.approveToolCall({
-      toolCallId
+      toolCallId,
+      ...remember === true ? {
+        remember: true
+      } : {},
+      ...via !== void 0 ? {
+        via
+      } : {}
     });
   }, [
     client
   ]);
-  const reject = useCallback5(async ({ toolCallId, reason }) => {
+  const reject = useCallback6(async ({ toolCallId, reason, via }) => {
     await client.rejectToolCall({
       toolCallId,
       ...reason !== void 0 ? {
         reason
+      } : {},
+      ...via !== void 0 ? {
+        via
       } : {}
     });
   }, [
     client
   ]);
-  const answer = useCallback5(async ({ toolCallId, answers }) => {
+  const answer = useCallback6(async ({ toolCallId, answers }) => {
     await client.answerToolCall({
       toolCallId,
       ...answers !== void 0 ? {
@@ -3076,14 +3604,14 @@ function useAgentChat(options) {
   }, [
     client
   ]);
-  const skip = useCallback5(async ({ toolCallId }) => {
+  const skip = useCallback6(async ({ toolCallId }) => {
     await client.skipToolCall({
       toolCallId
     });
   }, [
     client
   ]);
-  const regenerate = useCallback5(() => {
+  const regenerate = useCallback6(() => {
     if (isTurnInFlight()) return;
     regenerateNext.current = true;
     turnInFlight.current = true;
@@ -3146,27 +3674,41 @@ export {
   MessageList,
   SPEECH_LANGUAGES,
   applyCompletion,
+  approvalCountdown,
   backgroundRunsFromThread,
   buildTranscriptBlocks,
+  correctedCallIds,
   createSkillsSource,
   describeTimestamp,
+  describeToolCall,
   describeUsage,
   extractMessageText,
+  fillTemplate,
   filterAutocompleteItems,
   findActiveTrigger,
   formatElapsed,
   formatRelativeTime,
+  groupToolActivity,
+  inferResultView,
+  isActionCall,
   loadStoredSpeechLang,
   persistSpeechLang,
+  phraseFor,
+  readPath,
   readReasoningMs,
+  resolveResultView,
   storedMessageToUiMessage,
   storedThreadToUiMessages,
+  toolCallState,
+  toolCatalogFrom,
   useAgentChat,
+  useApprovalCountdown,
   useChatTranscript,
   useComposerAutocomplete,
   useElapsed,
   useSpeechRecognition,
   useStickToBottom,
+  useToolCatalog,
   useTranscriptItem
 };
 //# sourceMappingURL=index.js.map