@agent-native/core 0.84.49 → 0.84.52

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 }

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

@@ -151,11 +151,18 @@ export const SSE_ACTION_PREPARATION_STALL_TIMEOUT_MS = 90_000;
 export interface SSEStreamOptions {
   /**
    * Durable background runs have their own server-side liveness budget and
-   * heartbeat. While one is active, keepalive-only periods and zero-byte
-   * action-preparation activity should keep the client attached instead of
-   * aborting and starting duplicate continuations.
+   * heartbeat. While one is active, generic keepalive-only periods keep the
+   * client attached. Tool-input preparation is stricter: real byte progress
+   * keeps long payloads alive, but zero-byte/silent preparation still recovers
+   * so one stuck action cannot pin the chat forever.
    */
   durableBackgroundRun?: boolean;
+  /**
+   * Optional caller-owned preparation watchdog state. Passing the same object
+   * across reconnect reads keeps a stuck action preparation from getting a
+   * fresh stall budget every time the browser reattaches to the same run.
+   */
+  preparingActionState?: PreparingActionState;
 }
 
 type ActivityTrailEntry = AgentActivityTrailEntry;
@@ -176,8 +183,9 @@ type PreparingActionEntry = {
   lastProgressAt?: number;
 };
 
-type PreparingActionState = {
+export type PreparingActionState = {
   entries?: Map<string, PreparingActionEntry>;
+  toolEntries?: Map<string, PreparingActionEntry>;
 };
 
 function formatProgressBytes(bytes: number): string {
@@ -278,6 +286,24 @@ function findPendingToolCallIndex(
   return -1;
 }
 
+function findCompletedToolCallIndex(
+  content: ContentPart[],
+  toolCallId?: string,
+): number {
+  if (!toolCallId) return -1;
+  for (let i = content.length - 1; i >= 0; i--) {
+    const part = content[i];
+    if (
+      part.type === "tool-call" &&
+      part.toolCallId === toolCallId &&
+      part.result !== undefined
+    ) {
+      return i;
+    }
+  }
+  return -1;
+}
+
 function appendActivityTrail(
   trail: ActivityTrailEntry[],
   next: ActivityTrailEntry,
@@ -293,6 +319,37 @@ function appendActivityTrail(
   }
 }
 
+function refreshPreparingToolEntry(state: PreparingActionState, tool: string) {
+  const remainingEntries = [...(state.entries?.values() ?? [])].filter(
+    (entry) => entry.tool === tool,
+  );
+  if (remainingEntries.length === 0) {
+    state.toolEntries?.delete(tool);
+    return;
+  }
+  const deadlineBasis = (entry: PreparingActionEntry) =>
+    entry.lastProgressAt ?? entry.startedAt ?? Number.POSITIVE_INFINITY;
+  const oldestEntry = remainingEntries.reduce((oldest, entry) =>
+    deadlineBasis(entry) < deadlineBasis(oldest) ? entry : oldest,
+  );
+  const lastProgressBytes = remainingEntries.reduce<number | undefined>(
+    (max, entry) =>
+      entry.lastProgressBytes === undefined
+        ? max
+        : Math.max(max ?? 0, entry.lastProgressBytes),
+    undefined,
+  );
+  const toolEntries =
+    state.toolEntries ?? new Map<string, PreparingActionEntry>();
+  state.toolEntries = toolEntries;
+  toolEntries.set(tool, {
+    tool,
+    startedAt: oldestEntry.startedAt,
+    lastProgressAt: oldestEntry.lastProgressAt,
+    lastProgressBytes,
+  });
+}
+
 function updatePreparingActionState(
   state: PreparingActionState,
   ev: SSEEvent,
@@ -301,7 +358,8 @@ function updatePreparingActionState(
   if (ev.type === "activity" && isPreparingActionActivity(ev)) {
     const tool = ev.tool?.trim() || undefined;
     if (!tool) return false;
-    const key = ev.id?.trim() || tool;
+    const id = ev.id?.trim();
+    const key = id || tool;
     const entries = state.entries ?? new Map<string, PreparingActionEntry>();
     state.entries = entries;
     let entry = entries.get(key);
@@ -314,22 +372,35 @@ function updatePreparingActionState(
       };
       entries.set(key, entry);
     }
+    const toolEntries =
+      state.toolEntries ?? new Map<string, PreparingActionEntry>();
+    state.toolEntries = toolEntries;
+    let toolEntry = toolEntries.get(tool);
+    if (!toolEntry) {
+      toolEntry = {
+        tool,
+        startedAt: now,
+        lastProgressAt: undefined,
+        lastProgressBytes: undefined,
+      };
+      toolEntries.set(tool, toolEntry);
+    }
     const progressBytes = activityProgressBytes(ev);
     const previousBytes = entry.lastProgressBytes ?? 0;
+    let madeProgress = false;
     if (progressBytes !== undefined) {
       entry.lastProgressBytes = Math.max(previousBytes, progressBytes);
+      toolEntry.lastProgressBytes = Math.max(
+        toolEntry.lastProgressBytes ?? 0,
+        progressBytes,
+      );
+      madeProgress = id ? progressBytes > previousBytes : progressBytes > 0;
     }
-    if (!ev.id?.trim()) {
-      if (progressBytes !== undefined && progressBytes > 0) {
-        entry.lastProgressAt = now;
-        return true;
-      }
-      return false;
-    }
-    if (progressBytes !== undefined && progressBytes > previousBytes) {
+    if (madeProgress) {
       // A byte increase is proof the model is still streaming this action's
       // argument. Repeated zero-byte prep activity is only a heartbeat.
       entry.lastProgressAt = now;
+      toolEntry.lastProgressAt = now;
       return true;
     }
     return false;
@@ -348,29 +419,31 @@ function updatePreparingActionState(
       const tool = ev.tool?.trim();
       const id = ev.id?.trim();
       for (const [key, entry] of state.entries ?? []) {
-        if ((id && key === id) || (!id && entry.tool === tool)) {
+        if ((id && key === id) || (!id && tool && entry.tool === tool)) {
           state.entries?.delete(key);
         }
       }
+      if (tool) {
+        refreshPreparingToolEntry(state, tool);
+      }
     } else {
       state.entries?.clear();
+      state.toolEntries?.clear();
     }
   }
   return undefined;
 }
 
-function hasStalledPreparingAction(
-  state: PreparingActionState,
-  now: number,
-  options?: SSEStreamOptions,
-) {
-  if (options?.durableBackgroundRun === true) return false;
+function hasStalledPreparingAction(state: PreparingActionState, now: number) {
   // Fire only when a tool input has gone SILENT — no further streaming deltas
   // for the whole window — never merely because a large input has been
   // streaming for a long time. `lastProgressAt` advances on every delta
   // heartbeat, so an actively-streaming large output keeps resetting this and
   // survives; a genuinely stuck prep (keepalive-only, no deltas) trips it.
-  for (const entry of state.entries?.values() ?? []) {
+  for (const entry of [
+    ...(state.toolEntries?.values() ?? []),
+    ...(state.entries?.values() ?? []),
+  ]) {
     if (
       entry.startedAt !== undefined &&
       now - (entry.lastProgressAt ?? entry.startedAt) >=
@@ -787,6 +860,9 @@ export function processEvent(
   if (ev.type === "tool_start") {
     const args = (ev.input ?? {}) as Record<string, string>;
     const tool = ev.tool ?? "unknown";
+    if (findCompletedToolCallIndex(content, ev.id) >= 0) {
+      return { action: "continue" };
+    }
     if (typeof window !== "undefined") {
       window.dispatchEvent(
         new CustomEvent("agent-native:tool-start", {
@@ -868,6 +944,9 @@ export function processEvent(
     // so a tool_done frame with an undefined tool name still matches its
     // pending tool-call entry instead of leaving it forever unresolved.
     const doneTool = ev.tool ?? "unknown";
+    if (findCompletedToolCallIndex(content, ev.id) >= 0) {
+      return { action: "continue" };
+    }
     if (typeof window !== "undefined") {
       window.dispatchEvent(
         new CustomEvent("agent-native:tool-done", {
@@ -1219,7 +1298,8 @@ export async function* readSSEStream(
   let buf = "";
   let lastMeaningfulEventAt = Date.now();
   const activityTrail: ActivityTrailEntry[] = [];
-  const preparingActionState: PreparingActionState = {};
+  const preparingActionState: PreparingActionState =
+    options?.preparingActionState ?? {};
   const processEventState: ProcessEventState = {
     completedToolsAfterLastAssistantText: new Set(),
   };
@@ -1340,9 +1420,7 @@ export async function* readSSEStream(
         );
 
         if (result) yield withStreamMetadata(result);
-        if (
-          hasStalledPreparingAction(preparingActionState, Date.now(), options)
-        ) {
+        if (hasStalledPreparingAction(preparingActionState, Date.now())) {
           throw new AgentAutoContinueSignal({
             reason: "no_progress",
             activityTrail: [...activityTrail],
@@ -1413,7 +1491,8 @@ export async function readSSEStreamRaw(
   let buf = "";
   let lastMeaningfulEventAt = Date.now();
   const activityTrail: ActivityTrailEntry[] = [];
-  const preparingActionState: PreparingActionState = {};
+  const preparingActionState: PreparingActionState =
+    options?.preparingActionState ?? {};
   const processEventState: ProcessEventState = {
     completedToolsAfterLastAssistantText: new Set(),
   };
@@ -1525,9 +1604,7 @@ export async function readSSEStreamRaw(
               : { reason: "stream_ended", activityTrail: [...activityTrail] },
           );
         }
-        if (
-          hasStalledPreparingAction(preparingActionState, Date.now(), options)
-        ) {
+        if (hasStalledPreparingAction(preparingActionState, Date.now())) {
           onUpdate(contentSnapshot(content));
           throw new AgentAutoContinueSignal({
             reason: "no_progress",

package/corpus/templates/analytics/app/pages/sessions/SessionDetailPage.tsx

@@ -429,6 +429,11 @@ function ReplayPlayer({
       if (events.length < 2) {
         throw new Error(t("sessions.noReplayEvents"));
       }
+      if (
+        !events.some((event) => event.type === RRWEB_EVENT_TYPE.FullSnapshot)
+      ) {
+        throw new Error(t("sessions.noReplayEvents"));
+      }
       setStatus("loading");
       setError(null);
       await import("@rrweb/replay/dist/style.css");

package/corpus/templates/analytics/changelog/2026-07-02-agent-chat-can-keep-working-through-longer-data-queries-inst.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-02
+---
+
+Agent chat can keep working through longer data queries instead of stopping mid-action.

package/corpus/templates/analytics/changelog/2026-07-02-session-replay-playback-recovers-from-failed-snapshot-uploads.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-02
+---
+
+Session replay playback now preserves the initial page snapshot when an upload needs to retry.

package/corpus/templates/analytics/netlify.toml

@@ -9,11 +9,14 @@ GA_MEASUREMENT_ID = "G-ESF7FYXGN9"
 NITRO_PRESET = "netlify"
 NPM_CONFIG_PRODUCTION = "false"
 AGENT_PROD_CODE_EXECUTION = "sandboxed"
+AGENT_CHAT_DURABLE_BACKGROUND = "true"
 
 # A2A delegation calls run a full agent loop (LLM + tool calls + DB queries).
 # Hosted agent chat uses a soft timeout before this function timeout so the
 # hidden auto-continuation path can hand off before Netlify kills the function.
 # If AGENT_RUN_SOFT_TIMEOUT_MS is customized, keep it below this timeout.
+# Agent chat runs are dispatched to the emitted Netlify background function;
+# the normal server timeout still protects non-background HTTP handlers.
 [functions."*"]
 timeout = 75
 

package/corpus/templates/analytics/server/lib/session-replay.ts

@@ -152,7 +152,8 @@ const MAX_REPLAY_BLOB_REF_LENGTH = 16 * 1024;
 const MAX_REPLAY_METADATA_BYTES = 16 * 1024;
 const MAX_REPLAY_EVENTS_PER_CHUNK = 1_000;
 const MAX_REPLAY_EVENTS_READ = 10_000;
-const MAX_REPLAY_EVENTS_RESPONSE_BYTES = 2 * 1024 * 1024;
+const MAX_REPLAY_EVENTS_RESPONSE_BYTES =
+  MAX_BLOB_REPLAY_CHUNK_BYTES + 512 * 1024;
 const DEFAULT_SESSION_RECORDINGS_LIMIT = 50;
 const MAX_SESSION_RECORDINGS_LIMIT = 100;
 const DEFAULT_REPLAY_RETENTION_DAYS = 30;
@@ -550,6 +551,12 @@ async function storeReplayChunkBlob(
         503,
       );
     }
+    if (chunk.byteLength > MAX_INLINE_REPLAY_CHUNK_BYTES) {
+      throw replayError(
+        "Session replay chunk is too large for inline SQL fallback. Configure private blob storage for full snapshot playback.",
+        503,
+      );
+    }
     warnInlineReplayFallback();
     return chunk;
   }
@@ -590,10 +597,7 @@ function normalizeReplayChunk(rawValue: unknown): NormalizedSessionReplayChunk {
     storageKind === "inline"
       ? Buffer.byteLength(inlineData ?? "", "utf8")
       : (replayInteger(raw.byteLength ?? raw.bytes) ?? 0);
-  const maxBytes =
-    storageKind === "inline"
-      ? MAX_INLINE_REPLAY_CHUNK_BYTES
-      : MAX_BLOB_REPLAY_CHUNK_BYTES;
+  const maxBytes = MAX_BLOB_REPLAY_CHUNK_BYTES;
   if (byteLength <= 0 || byteLength > maxBytes) {
     throw replayError(
       `Replay ${storageKind} chunks must be between 1 and ${maxBytes} bytes`,

package/corpus/templates/analytics/server/plugins/agent-chat.ts

@@ -28,6 +28,7 @@ import {
 } from "../lib/scoped-settings";
 
 const DATA_DICT_PREFIX = "data-dict-";
+const ANALYTICS_BACKGROUND_RUN_SOFT_TIMEOUT_MS = 13 * 60_000;
 
 const INITIAL_TOOL_NAMES = [
   "view-screen",
@@ -170,6 +171,8 @@ export default createAgentChatPlugin({
   // Operators deploying to trusted internal environments can set
   // AGENT_PROD_CODE_EXECUTION=trusted to also enable bash/read/edit/write.
   codeExecution: { production: "sandboxed" },
+  durableBackgroundRuns: true,
+  runSoftTimeoutMs: ANALYTICS_BACKGROUND_RUN_SOFT_TIMEOUT_MS,
   resolveOrgId: async (event) => {
     const ctx = await getOrgContext(event);
     return ctx.orgId;

package/corpus/templates/plan/changelog/2026-07-02-agent-chat-can-keep-working-through-longer-visual-plan-updat.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-02
+---
+
+Agent chat can keep working through longer visual plan updates instead of stopping mid-action.

package/corpus/templates/plan/netlify.toml

@@ -8,8 +8,11 @@ functions = "templates/plan/.netlify/functions-internal"
 GA_MEASUREMENT_ID = "G-ESF7FYXGN9"
 NITRO_PRESET = "netlify"
 NPM_CONFIG_PRODUCTION = "false"
+AGENT_CHAT_DURABLE_BACKGROUND = "true"
 
 # A2A/MCP calls may include plan generation, artifact serialization, and
 # feedback polling. Keep this aligned with other agent-heavy hosted templates.
+# Agent chat runs are dispatched to the emitted Netlify background function;
+# the normal server timeout still protects non-background HTTP handlers.
 [functions."*"]
 timeout = 75