fix: serialize reconnect resume re-probes (parity with agents 0.17.2, #1837)

The socket "open" handler no longer issues a resumeStream() re-probe while one is still in flight (reconnect storm), preventing the AI SDK's shared activeResponse from being overwritten and cleared out from under an earlier resume's finalizer (which then read undefined and threw). Gate on an in-flight flag plus a generation counter so teardown invalidates an orphaned late finalizer. Hook-only; no public API or peer-floor change.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01G4vL8mATMNDHcvGP2yoJ5c

Author: ymansurozer

README.md

@@ -165,6 +165,7 @@ const transport = new WebSocketChatTransport({
 | `cancelOnClientAbort` (local-only abort, default) | ✅ |
 | Pre-stream `cf_agent_stream_pending` (extended resume probe) | ✅ |
 | `connectionError` (terminal WebSocket close) | ✅ |
+| Reconnect resume serialization (in-flight gate, `agents` 0.17.2 / #1837) | ✅ |
 | `useAgent` connection hook | 🚧 roadmap |
 | Initial-message HTTP cache | 🚧 roadmap |
 | `isServerStreaming` / `isStreaming` flags | 🚧 roadmap |
@@ -174,7 +175,7 @@ const transport = new WebSocketChatTransport({
 ```bash
 pnpm install
 pnpm exec playwright install chromium
-pnpm test       # 79 tests in chromium (vitest-browser-vue)
+pnpm test       # 80 tests in chromium (vitest-browser-vue)
 pnpm typecheck
 pnpm lint
 pnpm build

src/tests/use-agent-chat.test.ts

@@ -1064,6 +1064,44 @@ describe("useAgentChat — resume fallback dedupe", () => {
   });
 });
 
+// ── reconnect resume serialization (#1837) ──────────────────────
+//
+// Upstream agents 0.17.2 (#1837): the AI SDK's Chat.makeRequest shares one mutable
+// activeResponse with no concurrency guard, so overlapping resume re-probes during a
+// reconnect storm crash the first resume's finalizer. The open handler must serialize
+// resumes — never issue a second resumeStream() while one is still in flight — and
+// reopen the gate once the in-flight resume settles.
+
+describe("useAgentChat — reconnect resume serialization (#1837)", () => {
+  it("suppresses a second resume re-probe while one is in flight, then resumes again after it settles", async () => {
+    const { chat, client, unmount } = mountChat({ onError: () => {} });
+
+    // Keep the first re-probe pending so the in-flight gate stays closed, and observe
+    // how many resumeStream() calls the open handler issues.
+    let settleResume!: () => void;
+    const inFlight = new Promise<void>((resolve) => {
+      settleResume = resolve;
+    });
+    const resumeStream = vi.spyOn(chat.chat, "resumeStream").mockImplementation(() => inFlight);
+
+    // Reconnect storm: two socket opens in succession while the first resume is pending.
+    client.emit("open", new Event("open"));
+    client.emit("open", new Event("open"));
+
+    // Only the first open re-probes; the second is suppressed by the in-flight gate.
+    expect(resumeStream).toHaveBeenCalledTimes(1);
+
+    // Once the in-flight resume settles, the gate reopens and a later open resumes again.
+    settleResume();
+    await tick();
+    client.emit("open", new Event("open"));
+    expect(resumeStream).toHaveBeenCalledTimes(2);
+
+    resumeStream.mockRestore();
+    unmount();
+  });
+});
+
 // ── isRecovering (0.8.0) ────────────────────────────────────────
 
 describe("useAgentChat — isRecovering", () => {

src/use-agent-chat.ts

@@ -265,6 +265,13 @@ export function useAgentChat<AgentT = unknown, ChatMessage extends UIMessage = U
   const fallbackAckedResumeRequestIds = new Set<string>();
   let streamState: BroadcastStreamState = { status: "idle" };
   let isResumingToolContinuation = false;
+  // Serialize reconnect resume re-probes (#1837, upstream agents 0.17.2). The AI SDK's
+  // Chat.makeRequest shares one mutable activeResponse with no concurrency guard, so a
+  // second resumeStream() issued while the first is still in flight (reconnect storm)
+  // overwrites+clears it before the first finalizer runs → a crash. Gate on an in-flight
+  // flag; a generation counter lets teardown invalidate an orphaned late finalizer.
+  let resumeInFlight = false;
+  let resumeGeneration = 0;
 
   /** True while the server is recovering a durable chat turn (distinct from streaming). */
   const isRecovering = ref(false);
@@ -538,8 +545,23 @@ export function useAgentChat<AgentT = unknown, ChatMessage extends UIMessage = U
     // A successful (re)connection clears any prior terminal connection error.
     connectionError.value = null;
     options.onOpen?.(event);
-    if (options.resume !== false) {
-      void chat.resumeStream();
+    // Re-probe the stream on open, but never overlap resume calls (#1837): skip if a
+    // resume is already in flight, a tool continuation is resuming, or the transport is
+    // mid resume-handshake. The gate is cleared by the in-flight resume's own finalizer.
+    if (options.resume !== false && !resumeInFlight && !isResumingToolContinuation && !transport.isAwaitingResume()) {
+      resumeInFlight = true;
+      const myGeneration = resumeGeneration;
+      void chat
+        .resumeStream()
+        .catch(() => {})
+        .finally(() => {
+          // A teardown between issue and settle bumps the generation; ignore that stale
+          // finalizer so it can't reopen the gate on a disposed instance.
+          if (resumeGeneration !== myGeneration) {
+            return;
+          }
+          resumeInFlight = false;
+        });
     }
   });
   socket.addEventListener("close", (event: Event) => {
@@ -560,6 +582,10 @@ export function useAgentChat<AgentT = unknown, ChatMessage extends UIMessage = U
   onScopeDispose(() => {
     fallbackAckedResumeRequestIds.clear();
     isRecovering.value = false;
+    // Force the resume gate open and bump the generation so any orphaned in-flight
+    // resume's late finalizer is ignored rather than reopening the gate (#1837).
+    resumeGeneration++;
+    resumeInFlight = false;
     socket.close();
   });