@agent-native/core 0.85.7 → 0.86.1

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

@@ -714,6 +714,90 @@ function completedToolRepeatSignature(
   ].join("\u0000");
 }
 
+/**
+ * Result prefixes the server emits when a tool_start/tool_done pair is a
+ * REPLAY of a call that already executed in an earlier interrupted chunk of
+ * this turn (tool-call journal hard-block and zombie-ledger recovery in
+ * production-agent.ts). These are not new calls — rendering them as separate
+ * cards produces the "same tool twice, one spinning / one done" duplicate.
+ */
+const JOURNAL_RECOVERY_RESULT_PREFIXES = [
+  "(Already completed in an earlier interrupted attempt",
+  "(Recovered from prior interrupted chunk",
+] as const;
+
+function isJournalRecoveryResult(result: unknown): boolean {
+  return (
+    typeof result === "string" &&
+    JOURNAL_RECOVERY_RESULT_PREFIXES.some((prefix) => result.startsWith(prefix))
+  );
+}
+
+/**
+ * Merge a journal/ledger-recovered tool_done into the earlier card for the
+ * same logical call instead of leaving a duplicate pair. Two shapes occur:
+ *
+ * 1. The original card already completed (reconnect/continuation replay): the
+ *    recovery card at `completedIndex` is redundant — drop it, keeping the
+ *    original result.
+ * 2. The recovery result attached to the ORIGINAL still-pending card (the
+ *    id-less replay tool_done name-matches the earliest pending card): the
+ *    replay's own tool_start pushed a second pending card AFTER it that no
+ *    tool_done will ever resolve — remove that stuck-spinner artifact.
+ *
+ * Gated strictly on the recovery result markers so genuinely repeated
+ * identical calls are never collapsed. Returns true when it spliced the card
+ * at `completedIndex` (callers must not reuse the index afterwards).
+ */
+function coalesceJournalRecoveredTool(
+  content: ContentPart[],
+  completedIndex: number,
+): boolean {
+  const current = content[completedIndex];
+  if (!current || current.type !== "tool-call") return false;
+  if (!isJournalRecoveryResult(current.result)) return false;
+  const matchesCurrentCall = (
+    part: ContentPart,
+  ): part is Extract<ContentPart, { type: "tool-call" }> =>
+    part.type === "tool-call" &&
+    part.activity !== true &&
+    part.toolName === current.toolName &&
+    part.argsText === current.argsText;
+
+  for (let i = completedIndex - 1; i >= 0; i--) {
+    const prior = content[i];
+    if (!matchesCurrentCall(prior)) continue;
+    if (prior.result === undefined) {
+      // The original was interrupted mid-flight (spinner) — resolve it with
+      // the recovered result instead of showing a second card.
+      prior.result = current.result;
+      if (current.isError !== undefined) prior.isError = current.isError;
+      if (current.completedSideEffect !== undefined) {
+        prior.completedSideEffect = current.completedSideEffect;
+      }
+      if (current.mcpApp) prior.mcpApp = current.mcpApp;
+      if (current.chatUI) prior.chatUI = current.chatUI;
+    }
+    content.splice(completedIndex, 1);
+    return true;
+  }
+
+  // No earlier card — the recovery result landed on the original pending card
+  // itself. Remove any later still-pending replay-start artifact for the same
+  // call so it doesn't spin forever.
+  for (let i = content.length - 1; i > completedIndex; i--) {
+    const later = content[i];
+    if (
+      later.type === "tool-call" &&
+      matchesCurrentCall(later) &&
+      later.result === undefined
+    ) {
+      content.splice(i, 1);
+    }
+  }
+  return false;
+}
+
 function coalesceCompletedToolRepeat(
   content: ContentPart[],
   completedIndex: number,
@@ -1022,7 +1106,12 @@ export function processEvent(
         if (part.activity !== true && part.isError !== true) {
           markCompletedToolAfterAssistantText(state, part.toolName);
         }
-        coalesceCompletedToolRepeat(content, doneIdx);
+        // Journal/ledger replay merge first (may splice the card at doneIdx —
+        // when it does, the adjacent-repeat coalesce below must not run on the
+        // stale index).
+        if (!coalesceJournalRecoveredTool(content, doneIdx)) {
+          coalesceCompletedToolRepeat(content, doneIdx);
+        }
       }
     }
     return {

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

@@ -32,6 +32,15 @@ import { ensureEmbedAuthFetchInterceptor } from "./embed-auth.js";
 
 const ACTION_PREFIX = agentNativePath("/_agent-native/actions");
 
+/**
+ * Upper bound on how long a single action fetch may stay in flight (headers
+ * AND body). Converts a hung server/proxy/connection into a visible, typed
+ * failure instead of a UI that spins forever. Generous on purpose: it sits
+ * above every server-side budget (serverless function limits, hosted run
+ * wall-clock), so it only fires when something is genuinely stuck.
+ */
+const DEFAULT_ACTION_TIMEOUT_MS = 60_000;
+
 function isAuthFailure(error: unknown): boolean {
   return (
     !!error &&
@@ -42,14 +51,37 @@ function isAuthFailure(error: unknown): boolean {
   );
 }
 
-function defaultActionQueryRetry(
+function isActionTimeout(error: unknown): boolean {
+  return (
+    !!error &&
+    typeof error === "object" &&
+    (error as { timedOut?: unknown }).timedOut === true
+  );
+}
+
+/** @internal exported for tests */
+export function defaultActionQueryRetry(
   failureCount: number,
   error: unknown,
 ): boolean {
   if (isAuthFailure(error)) return false;
+  // A timeout already made the user wait the full timeout window once;
+  // silently retrying would multiply that wait. Surface it instead.
+  if (isActionTimeout(error)) return false;
   return failureCount < 3;
 }
 
+/**
+ * Default retry backoff for action queries. React Query's stock retryDelay
+ * (1s → 2s → 4s) makes a failing query sit on a spinner for ~7s before the
+ * error surfaces; interactive data fetches want failures visible fast.
+ *
+ * @internal exported for tests
+ */
+export function defaultActionQueryRetryDelay(failureCount: number): number {
+  return Math.min(500 * 2 ** failureCount, 2_000);
+}
+
 // ---------------------------------------------------------------------------
 // Action type registry — augmented by generated code
 // ---------------------------------------------------------------------------
@@ -89,6 +121,10 @@ export type ClientActionMethod = "GET" | "POST" | "PUT" | "DELETE";
 
 export interface ClientActionCallOptions {
   method?: ClientActionMethod;
+  /** Abort signal for the underlying fetch. */
+  signal?: AbortSignal;
+  /** Override the default 60s fetch timeout for long-running actions. */
+  timeoutMs?: number;
 }
 
 // ---------------------------------------------------------------------------
@@ -135,10 +171,22 @@ function appendActionQueryParam(
   qs.append(key, String(value));
 }
 
+export interface ActionFetchOptions {
+  /**
+   * Abort signal from the caller (React Query passes one per queryFn
+   * invocation so superseded requests — key change, unmount, refetch — cancel
+   * the underlying network request instead of hogging a connection slot).
+   */
+  signal?: AbortSignal;
+  /** Per-call override for the fetch timeout. */
+  timeoutMs?: number;
+}
+
 async function actionFetch<T>(
   name: string,
   method: string,
   params?: Record<string, any>,
+  options?: ActionFetchOptions,
 ): Promise<T> {
   ensureEmbedAuthFetchInterceptor();
   let url = `${ACTION_PREFIX}/${name}`;
@@ -168,34 +216,76 @@ async function actionFetch<T>(
     init.body = JSON.stringify(params);
   }
 
-  let res: Response;
-  try {
-    res = await fetch(url, init);
-  } catch (err) {
-    // Network failures, CORS, server unreachable, etc. — give the caller a
-    // useful message instead of the opaque "Failed to fetch".
-    const cause = err instanceof Error ? err.message : String(err);
-    throw new Error(`Action ${name} failed: ${cause}`);
+  // One controller drives both cancellation sources: the caller's signal
+  // (superseded query, unmount) and the timeout. The timer stays armed until
+  // the BODY is fully read — headers arriving quickly while the body stalls
+  // is exactly the hang this bounds.
+  const outerSignal = options?.signal;
+  const timeoutMs = options?.timeoutMs ?? DEFAULT_ACTION_TIMEOUT_MS;
+  const controller =
+    typeof AbortController === "undefined" ? null : new AbortController();
+  const onOuterAbort = () => controller?.abort();
+  if (outerSignal && controller) {
+    if (outerSignal.aborted) controller.abort();
+    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 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;
+  };
 
-  // 204 No Content — nothing to parse.
-  if (res.status === 204) return null as T;
-
-  // Read the body as text first so we can:
-  //   - tolerate empty bodies (avoids "Unexpected end of JSON input")
-  //   - surface non-JSON error responses (HTML 401/404 pages, plain text, etc.)
-  //   - preserve the original HTTP status in the thrown error
-  // Track read failures separately from "no body" — a stream interruption /
-  // decode failure on a 2xx response should error rather than silently
-  // succeed with `null`.
+  let res: Response;
   let raw = "";
   let readFailed = false;
   let readError: unknown;
   try {
-    raw = await res.text();
-  } catch (err) {
-    readFailed = true;
-    readError = err;
+    try {
+      res = await fetch(url, init);
+    } catch (err) {
+      if (timedOut) throwTimeout();
+      // Caller-initiated cancellation — rethrow untouched so React Query
+      // recognizes it as a cancellation rather than a query failure.
+      if (outerSignal?.aborted) throw err;
+      // Network failures, CORS, server unreachable, etc. — give the caller a
+      // useful message instead of the opaque "Failed to fetch".
+      const cause = err instanceof Error ? err.message : String(err);
+      throw new Error(`Action ${name} failed: ${cause}`);
+    }
+
+    // 204 No Content — nothing to parse.
+    if (res.status === 204) return null as T;
+
+    // Read the body as text first so we can:
+    //   - tolerate empty bodies (avoids "Unexpected end of JSON input")
+    //   - surface non-JSON error responses (HTML 401/404 pages, plain text, etc.)
+    //   - preserve the original HTTP status in the thrown error
+    // Track read failures separately from "no body" — a stream interruption /
+    // decode failure on a 2xx response should error rather than silently
+    // succeed with `null`.
+    try {
+      raw = await res.text();
+    } catch (err) {
+      if (timedOut) throwTimeout();
+      if (outerSignal?.aborted) throw err;
+      readFailed = true;
+      readError = err;
+    }
+  } finally {
+    if (timer) clearTimeout(timer);
+    if (outerSignal) outerSignal.removeEventListener("abort", onOuterAbort);
   }
 
   let data: any = undefined;
@@ -266,7 +356,10 @@ export function callAction<
   options: ClientActionCallOptions = {},
 ): Promise<TResult extends undefined ? ActionResult<TName> : TResult> {
   type R = TResult extends undefined ? ActionResult<TName> : TResult;
-  return actionFetch<R>(actionName, options.method ?? "POST", params);
+  return actionFetch<R>(actionName, options.method ?? "POST", params, {
+    signal: options.signal,
+    timeoutMs: options.timeoutMs,
+  });
 }
 
 // ---------------------------------------------------------------------------
@@ -301,8 +394,13 @@ export function useActionQuery<
   type R = TResult extends undefined ? ActionResult<TName> : TResult;
   return useQuery<R>({
     queryKey: ["action", actionName, params],
-    queryFn: () => actionFetch<R>(actionName, "GET", params),
+    // Thread React Query's per-fetch AbortSignal into the network request so
+    // superseded fetches (key change, unmount, rapid refetch) actually cancel
+    // instead of holding a per-origin connection slot until they finish.
+    queryFn: ({ signal }) =>
+      actionFetch<R>(actionName, "GET", params, { signal }),
     retry: defaultActionQueryRetry,
+    retryDelay: defaultActionQueryRetryDelay,
     ...options,
   });
 }

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

@@ -149,9 +149,15 @@ export function useAgentEngineConfigured(
 
   useEffect(() => {
     let cancelled = false;
+    // Monotonic call counter: overlapping checks (mount + a
+    // `agent-engine:configured-changed` fired right after a key is saved) can
+    // 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;
     const check = async (options?: { missingFallback?: boolean }) => {
+      const seq = ++requestSeq;
       const nextState = await fetchAgentEngineConfiguredState(enabled, options);
-      if (cancelled) return;
+      if (cancelled || seq !== requestSeq) return;
       if (nextState === "unknown") {
         return;
       }

package/corpus/core/src/client/use-chat-threads.ts

@@ -677,19 +677,30 @@ export function useChatThreads(
   const detachThread = useCallback(
     async (threadId: string): Promise<void> => {
       try {
-        await fetch(`${apiUrl}/threads/${encodeURIComponent(threadId)}`, {
-          method: "PUT",
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify({ scope: null }),
-        });
+        const res = await fetch(
+          `${apiUrl}/threads/${encodeURIComponent(threadId)}`,
+          {
+            method: "PUT",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ scope: null }),
+          },
+        );
+        if (!res.ok) {
+          // Server rejected the detach (403/404/500) — resync from the
+          // server instead of applying a scope change that didn't happen.
+          await fetchThreads();
+          return;
+        }
         setThreads((prev) =>
           prev.map((t) => (t.id === threadId ? { ...t, scope: null } : t)),
         );
         optimisticThreadScopesRef.current.set(threadId, null);
         emitThreadsUpdated();
-      } catch {}
+      } catch {
+        await fetchThreads().catch(() => {});
+      }
     },
-    [apiUrl],
+    [apiUrl, fetchThreads],
   );
 
   const pinThread = useCallback(

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

@@ -32,7 +32,7 @@ class HttpStatusError extends Error {
   }
 }
 
-type SyncEvent = {
+export type SyncEvent = {
   version?: number;
   source?: string;
   type?: string;
@@ -147,6 +147,13 @@ interface TransportSubscription {
   interval: number;
   /** Requested fallback interval while SSE is connected. */
   fallbackInterval: number;
+  /**
+   * Optional: notified when the shared SSE connection opens or closes (also
+   * fired once with the current state when the subscriber joins). Lets
+   * subscribers with their own fallback loops (e.g. the collab doc poll)
+   * relax their cadence while the push path is healthy.
+   */
+  onSseStateChange?: (connected: boolean) => void;
 }
 
 class SyncTransport {
@@ -158,6 +165,7 @@ class SyncTransport {
   private eventSource: EventSource | null = null;
   private sseConnected = false;
   private authFailureUntil = 0;
+  private consecutiveFailures = 0;
 
   constructor(
     private readonly pollUrl: string,
@@ -175,6 +183,7 @@ class SyncTransport {
       this.stopped = false;
       this.start();
     }
+    sub.onSseStateChange?.(this.sseConnected);
   }
 
   remove(id: symbol): void {
@@ -226,6 +235,14 @@ class SyncTransport {
     }
   }
 
+  private setSseConnected(connected: boolean): void {
+    if (this.sseConnected === connected) return;
+    this.sseConnected = connected;
+    for (const sub of this.subscribers.values()) {
+      sub.onSseStateChange?.(connected);
+    }
+  }
+
   // -------------------------------------------------------------------------
   // SSE + poll loop (mirrors the original per-hook logic exactly)
   // -------------------------------------------------------------------------
@@ -246,15 +263,21 @@ class SyncTransport {
       }, authDelay);
       return;
     }
-    this.timer = setTimeout(
-      () => {
-        this.timer = null;
-        void this.poll();
-      },
-      this.sseConnected
-        ? this.effectiveFallbackInterval
-        : this.effectiveInterval,
-    );
+    const base = this.sseConnected
+      ? this.effectiveFallbackInterval
+      : this.effectiveInterval;
+    // Exponential backoff while polls keep failing (500s during a deploy,
+    // DNS blips, a struggling DB). Auth failures have their own cooldown
+    // above; this covers everything else so a down server isn't hammered at
+    // full cadence. Resets on the first successful poll.
+    const delay =
+      this.consecutiveFailures > 0
+        ? Math.min(base * 2 ** Math.min(this.consecutiveFailures, 5), 30_000)
+        : base;
+    this.timer = setTimeout(() => {
+      this.timer = null;
+      void this.poll();
+    }, delay);
   }
 
   private reschedule(): void {
@@ -271,7 +294,7 @@ class SyncTransport {
     if (!this.eventSource) return;
     this.eventSource.close();
     this.eventSource = null;
-    this.sseConnected = false;
+    this.setSseConnected(false);
   }
 
   private connectEvents(): void {
@@ -288,11 +311,11 @@ class SyncTransport {
     const source = new EventSource(this.sseUrl);
     this.eventSource = source;
     source.onopen = () => {
-      this.sseConnected = true;
+      this.setSseConnected(true);
       this.schedulePoll();
     };
     source.onerror = () => {
-      this.sseConnected = false;
+      this.setSseConnected(false);
       // When the browser gives up permanently (HTTP error → readyState
       // CLOSED), it won't auto-reconnect. Drop the ref so a later
       // connectEvents() (on focus/visibility) can establish a fresh stream;
@@ -342,16 +365,18 @@ class SyncTransport {
         this.effectiveInterval,
       );
       if (this.stopped) return;
+      this.consecutiveFailures = 0;
       const events = data.events ?? [];
       this.applyVersion(events, data.version);
       this.fan(events, data.version);
     } catch (err) {
       if (this.stopped) return;
+      this.consecutiveFailures++;
       if (isAuthFailure(err)) {
         this.authFailureUntil = Date.now() + POLL_AUTH_FAILURE_COOLDOWN_MS;
         this.closeEvents();
       }
-      // Network error — will retry on next interval.
+      // Network error — retried on the next (backed-off) interval.
     } finally {
       this.inFlight = false;
       this.schedulePoll();
@@ -456,6 +481,56 @@ export function _resetSyncTransportRegistryForTests(): void {
   transportRegistry.clear();
 }
 
+export interface SubscribeSyncEventsOptions {
+  /** Receives every batch of change events (SSE push or poll). */
+  onEvents: (events: SyncEvent[], version: number | undefined) => void;
+  /** Notified when the shared SSE connection opens/closes (and once on join). */
+  onSseStateChange?: (connected: boolean) => void;
+  pollUrl?: string;
+  sseUrl?: string | false;
+  pauseWhenHidden?: boolean;
+  /**
+   * Poll cadence this subscriber requests from the SHARED poll loop. The
+   * transport uses the minimum across subscribers, so the defaults here are
+   * deliberately high: subscribing must not speed up the shared poll —
+   * useDbSync (mounted by every template root) already sets the pace.
+   */
+  interval?: number;
+  fallbackInterval?: number;
+}
+
+/**
+ * Subscribe to the shared SSE + poll transport without the React Query
+ * invalidation behavior of `useDbSync`. Use this instead of opening another
+ * `EventSource` to `/_agent-native/events` — a browser tab should hold ONE
+ * SSE connection no matter how many features listen to it (extra streams eat
+ * the per-origin connection budget and starve data fetches, especially on
+ * HTTP/1.1 dev servers).
+ *
+ * Returns an unsubscribe function. Safe to call only in browser contexts.
+ */
+export function subscribeSyncEvents(
+  options: SubscribeSyncEventsOptions,
+): () => void {
+  const pollUrl = agentNativePath(options.pollUrl ?? "/_agent-native/poll");
+  const sseUrl = resolveSseUrl(options.sseUrl);
+  const transport = getOrCreateTransport(pollUrl, sseUrl);
+  const id = Symbol("subscribeSyncEvents");
+  transport.add(id, {
+    onEvents: options.onEvents,
+    onSseStateChange: options.onSseStateChange,
+    pauseWhenHidden: options.pauseWhenHidden ?? true,
+    interval: options.interval ?? 60_000,
+    fallbackInterval: options.fallbackInterval ?? 60_000,
+  });
+  return () => {
+    transport.remove(id);
+    if (!transport["subscribers"].size) {
+      releaseTransport(pollUrl, sseUrl);
+    }
+  };
+}
+
 /**
  * Hook that listens to /_agent-native/events for DB change events and
  * invalidates react-query caches when changes are detected. Falls back to
@@ -557,8 +632,18 @@ export function useDbSync(
         if (src && ver > 0) bumpChangeVersion(src, ver);
       }
 
-      if (relevant.length > 0 && queryClient) {
-        const hasActionEvent = relevant.some((evt) => evt.source === "action");
+      // Awareness (cursor/presence) events never change action/extension/
+      // app-state query results, but they arrive on every peer keystroke and
+      // carry no version (so the freshness filter always passes them). Keep
+      // them out of the invalidate block or an idle collaborative doc turns
+      // every peer's cursor move into a framework-wide refetch storm; they
+      // still reach onEvent below for callers that render presence.
+      const invalidating = relevant.filter((e) => e.source !== "awareness");
+
+      if (invalidating.length > 0 && queryClient) {
+        const hasActionEvent = invalidating.some(
+          (evt) => evt.source === "action",
+        );
         if (hasActionEvent) {
           // Custom apps frequently start with raw `useQuery` calls before
           // graduating to `useActionQuery` or source-versioned query keys.
@@ -585,13 +670,13 @@ export function useDbSync(
         queryClient.invalidateQueries({ queryKey: ["tool"] });
         queryClient.invalidateQueries({ queryKey: ["tools"] });
         queryClient.invalidateQueries({ queryKey: ["app-state"] });
-        if (hasAppStateEvent(relevant, "navigate")) {
+        if (hasAppStateEvent(invalidating, "navigate")) {
           queryClient.invalidateQueries({ queryKey: ["navigate-command"] });
         }
-        if (hasAppStateEvent(relevant, "show-questions")) {
+        if (hasAppStateEvent(invalidating, "show-questions")) {
           queryClient.invalidateQueries({ queryKey: ["show-questions"] });
         }
-        if (hasAppStateEvent(relevant, "__set_url__")) {
+        if (hasAppStateEvent(invalidating, "__set_url__")) {
           queryClient.invalidateQueries({ queryKey: ["__set_url__"] });
         }
       }