@agent-native/core 0.98.4 → 0.98.6

package/corpus/core/src/client/agent-chat-adapter.ts

@@ -178,6 +178,16 @@ const BACKGROUND_FOLLOW_POLL_INTERVAL_MS = 1_000;
 // accurate if any of the four numbers change.
 export const BACKGROUND_FOLLOW_IDLE_TIMEOUT_MS = 150_000;
 
+// A re-observed terminal run whose outcome would be an ERROR (never a
+// genuine "done" success) gets a short extra grace window before the follow
+// loop surfaces it: the server's dead-run recovery can reap a lost
+// background run and insert a claimable successor a beat after the client
+// first sees the stale terminal row. Deliberately much shorter than
+// BACKGROUND_FOLLOW_IDLE_TIMEOUT_MS — this exists to absorb that narrow
+// insert-latency race, not to mask a genuinely lost run behind a long hang
+// before the user sees an error.
+const BACKGROUND_TERMINAL_ERROR_GRACE_POLLS = 5;
+
 /**
  * User-facing copy for the server's background terminal reasons
  * (`agent_runs.terminal_reason`, surfaced by /runs/active). These runs died in
@@ -200,6 +210,50 @@ const BACKGROUND_TERMINAL_REASON_MESSAGES: Record<string, string> = {
     "This request needed more automatic continuations than allowed and was stopped. Try breaking it into smaller steps.",
 };
 
+/**
+ * `agent_runs.terminal_reason` values that mark a CHUNK boundary, not the end
+ * of the turn — `markBackgroundContinuationChunkTerminal` (production-agent.ts)
+ * writes status "completed" with one of these bare reasons whenever a
+ * background chunk ends at a continuation boundary (mirrors
+ * `AgentLoopContinuationReason` there). A run in this state is expected to be
+ * replaced by a server-chained successor row; it must never be read as "the
+ * turn is done" just because its own row says `status: "completed"`.
+ */
+const BACKGROUND_CONTINUATION_TERMINAL_REASONS = new Set<string>([
+  "run_timeout",
+  "loop_limit",
+  "max_tokens",
+  "stream_ended",
+  "gateway_timeout",
+  "network_interrupted",
+  "no_progress",
+]);
+
+/**
+ * True when the given `/runs/active` snapshot, if surfaced as a background
+ * terminal outcome right now, would render as an error rather than a
+ * successful completion. Mirrors `emitBackgroundTerminalOutcome`'s own
+ * mappedMessage/hasErrorTerminalReason/status branching (kept in sync with
+ * it) so callers can decide whether an error-surfacing grace window applies
+ * BEFORE actually emitting anything.
+ */
+function isBackgroundTerminalErrorOutcome(
+  lastKnown: Record<string, unknown> | null,
+): boolean {
+  const status = typeof lastKnown?.status === "string" ? lastKnown.status : "";
+  const rawTerminalReason =
+    typeof lastKnown?.terminalReason === "string"
+      ? lastKnown.terminalReason
+      : "";
+  const hasErrorTerminalReason = rawTerminalReason.startsWith("error:");
+  const terminalReason = rawTerminalReason.replace(/^error:/, "");
+  const mappedMessage = terminalReason
+    ? BACKGROUND_TERMINAL_REASON_MESSAGES[terminalReason]
+    : undefined;
+  if (mappedMessage || hasErrorTerminalReason) return true;
+  return status !== "completed";
+}
+
 function normalizeMentions(text: string): string {
   return text.replace(/@\[([^\]|]+)\|[^\]]+\]/g, "@$1");
 }
@@ -2387,6 +2441,52 @@ export function createAgentChatAdapter(
           };
           dispatchResumingUiEvent();
 
+          // Before surfacing a background terminal ERROR (never called for a
+          // genuine "done" success — see call site), give the server's
+          // reap-and-recover path a short extra window to insert a claimable
+          // successor row for this turn. Returns as soon as `/runs/active`
+          // reports a DIFFERENT runId than the stale one, so the caller can
+          // hand back to the main loop and follow it seamlessly instead of
+          // erroring out from under it.
+          const awaitBackgroundErrorRecoverySuccessor = async (
+            staleRunId: string,
+          ): Promise<"successor" | "timeout" | "aborted"> => {
+            for (
+              let attempt = 0;
+              attempt < BACKGROUND_TERMINAL_ERROR_GRACE_POLLS;
+              attempt++
+            ) {
+              if (abortSignal.aborted) return "aborted";
+              dispatchResumingUiEvent();
+              await delay(BACKGROUND_FOLLOW_POLL_INTERVAL_MS, abortSignal);
+              if (abortSignal.aborted) return "aborted";
+              let recheck: Record<string, unknown> | null = null;
+              try {
+                const activeRes = await fetch(
+                  `${apiUrl}/runs/active?threadId=${encodeURIComponent(threadId!)}`,
+                  { signal: abortSignal },
+                );
+                if (activeRes.ok) {
+                  recheck = await activeRes.json().catch(() => null);
+                }
+              } catch (pollErr: unknown) {
+                if (pollErr instanceof Error && pollErr.name === "AbortError") {
+                  return "aborted";
+                }
+                // Transient poll failure — this attempt counts as "no
+                // successor yet", not a hard failure of the grace window.
+              }
+              const recheckRunId =
+                recheck?.active === true && recheck.runId
+                  ? String(recheck.runId)
+                  : null;
+              if (recheckRunId && recheckRunId !== staleRunId) {
+                return "successor";
+              }
+            }
+            return "timeout";
+          };
+
           let idleSince: number | null = null;
           let lastSeenActive: Record<string, unknown> | null = null;
           // Terminal runs already replayed once. A recoverable terminal error
@@ -2394,7 +2494,10 @@ export function createAgentChatAdapter(
           // which used to re-drive a POST in foreground mode. In follow mode
           // the server owns recovery, so a SECOND visit to the same terminal
           // run means the turn is over — surface the outcome instead of
-          // re-replaying it every poll for the whole reconnect window.
+          // re-replaying it every poll for the whole reconnect window. (A
+          // CONTINUATION-class terminal_reason is the one exception: see the
+          // isContinuationChunkBoundary check below, which keeps polling
+          // instead of surfacing anything.)
           const replayedTerminalRunIds = new Set<string>();
 
           while (true) {
@@ -2458,6 +2561,64 @@ export function createAgentChatAdapter(
                     return "client_continue";
                   }
                 }
+                const rawTerminalReason =
+                  typeof active?.terminalReason === "string"
+                    ? active.terminalReason
+                    : "";
+                const bareTerminalReason = rawTerminalReason.replace(
+                  /^error:/,
+                  "",
+                );
+                // A re-observed "completed" row with a CONTINUATION-class
+                // reason (run_timeout/no_progress/loop_limit/…) is a MID-TURN
+                // chunk boundary, not the end of the turn — a warm instance
+                // can keep serving this stale row for a beat before the
+                // pre-inserted successor becomes visible. Emitting a terminal
+                // outcome here is exactly the bug this branch exists to
+                // avoid: it would flip the message to "done" while the
+                // successor's content is still coming. Keep polling on the
+                // shared idle budget instead; a truly stuck handoff still
+                // fails loud (never a silent stop) once it expires.
+                const isContinuationChunkBoundary =
+                  activeStatus === "completed" &&
+                  !rawTerminalReason.startsWith("error:") &&
+                  !BACKGROUND_TERMINAL_REASON_MESSAGES[bareTerminalReason] &&
+                  BACKGROUND_CONTINUATION_TERMINAL_REASONS.has(
+                    bareTerminalReason,
+                  );
+                if (isContinuationChunkBoundary) {
+                  if (idleSince === null) idleSince = Date.now();
+                  if (
+                    Date.now() - idleSince >=
+                    BACKGROUND_FOLLOW_IDLE_TIMEOUT_MS
+                  ) {
+                    yield* emitBackgroundTerminalError({
+                      message:
+                        "The agent's background run stopped between chunks and no continuation appeared. You can retry from the preserved chat context.",
+                      errorCode: "background_run_lost",
+                      details: `terminal_reason: ${rawTerminalReason}`,
+                    });
+                    return "completed";
+                  }
+                  dispatchResumingUiEvent();
+                  await delay(BACKGROUND_FOLLOW_POLL_INTERVAL_MS, abortSignal);
+                  continue;
+                }
+                if (isBackgroundTerminalErrorOutcome(active)) {
+                  const graceOutcome =
+                    await awaitBackgroundErrorRecoverySuccessor(activeRunId);
+                  if (graceOutcome === "aborted") {
+                    clearActiveRun();
+                    return "completed";
+                  }
+                  if (graceOutcome === "successor") {
+                    // A successor claimed the turn while we waited — hand
+                    // back to the top of the loop so it attaches and follows
+                    // it exactly like any other newly-discovered run instead
+                    // of duplicating that bookkeeping here.
+                    continue;
+                  }
+                }
                 yield* emitBackgroundTerminalOutcome(active);
                 return "completed";
               }
@@ -2513,6 +2674,13 @@ export function createAgentChatAdapter(
               }
               dispatchResumingUiEvent();
             } else {
+              // No active run visible for this turn yet (the gap between a
+              // chunk ending and the successor becoming pollable). Refresh
+              // the "Resuming…" bridge on every tick here too — not just
+              // when an active run IS visible — so the client's own
+              // isAutoResuming window can't lapse into a false-idle UI while
+              // this loop is still confidently waiting out its own budget.
+              dispatchResumingUiEvent();
               if (idleSince === null) idleSince = Date.now();
               if (Date.now() - idleSince >= BACKGROUND_FOLLOW_IDLE_TIMEOUT_MS) {
                 captureChatClientError(

package/corpus/core/src/client/chat/message-components.tsx

@@ -842,6 +842,7 @@ export function shouldShowAssistantMessageFooter({
 
 function ReasoningMessagePart() {
   const part = useMessagePartReasoning();
+  const chatRunning = React.useContext(ChatRunningContext);
   const isStreaming = part.status?.type === "running";
   // Time thinking client-side: record the moment streaming first starts and
   // the moment it stops so the cell can show "Thought for Xs". Historical
@@ -864,6 +865,8 @@ function ReasoningMessagePart() {
       text={part.text}
       isStreaming={isStreaming}
       durationMs={durationMs}
+      defaultOpen={isStreaming || !chatRunning}
+      autoCollapse={chatRunning}
     />
   );
 }

package/corpus/core/src/client/chat/tool-call-display.tsx

@@ -404,45 +404,16 @@ export function AnimatedCollapse({
   open: boolean;
   children: React.ReactNode;
 }) {
-  const ref = useRef<HTMLDivElement>(null);
-  const [height, setHeight] = useState<number | "auto">(open ? "auto" : 0);
   const [mounted, setMounted] = useState(open);
-  const reduceMotionRef = useRef(false);
-
-  useEffect(() => {
-    reduceMotionRef.current =
-      typeof window !== "undefined" &&
-      !!window.matchMedia?.("(prefers-reduced-motion: reduce)").matches;
-  }, []);
 
   useLayoutEffect(() => {
     if (open) setMounted(true);
   }, [open]);
 
-  useLayoutEffect(() => {
-    const el = ref.current;
-    if (!el || !mounted) return;
-    if (reduceMotionRef.current) {
-      setHeight(open ? "auto" : 0);
-      if (!open) setMounted(false);
-      return;
-    }
-    if (open) {
-      const full = el.scrollHeight;
-      setHeight(0);
-      const frame = requestAnimationFrame(() => setHeight(full));
-      return () => cancelAnimationFrame(frame);
-    }
-    setHeight(el.scrollHeight);
-    const frame = requestAnimationFrame(() => setHeight(0));
-    return () => cancelAnimationFrame(frame);
-  }, [open, mounted]);
-
   const onTransitionEnd = useCallback(
     (event: React.TransitionEvent<HTMLDivElement>) => {
-      if (event.propertyName !== "height") return;
-      if (open) setHeight("auto");
-      else setMounted(false);
+      if (event.propertyName !== "grid-template-rows" || open) return;
+      setMounted(false);
     },
     [open],
   );
@@ -451,12 +422,12 @@ export function AnimatedCollapse({
 
   return (
     <div
-      ref={ref}
-      className="overflow-hidden transition-[height] duration-200 ease-[var(--ease-collapse)]"
-      style={{ height: height === "auto" ? "auto" : `${height}px` }}
+      className="agent-chat-collapse"
+      data-state={open ? "open" : "closed"}
+      aria-hidden={!open}
       onTransitionEnd={onTransitionEnd}
     >
-      {children}
+      <div className="agent-chat-collapse__content">{children}</div>
     </div>
   );
 }
@@ -953,6 +924,7 @@ export function ReconnectStreamMessage({
                 key={`reconnect-reasoning-${i}`}
                 text={part.text}
                 isStreaming={chatRunning && i === streamingReasoningPartIndex}
+                defaultOpen={chatRunning && i === streamingReasoningPartIndex}
               />
             );
           }
@@ -996,11 +968,14 @@ export function ReasoningCell({
   text,
   isStreaming = false,
   defaultOpen,
+  autoCollapse = false,
   durationMs,
 }: {
   text: string;
   isStreaming?: boolean;
   defaultOpen?: boolean;
+  /** Animate closed when a live reasoning segment finishes during a run. */
+  autoCollapse?: boolean;
   /**
    * Elapsed thinking time in ms, once known. Only meaningful once streaming
    * has finished — callers that track live timing (see ReasoningMessagePart)
@@ -1011,7 +986,16 @@ export function ReasoningCell({
 }) {
   const embeddedInWorkSummary = React.useContext(WorkSummaryContentContext);
   const [open, setOpen] = useState(defaultOpen ?? true);
+  const wasStreamingRef = useRef(isStreaming);
   const trimmed = text.trim();
+
+  useEffect(() => {
+    if (autoCollapse && wasStreamingRef.current && !isStreaming) {
+      setOpen(false);
+    }
+    wasStreamingRef.current = isStreaming;
+  }, [autoCollapse, isStreaming]);
+
   if (!trimmed && !isStreaming) return null;
 
   if (embeddedInWorkSummary) {
@@ -1024,7 +1008,7 @@ export function ReasoningCell({
 
   const label = isStreaming
     ? "Thinking"
-    : durationMs != null && durationMs >= 1000
+    : durationMs != null
       ? `Thought for ${formatWorkedDuration(durationMs)}`
       : "Thought";
   // Only clamp to a scroll-free "tail" view while actively streaming and

package/corpus/core/src/client/conversation/use-near-bottom-autoscroll.ts

@@ -243,6 +243,12 @@ export function useNearBottomAutoscroll<TElement extends HTMLElement>({
     window.setTimeout(() => scrollToBottomIfFollowing(generation), 80);
   }, [scrollToBottomIfFollowing]);
 
+  const resumeFollowing = useCallback(() => {
+    const el = scrollRef.current;
+    setFollowingBottom(true, true, el ?? undefined);
+    scrollToBottomAfterPaint();
+  }, [scrollToBottomAfterPaint, setFollowingBottom]);
+
   const markNearBottom = useCallback(() => {
     setFollowingBottom(true, true, scrollRef.current ?? undefined);
   }, [setFollowingBottom]);
@@ -267,5 +273,6 @@ export function useNearBottomAutoscroll<TElement extends HTMLElement>({
     markNearBottom,
     scrollToBottom,
     scrollToBottomAfterPaint,
+    resumeFollowing,
   };
 }

package/corpus/core/src/client/extensions/AgentNativeExtensionFrame.tsx

@@ -9,6 +9,7 @@ import React, {
   type IframeHTMLAttributes,
 } from "react";
 
+import { SESSION_REPLAY_IFRAME_ATTRIBUTE } from "../../session-replay-iframe-protocol.js";
 import {
   createAgentNativeHostBridge,
   type AgentNativeClientAction,
@@ -604,6 +605,7 @@ export const AgentNativeExtensionFrame = forwardRef<
   return (
     <iframe
       {...iframeProps}
+      {...{ [SESSION_REPLAY_IFRAME_ATTRIBUTE]: "" }}
       key={`${extension.id}:${extension.updatedAt ?? ""}`}
       ref={(node) => {
         iframeRef.current = node;

package/corpus/core/src/client/extensions/EmbeddedExtension.tsx

@@ -10,6 +10,7 @@ import { useNavigate } from "react-router";
 
 import { extensionPath } from "../../extensions/path.js";
 import { THEME_VAR_NAMES } from "../../extensions/theme.js";
+import { SESSION_REPLAY_IFRAME_ATTRIBUTE } from "../../session-replay-iframe-protocol.js";
 import { sendToAgentChat } from "../agent-chat.js";
 import { agentNativePath } from "../api-path.js";
 import { useAppearance } from "../appearance.js";
@@ -425,6 +426,7 @@ export function EmbeddedExtension({
   return (
     <div className={`relative group/embedded-extension ${className ?? ""}`}>
       <iframe
+        {...{ [SESSION_REPLAY_IFRAME_ATTRIBUTE]: "" }}
         ref={iframeRef}
         key={`${extensionId}-${extension.updatedAt ?? ""}`}
         src={iframeSrc}

package/corpus/core/src/client/extensions/ExtensionEditor.tsx

@@ -6,10 +6,12 @@ import {
   IconX,
 } from "@tabler/icons-react";
 import { useQuery, useQueryClient } from "@tanstack/react-query";
-import { useState, useEffect } from "react";
+import { useEffect, useMemo, useState } from "react";
 import { Link, useNavigate } from "react-router";
 
 import { extensionPath } from "../../extensions/path.js";
+import { injectSessionReplayIframeBootstrap } from "../../extensions/session-replay-iframe.js";
+import { SESSION_REPLAY_IFRAME_ATTRIBUTE } from "../../session-replay-iframe-protocol.js";
 import { agentNativePath } from "../api-path.js";
 import {
   Popover,
@@ -61,6 +63,10 @@ export function ExtensionEditor({ extensionId }: ExtensionEditorProps) {
   const [deleting, setDeleting] = useState(false);
   const [menuOpen, setMenuOpen] = useState(false);
   const [confirmingDelete, setConfirmingDelete] = useState(false);
+  const previewHtml = useMemo(
+    () => injectSessionReplayIframeBootstrap(content),
+    [content],
+  );
 
   const slotsQuery = useQuery<SlotDeclaration[]>({
     queryKey: ["extension-slots", extensionId],
@@ -425,7 +431,8 @@ export function ExtensionEditor({ extensionId }: ExtensionEditorProps) {
           <div className="w-1/2">
             {content ? (
               <iframe
-                srcDoc={content}
+                {...{ [SESSION_REPLAY_IFRAME_ATTRIBUTE]: "" }}
+                srcDoc={previewHtml}
                 className="h-full w-full border-0"
                 sandbox="allow-scripts allow-forms"
                 title={t("extensions.previewTitle")}

package/corpus/core/src/client/extensions/ExtensionViewer.tsx

@@ -17,6 +17,7 @@ import { Link, useLocation, useNavigate } from "react-router";
 import { buildExtensionHtml } from "../../extensions/html-shell.js";
 import { extensionPath, isExtensionPathname } from "../../extensions/path.js";
 import { getThemeVars } from "../../extensions/theme.js";
+import { SESSION_REPLAY_IFRAME_ATTRIBUTE } from "../../session-replay-iframe-protocol.js";
 import { sendToAgentChat } from "../agent-chat.js";
 import { AgentToggleButton } from "../AgentPanel.js";
 import { agentNativePath, appPath } from "../api-path.js";
@@ -1400,6 +1401,7 @@ export function ExtensionViewer({ extensionId }: ExtensionViewerProps) {
             </div>
           )}
           <iframe
+            {...{ [SESSION_REPLAY_IFRAME_ATTRIBUTE]: "" }}
             ref={iframeRef}
             key={`${extension.updatedAt}-${refreshKey}`}
             src={iframeSrcDoc ? undefined : iframeSrc}

package/corpus/core/src/client/extensions/InlineExtensionFrame.tsx

@@ -2,6 +2,7 @@ import { useEffect, useMemo, useRef, useState } from "react";
 
 import { buildExtensionHtml } from "../../extensions/html-shell.js";
 import { getThemeVars } from "../../extensions/theme.js";
+import { SESSION_REPLAY_IFRAME_ATTRIBUTE } from "../../session-replay-iframe-protocol.js";
 import { sendToAgentChat } from "../agent-chat.js";
 import { agentNativePath } from "../api-path.js";
 import {
@@ -641,6 +642,7 @@ export function InlineExtensionFrame({
   return (
     <div className={`relative ${className ?? ""}`}>
       <iframe
+        {...{ [SESSION_REPLAY_IFRAME_ATTRIBUTE]: "" }}
         ref={iframeRef}
         key={`${resolvedId}-${extension.updatedAt ?? "inline"}-${isTransient ? "transient" : "persisted"}`}
         src={iframeSrc}

package/corpus/core/src/client/extensions/portable-extension.ts

@@ -1,4 +1,5 @@
 import { EXTENSION_IFRAME_META_CSP } from "../../extensions/html-shell.js";
+import { buildSessionReplayIframeBootstrap } from "../../extensions/session-replay-iframe.js";
 import { AGENT_NATIVE_HOST_MESSAGE_TYPES } from "../host-bridge.js";
 
 export const AGENT_NATIVE_EXTENSION_MESSAGE_TYPES = {
@@ -702,6 +703,7 @@ export function buildAgentNativeExtensionHtml({
       }, '*');
     })();
   </script>
+${buildSessionReplayIframeBootstrap()}
 </head>
 <body>
 ${content}