@coder/ai-sdk-agent 0.6.3 → 0.7.1

package/README.md

@@ -324,19 +324,19 @@ for (const ev of events) {
 `timestamp` (`Date.now()` at observation — comparable to server‑side timestamps
 such as a message's `created_at`, for delivery‑lag measurements):
 
-| event            | when                                                | payload (besides `timestamp`)                                                                                                                                                                         |
-| ---------------- | --------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `http:request`   | a REST request is sent                              | `id` (correlates the pair), `method`, `path`                                                                                                                                                          |
-| `http:response`  | response headers arrive (incl. non‑2xx, `ok:false`) | `id`, `method`, `path`, `status`, `ok`, `durationMs`                                                                                                                                                  |
-| `http:error`     | the fetch itself rejects (network failure, abort)   | `id`, `method`, `path`, `message`, `durationMs`                                                                                                                                                       |
-| `ws:dial`        | a stream connection attempt starts                  | `chatId`, `attempt` (1‑based, increments per redial), `url`                                                                                                                                           |
-| `ws:open`        | the WebSocket handshake completes                   | `chatId`, `attempt`                                                                                                                                                                                   |
-| `ws:event`       | a decoded stream event arrives                      | `chatId`, `attempt`, `event` (the decoded `ChatStreamEvent`, by reference — don't mutate)                                                                                                             |
-| `ws:close`       | the connection ends (exactly one per dial)          | `chatId`, `attempt`, `code`/`reason` when the server/network closed it; absent when the reader closed it (settle, teardown, redial)                                                                   |
-| `ws:error`       | a socket error or unparseable frame                 | `chatId`, `attempt`, `message`                                                                                                                                                                        |
-| `ws:redial`      | a dropped connection is about to be redialed        | `chatId`, `attempt` (the ended connection), `consecutiveFailures`, `maxConsecutiveFailures`, `backoffMs`                                                                                              |
-| `segment:start`  | a turn segment (one model round‑trip) starts        | `segment` (1‑based per model instance), `chatId` (absent before the first turn creates the chat)                                                                                                      |
-| `segment:settle` | the segment ends (exactly one per start)            | `segment`, `chatId`, `durationMs`, and: `status` + `finishReason` on a clean settle, `error` (`{name, message}`, plus `status` if the run still settled terminally) on failure, neither on a teardown |
+| event            | when                                                | payload (besides `timestamp`)                                                                                                                                                                                                                                                     |
+| ---------------- | --------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `http:request`   | a REST request is sent                              | `id` (correlates the pair), `method`, `path`                                                                                                                                                                                                                                      |
+| `http:response`  | response headers arrive (incl. non‑2xx, `ok:false`) | `id`, `method`, `path`, `status`, `ok`, `durationMs`                                                                                                                                                                                                                              |
+| `http:error`     | the fetch itself rejects (network failure, abort)   | `id`, `method`, `path`, `message`, `durationMs`                                                                                                                                                                                                                                   |
+| `ws:dial`        | a stream connection attempt starts                  | `chatId`, `reader` (identifies the `streamChatEvents` call), `attempt` (1‑based per reader, increments per redial), `url`                                                                                                                                                         |
+| `ws:open`        | the WebSocket handshake completes                   | `chatId`, `reader`, `attempt`                                                                                                                                                                                                                                                     |
+| `ws:event`       | a decoded stream event arrives                      | `chatId`, `reader`, `attempt`, `event` (the decoded `ChatStreamEvent`, by reference — don't mutate)                                                                                                                                                                               |
+| `ws:close`       | the connection ends (exactly one per dial)          | `chatId`, `reader`, `attempt`, `code`/`reason` when the server/network closed it; absent when the reader closed it (settle, teardown, redial)                                                                                                                                     |
+| `ws:error`       | a socket error or unparseable frame                 | `chatId`, `reader`, `attempt`, `message`                                                                                                                                                                                                                                          |
+| `ws:redial`      | a dropped connection is about to be redialed        | `chatId`, `reader`, `attempt` (the ended connection), `consecutiveFailures`, `maxConsecutiveFailures`, `backoffMs`                                                                                                                                                                |
+| `segment:start`  | a turn segment (one model round‑trip) starts        | `segment` (1‑based per model instance), `chatId` (absent before the first turn creates the chat)                                                                                                                                                                                  |
+| `segment:settle` | the segment ends (exactly one per start)            | `segment`, `chatId`, `reader` (the reader that served the segment; absent if none was acquired), `durationMs`, and: `status` + `finishReason` on a clean settle, `error` (`{name, message}`, plus `status` if the run still settled terminally) on failure, neither on a teardown |
 
 Semantics worth knowing:
 
@@ -348,8 +348,18 @@ Semantics worth knowing:
   `Coder-Session-Token` header, which is deliberately excluded); `path`/`url`
   never contain credentials.
 - `ws:event` fires at arrival, **before** replay dedup: after a redial, chatd's
-  replay of the in‑progress episode is visible here (correlate with `attempt`)
+  replay of the in‑progress episode is visible here (correlate with `reader`/`attempt`)
   even though the reader suppresses the duplicates it forwards to the turn.
+- Every `ws:*` event carries `reader` — a monotonic id for the
+  `streamChatEvents` call (reader) behind the connection, allocated from one
+  process‑wide counter so it stays unique across model and client instances.
+  `attempt` restarts at 1 per reader, so identify a connection as
+  `(chatId, reader, attempt)`, never `(chatId, attempt)` alone: a client‑tool
+  pause the caller abandons is closed fire‑and‑forget when the next turn dials
+  its replacement, and the superseded reader's late `ws:close` (or a raced‑in
+  frame) can emit after the new reader's `ws:dial` — the reader id is what
+  tells them apart. `segment:settle` names the reader that served the segment;
+  `segment:start` predates stream acquisition and carries none.
 - A multi‑step turn that drives client tools emits one `segment:start`/
   `segment:settle` pair per round‑trip, all riding **one** `ws:dial`ed
   connection — the stream is retained across `requires_action` pauses. A pause
@@ -1118,15 +1128,31 @@ checkpoint:
   // to interrupting — and journals each action write-ahead, so a recovery
   // pass that dies mid-recovery is visible — and classifiable — to the next.
   declare function reconcileClientTools(): Promise<boolean>;
-  // Entries are per-ATTEMPT: clear/supersede them transactionally with
-  // recording the attempt's result, or a stale verdict misclassifies the
-  // next attempt on this chat — attempt-scoped journal keys close the
-  // remaining double-crash window (see
-  // https://github.com/coder/ai-sdk/issues/92).
+  // Journal entries are per-ATTEMPT, so the chat id alone cannot scope them:
+  // a verdict from attempt N must not classify attempt N+1 (double crash),
+  // and a later step's recovery on the same chat must not inherit this
+  // one's. Every entry pins the step marker and an attempt count at write
+  // time; a consult applies an entry only while both still match, so each
+  // resubmission retires every earlier verdict by itself — there is no
+  // clear step to forget.
+  type JournalEntry = {
+    // "submitting" is written ahead of every send on a checkpointed chat;
+    // "resumed" / "cut-short" are the ledger reconcile's verdict (both in
+    // the next sections).
+    state: "submitting" | "resumed" | "cut-short";
+    marker: string; // the step-scoped marker ("Recover the result…", below)
+    attempt: number; // markerAttempts() at write time
+    at: number; // write time — bounds the in-flight-send wait below
+  };
   declare const journal: {
-    get(chatId: string): Promise<"resumed" | "cut-short" | undefined>;
-    set(chatId: string, state: "resumed" | "cut-short"): Promise<void>;
+    get(chatId: string): Promise<JournalEntry | undefined>;
+    set(chatId: string, entry: JournalEntry): Promise<void>;
   };
+  // This step's attempts committed so far: user messages in the converted
+  // transcript carrying the marker. Steps run sequentially, so they sit
+  // contiguous at the tail of history — page newest-first (as the recovery
+  // scan below already does) and stop at the first user message without it.
+  declare function markerAttempts(): Promise<number>;
 
   // Bounded: a stalled deployment must fail the step, not hang it.
   const deadline = AbortSignal.timeout(15_000);
@@ -1134,7 +1160,11 @@ checkpoint:
   // below: a 409 means there was nothing to stop.
   let cutShort = true;
   let { status } = await agent.client.getChat(agent.chatId!, deadline);
-  const journaled = await journal.get(agent.chatId!);
+  // Recompute what the entry pinned at write time; a mismatch on either
+  // means it classifies an earlier attempt (or another step's) — dead, skip.
+  const entry = await journal.get(agent.chatId!);
+  const attempts = await markerAttempts();
+  const journaled = entry?.marker === marker && entry.attempt === attempts ? entry : undefined;
   if (status === "requires_action") {
     // The crash hit a client tool mid-execution: this pause is the only
     // pending record of its committed effects. Never interrupt it away —
@@ -1142,8 +1172,8 @@ checkpoint:
     // (reviving the run — nothing was cut short) or interrupts itself only
     // when nothing committed.
     cutShort = await reconcileClientTools();
-  } else if (journaled) {
-    // A previous recovery pass acted on this chat, then died before the
+  } else if (journaled && journaled.state !== "submitting") {
+    // A previous recovery pass acted on this attempt, then died before the
     // step's result was recorded. Its journaled state is the verdict:
     // "resumed" — it revived the run by submitting recorded results;
     // interrupting now would cut down a run doing the step's work, and the
@@ -1151,7 +1181,7 @@ checkpoint:
     // idempotency keys. Let it finish; nothing was cut short.
     // "cut-short" — it went on to interrupt (an unstarted sibling in the
     // batch); the attempt is truncated, so the check below must resubmit.
-    cutShort = journaled === "cut-short";
+    cutShort = journaled.state === "cut-short";
     if (cutShort) {
       // The journal records write-ahead INTENT, not a landed interrupt: the
       // pass may have died in between, leaving the revived run working.
@@ -1172,6 +1202,24 @@ checkpoint:
       else throw err;
     });
   }
+  // One thing can still be in flight here: the crashed attempt's own SEND. A
+  // matching "submitting" entry — its attempt count has not grown — means the
+  // process died with `createChatMessage` possibly en route, and the server
+  // can commit it AFTER every read above (the 409 only said nothing was
+  // running THEN). Sleep out what remains of the entry's commit window —
+  // requestTimeoutMs past the write is the conservative horizon, and a
+  // restart has usually consumed it already — so a late-landing turn starts
+  // before the settle poll below and the next section's negative history
+  // read is past the window. Then recount: a send that never landed OVER AN
+  // EXISTING attempt pins cutShort — the step only ever plans a resubmission
+  // over a cut-short, errored, or unsubmitted attempt, so the write-ahead
+  // that superseded a "cut-short" verdict still carries its consequence, and
+  // the scan below cannot mistake the old attempt's truncated tail for a
+  // finished result.
+  if (journaled?.state === "submitting") {
+    await new Promise((r) => setTimeout(r, Math.max(0, journaled.at + 300_000 - Date.now())));
+    if ((await markerAttempts()) === journaled.attempt && journaled.attempt > 0) cutShort = true;
+  }
   // The 15 s interrupt bound must not cap what follows: a reconciled pause
   // revives a full model/tool continuation. Budget the settle poll — and the
   // history reads after it — on the turn scale, like the step itself.
@@ -1266,7 +1314,8 @@ event — and the ledger holds the verdict on each:
 // The step's configured ToolSet names: history does not record which calls
 // were client tools (see [Rehydrating chat history]), so — like the SDK's
 // own derivation — restrict to the names this step registers; a server/MCP
-// call must never reach the ledger as "unstarted".
+// call must never reach the ledger as "unstarted". (The recovery scan's
+// final-text cut reuses this set — next section.)
 const clientTools = new Set(["charge_card"]);
 
 // Pending = the last assistant message's client (non-provider-executed,
@@ -1321,9 +1370,14 @@ if (results.length > 0 || unstarted) {
   // call — a mixed batch journals "cut-short" before even its submission,
   // so no crash point can leave a stale "resumed" masking the pending
   // interrupt. Every crash then either re-reconciles the stable pause or
-  // re-drives the journaled intent. Clear the entry only once the step's
-  // result is finally recorded.
-  await journal.set(agent.chatId!, unstarted ? "cut-short" : "resumed");
+  // re-drives the journaled intent. Scoped to THIS attempt: a resubmission
+  // grows the marker count and retires the verdict on its own.
+  await journal.set(agent.chatId!, {
+    state: unstarted ? "cut-short" : "resumed",
+    marker,
+    attempt: await markerAttempts(),
+    at: Date.now(),
+  });
 }
 if (results.length > 0) await agent.client.submitToolResults(agent.chatId!, { results }, deadline);
 if (unstarted) await agent.client.interruptChat(agent.chatId!, deadline);
@@ -1358,11 +1412,29 @@ step's return value was recorded.** History now holds a perfectly good
 result; a retried step that blindly resubmits runs the whole turn again —
 duplicated output, repeated workspace/MCP/tool effects. This is the
 at‑least‑once boundary every durable engine has around external effects, and
-the chat itself is the record that closes it. Make attempts matchable first —
-the server stores the prompt verbatim, so embed a step‑scoped marker:
+the chat itself is the record that narrows it to one honest window (below).
+Make attempts matchable first — the server stores the prompt verbatim, so
+embed a step‑scoped marker — and journal every send before it leaves the
+process:
 
 ```ts
 const marker = `[${workflowId}/step-2]`; // stable across this step's retries
+// Write-ahead, BEFORE the send — first attempt and recovery resubmit alike.
+// A crash before this write proves no send ever started; a crash after it
+// leaves a dated entry whose commit window the settle-wait sleeps out. On a
+// resubmission this write supersedes the "cut-short" verdict it acts on —
+// safely: an unlanded send over an existing attempt makes the settle-wait
+// pin cutShort right back. A first turn has no chat id to journal under: its
+// send-crash window belongs to the empty-checkpoint sweep
+// ("Recover after a crash").
+if (agent.chatId) {
+  await journal.set(agent.chatId, {
+    state: "submitting",
+    marker,
+    attempt: await markerAttempts(),
+    at: Date.now(),
+  });
+}
 const { text } = await agent.generate({ prompt: `${marker} ${prompt}` });
 ```
 
@@ -1391,25 +1463,27 @@ const submitted = lastUser?.parts.some((p) => p.type === "text" && p.text.includ
 
 if (submitted && !cutShort && (status === "waiting" || status === "completed")) {
   // The attempt finished; only the recording was lost. Recover what
-  // `generate().text` would have returned — the FINAL step's text. A turn
-  // that crossed tool calls commits narration between them too, so cut the
-  // turn's parts after the last tool part and join the text that follows.
+  // `generate().text` would have returned — the FINAL step's text. Only a
+  // CLIENT tool ends an AI SDK step, and narration lands on both sides of a
+  // server-side call, so cut after the last part named in `clientTools`
+  // (shared with the reconcile above) and join the text that follows.
   const parts = transcript
     .slice(transcript.indexOf(lastUser!) + 1)
     .filter((m) => m.role === "assistant")
     .flatMap((m) => m.parts);
   return parts
-    .slice(parts.findLastIndex((p) => p.type === "dynamic-tool") + 1)
+    .slice(parts.findLastIndex((p) => p.type === "dynamic-tool" && clientTools.has(p.toolName)) + 1)
     .filter((p) => p.type === "text")
     .map((p) => p.text)
     .join("");
 }
 // Resubmit only what never finished: the prompt never reached the server
-// (!submitted), the turn failed (status "error" — normal retry judgment
-// applies), or the interrupt cut a live run short (cutShort — the model sees
-// its own aborted attempt in history and continues from it). One exit is
-// neither: a requires_action settle goes back to ledger reconciliation
-// (previous section) — never to recovery or resubmission.
+// (!submitted — sound only behind the write-ahead; see below), the turn
+// failed (status "error" — normal retry judgment applies), or the interrupt
+// cut a live run short (cutShort — the model sees its own aborted attempt in
+// history and continues from it). One exit is neither: a requires_action
+// settle goes back to ledger reconciliation (previous section) — never to
+// recovery or resubmission.
 ```
 
 - **`cutShort` is the completed/interrupted discriminator — but a 409 only
@@ -1421,22 +1495,39 @@ if (submitted && !cutShort && (status === "waiting" || status === "completed"))
   hard crash, false after a `requestTimeoutMs` expiry — the expiry already
   fired the SDK's own best‑effort interrupt, which may have stopped the run
   before recovery ever looked. Carry the reason recovery ran: when it follows
-  a known timeout or abort — or a journaled earlier interrupt (write‑ahead,
-  like the tool ledger, if the recovery pass can itself crash between its
-  interrupt and the resubmit) — pin `cutShort` to `true` and let only the
-  hard‑crash path trust the 409.
-- **The cut lands after the last tool part of _either_ kind.** History does
-  not mark which tool calls were client tools
-  ([Rehydrating chat history](#rehydrating-chat-history)), so when a final
-  step narrates _before_ a server‑side tool call, that preamble is dropped
-  too — the recovered text is the answer following the turn's last tool
-  activity.
+  a known timeout or abort — or a matching journaled `"cut-short"`, or an
+  unlanded `"submitting"` over an existing attempt (the settle‑wait already
+  pins both) — pin `cutShort` to `true` and let only the hard‑crash path
+  trust the 409.
+- **`!submitted` races the crashed attempt's own send.** A crash kills the
+  process, not necessarily its in‑flight `createChatMessage` — the server can
+  commit that request _after_ an interrupt 409'd and a history read saw no
+  marker, and a resubmit on that evidence queues the turn twice, duplicating
+  its workspace/MCP/tool effects. The write‑ahead is what makes the negative
+  read honest: no matching `"submitting"` entry proves no send ever started,
+  and a matching one held recovery at the settle‑wait until the entry's
+  commit horizon passed. That narrows the window; only server‑enforced
+  submission idempotency could close it, and `POST /chats/{id}/messages`
+  offers none today. A commit that outlasts even the horizon still lands
+  under the same marker, so the duplicate is at least visible — in history,
+  and to the next consult's attempt count.
+- **The cut lands at the last _configured client‑tool_ boundary.** History
+  does not mark which calls were client tools
+  ([Rehydrating chat history](#rehydrating-chat-history)), so the cut
+  classifies by name against the reconcile's `clientTools` set — narration
+  before a trailing _server‑side_ call survives, matching what
+  `generate().text` aggregates. What name‑matching cannot see: a call
+  recorded under a name the step no longer configures (a tool renamed
+  between deploys) reads as server‑side and leaks earlier‑step narration
+  into the result, and a server tool sharing a configured name still cuts
+  final‑step narration away.
 - **Steps with structured results recover the call's input, not the text.**
   A [structured output](#structured-output) step's answer is the
   `structured_output` call's typed input, which rehydrates as a
   `dynamic-tool` part on the recovered turn
-  ([Rehydrating chat history](#rehydrating-chat-history)) — the text join
-  above would slice it away and return only the ack prose that follows.
+  ([Rehydrating chat history](#rehydrating-chat-history)) — and
+  `structured_output` is one of the step's configured client tools, so the
+  text join above cuts at it and returns only the ack prose that follows.
   Recover the filed call instead — this scan replaces the text join
   _inside_ the recovery branch above, reusing its `parts` — validated
   client‑side exactly like the live path (rule 2 there — the schema is the
@@ -1566,7 +1657,8 @@ export async function archiveWorkflowChat(workflowId: string): Promise<void> {
 - Let redials self‑heal; own every retry decision — a re‑run step resubmits
   its prompt as a new user turn.
 - Before resubmitting after a crash: reconcile the tool ledger before any
-  interrupt, and recover a finished attempt's result from history.
+  interrupt, recover a finished attempt's result from history, and trust
+  "never submitted" only past the journaled send's commit window.
 - Keep concurrent steps' fan‑out within workspace quota —
   [Workspaces & quota](#workspaces--quota).
 - Steps that don't need server‑side tools (plan / extract / synthesize) are

package/dist/index.d.ts

@@ -382,9 +382,24 @@ interface HttpErrorTransportEvent extends HttpTransportEventBase {
 }
 interface StreamTransportEventBase extends TransportEventBase {
     chatId: string;
+    /**
+     * Identifies the reader (one `streamChatEvents` call) this event belongs
+     * to: monotonically increasing, allocated per call from one module-global
+     * (process-wide) counter — NOT per model or client instance, so
+     * `(chatId, reader, attempt)` stays unique for the lifetime of any
+     * subscriber, even one shared across instances (issue #94). Readers on
+     * other chats/clients advance the same counter, so ids are ordered but not
+     * dense per chat. Use it to tell a superseded reader's late events apart
+     * from the live reader's: a client-tool pause abandoned by the caller is
+     * closed fire-and-forget when the next turn dials its replacement, and the
+     * old reader's `ws:close` (or a raced-in frame) can emit after the new
+     * reader's `ws:dial` — both would otherwise be ambiguous at `attempt` 1.
+     */
+    reader: number;
     /**
      * 1-based connection attempt within one reader (`streamChatEvents` call —
-     * with stream retention (#44), one per turn). Increments on every redial.
+     * with stream retention (#44), one per turn). Increments on every redial
+     * and restarts at 1 for each new reader.
      */
     attempt: number;
 }
@@ -446,6 +461,17 @@ interface SegmentTransportEventBase extends TransportEventBase {
     segment: number;
     /** Undefined on a first turn's start until the chat is created. */
     chatId?: string;
+    /**
+     * The reader (`streamChatEvents` call — the `reader` on `ws:*` events) that
+     * served this segment, correlating it with the connection's `ws:*` events.
+     * Absent on `segment:start`, which is emitted before the segment acquires
+     * its stream (a fresh turn dials only once the chat exists, and even a
+     * stream retained by a client-tool pause can still be replaced — stamping a
+     * predicted reader could lie), and on a settle when the segment failed
+     * before acquiring one. Segments of one turn share the reader: the stream
+     * is retained across `requires_action` pauses (#44).
+     */
+    reader?: number;
 }
 /**
  * A segment (one model round-trip: submission plus the server run until it
@@ -531,6 +557,13 @@ interface StreamChatEventsOptions {
      * listeners are registered. See {@link CoderTransportEvent}.
      */
     onTransportEvent?: TransportEventHandler;
+    /**
+     * Reader id stamped on this call's `ws:*` events, for callers that need to
+     * know it (the model records it to stamp `segment:settle` with the reader
+     * that served the segment). Must come from {@link nextStreamReaderId};
+     * allocated automatically when absent.
+     */
+    reader?: number;
 }
 /**
  * Opens the chatd `/stream` WebSocket and yields decoded {@link ChatStreamEvent}s
@@ -678,6 +711,8 @@ declare class CoderChatClient {
     streamEvents(chatId: string, opts?: {
         afterId?: number;
         signal?: AbortSignal;
+        /** Pre-allocated reader id for `ws:*` events — see {@link streamChatEvents}. */
+        reader?: number;
     }): AsyncGenerator<ChatStreamEvent, void, void>;
     /**
      * Watch lifecycle events (status/title changes, creation, deletion, …) for

package/dist/index.js

@@ -185,6 +185,11 @@ function httpToWs(baseUrl) {
   if (baseUrl.startsWith("http://")) return `ws://${baseUrl.slice("http://".length)}`;
   return baseUrl;
 }
+var readerSeq = 0;
+function nextStreamReaderId() {
+  readerSeq += 1;
+  return readerSeq;
+}
 var STREAM_BACKOFF_INITIAL_MS = 1e3;
 var STREAM_BACKOFF_CAP_MS = 3e4;
 var STREAM_MAX_CONSECUTIVE_FAILURES = 5;
@@ -197,7 +202,8 @@ function streamChatEvents(options) {
     if (external.aborted) chain();
     else external.addEventListener("abort", chain, { once: true });
   }
-  const inner = streamChatEventsLoop({ ...options, signal: controller.signal });
+  const reader = options.reader ?? nextStreamReaderId();
+  const inner = streamChatEventsLoop({ ...options, reader, signal: controller.signal });
   const detach = () => external?.removeEventListener("abort", chain);
   const finish = async () => {
     controller.abort();
@@ -240,7 +246,7 @@ function streamChatEvents(options) {
   };
 }
 async function* streamChatEventsLoop(options) {
-  const { baseUrl, token, chatId, signal } = options;
+  const { baseUrl, token, chatId, signal, reader } = options;
   const factory = options.webSocketFactory ?? defaultFactory;
   const emit = safeTransportEmitter(options.onTransportEvent);
   let attempt = 0;
@@ -269,15 +275,15 @@ async function* streamChatEventsLoop(options) {
       resolveNext = void 0;
     };
     attempt += 1;
-    emit?.({ type: "ws:dial", chatId, attempt, url, timestamp: Date.now() });
+    emit?.({ type: "ws:dial", chatId, reader, attempt, url, timestamp: Date.now() });
     let ws;
     try {
       ws = factory(url, { headers: { "Coder-Session-Token": token } });
     } catch (err) {
       if (emit) {
         const message = err instanceof Error ? err.message : String(err);
-        emit({ type: "ws:error", chatId, attempt, message, timestamp: Date.now() });
-        emit({ type: "ws:close", chatId, attempt, timestamp: Date.now() });
+        emit({ type: "ws:error", chatId, reader, attempt, message, timestamp: Date.now() });
+        emit({ type: "ws:close", chatId, reader, attempt, timestamp: Date.now() });
       }
       throw err;
     }
@@ -307,6 +313,7 @@ async function* streamChatEventsLoop(options) {
         emit?.({
           type: "ws:error",
           chatId,
+          reader,
           attempt,
           message: "failed to parse chat stream frame",
           timestamp: Date.now()
@@ -323,6 +330,7 @@ async function* streamChatEventsLoop(options) {
           emit?.({
             type: "ws:event",
             chatId,
+            reader,
             attempt,
             event: e,
             timestamp: Date.now()
@@ -333,6 +341,7 @@ async function* streamChatEventsLoop(options) {
         emit?.({
           type: "ws:event",
           chatId,
+          reader,
           attempt,
           event: batch,
           timestamp: Date.now()
@@ -343,7 +352,7 @@ async function* streamChatEventsLoop(options) {
     const onError = (ev) => {
       if (finished) return;
       const message = ev && typeof ev === "object" && "message" in ev ? String(ev.message) : "chat stream socket error";
-      emit?.({ type: "ws:error", chatId, attempt, message, timestamp: Date.now() });
+      emit?.({ type: "ws:error", chatId, reader, attempt, message, timestamp: Date.now() });
       const status = upgradeStatus(message);
       failure = status !== void 0 && status >= 400 && status < 500 && !TRANSIENT_UPGRADE_STATUSES.has(status) ? new CoderApiError({ status, method: "GET", path, message }) : new CoderAgentError(message);
       finished = true;
@@ -355,6 +364,7 @@ async function* streamChatEventsLoop(options) {
         const closeEvent = {
           type: "ws:close",
           chatId,
+          reader,
           attempt,
           timestamp: Date.now()
         };
@@ -365,7 +375,7 @@ async function* streamChatEventsLoop(options) {
       finished = true;
       wake();
     };
-    const onOpen = emit ? () => emit({ type: "ws:open", chatId, attempt, timestamp: Date.now() }) : void 0;
+    const onOpen = emit ? () => emit({ type: "ws:open", chatId, reader, attempt, timestamp: Date.now() }) : void 0;
     if (onOpen) ws.addEventListener("open", onOpen);
     ws.addEventListener("message", onMessage);
     ws.addEventListener("error", onError);
@@ -426,7 +436,7 @@ async function* streamChatEventsLoop(options) {
       }
       if (emit && !closeEmitted) {
         closeEmitted = true;
-        emit({ type: "ws:close", chatId, attempt, timestamp: Date.now() });
+        emit({ type: "ws:close", chatId, reader, attempt, timestamp: Date.now() });
       }
     }
     if (signal?.aborted) return;
@@ -451,6 +461,7 @@ async function* streamChatEventsLoop(options) {
     emit?.({
       type: "ws:redial",
       chatId,
+      reader,
       attempt,
       consecutiveFailures: failures,
       maxConsecutiveFailures: STREAM_MAX_CONSECUTIVE_FAILURES,
@@ -867,6 +878,7 @@ var CoderChatClient = class {
       chatId,
       afterId: opts?.afterId,
       signal: opts?.signal,
+      reader: opts?.reader,
       webSocketFactory: this.#webSocketFactory,
       onTransportEvent: this.#onTransportEvent
     });
@@ -1145,6 +1157,12 @@ function dynamicToolNames(tools) {
 // src/model/session-stream.ts
 var SessionChatStream = class {
   chatId;
+  /**
+   * The reader id stamped on the wrapped reader's `ws:*` transport events —
+   * the model stamps it on `segment:settle` so segments correlate with the
+   * connection that served them (issue #94).
+   */
+  reader;
   #events;
   #controller = new AbortController();
   #pending;
@@ -1153,6 +1171,7 @@ var SessionChatStream = class {
   #closePromise;
   constructor(opts) {
     this.chatId = opts.chatId;
+    this.reader = opts.reader;
     this.#events = opts.open(this.#controller.signal);
   }
   get closed() {
@@ -1811,9 +1830,11 @@ var CoderLanguageModel = class {
     }
     this.#retainedStream = void 0;
     if (retained) void retained.close();
+    const reader = nextStreamReaderId();
     const created = new SessionChatStream({
       chatId,
-      open: (streamSignal) => this.#config.client.streamEvents(chatId, { afterId, signal: streamSignal })
+      reader,
+      open: (streamSignal) => this.#config.client.streamEvents(chatId, { afterId, signal: streamSignal, reader })
     });
     this.#retainedStream = created;
     return created;
@@ -1977,6 +1998,7 @@ var CoderLanguageModel = class {
       };
       const chatId = segmentChat.chatId ?? this.#chatId;
       if (chatId !== void 0) settleEvent.chatId = chatId;
+      if (segmentChat.reader !== void 0) settleEvent.reader = segmentChat.reader;
       if (!failed && finishReason === void 0) {
         if (segmentChat.timeoutError) {
           failure = segmentChat.timeoutError;
@@ -2140,6 +2162,7 @@ var CoderLanguageModel = class {
       let recoveryAttempted = false;
       const stream = this.#acquireStream(action.kind === "resume", chatId, afterId);
       streamAcquired = true;
+      if (segmentChat) segmentChat.reader = stream.reader;
       let onSegmentAbort;
       const segmentAborted = signal ? new Promise((resolve) => {
         onSegmentAbort = () => resolve(SEGMENT_ABORTED);