@agent-native/core 0.84.51 → 0.84.52

package/corpus/README.md

@@ -28,4 +28,4 @@ rg -n "defineAction|useActionQuery" node_modules/@agent-native/core/corpus
 ## Generated Counts
 
 - core files: 2044
-- template files: 4998
+- template files: 5001

package/corpus/core/CHANGELOG.md

@@ -1,5 +1,13 @@
 # @agent-native/core
 
+## 0.84.52
+
+### Patch Changes
+
+- ca38cc7: Carry action-preparation stall detection across reconnect reads for the same run so zero-byte tool input retries cannot keep background chats alive indefinitely.
+- 899ebf1: Hide the diff "Show all lines" footer when annotation anchoring already renders every line.
+- c1e18fb: Make session replay uploads retry failed batches without advancing sequence ids.
+
 ## 0.84.51
 
 ### Patch Changes

package/corpus/core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-native/core",
-  "version": "0.84.51",
+  "version": "0.84.52",
   "description": "Framework for agent-native application development — where AI agents and UI share SQL state, actions, and context",
   "homepage": "https://github.com/BuilderIO/agent-native#readme",
   "bugs": {

package/corpus/core/src/agent/run-store.ts

@@ -763,9 +763,9 @@ export async function reconcileTerminalRunFromEvents(
     sql: `UPDATE agent_runs
           SET status = ?,
               completed_at = COALESCE(completed_at, ?, ${livenessBasisSql()}),
-              error_code = CASE WHEN ? IS NOT NULL THEN ? ELSE error_code END,
-              error_detail = CASE WHEN ? IS NOT NULL THEN ? ELSE error_detail END,
-              terminal_reason = COALESCE(terminal_reason, ?)
+              error_code = ?,
+              error_detail = ?,
+              terminal_reason = ?
           WHERE id = ?
             AND (
               status = 'running'
@@ -775,8 +775,6 @@ export async function reconcileTerminalRunFromEvents(
       status,
       latest.eventAt,
       errorCode,
-      errorCode,
-      errorDetail,
       errorDetail,
       terminalReason,
       runId,
@@ -1248,7 +1246,7 @@ export async function listRunsForThread(
   await ensureRunTables();
   const limit = Math.min(Math.max(options.limit ?? 10, 1), 50);
   const client = getDbExec();
-  const { rows } = await client.execute({
+  let { rows } = await client.execute({
     sql: `SELECT id, thread_id, turn_id, status, started_at, heartbeat_at, completed_at, last_progress_at, error_code, abort_reason, dispatch_mode, terminal_reason, diag_stage
           FROM agent_runs
           WHERE thread_id = ?
@@ -1256,6 +1254,35 @@ export async function listRunsForThread(
           LIMIT ?`,
     args: [threadId, limit],
   });
+  let repairedTerminalRow = false;
+  for (const r of rows) {
+    const row = r as {
+      id?: string;
+      status?: string;
+      error_code?: string | null;
+    };
+    const runId = row.id;
+    if (!runId) continue;
+    const canReconcileFromEvents =
+      row.status === "running" ||
+      (row.status === "errored" &&
+        row.error_code === STALE_RUN_ERROR_EVENT.errorCode);
+    if (!canReconcileFromEvents) continue;
+    repairedTerminalRow =
+      (await reconcileTerminalRunFromEvents(runId).catch(() => false)) ||
+      repairedTerminalRow;
+  }
+  if (repairedTerminalRow) {
+    const refreshed = await client.execute({
+      sql: `SELECT id, thread_id, turn_id, status, started_at, heartbeat_at, completed_at, last_progress_at, error_code, abort_reason, dispatch_mode, terminal_reason, diag_stage
+            FROM agent_runs
+            WHERE thread_id = ?
+            ORDER BY started_at DESC
+            LIMIT ?`,
+      args: [threadId, limit],
+    });
+    rows = refreshed.rows;
+  }
   return rows.map((r) => {
     const row = r as {
       id: string;

package/corpus/core/src/client/AssistantChat.tsx

@@ -153,6 +153,7 @@ import {
 import {
   AgentAutoContinueSignal,
   type ContentPart,
+  type PreparingActionState,
   readSSEStreamRaw,
   settleInterruptedToolCalls,
 } from "./sse-event-processor.js";
@@ -675,7 +676,7 @@ export function resolveAssistantChatRunningStatusLabel({
 }): string {
   if (runningActivityLabel) return runningActivityLabel;
   if (isAutoResuming) return "Resuming";
-  if (isReconnecting && hasReconnectContent) return "Continuing";
+  if (isReconnecting && hasReconnectContent) return "Still working";
   return "Thinking";
 }
 
@@ -1516,7 +1517,7 @@ const AssistantChatInner = forwardRef<
   const textStreaming = showRunningInUI || externalStreaming;
   // A revealed activity label wins; otherwise keep recovery states calm and
   // product-facing. Reconnect is transport machinery, so normal replay reads as
-  // "Continuing" instead of exposing "Reconnecting" mid-chat.
+  // ongoing work instead of exposing "Reconnecting" mid-chat.
   const runningStatusLabel = resolveAssistantChatRunningStatusLabel({
     runningActivityLabel,
     isAutoResuming,
@@ -1863,6 +1864,27 @@ const AssistantChatInner = forwardRef<
       const streamReconnect = async () => {
         let noProgressDuringReconnect = false;
         let latestContent: ContentPart[] = [];
+        const preparingActionState: PreparingActionState = {};
+        const sameRunStillActive = async (): Promise<
+          "active" | "inactive" | "unknown"
+        > => {
+          try {
+            const res = await fetch(
+              `${apiUrl}/runs/active?threadId=${encodeURIComponent(threadId)}`,
+              { signal: abortCtrl.signal },
+            );
+            if (!res.ok) return "unknown";
+            const info = (await res.json()) as ActiveRunLookup;
+            return info.active === true &&
+              String(info.runId ?? "") === runId &&
+              info.status === "running" &&
+              !activeRunLooksStale(info)
+              ? "active"
+              : "inactive";
+          } catch {
+            return "unknown";
+          }
+        };
         const threadPollInterval =
           afterSeq > 0
             ? window.setInterval(() => {
@@ -1871,15 +1893,28 @@ const AssistantChatInner = forwardRef<
               }, 2000)
             : undefined;
         try {
-          const sseRes = await fetch(
-            `${apiUrl}/runs/${encodeURIComponent(runId)}/events?after=${afterSeq}`,
-            { signal: abortCtrl.signal },
-          );
-          if (sseRes.ok && sseRes.body) {
-            const content: ContentPart[] = [];
-            latestContent = content;
-            const toolCallCounter = { value: 0 };
+          const content: ContentPart[] = [];
+          latestContent = content;
+          const toolCallCounter = { value: 0 };
 
+          while (
+            reconnectRunIdRef.current === runId &&
+            !abortCtrl.signal.aborted
+          ) {
+            const reconnectAfterSeq = resolveReconnectAfterSeq(threadId, runId);
+            reconnectTailOnlyRef.current = reconnectAfterSeq > 0;
+            const sseRes = await fetch(
+              `${apiUrl}/runs/${encodeURIComponent(runId)}/events?after=${reconnectAfterSeq}`,
+              { signal: abortCtrl.signal },
+            );
+            if (!sseRes.ok || !sseRes.body) {
+              const activeState = await sameRunStillActive();
+              if (activeState !== "inactive") {
+                await new Promise((resolve) => window.setTimeout(resolve, 250));
+                continue;
+              }
+              break;
+            }
             let rafPending = false;
             let latestSnapshot: ContentPart[] = [];
             const scheduleUpdate = (snapshot: ContentPart[]) => {
@@ -1892,21 +1927,47 @@ const AssistantChatInner = forwardRef<
               });
             };
 
-            await readSSEStreamRaw(
-              sseRes.body,
-              content,
-              toolCallCounter,
-              tabId,
-              scheduleUpdate,
-              (seq) => {
-                markReconnectProgress();
-                updateActiveRunSeq(seq);
-              },
-            );
-            if (afterSeq === 0) {
-              setReconnectContent([...content]);
+            try {
+              await readSSEStreamRaw(
+                sseRes.body,
+                content,
+                toolCallCounter,
+                tabId,
+                scheduleUpdate,
+                (seq) => {
+                  markReconnectProgress();
+                  updateActiveRunSeq(seq);
+                },
+                { preparingActionState },
+              );
+              if (reconnectAfterSeq === 0) {
+                setReconnectContent([...content]);
+              }
+              break;
+            } catch (err) {
+              if (
+                err instanceof AgentAutoContinueSignal &&
+                err.reason === "stream_ended"
+              ) {
+                if (reconnectAfterSeq === 0) {
+                  setReconnectContent([...content]);
+                }
+                const activeState = await sameRunStillActive();
+                if (activeState !== "inactive") {
+                  await new Promise((resolve) =>
+                    window.setTimeout(resolve, 250),
+                  );
+                  continue;
+                }
+              }
+              throw err;
             }
           }
+          if (reconnectTimedOut && abortCtrl.signal.aborted) {
+            const timeoutError = new Error("Reconnect timed out");
+            timeoutError.name = "AbortError";
+            throw timeoutError;
+          }
         } catch (err) {
           if (
             err instanceof AgentAutoContinueSignal &&

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

@@ -20,6 +20,7 @@ import {
   type AgentActivityTrailEntry,
   type AgentAutoContinueErrorInfo,
   type ContentPart,
+  type PreparingActionState,
   readSSEStream,
   settleInterruptedToolCalls,
 } from "./sse-event-processor.js";
@@ -1381,6 +1382,10 @@ export function createAgentChatAdapter(
       let runId: string | null = null;
       let lastSeq = -1;
       const seenRunSeqs = new Map<string, number>();
+      const preparingActionStatesByRun = new Map<
+        string,
+        PreparingActionState
+      >();
       let currentRunDispatchMode: string | null = null;
       let currentMessageText = normalizeMentions(
         recoveryMessageText.trim() || userMessageText,
@@ -1570,9 +1575,23 @@ export function createAgentChatAdapter(
         }
       };
 
+      const preparingActionStateForRun = (
+        id: string | null,
+      ): PreparingActionState | undefined => {
+        if (!id) return undefined;
+        const existing = preparingActionStatesByRun.get(id);
+        if (existing) return existing;
+        const state: PreparingActionState = {};
+        preparingActionStatesByRun.set(id, state);
+        return state;
+      };
+
       const currentSSEOptions = () => ({
         durableBackgroundRun:
           currentRunDispatchMode?.startsWith("background") === true,
+        ...(runId
+          ? { preparingActionState: preparingActionStateForRun(runId) }
+          : {}),
       });
 
       const captureChatClientError = (

package/corpus/core/src/client/blocks/library/DiffBlock.tsx

@@ -838,8 +838,8 @@ function DiffRead({
     effectiveMode === "split" ? splitLineCount : rows.length;
   const shouldLimitRows = totalVisibleLineCount > DEFAULT_VISIBLE_DIFF_LINES;
   // Never truncate away an annotated row: extend the window past the last one.
-  const effectiveRowLimit = useMemo(() => {
-    if (showAllRows || !shouldLimitRows) return undefined;
+  const collapsedRowLimit = useMemo(() => {
+    if (!shouldLimitRows) return undefined;
     let limit = DEFAULT_VISIBLE_DIFF_LINES;
     if (hasAnnotations) {
       for (let idx = rows.length - 1; idx >= limit; idx -= 1) {
@@ -850,8 +850,10 @@ function DiffRead({
       }
     }
     return limit;
-  }, [showAllRows, shouldLimitRows, hasAnnotations, rows, markersForRow]);
-  const rowLimit = effectiveRowLimit;
+  }, [shouldLimitRows, hasAnnotations, rows, markersForRow]);
+  const hasHiddenRows =
+    collapsedRowLimit != null && collapsedRowLimit < totalVisibleLineCount;
+  const rowLimit = showAllRows ? undefined : collapsedRowLimit;
   const displayedRows =
     effectiveMode === "unified" && rowLimit ? rows.slice(0, rowLimit) : rows;
 
@@ -965,7 +967,7 @@ function DiffRead({
           ctx={ctx}
         />
       )}
-      {!unchanged && shouldLimitRows && (
+      {!unchanged && hasHiddenRows && (
         <button
           type="button"
           data-plan-interactive

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

@@ -8,6 +8,7 @@ type ReplayEvent = Record<string, unknown>;
 type QueuedReplayEvent = {
   json: string;
   timestampMs: number;
+  type: number | null;
 };
 type ReplayStopFn = () => void;
 export type SessionReplayUrlMatcher =
@@ -48,6 +49,7 @@ interface SessionReplayState {
   /** Pre-serialized + scrubbed event JSON strings, ready to splice at flush. */
   queue: QueuedReplayEvent[];
   queuedBytes: number;
+  retryBatches: QueuedReplayEvent[][];
   flushTimer: number | null;
   maxDurationTimer: number | null;
   flushing: boolean;
@@ -195,6 +197,7 @@ const DEFAULT_MAX_DURATION_MS = 30 * 60 * 1000;
 const DEFAULT_MAX_EVENTS_PER_BATCH = 50;
 const DEFAULT_MAX_BATCH_BYTES = 256 * 1024;
 const MAX_KEEPALIVE_REPLAY_UPLOAD_BYTES = 60 * 1024;
+const RRWEB_FULL_SNAPSHOT_EVENT_TYPE = 2;
 const URL_LIKE_KEYS = new Set([
   "url",
   "uri",
@@ -219,6 +222,7 @@ function getState(): SessionReplayState {
       sequence: 0,
       queue: [],
       queuedBytes: 0,
+      retryBatches: [],
       flushTimer: null,
       maxDurationTimer: null,
       flushing: false,
@@ -613,11 +617,10 @@ function enqueueReplayEvent(
   state.queue.push({
     json: serialized,
     timestampMs: replayEventTimestampMs(event),
+    type: typeof event.type === "number" ? event.type : null,
   });
   state.queuedBytes += estimatedBytes;
-  if (state.queue.length >= state.options.maxEventsPerBatch) {
-    void flushSessionReplay("max-events");
-  }
+  flushQueuedReplayIfNeeded(state);
 }
 
 function replayExtraProperties(
@@ -668,11 +671,18 @@ function replayPropertiesForUpload(
   return properties;
 }
 
+interface ReplayUploadPayload {
+  body: string;
+  replayId: string;
+  sessionId: string;
+  sequence: number;
+}
+
 function buildReplayBody(
   state: SessionReplayState,
   reason: string,
   events: QueuedReplayEvent[],
-): string | null {
+): ReplayUploadPayload | null {
   const options = state.options;
   if (!options || !state.replayId) return null;
   const sessionId = getAnalyticsSessionId();
@@ -713,19 +723,17 @@ function buildReplayBody(
     timestamp: new Date().toISOString(),
     properties,
   };
-  state.sequence += 1;
-  persistReplaySequence(
-    sessionId,
-    state.replayId,
-    state.startedAtMs,
-    state.sequence,
-  );
   // Events are already serialized+scrubbed JSON strings; splice them into the
   // envelope without re-serializing the (potentially large) events array.
   const envelopeJson = JSON.stringify(envelope);
-  return `${envelopeJson.slice(0, -1)},"events":[${events
-    .map((event) => event.json)
-    .join(",")}]}`;
+  return {
+    body: `${envelopeJson.slice(0, -1)},"events":[${events
+      .map((event) => event.json)
+      .join(",")}]}`,
+    replayId: state.replayId,
+    sessionId,
+    sequence: state.sequence,
+  };
 }
 
 interface ReplayUploadBody {
@@ -745,13 +753,6 @@ function isCrossOriginReplayEndpoint(endpoint: string): boolean {
   }
 }
 
-function replayUploadByteLength(body: string): number {
-  if (typeof TextEncoder !== "undefined") {
-    return new TextEncoder().encode(body).byteLength;
-  }
-  return body.length;
-}
-
 async function gzipReplayBody(body: string): Promise<Blob | null> {
   if (
     typeof CompressionStream === "undefined" ||
@@ -792,39 +793,68 @@ async function buildReplayUploadBody(body: string): Promise<ReplayUploadBody> {
   };
 }
 
+function replayUploadBodyBytes(body: BodyInit): number {
+  if (typeof body === "string") {
+    if (typeof TextEncoder !== "undefined") {
+      return new TextEncoder().encode(body).byteLength;
+    }
+    return body.length;
+  }
+  if (typeof Blob !== "undefined" && body instanceof Blob) {
+    return body.size;
+  }
+  if (body instanceof ArrayBuffer) {
+    return body.byteLength;
+  }
+  if (ArrayBuffer.isView(body)) {
+    return body.byteLength;
+  }
+  return MAX_KEEPALIVE_REPLAY_UPLOAD_BYTES + 1;
+}
+
+function canUseReplayKeepalive(body: BodyInit): boolean {
+  return replayUploadBodyBytes(body) <= MAX_KEEPALIVE_REPLAY_UPLOAD_BYTES;
+}
+
 async function sendReplayUpload(
   options: NormalizedSessionReplayOptions,
   body: string,
+  callbacks: { beforeKeepaliveUpload?: () => void } = {},
 ): Promise<void> {
   if (isCrossOriginReplayEndpoint(options.endpoint)) {
-    if (navigator.sendBeacon) {
-      const sent = navigator.sendBeacon(options.endpoint, body);
-      if (sent) return;
-    }
-    await fetch(options.endpoint, {
+    const canUseKeepalive = canUseReplayKeepalive(body);
+    if (canUseKeepalive) callbacks.beforeKeepaliveUpload?.();
+    const response = await fetch(options.endpoint, {
       method: "POST",
       body,
-      keepalive:
-        replayUploadByteLength(body) <= MAX_KEEPALIVE_REPLAY_UPLOAD_BYTES,
+      keepalive: canUseKeepalive,
       headers: { "Content-Type": "text/plain;charset=UTF-8" },
-    }).catch(() => {});
+    });
+    if (!response.ok) {
+      throw new Error(
+        `Session replay upload failed with HTTP ${response.status}`,
+      );
+    }
     return;
   }
 
   const upload = await buildReplayUploadBody(body);
-  if (!upload.compressed && navigator.sendBeacon) {
-    const sent = navigator.sendBeacon(options.endpoint, body);
-    if (sent) return;
-  }
-  await fetch(options.endpoint, {
+  const canUseKeepalive = canUseReplayKeepalive(upload.body);
+  if (canUseKeepalive) callbacks.beforeKeepaliveUpload?.();
+  const response = await fetch(options.endpoint, {
     method: "POST",
     body: upload.body,
-    keepalive: true,
+    keepalive: canUseKeepalive,
     headers: {
       ...upload.headers,
       "X-Agent-Native-Analytics-Key": options.publicKey,
     },
-  }).catch(() => {});
+  });
+  if (!response.ok) {
+    throw new Error(
+      `Session replay upload failed with HTTP ${response.status}`,
+    );
+  }
 }
 
 function isFinalFlushReason(reason: string): boolean {
@@ -838,26 +868,118 @@ function isFinalFlushReason(reason: string): boolean {
   ].includes(reason);
 }
 
+function shouldReserveSequenceBeforeKeepalive(reason: string): boolean {
+  return (
+    reason === "pagehide" ||
+    reason === "beforeunload" ||
+    reason === "visibility-hidden"
+  );
+}
+
+function hasFullSnapshot(events: QueuedReplayEvent[]): boolean {
+  return events.some((event) => event.type === RRWEB_FULL_SNAPSHOT_EVENT_TYPE);
+}
+
+function hasPendingReplayBatch(state: SessionReplayState): boolean {
+  return state.retryBatches.length > 0 || state.queue.length > 0;
+}
+
+function shouldFlushQueuedReplay(state: SessionReplayState): boolean {
+  if (!state.options || state.queue.length === 0) return false;
+  return (
+    hasFullSnapshot(state.queue) ||
+    state.queue.length >= state.options.maxEventsPerBatch ||
+    state.queuedBytes >= state.options.maxBatchBytes
+  );
+}
+
+function flushQueuedReplayIfNeeded(state: SessionReplayState): void {
+  const options = state.options;
+  if (!options) return;
+  if (state.retryBatches.length > 0) return;
+  if (!shouldFlushQueuedReplay(state)) return;
+  const reason = hasFullSnapshot(state.queue)
+    ? "full-snapshot"
+    : state.queue.length >= options.maxEventsPerBatch
+      ? "max-events"
+      : "max-bytes";
+  void flushSessionReplay(reason);
+}
+
+function queuedReplayBytes(events: QueuedReplayEvent[]): number {
+  return events.reduce((total, event) => total + event.json.length, 0);
+}
+
+function restoreReplayEvents(
+  state: SessionReplayState,
+  events: QueuedReplayEvent[],
+): void {
+  state.retryBatches.unshift(events);
+}
+
+function advanceReplaySequence(
+  state: SessionReplayState,
+  payload: ReplayUploadPayload,
+): void {
+  if (state.replayId !== payload.replayId) return;
+  state.sequence = Math.max(state.sequence, payload.sequence + 1);
+  persistReplaySequence(
+    payload.sessionId,
+    payload.replayId,
+    state.startedAtMs,
+    state.sequence,
+  );
+}
+
+function rollbackReplaySequenceReservation(
+  state: SessionReplayState,
+  payload: ReplayUploadPayload,
+): void {
+  if (state.replayId !== payload.replayId) return;
+  if (state.sequence !== payload.sequence + 1) return;
+  state.sequence = payload.sequence;
+  persistReplaySequence(
+    payload.sessionId,
+    payload.replayId,
+    state.startedAtMs,
+    state.sequence,
+  );
+}
+
 export async function flushSessionReplay(reason = "manual"): Promise<void> {
   const state = getState();
-  if (!state.options || state.queue.length === 0 || state.flushing) return;
-  const events = state.queue.splice(0, state.queue.length);
-  state.queuedBytes = 0;
-  const body = buildReplayBody(state, reason, events);
-  if (!body || !state.options) {
-    state.queue = events.concat(state.queue);
-    state.queuedBytes += events.reduce(
-      (total, event) => total + event.json.length,
-      0,
-    );
+  if (!state.options || !hasPendingReplayBatch(state) || state.flushing) return;
+  const events = state.retryBatches.shift() ?? state.queue.splice(0);
+  state.queuedBytes = queuedReplayBytes(state.queue);
+  const payload = buildReplayBody(state, reason, events);
+  if (!payload || !state.options) {
+    restoreReplayEvents(state, events);
     return;
   }
   state.flushing = true;
+  let uploaded = false;
+  let reservedSequence = false;
   try {
-    await sendReplayUpload(state.options, body);
+    await sendReplayUpload(state.options, payload.body, {
+      beforeKeepaliveUpload: shouldReserveSequenceBeforeKeepalive(reason)
+        ? () => {
+            advanceReplaySequence(state, payload);
+            reservedSequence = true;
+          }
+        : undefined,
+    });
+    if (!reservedSequence) advanceReplaySequence(state, payload);
+    uploaded = true;
+  } catch (error) {
+    if (reservedSequence) rollbackReplaySequenceReservation(state, payload);
+    restoreReplayEvents(state, events);
+    console.warn("[session-replay] upload failed", error);
   } finally {
     state.flushing = false;
   }
+  if (uploaded && hasPendingReplayBatch(state)) {
+    flushQueuedReplayIfNeeded(state);
+  }
 }
 
 function installUrlMonitor(state: SessionReplayState): void {
@@ -1002,6 +1124,7 @@ async function startSessionReplayRecorder(
   state.sequence = replaySession.sequence;
   state.queue = [];
   state.queuedBytes = 0;
+  state.retryBatches = [];
   state.stopRecorder = null;
   state.lastAuthenticatedProperties = replayUserEmail(initialProperties)
     ? { ...initialProperties }