@agent-native/core 0.122.4 → 0.123.0

package/corpus/core/src/client/settings/SecretsSection.tsx

@@ -35,6 +35,7 @@ import {
   TooltipContent,
   TooltipTrigger,
 } from "../components/ui/tooltip.js";
+import { useT } from "../i18n.js";
 import { cn } from "../utils.js";
 
 const Button = React.forwardRef<
@@ -608,6 +609,7 @@ function AdHocKeysSection({
   onShowFormChange: (show: boolean) => void;
   showEmptyState: boolean;
 }) {
+  const t = useT();
   const [keys, setKeys] = useState<AdHocKey[]>([]);
   const [loading, setLoading] = useState(true);
   const [reloadToken, setReloadToken] = useState(0);
@@ -769,48 +771,51 @@ function AdHocKeysSection({
             className="w-full text-[11px]"
             placeholder="Description (optional)"
           />
-          <div className="flex items-center gap-2">
-            <Picker
-              mode="select"
-              options={[
-                { value: "user", label: "Personal" },
-                { value: "workspace", label: "Workspace" },
-              ]}
-              value={formScope}
-              onChange={(value) => {
-                if (value === "user" || value === "workspace") {
-                  setFormScope(value);
-                }
-              }}
-              aria-label="Scope"
-              className="w-auto text-[11px]"
-            />
-            <div className="ms-auto flex items-center gap-1.5">
-              <Button
-                type="button"
-                intent="neutral"
-                emphasis="outline"
-                onClick={resetForm}
-                className="rounded border border-border px-2 py-1 text-[10px] font-medium text-muted-foreground hover:text-foreground"
-              >
-                Cancel
-              </Button>
-              <Button
-                type="button"
-                intent="primary"
-                emphasis="solid"
-                onClick={handleAdd}
-                disabled={!formName.trim() || !formValue.trim() || formBusy}
-                className="inline-flex items-center gap-1 rounded px-2 py-1 text-[10px] font-medium disabled:opacity-40"
-                style={{ backgroundColor: "#00B5FF", color: "white" }}
-              >
-                {formBusy ? (
-                  <IconLoader2 size={10} className="animate-spin" />
-                ) : (
-                  "Save"
-                )}
-              </Button>
-            </div>
+          <Picker
+            mode="select"
+            options={[
+              { value: "user", label: t("secrets.scopePersonal") },
+              { value: "workspace", label: t("secrets.scopeWorkspace") },
+            ]}
+            value={formScope}
+            onChange={(value) => {
+              if (value === "user" || value === "workspace") {
+                setFormScope(value);
+              }
+            }}
+            aria-label={t("secrets.scopeLabel")}
+            description={t(
+              formScope === "user"
+                ? "secrets.scopePersonalDescription"
+                : "secrets.scopeWorkspaceDescription",
+            )}
+            className="text-[11px]"
+          />
+          <div className="flex items-center justify-end gap-1.5">
+            <Button
+              type="button"
+              intent="neutral"
+              emphasis="outline"
+              onClick={resetForm}
+              className="rounded border border-border px-2 py-1 text-[10px] font-medium text-muted-foreground hover:text-foreground"
+            >
+              Cancel
+            </Button>
+            <Button
+              type="button"
+              intent="primary"
+              emphasis="solid"
+              onClick={handleAdd}
+              disabled={!formName.trim() || !formValue.trim() || formBusy}
+              className="inline-flex items-center gap-1 rounded px-2 py-1 text-[10px] font-medium disabled:opacity-40"
+              style={{ backgroundColor: "#00B5FF", color: "white" }}
+            >
+              {formBusy ? (
+                <IconLoader2 size={10} className="animate-spin" />
+              ) : (
+                "Save"
+              )}
+            </Button>
           </div>
           {formError && <p className="text-[10px] text-red-500">{formError}</p>}
         </div>

package/corpus/core/src/client/settings/VoiceTranscriptionSection.tsx

@@ -19,7 +19,6 @@ import {
   IconExternalLink,
   IconLoader2,
   IconLockOpen,
-  IconMicrophone,
 } from "@tabler/icons-react";
 import React, { useCallback, useEffect, useState } from "react";
 
@@ -943,7 +942,3 @@ function SystemAudioStatus() {
     </div>
   );
 }
-
-export function VoiceTranscriptionIcon() {
-  return <IconMicrophone size={14} />;
-}

package/corpus/core/src/client/sse-event-processor.ts

@@ -167,12 +167,20 @@ export class AgentAutoContinueSignal extends Error {
   readonly maxIterations?: number;
   readonly activityTrail: AgentActivityTrailEntry[];
   readonly errorInfo?: AgentAutoContinueErrorInfo;
+  /**
+   * True when a CLIENT watchdog produced this signal rather than the server
+   * asking for a continuation. The two need opposite handling: a server
+   * `auto_continue` wants a fresh POST, a client watchdog only means "the
+   * browser stopped seeing bytes" and must reattach instead.
+   */
+  readonly clientWatchdog: boolean;
 
   constructor(options: {
     reason: AgentAutoContinueReason;
     maxIterations?: number;
     activityTrail?: AgentActivityTrailEntry[];
     errorInfo?: AgentAutoContinueErrorInfo;
+    clientWatchdog?: boolean;
   }) {
     super(`Agent run needs automatic continuation: ${options.reason}`);
     this.name = "AgentAutoContinueSignal";
@@ -180,11 +188,45 @@ export class AgentAutoContinueSignal extends Error {
     this.maxIterations = options.maxIterations;
     this.activityTrail = options.activityTrail ?? [];
     this.errorInfo = options.errorInfo;
+    this.clientWatchdog = options.clientWatchdog === true;
   }
 }
 
-export const SSE_NO_PROGRESS_TIMEOUT_MS = 75_000;
+/**
+ * Client no-progress window for foreground runs. MUST stay ABOVE the server's
+ * authoritative backstop (`RUN_NO_PROGRESS_HARD_TIMEOUT_MS`, 150s in
+ * agent/run-manager.ts) so the server's recovery ladder always gets first
+ * chance and the browser is never the primary stall detector. At the old 75s
+ * this fired below every server bound, so the whole server ladder was dead
+ * code and the median hosted foreground turn ended as a client-declared stall.
+ * Progress accounting here deliberately mirrors the server's
+ * `shouldBumpProgressForEvent` (keepalives and zero-byte prep activity do not
+ * count) so the two never disagree about what "progress" means.
+ */
+export const SSE_NO_PROGRESS_TIMEOUT_MS = 180_000;
 export const SSE_ACTION_PREPARATION_STALL_TIMEOUT_MS = 90_000;
+/**
+ * Window applied instead of the normal no-progress budget while a tool call or
+ * A2A delegation is open. The server deliberately suspends its own backstop for
+ * exactly this case — tool execution legitimately emits nothing for minutes —
+ * so without the mirror here the browser silently caps every long tool at the
+ * shorter window and kills a run the server believes is healthy.
+ */
+export const SSE_IN_FLIGHT_WORK_TIMEOUT_MS = 15 * 60_000;
+
+/**
+ * Open-work delta for one event: +1 when a tool call or A2A delegation starts,
+ * -1 when it settles. Mirrors the server's `in_flight_since` marker.
+ */
+export function sseInFlightWorkDelta(ev: SSEEvent): number {
+  if (ev.type === "tool_start") return 1;
+  if (ev.type === "tool_done") return -1;
+  if (ev.type === "agent_call") {
+    if (ev.status === "start") return 1;
+    if (ev.status === "done" || ev.status === "error") return -1;
+  }
+  return 0;
+}
 /**
  * Widened client watchdog windows for durable background runs. The SERVER is
  * the recovery brain for these runs: its run-manager no-progress backstop
@@ -608,7 +650,10 @@ async function readChunkWithProgressTimeout(
   }
   if (result === "timeout") {
     await reader.cancel("no_progress").catch(() => {});
-    throw new AgentAutoContinueSignal({ reason: "no_progress" });
+    throw new AgentAutoContinueSignal({
+      reason: "no_progress",
+      clientWatchdog: true,
+    });
   }
   return result;
 }
@@ -655,7 +700,15 @@ function isAutoRecoverableError(ev: SSEEvent, errMsg: string): boolean {
     // the recovery banner reads "stopped before finishing", but it must NOT
     // auto-continue: another POST would hit the same ~40s wall and churn. The
     // user retries deliberately (ideally as a single bulk action).
-    code === "run_budget_exhausted"
+    code === "run_budget_exhausted" ||
+    // `aborted_<reason>` is emitted by `terminalEventForAbortReason` for every
+    // abort that is neither a user stop nor a continuation boundary — a Slack
+    // cancel, a stuck-banner auto-retry, an operator kill. Whoever aborted the
+    // run owns the retry; auto-continuing here restarts work someone just
+    // stopped (and double-fires alongside the stuck banner's own retry). They
+    // stay `recoverable: true` so the banner still reads "stopped before
+    // finishing".
+    code.startsWith("aborted_")
   ) {
     return false;
   }
@@ -1771,6 +1824,11 @@ export async function* readSSEStream(
   };
   let renderUpdatesThisTurn = 0;
   let nextEventLoopTurn: Promise<void> | null = null;
+  let inFlightWork = 0;
+  const currentNoProgressTimeoutMs = () =>
+    inFlightWork > 0
+      ? Math.max(noProgressTimeoutMs, SSE_IN_FLIGHT_WORK_TIMEOUT_MS)
+      : noProgressTimeoutMs;
 
   const paceRenderUpdate = async (): Promise<void> => {
     renderUpdatesThisTurn += 1;
@@ -1825,7 +1883,7 @@ export async function* readSSEStream(
         readResult = await readChunkWithProgressTimeout(
           reader,
           lastMeaningfulEventAt,
-          noProgressTimeoutMs,
+          currentNoProgressTimeoutMs(),
         );
       } catch (err) {
         if (err instanceof AgentAutoContinueSignal) {
@@ -1834,6 +1892,7 @@ export async function* readSSEStream(
             maxIterations: err.maxIterations,
             activityTrail: [...activityTrail],
             errorInfo: err.errorInfo,
+            clientWatchdog: err.clientWatchdog,
           });
         }
         throw err;
@@ -1858,6 +1917,7 @@ export async function* readSSEStream(
           continue;
         }
         const now = Date.now();
+        inFlightWork = Math.max(0, inFlightWork + sseInFlightWorkDelta(ev));
         const actionPreparationProgress = updatePreparingActionState(
           preparingActionState,
           ev,
@@ -1918,6 +1978,7 @@ export async function* readSSEStream(
           throw new AgentAutoContinueSignal({
             reason: "no_progress",
             activityTrail: [...activityTrail],
+            clientWatchdog: true,
           });
         }
         if (action === "auto_continue") {
@@ -1938,11 +1999,12 @@ export async function* readSSEStream(
 
       if (
         !sawProgressEvent &&
-        Date.now() - lastMeaningfulEventAt >= noProgressTimeoutMs
+        Date.now() - lastMeaningfulEventAt >= currentNoProgressTimeoutMs()
       ) {
         throw new AgentAutoContinueSignal({
           reason: "no_progress",
           activityTrail: [...activityTrail],
+          clientWatchdog: true,
         });
       }
     }
@@ -1962,6 +2024,7 @@ export async function* readSSEStream(
   throw new AgentAutoContinueSignal({
     reason: "stream_ended",
     activityTrail: [...activityTrail],
+    clientWatchdog: true,
   });
 }
 
@@ -1998,6 +2061,11 @@ export async function readSSEStreamRaw(
   // identical content a second time when the stream closes without a terminal
   // event.
   let emittedLatestContent = false;
+  let inFlightWork = 0;
+  const currentNoProgressTimeoutMs = () =>
+    inFlightWork > 0
+      ? Math.max(noProgressTimeoutMs, SSE_IN_FLIGHT_WORK_TIMEOUT_MS)
+      : noProgressTimeoutMs;
 
   try {
     while (true) {
@@ -2006,7 +2074,7 @@ export async function readSSEStreamRaw(
         readResult = await readChunkWithProgressTimeout(
           reader,
           lastMeaningfulEventAt,
-          noProgressTimeoutMs,
+          currentNoProgressTimeoutMs(),
         );
       } catch (err) {
         if (err instanceof AgentAutoContinueSignal) {
@@ -2015,6 +2083,7 @@ export async function readSSEStreamRaw(
             maxIterations: err.maxIterations,
             activityTrail: [...activityTrail],
             errorInfo: err.errorInfo,
+            clientWatchdog: err.clientWatchdog,
           });
         }
         throw err;
@@ -2039,6 +2108,7 @@ export async function readSSEStreamRaw(
           continue;
         }
         const now = Date.now();
+        inFlightWork = Math.max(0, inFlightWork + sseInFlightWorkDelta(ev));
         const actionPreparationProgress = updatePreparingActionState(
           preparingActionState,
           ev,
@@ -2113,6 +2183,7 @@ export async function readSSEStreamRaw(
           throw new AgentAutoContinueSignal({
             reason: "no_progress",
             activityTrail: [...activityTrail],
+            clientWatchdog: true,
           });
         }
         if (
@@ -2126,11 +2197,12 @@ export async function readSSEStreamRaw(
 
       if (
         !sawProgressEvent &&
-        Date.now() - lastMeaningfulEventAt >= noProgressTimeoutMs
+        Date.now() - lastMeaningfulEventAt >= currentNoProgressTimeoutMs()
       ) {
         throw new AgentAutoContinueSignal({
           reason: "no_progress",
           activityTrail: [...activityTrail],
+          clientWatchdog: true,
         });
       }
     }
@@ -2144,5 +2216,8 @@ export async function readSSEStreamRaw(
   if (content.length > 0 && !emittedLatestContent) {
     onUpdate(contentSnapshot(content));
   }
-  throw new AgentAutoContinueSignal({ reason: "stream_ended" });
+  throw new AgentAutoContinueSignal({
+    reason: "stream_ended",
+    clientWatchdog: true,
+  });
 }

package/corpus/core/src/client/use-action.ts

@@ -324,22 +324,31 @@ async function performActionFetch<T>(
     else outerSignal.addEventListener("abort", onOuterAbort, { once: true });
   }
   let timedOut = false;
-  const timer = controller
-    ? setTimeout(() => {
-        timedOut = true;
-        controller.abort();
-      }, timeoutMs)
-    : null;
-  if (controller) init.signal = controller.signal;
-
-  const throwTimeout = (): never => {
+  const timeoutError = (): Error => {
     const error = new Error(
       `Action ${name} timed out after ${Math.round(timeoutMs / 1000)}s`,
     );
     (error as any).timedOut = true;
     (error as any).status = 408;
-    throw error;
+    return error;
   };
+  const throwTimeout = (): never => {
+    throw timeoutError();
+  };
+  // The timeout rejects the caller directly, not just via `controller.abort()`.
+  // Aborting only works if the transport honors the signal; a patched fetch, a
+  // wedged service worker, or a stalled body stream that never settles would
+  // otherwise leave the request — and the UI's loading state — pending forever.
+  let rejectTimedOut: (error: unknown) => void = () => {};
+  const timedOutSignal = new Promise<never>((_resolve, reject) => {
+    rejectTimedOut = reject;
+  });
+  const timer = setTimeout(() => {
+    timedOut = true;
+    controller?.abort();
+    rejectTimedOut(timeoutError());
+  }, timeoutMs);
+  if (controller) init.signal = controller.signal;
 
   let res: Response;
   let raw = "";
@@ -347,7 +356,7 @@ async function performActionFetch<T>(
   let readError: unknown;
   try {
     try {
-      res = await fetch(url, init);
+      res = await Promise.race([fetch(url, init), timedOutSignal]);
       options?.onResponse?.(res);
     } catch (err) {
       if (timedOut) throwTimeout();
@@ -391,7 +400,7 @@ async function performActionFetch<T>(
     // decode failure on a 2xx response should error rather than silently
     // succeed with `null`.
     try {
-      raw = await res.text();
+      raw = await Promise.race([res.text(), timedOutSignal]);
     } catch (err) {
       if (timedOut) throwTimeout();
       if (outerSignal?.aborted) throw err;
@@ -399,7 +408,7 @@ async function performActionFetch<T>(
       readError = err;
     }
   } finally {
-    if (timer) clearTimeout(timer);
+    clearTimeout(timer);
     if (outerSignal) outerSignal.removeEventListener("abort", onOuterAbort);
   }
 

package/corpus/core/src/client/use-agent-engine-configured.ts

@@ -5,7 +5,13 @@ import { agentNativePath } from "./api-path.js";
 
 const PROVIDER_ENV_VAR_SET = new Set(PROVIDER_ENV_VARS);
 
-/** `unknown` until the first check resolves, so callers don't flash the gate. */
+/**
+ * Three distinct situations, never collapsed:
+ * - `configured` / `missing` are authoritative answers from the status routes.
+ * - `unknown` (first check in flight) and `unavailable` (the check failed, a
+ *   retry is scheduled) both mean *we do not know*. Neither is evidence that
+ *   no provider is configured, so neither may gate the composer.
+ */
 export type AgentEngineConfiguredState =
   | "unknown"
   | "configured"
@@ -33,7 +39,14 @@ export interface UseAgentEngineConfiguredOptions {
   threadId?: string | null;
 }
 
-const DEFAULT_STATUS_CHECK_TIMEOUT_MS = 2500;
+// Abort ceiling for a hung request, NOT a deadline the probes race against.
+// `/agent-engine/status` resolves session, org context, a scoped secret and a
+// settings row — several DB round-trips that measured ~4.7s on a warm local
+// dev server, so any budget short enough to "feel fast" just manufactures a
+// fake answer. Losing this ceiling is treated as "don't know", never "missing".
+const DEFAULT_STATUS_CHECK_TIMEOUT_MS = 15000;
+const RETRY_BASE_MS = 2000;
+const RETRY_MAX_MS = 30000;
 
 async function fetchStatusJson(
   path: string,
@@ -148,8 +161,8 @@ export async function fetchAgentEngineConfiguredState(
  * composer and app prompt boxes. Checks the env-key / Builder / BYOK status
  * endpoints on mount, re-checks on `agent-engine:configured-changed`, and folds
  * in the adapter's `agent-chat:missing-api-key` signal. Pass `enabled = false`
- * to short-circuit to configured; unavailable checks can be retried by firing
- * `agent-engine:configured-changed`.
+ * to short-circuit to configured. A check that cannot reach an authoritative
+ * answer retries on a backoff until it does, so the gate can never latch.
  */
 export function useAgentEngineConfigured(
   enabled = true,
@@ -164,11 +177,29 @@ export function useAgentEngineConfigured(
     // resolve out of order; only the latest call may write state, or a slow
     // stale "missing" response would overwrite the fresh "configured" one.
     let requestSeq = 0;
+    let retryTimer: ReturnType<typeof setTimeout> | undefined;
+    let retryAttempt = 0;
     const check = async (options?: { missingFallback?: boolean }) => {
       const seq = ++requestSeq;
+      if (retryTimer !== undefined) {
+        clearTimeout(retryTimer);
+        retryTimer = undefined;
+      }
       const nextState = await fetchAgentEngineConfiguredState(enabled, options);
       if (cancelled || seq !== requestSeq) return;
       setState(nextState === "unknown" ? "unavailable" : nextState);
+      if (nextState === "configured" || nextState === "missing") {
+        retryAttempt = 0;
+        return;
+      }
+      // No authoritative answer yet. Keep asking: a failed probe that latched
+      // permanently is what left users staring at a dead composer with no way
+      // back short of a reload.
+      const delay = Math.min(RETRY_BASE_MS * 2 ** retryAttempt, RETRY_MAX_MS);
+      retryAttempt += 1;
+      retryTimer = setTimeout(() => {
+        void check();
+      }, delay);
     };
     const onConfiguredChanged = () => {
       void check();
@@ -192,6 +223,7 @@ export function useAgentEngineConfigured(
     window.addEventListener("agent-chat:missing-api-key", onMissing);
     return () => {
       cancelled = true;
+      if (retryTimer !== undefined) clearTimeout(retryTimer);
       window.removeEventListener(
         "agent-engine:configured-changed",
         onConfiguredChanged,

package/corpus/core/src/client/use-db-sync.ts

@@ -18,6 +18,7 @@ import { bumpChangeVersion } from "./use-change-version.js";
 
 interface Query {
   queryKey: readonly unknown[];
+  state?: { error?: unknown };
 }
 
 interface QueryClient {
@@ -179,6 +180,18 @@ function isAuthFailure(error: unknown): boolean {
   );
 }
 
+/**
+ * True for a query whose last fetch failed authorization. Such a query needs a
+ * new session, not another request: every background invalidation reissues the
+ * identical 401. One expired session used to turn the sync loop into a poll
+ * storm (135k 401s over 20h across a handful of action queries), so sync-driven
+ * invalidation skips these. A remount, a mutation, or an explicit refetch still
+ * retries them.
+ */
+function hasTerminalAuthFailure(query: Query): boolean {
+  return isAuthFailure(query.state?.error);
+}
+
 /**
  * App-state keys that drive immediate UI navigation/interaction and must
  * never sit behind the invalidation coalesce window (see
@@ -1190,10 +1203,17 @@ export function useDbSync(
         // in flight, let it finish instead of aborting and immediately
         // launching the same request again. Repeated action events otherwise
         // turn a slow endpoint into a cancel/restart loop that never settles.
-        const invalidateWithoutCancel = (filters?: {
+        const invalidateWithoutCancel = (requested?: {
           queryKey?: string[];
           predicate?: (query: Query) => boolean;
         }) => {
+          const callerPredicate = requested?.predicate;
+          const filters = {
+            ...requested,
+            predicate: (query: Query) =>
+              !hasTerminalAuthFailure(query) &&
+              (callerPredicate?.(query) ?? true),
+          };
           const needsTrailingRefresh =
             (queryClient.isFetching?.(filters) ?? 0) > 0;
           const completion = queryClient.invalidateQueries(filters, {