@agent-native/core 0.85.6 → 0.86.0

package/corpus/core/src/client/session-replay.ts

@@ -95,9 +95,16 @@ export interface SessionReplayConsoleOptions {
  * `agent-native.network` custom events emitted per recording session
  * (default 2000); once hit, capture stops for the rest of the session and one
  * final truncation-notice event is emitted.
+ *
+ * `captureErrorBodies` (default true) additionally captures a bounded,
+ * redacted response-body snippet for 5xx responses only -- request bodies
+ * and headers are never captured, and non-5xx/network-failure responses
+ * never carry a body. `maxErrorBodyLength` (default 2048) caps that snippet.
  */
 export interface SessionReplayNetworkOptions {
   maxEvents?: number;
+  captureErrorBodies?: boolean;
+  maxErrorBodyLength?: number;
 }
 
 export interface SessionReplayOptions {
@@ -141,7 +148,9 @@ export interface SessionReplayOptions {
   console?: boolean | SessionReplayConsoleOptions;
   /**
    * Capture fetch/XHR requests as `agent-native.network` custom rrweb
-   * events (method, URL, status, timing -- never bodies or headers).
+   * events (method, URL, status, timing). Request bodies and headers are
+   * never captured; response bodies are captured only as a bounded,
+   * redacted snippet for 5xx responses (see `captureErrorBodies`).
    * Defaults to on whenever session replay is enabled. Pass `false` to
    * disable, or an options object to override caps.
    */
@@ -203,6 +212,10 @@ interface NormalizedSessionReplayOptions {
 
 interface NormalizedCaptureOptions {
   maxEvents: number;
+  /** Network-only: capture a bounded 5xx response-body snippet. Unused by console. */
+  captureErrorBodies?: boolean;
+  /** Network-only: cap (chars) for the captured error-body snippet. */
+  maxErrorBodyLength?: number;
 }
 
 const DEFAULT_REPLAY_PATH = "/api/analytics/replay";
@@ -263,6 +276,10 @@ const MAX_CONSOLE_ARGS = 10;
 const MAX_CONSOLE_STACK_LENGTH = 2000;
 const MAX_CONSOLE_SERIALIZE_DEPTH = 4;
 const MAX_CONSOLE_SERIALIZE_ENTRIES = 20;
+/** Default cap (chars) for a captured 5xx response-body snippet. */
+const DEFAULT_MAX_ERROR_BODY_LENGTH = 2048;
+/** Hard timeout for the async response-body read; emit without body past this. */
+const ERROR_BODY_READ_TIMEOUT_MS = 1500;
 
 /**
  * Re-entrancy guard: true while the recorder itself is emitting custom events
@@ -644,10 +661,12 @@ function normalizeOptions(
 
 /**
  * Console/network capture default to ON whenever session replay records;
- * `false` disables a category, an object form overrides its caps.
+ * `false` disables a category, an object form overrides its caps. Network
+ * options may additionally carry `captureErrorBodies`/`maxErrorBodyLength`;
+ * console ignores those fields.
  */
 function normalizeCaptureToggle(
-  value: boolean | { maxEvents?: number } | undefined,
+  value: boolean | SessionReplayNetworkOptions | undefined,
   defaultMaxEvents: number,
 ): NormalizedCaptureOptions | null {
   if (value === false) return null;
@@ -657,7 +676,16 @@ function normalizeCaptureToggle(
     Number.isFinite(overrides.maxEvents)
       ? Math.max(1, Math.floor(overrides.maxEvents))
       : defaultMaxEvents;
-  return { maxEvents };
+  const maxErrorBodyLength =
+    typeof overrides.maxErrorBodyLength === "number" &&
+    Number.isFinite(overrides.maxErrorBodyLength)
+      ? Math.max(0, Math.floor(overrides.maxErrorBodyLength))
+      : DEFAULT_MAX_ERROR_BODY_LENGTH;
+  return {
+    maxEvents,
+    captureErrorBodies: overrides.captureErrorBodies !== false,
+    maxErrorBodyLength,
+  };
 }
 
 function scrubStringValue(key: string, value: string): string {
@@ -1507,6 +1535,36 @@ function isCaptureExcludedUrl(rawUrl: string, ingestEndpoint: string): boolean {
   return false;
 }
 
+/**
+ * Best-effort, synchronous read of a 5xx XHR response body, sliced to `cap`
+ * before redaction runs (caller redacts). Only reads `responseText` when
+ * `responseType` is "" or "text" -- other response types are read via
+ * `JSON.stringify` (guarded) for `"json"`, and skipped entirely otherwise
+ * since arbitrary binary/blob/arraybuffer bodies are not useful error text.
+ */
+function readXhrErrorBody(
+  xhr: XMLHttpRequest,
+  cap: number,
+): string | undefined {
+  try {
+    const responseType = xhr.responseType;
+    if (responseType === "" || responseType === "text") {
+      const text = xhr.responseText;
+      return typeof text === "string" ? text.slice(0, cap) : undefined;
+    }
+    if (responseType === "json") {
+      try {
+        return JSON.stringify(xhr.response)?.slice(0, cap);
+      } catch {
+        return undefined;
+      }
+    }
+    return undefined;
+  } catch {
+    return undefined;
+  }
+}
+
 function installNetworkCapture(
   state: SessionReplayState,
   captureOptions: NormalizedCaptureOptions,
@@ -1531,6 +1589,11 @@ function installNetworkCapture(
     emitReplayCustomEvent(state, SESSION_REPLAY_NETWORK_EVENT_TAG, payload);
   };
 
+  const errorBodyCap =
+    captureOptions.captureErrorBodies !== false
+      ? (captureOptions.maxErrorBodyLength ?? DEFAULT_MAX_ERROR_BODY_LENGTH)
+      : null;
+
   const recordRequest = (
     api: "fetch" | "xhr",
     method: string,
@@ -1539,6 +1602,7 @@ function installNetworkCapture(
     ok: boolean,
     durationMs: number,
     error?: string,
+    responseBody?: string,
   ) => {
     if (stopped) return;
     try {
@@ -1560,12 +1624,58 @@ function installNetworkCapture(
               ),
             }
           : {}),
+        ...(responseBody
+          ? {
+              responseBody: truncateCaptureText(
+                redactCaptureText(responseBody),
+                errorBodyCap ?? DEFAULT_MAX_ERROR_BODY_LENGTH,
+              ),
+            }
+          : {}),
       });
     } catch {
       // capture must never break the host page
     }
   };
 
+  /**
+   * Best-effort bounded read of a 5xx response body. Reads a decoded stream
+   * up to `cap` chars and cancels the reader, or falls back to `.text()`
+   * sliced to `cap` when no readable stream is exposed. Never throws --
+   * opaque/no-body responses (or any read failure) resolve to undefined.
+   */
+  const readBoundedErrorBody = async (
+    response: Response,
+    cap: number,
+  ): Promise<string | undefined> => {
+    try {
+      const reader = response.body?.getReader?.();
+      if (reader) {
+        const decoder = new TextDecoder();
+        let text = "";
+        while (text.length < cap) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          if (value) text += decoder.decode(value, { stream: true });
+        }
+        // Fire-and-forget: cancelling an already-exhausted (or still-open but
+        // no-longer-wanted) reader can hang indefinitely on some stream
+        // implementations. We never need the result, so don't await it --
+        // that would defeat the whole point of bounding this read.
+        try {
+          reader.cancel().catch(() => {});
+        } catch {
+          // best-effort; some readers throw synchronously instead
+        }
+        return text.slice(0, cap);
+      }
+      const text = await response.text();
+      return text.slice(0, cap);
+    } catch {
+      return undefined;
+    }
+  };
+
   const restores: Array<() => void> = [];
 
   if (typeof window.fetch === "function") {
@@ -1593,8 +1703,10 @@ function installNetworkCapture(
         return originalFetch.call(self, input as RequestInfo | URL, init);
       }
       const startedAt = performance.now();
-      // Call the original exactly as the page did; never read bodies, never
-      // replace the response, propagate rejections untouched.
+      // Call the original exactly as the page did; never read the caller's
+      // response before returning it, never replace the response, propagate
+      // rejections untouched. A 5xx body snippet (if any) is read from a
+      // clone and emitted from a detached promise chain afterward.
       const result = originalFetch.call(self, input as RequestInfo | URL, init);
       if (!result || typeof (result as Promise<Response>).then !== "function") {
         return result;
@@ -1602,14 +1714,62 @@ function installNetworkCapture(
       return result.then(
         (response) => {
           try {
-            recordRequest(
-              "fetch",
-              method,
-              url,
-              response.status,
-              response.ok,
-              performance.now() - startedAt,
-            );
+            const durationMs = performance.now() - startedAt;
+            if (errorBodyCap !== null && response.status >= 500) {
+              // Clone immediately -- before any other code (including this
+              // handler returning) can consume the original body -- so the
+              // clone's stream is guaranteed unconsumed.
+              let clone: Response | null = null;
+              try {
+                clone = response.clone();
+              } catch {
+                clone = null;
+              }
+              if (clone) {
+                const bodyPromise = readBoundedErrorBody(clone, errorBodyCap);
+                const timeoutPromise = new Promise<undefined>((resolve) => {
+                  setTimeout(
+                    () => resolve(undefined),
+                    ERROR_BODY_READ_TIMEOUT_MS,
+                  );
+                });
+                // Detached chain: never rejects, never awaited by the caller.
+                Promise.race([bodyPromise, timeoutPromise])
+                  .then((responseBody) => {
+                    recordRequest(
+                      "fetch",
+                      method,
+                      url,
+                      response.status,
+                      response.ok,
+                      durationMs,
+                      undefined,
+                      responseBody,
+                    );
+                  })
+                  .catch(() => {
+                    // never affect the caller
+                  });
+              } else {
+                recordRequest(
+                  "fetch",
+                  method,
+                  url,
+                  response.status,
+                  response.ok,
+                  durationMs,
+                );
+              }
+            } else {
+              recordRequest(
+                "fetch",
+                method,
+                url,
+                response.status,
+                response.ok,
+                durationMs,
+              );
+            }
           } catch {
             // never affect the caller
           }
@@ -1700,14 +1860,20 @@ function installNetworkCapture(
             "loadend",
             () => {
               const status = typeof this.status === "number" ? this.status : 0;
+              const effectiveStatus = errorMessage ? 0 : status;
+              let responseBody: string | undefined;
+              if (errorBodyCap !== null && !errorMessage && status >= 500) {
+                responseBody = readXhrErrorBody(this, errorBodyCap);
+              }
               recordRequest(
                 "xhr",
                 info.method,
                 info.url,
-                errorMessage ? 0 : status,
+                effectiveStatus,
                 !errorMessage && status >= 200 && status < 300,
                 performance.now() - startedAt,
                 errorMessage,
+                responseBody,
               );
               xhrInfo.delete(this);
             },

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(