@agent-native/core 0.131.9 → 0.132.1

package/src/audit/redact.ts

@@ -12,7 +12,7 @@
  */
 
 const SENSITIVE_KEY =
-  /(pass(word|phrase)?|secret|token|api[_-]?key|apikey|authorization|bearer|credential|cookie|session[_-]?(id|token)|private[_-]?key|client[_-]?secret|signing[_-]?secret|access[_-]?key|refresh[_-]?token|webhook[_-]?(url|secret))/i;
+  /(?:pass(?:word|phrase)?|secret|token|api[_-]?key|apikey|authorization|bearer|credential|cookie|session[_-]?(?:id|token)|private[_-]?key|client[_-]?secret|signing[_-]?secret|access[_-]?key|refresh[_-]?token|webhook[_-]?(?:url|secret))/i;
 
 const REDACTED = "[redacted]";
 const MAX_STRING = 2000;
@@ -20,6 +20,11 @@ const MAX_DEPTH = 6;
 const MAX_KEYS = 100;
 const MAX_ARRAY = 100;
 const MAX_JSON = 8000;
+/**
+ * Head room reserved for the `…(N more chars)` marker so a truncated summary
+ * still fits its caller's cap. Callers below this cannot carry a marker at all.
+ */
+const MARKER_SLACK = 32;
 
 /** Heuristic: does a bare string value look like a secret? */
 function looksSecret(value: string): boolean {
@@ -42,21 +47,32 @@ function looksSecret(value: string): boolean {
   return false;
 }
 
-function redactString(value: string): string {
+function redactString(value: string, maxString: number): string {
   if (looksSecret(value)) return REDACTED;
-  if (value.length > MAX_STRING) {
-    return `${value.slice(0, MAX_STRING)}…(${value.length - MAX_STRING} more chars)`;
+  if (value.length > maxString) {
+    return `${value.slice(0, maxString)}…(${value.length - maxString} more chars)`;
   }
   return value;
 }
 
-function redact(value: unknown, depth: number): unknown {
+function redactEmbeddedSecrets(value: string): string {
+  const bearer = value.replace(/\b(bearer\s+)([^\s"',}]+)/gi, `$1${REDACTED}`);
+  const credentialField = new RegExp(
+    `(["']?\\b${SENSITIVE_KEY.source}\\b["']?\\s*[:=]\\s*)(["']?)(?!bearer\\b)([^"'\\s,}]+)\\2`,
+    "gi",
+  );
+  return bearer.replace(credentialField, `$1$2${REDACTED}$2`);
+}
+
+function redact(value: unknown, depth: number, maxString: number): unknown {
   if (value == null) return value;
-  if (typeof value === "string") return redactString(value);
+  if (typeof value === "string") return redactString(value, maxString);
   if (typeof value === "number" || typeof value === "boolean") return value;
   if (depth >= MAX_DEPTH) return "[…]";
   if (Array.isArray(value)) {
-    const out = value.slice(0, MAX_ARRAY).map((v) => redact(v, depth + 1));
+    const out = value
+      .slice(0, MAX_ARRAY)
+      .map((v) => redact(v, depth + 1, maxString));
     if (value.length > MAX_ARRAY)
       out.push(`…(${value.length - MAX_ARRAY} more)`);
     return out;
@@ -70,7 +86,9 @@ function redact(value: unknown, depth: number): unknown {
         break;
       }
       n += 1;
-      out[k] = SENSITIVE_KEY.test(k) ? REDACTED : redact(v, depth + 1);
+      out[k] = SENSITIVE_KEY.test(k)
+        ? REDACTED
+        : redact(v, depth + 1, maxString);
     }
     return out;
   }
@@ -78,32 +96,100 @@ function redact(value: unknown, depth: number): unknown {
   return undefined;
 }
 
+export interface RedactLimits {
+  /**
+   * Hard cap on the serialized output, INCLUDING the truncation envelope.
+   * Surfaces with their own wire budget (the A2A activity snapshot) pass a
+   * tighter cap than the audit-log default.
+   */
+  maxJson?: number;
+  /** Cap on any single string value before it gets a truncation marker. */
+  maxString?: number;
+}
+
 /**
  * Redact and serialize call arguments to a capped JSON string, or `null` when
  * there is nothing to record. Never throws.
  */
-export function redactArgsToJson(args: unknown): string | null {
+export function redactArgsToJson(
+  args: unknown,
+  limits?: RedactLimits,
+): string | null {
+  const maxJson = Math.max(MARKER_SLACK * 4, limits?.maxJson ?? MAX_JSON);
+  const maxString = limits?.maxString ?? MAX_STRING;
   try {
     if (args == null) return null;
-    const redacted = redact(args, 0);
+    const redacted = redact(args, 0, maxString);
     if (redacted === undefined) return null;
     const json = JSON.stringify(redacted);
     if (json == null) return null;
-    if (json.length > MAX_JSON) {
-      // Slicing the serialized JSON would yield an unparseable string. Wrap a
-      // preview in a valid envelope so `get-audit-event` can always JSON.parse
-      // the stored `input`.
-      return JSON.stringify({
+    if (json.length <= maxJson) return json;
+    // Slicing the serialized JSON would yield an unparseable string. Wrap a
+    // preview in a valid envelope so `get-audit-event` can always JSON.parse
+    // the stored `input`. JSON escaping makes the envelope overhead
+    // content-dependent, so shrink the preview until the whole thing measures
+    // under the cap rather than guessing at the overhead.
+    const envelope = (preview: string) =>
+      JSON.stringify({
         _auditTruncated: true,
         originalBytes: json.length,
-        preview: json.slice(0, MAX_JSON),
+        preview,
       });
+    let take = maxJson;
+    let out = envelope(json.slice(0, take));
+    while (out.length > maxJson && take > 0) {
+      take = Math.max(0, take - Math.max(1, out.length - maxJson));
+      out = envelope(json.slice(0, take));
     }
-    return json;
+    return out;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Same bounds as `redactArgsToJson`, returned as a structural value for
+ * surfaces whose consumers expect an object (transcript `metadata.input`).
+ */
+export function redactArgsToValue(
+  args: unknown,
+  limits?: RedactLimits,
+): unknown {
+  const json = redactArgsToJson(args, limits);
+  if (json == null) return null;
+  try {
+    return JSON.parse(json);
   } catch {
     return null;
   }
 }
 
+/**
+ * Bounded, redacted plain-text summary of a tool result. Oversized text keeps
+ * its head and gains an explicit `…(N more chars)` marker, so a reader can
+ * always tell a short result from a clipped one.
+ */
+export function redactTextToSummary(
+  text: string,
+  maxChars = MAX_STRING,
+): string | null {
+  if (!text) return null;
+  // Only ever walk a bounded head: a multi-megabyte tool result must not be
+  // scanned in full just to produce a preview of it.
+  const head = text.slice(0, maxChars + MARKER_SLACK);
+  const redactedHead = redactEmbeddedSecrets(head);
+  if (looksSecret(redactedHead.trim())) return REDACTED;
+  if (text.length <= maxChars && redactedHead.length <= maxChars) {
+    return redactedHead;
+  }
+  const keep = Math.max(0, maxChars - MARKER_SLACK);
+  return `${redactedHead.slice(0, keep)}…(${text.length - keep} more chars)`;
+}
+
 /** Exposed for tests. */
-export const __test = { looksSecret, redact, SENSITIVE_KEY };
+export const __test = {
+  looksSecret,
+  redact,
+  redactEmbeddedSecrets,
+  SENSITIVE_KEY,
+};

package/src/client/AgentPanel.tsx

@@ -88,6 +88,7 @@ import {
 } from "./agent-sidebar-state.js";
 import { trackEvent } from "./analytics.js";
 import { agentNativePath, appPath } from "./api-path.js";
+import { readClientAppState } from "./application-state.js";
 import { assistantUiRecoverableRenderErrorKind } from "./assistant-ui-recovery.js";
 import type { AssistantChatProps } from "./AssistantChat.js";
 import { shouldParentFrameOwnAgentPanel } from "./builder-frame.js";
@@ -2356,13 +2357,7 @@ function URLSync({ browserTabId }: { browserTabId?: string }) {
     queryKey: setUrlQueryKey,
     queryFn: async () => {
       const read = async (key: string) => {
-        const res = await fetch(
-          agentNativePath(`/_agent-native/application-state/${key}`),
-        );
-        if (!res.ok || res.status === 204) return null;
-        const text = await res.text();
-        if (!text) return null;
-        const data = JSON.parse(text);
+        const data = await readClientAppState<Record<string, unknown>>(key);
         return data ? { key, command: data } : null;
       };
       try {

package/src/client/MultiTabAssistantChat.tsx

@@ -2610,6 +2610,9 @@ export function MultiTabAssistantChat({
                   hasInFlightWork={() =>
                     chatRefs.current.get(tabId)?.hasInFlightWork() ?? false
                   }
+                  isAwaitingResponse={() =>
+                    chatRefs.current.get(tabId)?.isRunning() ?? false
+                  }
                   onRetry={() => {
                     const handle = chatRefs.current.get(tabId);
                     handle?.sendRecoveryMessage(

package/src/client/RunStuckBanner.tsx

@@ -50,6 +50,16 @@ export interface RunStuckBannerProps {
    * render; omit to keep the unconditional Retry/Cancel behavior.
    */
   hasInFlightWork?: () => boolean;
+  /**
+   * Returns true when this chat is actually waiting on a reply - typically
+   * backed by `chatHandle.isRunning()`. "Stuck" is a claim about THIS client,
+   * but the run row is the server's; a turn that finished normally can leave a
+   * row in `running` (terminal marking is best-effort, and the stale-run reaper
+   * runs later). Without this gate an idle, completed chat shows the warning
+   * and auto-retry re-prompts a thread the user considers done. Checked fresh
+   * on every render; omit to keep the unconditional behavior.
+   */
+  isAwaitingResponse?: () => boolean;
   /**
    * Called whenever the stuck state transitions. Useful for surfacing
    * observability events (Sentry, PostHog) at the call site.
@@ -170,6 +180,7 @@ export function RunStuckBanner({
   autoRetry = false,
   autoRetryOwnerId,
   hasInFlightWork,
+  isAwaitingResponse,
   className,
 }: RunStuckBannerProps) {
   const state = useRunStuckDetection({
@@ -180,6 +191,11 @@ export function RunStuckBanner({
   });
   const abortRun = useAbortRun(apiUrl);
   const [busy, setBusy] = useState<BusyState>({ type: "none" });
+  // "An automatic attempt was made for this run" is a different fact from
+  // "the controls are locked while a request is in flight". Sharing one flag
+  // for both would force the buttons to stay disabled just to keep the
+  // message on screen.
+  const [autoRetriedRunId, setAutoRetriedRunId] = useState<string | null>(null);
   const autoRetriedRunIdsRef = useRef<Set<string>>(new Set());
   const generatedOwnerIdRef = useRef<string | null>(null);
   if (!generatedOwnerIdRef.current) {
@@ -204,6 +220,7 @@ export function RunStuckBanner({
   // either signal says so.
   const inFlightWork =
     state.hasInFlightWork === true || (hasInFlightWork?.() ?? false);
+  const awaitingResponse = isAwaitingResponse?.() ?? true;
   // Server-continued runs are recovered by the SERVER (chained continuation
   // chunks + lost-handoff sweep); an automatic client abort would kill a live
   // server-chained run. Auto-retry is therefore disabled unconditionally for
@@ -261,6 +278,9 @@ export function RunStuckBanner({
       // A live tool/A2A call in flight — never auto-abort real work (see
       // `inFlightWork` comment above).
       inFlightWork ||
+      // Nothing is waiting on this run here; re-prompting would restart a
+      // thread the user already considers finished.
+      !awaitingResponse ||
       !state.isStuck ||
       !state.runId ||
       busy.type !== "none" ||
@@ -274,21 +294,22 @@ export function RunStuckBanner({
       autoRetriedRunIdsRef.current.add(runId);
       if (!claimed) return;
       setBusy({ type: "retry", runId });
+      setAutoRetriedRunId(runId);
       trackEvent("agent_chat_stuck_auto_retry", {
         runId,
         threadId: threadId ?? null,
         stuckSinceMs: state.stuckSinceMs ?? null,
       });
       void abortRun(runId, "auto_stuck_retry").then((aborted) => {
-        if (aborted) {
-          onRetry?.(aborted);
-          return;
-        }
+        // Release the controls on both outcomes. If the abort does not move
+        // the row off `running`, polling may never observe a new run id. The
+        // automatic-attempt set still prevents re-entry.
         setBusy((current) =>
           current.type !== "none" && current.runId === runId
             ? { type: "none" }
             : current,
         );
+        if (aborted) onRetry?.(aborted);
       });
     });
   }, [
@@ -304,6 +325,7 @@ export function RunStuckBanner({
     state.runId,
     state.stuckSinceMs,
     threadId,
+    awaitingResponse,
   ]);
 
   // A stale progress timestamp is not actionable while the server is still
@@ -314,7 +336,8 @@ export function RunStuckBanner({
     !state.isStuck ||
     !state.runId ||
     backgroundWorkerStillAlive ||
-    inFlightWork
+    inFlightWork ||
+    !awaitingResponse
   ) {
     return null;
   }
@@ -380,7 +403,7 @@ export function RunStuckBanner({
             No progress
             {stuckSeconds != null ? ` for ${stuckSeconds}s` : ""}. The agent may
             have hit a server timeout or lost its connection.
-            {autoRetry && busyType === "retry"
+            {autoRetry && autoRetriedRunId === state.runId
               ? " Retrying automatically now."
               : ""}
           </span>

package/src/client/agent-chat.ts

@@ -9,6 +9,7 @@
 
 import type { ReasoningEffort } from "../shared/reasoning-effort.js";
 import { agentNativePath } from "./api-path.js";
+import { readClientAppState } from "./application-state.js";
 import {
   isInBuilderFrame,
   isTrustedBuilderMessage,
@@ -598,15 +599,9 @@ export async function refreshAgentChatContext(): Promise<AgentChatContextState>
     return agentChatContextState;
   }
   try {
-    const res = await fetch(
-      agentNativePath(
-        `/_agent-native/application-state/${AGENT_CHAT_CONTEXT_STATE_KEY}`,
-      ),
-    );
-    if (!res.ok || res.status === 204) return agentChatContextState;
-    const text = await res.text();
-    if (!text) return agentChatContextState;
-    const state = normalizeAgentChatContextState(JSON.parse(text));
+    const raw = await readClientAppState(AGENT_CHAT_CONTEXT_STATE_KEY);
+    if (raw === null) return agentChatContextState;
+    const state = normalizeAgentChatContextState(raw);
     if (!state) return agentChatContextState;
     return publishAgentChatContextItems(state.items, {
       persist: false,

package/src/client/application-state.ts

@@ -93,19 +93,117 @@ function jsonBody(value: unknown): string {
   return body;
 }
 
+/**
+ * Result of a batched read. `values` holds only the keys the server has a row
+ * for; every other requested key is in `missing`. A key stored with a `null`
+ * value lands in `values` with `null` and NOT in `missing` — that is how
+ * "never written" stays distinguishable from "written as null/empty".
+ */
+export interface ClientAppStateBatch {
+  values: Record<string, unknown>;
+  missing: string[];
+}
+
+/** Server caps a batch at 100 keys; stay under it when splitting. */
+const MAX_BATCH_KEYS = 100;
+
+export async function readClientAppStateMany(
+  keys: readonly string[],
+  options: ClientAppStateReadOptions = {},
+): Promise<ClientAppStateBatch> {
+  const unique = [...new Set(keys)];
+  for (const key of unique) appStateUrl(key); // validates the key shape
+  if (unique.length === 0) return { values: {}, missing: [] };
+
+  const merged: ClientAppStateBatch = { values: {}, missing: [] };
+  for (let i = 0; i < unique.length; i += MAX_BATCH_KEYS) {
+    const chunk = unique.slice(i, i + MAX_BATCH_KEYS);
+    const url = `${agentNativePath("/_agent-native/application-state")}?keys=${chunk
+      .map(encodeURIComponent)
+      .join(",")}`;
+    const response = await fetch(url, {
+      method: "GET",
+      cache: "no-store",
+      signal: options.signal,
+    });
+    const batch = await parseAppStateResponse<ClientAppStateBatch | null>(
+      response,
+      `Read application state [${chunk.join(", ")}]`,
+    );
+    if (!batch || typeof batch !== "object" || !batch.values) {
+      throw new Error(
+        `Read application state [${chunk.join(", ")}] returned an unexpected payload.`,
+      );
+    }
+    Object.assign(merged.values, batch.values);
+    merged.missing.push(...(batch.missing ?? []));
+  }
+  return merged;
+}
+
+// Reads issued in the same tick are coalesced into one batched request. Every
+// mounted composer, question card and suggestion hook reads its own key on
+// mount, which used to be one HTTP request (and one full identity resolution)
+// each — ~55 on an analytics dashboard load.
+let pendingBatch:
+  | { keys: Set<string>; promise: Promise<ClientAppStateBatch> }
+  | undefined;
+
+function scheduleBatchedRead(key: string): Promise<ClientAppStateBatch> {
+  if (pendingBatch) {
+    pendingBatch.keys.add(key);
+    return pendingBatch.promise;
+  }
+  const keys = new Set([key]);
+  const promise = new Promise<ClientAppStateBatch>((resolve, reject) => {
+    setTimeout(() => {
+      pendingBatch = undefined;
+      readClientAppStateMany([...keys]).then(resolve, reject);
+    }, 0);
+  });
+  pendingBatch = { keys, promise };
+  return promise;
+}
+
+function awaitWithAbort<T>(
+  promise: Promise<T>,
+  signal?: AbortSignal,
+): Promise<T> {
+  if (!signal) return promise;
+  const abortReason = () =>
+    signal.reason ?? new Error("The operation was aborted");
+  if (signal.aborted) return Promise.reject(abortReason());
+  return new Promise<T>((resolve, reject) => {
+    const onAbort = () => {
+      cleanup();
+      reject(abortReason());
+    };
+    const cleanup = () => signal.removeEventListener("abort", onAbort);
+    signal.addEventListener("abort", onAbort, { once: true });
+    promise.then(
+      (value) => {
+        cleanup();
+        if (signal.aborted) reject(abortReason());
+        else resolve(value);
+      },
+      (error) => {
+        cleanup();
+        reject(error);
+      },
+    );
+  });
+}
+
 export async function readClientAppState<T = unknown>(
   key: string,
   options: ClientAppStateReadOptions = {},
 ): Promise<T | null> {
-  const response = await fetch(appStateUrl(key), {
-    method: "GET",
-    cache: "no-store",
-    signal: options.signal,
-  });
-  return parseAppStateResponse<T | null>(
-    response,
-    `Read application state "${key}"`,
-  );
+  appStateUrl(key); // validates the key shape before it joins a batch
+  if (options.signal?.aborted) {
+    throw options.signal.reason ?? new Error("Aborted");
+  }
+  const batch = await awaitWithAbort(scheduleBatchedRead(key), options.signal);
+  return (batch.values[key] ?? null) as T | null;
 }
 
 export async function writeClientAppState<T = unknown>(
@@ -129,9 +227,14 @@ export async function deleteClientAppState(
 ): Promise<void> {
   const response = await fetch(appStateUrl(key), {
     method: "DELETE",
-    headers: options.requestSource
-      ? { "X-Request-Source": options.requestSource }
-      : undefined,
+    // DELETE carries no JSON body, so this custom header is the only
+    // same-origin marker the CSRF check can see from an embedded frame.
+    headers: {
+      "X-Agent-Native-CSRF": "1",
+      ...(options.requestSource
+        ? { "X-Request-Source": options.requestSource }
+        : {}),
+    },
     keepalive: options.keepalive,
     signal: options.signal,
   });

package/src/client/dynamic-suggestions.ts

@@ -1,6 +1,6 @@
 import { useEffect, useMemo, useState } from "react";
 
-import { agentNativePath } from "./api-path.js";
+import { readClientAppState } from "./application-state.js";
 import { useChangeVersions } from "./use-change-version.js";
 import type { ChatThreadScope } from "./use-chat-threads.js";
 
@@ -89,17 +89,9 @@ function appStateKeyForBrowserTab(key: string, browserTabId?: string): string {
 }
 
 async function readAppState(key: string): Promise<unknown> {
-  const res = await fetch(
-    agentNativePath(`/_agent-native/application-state/${key}`),
-  );
-  if (!res.ok || res.status === 204) return null;
-  const text = await res.text();
-  if (!text) return null;
-  try {
-    return JSON.parse(text);
-  } catch {
-    return null;
-  }
+  // Reads issued in the same tick coalesce into one batched request, so the
+  // four keys below cost one round trip rather than four.
+  return readClientAppState(key).catch(() => null);
 }
 
 async function readScopedAppState(

package/src/client/guided-questions.tsx

@@ -12,8 +12,11 @@ import {
 import { useCallback, useEffect, useMemo, useState } from "react";
 
 import { sendToAgentChat } from "./agent-chat.js";
-import { agentNativePath } from "./api-path.js";
-import { setClientAppState } from "./application-state.js";
+import {
+  deleteClientAppState,
+  readClientAppState,
+  setClientAppState,
+} from "./application-state.js";
 import { useChangeVersions } from "./use-change-version.js";
 import { cn } from "./utils.js";
 
@@ -998,10 +1001,6 @@ export function useGuidedQuestionFlow({
     () => normalizeBrowserTabId(browserTabId),
     [browserTabId],
   );
-  const endpointFor = useCallback(
-    (key: string) => agentNativePath(`/_agent-native/application-state/${key}`),
-    [],
-  );
   const scopedKey = normalizedBrowserTabId
     ? `${stateKey}:${normalizedBrowserTabId}`
     : stateKey;
@@ -1036,17 +1035,11 @@ export function useGuidedQuestionFlow({
     enabled,
     queryFn: async () => {
       const read = async (key: string) => {
-        const res = await fetch(endpointFor(key));
-        if (!res.ok) return null;
-        const text = await res.text();
-        if (!text) return null;
-        try {
-          const parsed = JSON.parse(text);
-          if (Array.isArray(parsed?.questions) && parsed.questions.length > 0) {
-            return parsed as GuidedQuestionPayload;
-          }
-        } catch {
-          return null;
+        const parsed = await readClientAppState<GuidedQuestionPayload>(
+          key,
+        ).catch(() => null);
+        if (Array.isArray(parsed?.questions) && parsed.questions.length > 0) {
+          return parsed;
         }
         return null;
       };
@@ -1086,16 +1079,12 @@ export function useGuidedQuestionFlow({
   const clear = useCallback(() => {
     setPayload(null);
     queryClient.setQueryData(resolvedQueryKey, null);
-    const del = (key: string) =>
-      fetch(endpointFor(key), {
-        method: "DELETE",
-        headers: { "X-Agent-Native-CSRF": "1" },
-      }).catch(() => {});
+    const del = (key: string) => deleteClientAppState(key).catch(() => {});
     // Clear whichever key actually held the payload (scoped or bare) so the
     // card doesn't reappear on the next poll.
     del(scopedKey);
     if (scopedKey !== stateKey) del(stateKey);
-  }, [endpointFor, queryClient, resolvedQueryKey, scopedKey, stateKey]);
+  }, [queryClient, resolvedQueryKey, scopedKey, stateKey]);
 
   const handleSubmit = useCallback(
     (answers: GuidedQuestionAnswers) => {