@coder/ai-sdk-agent 0.5.0 → 0.6.1

package/dist/index.js

@@ -163,6 +163,20 @@ var TERMINAL_STATUSES = /* @__PURE__ */ new Set([
 
 // src/coder/ws.ts
 import NodeWebSocket from "ws";
+
+// src/transport-events.ts
+function safeTransportEmitter(handler) {
+  if (!handler) return void 0;
+  return (event) => {
+    try {
+      void Promise.resolve(handler(event)).catch(() => {
+      });
+    } catch {
+    }
+  };
+}
+
+// src/coder/ws.ts
 var defaultFactory = (url, { headers }) => {
   return new NodeWebSocket(url, { headers });
 };
@@ -228,11 +242,14 @@ function streamChatEvents(options) {
 async function* streamChatEventsLoop(options) {
   const { baseUrl, token, chatId, signal } = options;
   const factory = options.webSocketFactory ?? defaultFactory;
+  const emit = safeTransportEmitter(options.onTransportEvent);
+  let attempt = 0;
   const wsBase = httpToWs(baseUrl);
   const path = `/api/experimental/chats/${chatId}/stream`;
   const query = options.afterId !== void 0 ? `?after_id=${options.afterId}` : "";
   const url = `${wsBase}${path}${query}`;
   let maxCommittedId = options.afterId;
+  const lastMessageJson = /* @__PURE__ */ new Map();
   let lastHistoryVersion;
   let lastGenerationAttempt;
   let lastSeq;
@@ -246,11 +263,24 @@ async function* streamChatEventsLoop(options) {
     let finished = false;
     let failure;
     let parseFailure = false;
+    let closeEmitted = false;
     const wake = () => {
       resolveNext?.();
       resolveNext = void 0;
     };
-    const ws = factory(url, { headers: { "Coder-Session-Token": token } });
+    attempt += 1;
+    emit?.({ type: "ws:dial", chatId, 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() });
+      }
+      throw err;
+    }
     const onAbort = () => {
       finished = true;
       try {
@@ -274,6 +304,13 @@ async function* streamChatEventsLoop(options) {
         const data = typeof ev.data === "string" ? ev.data : String(ev.data);
         batch = JSON.parse(data);
       } catch (err) {
+        emit?.({
+          type: "ws:error",
+          chatId,
+          attempt,
+          message: "failed to parse chat stream frame",
+          timestamp: Date.now()
+        });
         failure = new CoderAgentError("failed to parse chat stream frame", { cause: err });
         parseFailure = true;
         finished = true;
@@ -281,24 +318,55 @@ async function* streamChatEventsLoop(options) {
         return;
       }
       if (Array.isArray(batch)) {
-        for (const e of batch) queue.push(e);
+        for (const e of batch) {
+          queue.push(e);
+          emit?.({
+            type: "ws:event",
+            chatId,
+            attempt,
+            event: e,
+            timestamp: Date.now()
+          });
+        }
       } else if (batch && typeof batch === "object") {
         queue.push(batch);
+        emit?.({
+          type: "ws:event",
+          chatId,
+          attempt,
+          event: batch,
+          timestamp: Date.now()
+        });
       }
       wake();
     };
     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() });
       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;
       wake();
     };
-    const onClose = () => {
+    const onClose = (ev) => {
+      if (emit && !closeEmitted) {
+        closeEmitted = true;
+        const closeEvent = {
+          type: "ws:close",
+          chatId,
+          attempt,
+          timestamp: Date.now()
+        };
+        if (ev?.code !== void 0) closeEvent.code = ev.code;
+        if (ev?.reason !== void 0 && ev.reason !== "") closeEvent.reason = ev.reason;
+        emit(closeEvent);
+      }
       finished = true;
       wake();
     };
+    const onOpen = emit ? () => emit({ type: "ws:open", chatId, attempt, timestamp: Date.now() }) : void 0;
+    if (onOpen) ws.addEventListener("open", onOpen);
     ws.addEventListener("message", onMessage);
     ws.addEventListener("error", onError);
     ws.addEventListener("close", onClose);
@@ -324,9 +392,13 @@ async function* streamChatEventsLoop(options) {
               sawUntrackableDelta = true;
             }
           } else if (next.type === "message" && next.message) {
+            const serialized = JSON.stringify(next.message);
+            if (lastMessageJson.get(next.message.id) !== serialized) {
+              lastMessageJson.set(next.message.id, serialized);
+              progress = true;
+            }
             if (maxCommittedId === void 0 || next.message.id > maxCommittedId) {
               maxCommittedId = next.message.id;
-              progress = true;
               sawUntrackableDelta = false;
             }
           }
@@ -344,6 +416,7 @@ async function* streamChatEventsLoop(options) {
     } finally {
       finished = true;
       if (signal && abortListenerAdded) signal.removeEventListener("abort", onAbort);
+      if (onOpen) ws.removeEventListener("open", onOpen);
       ws.removeEventListener("message", onMessage);
       ws.removeEventListener("error", onError);
       ws.removeEventListener("close", onClose);
@@ -351,6 +424,10 @@ async function* streamChatEventsLoop(options) {
         ws.close(1e3);
       } catch {
       }
+      if (emit && !closeEmitted) {
+        closeEmitted = true;
+        emit({ type: "ws:close", chatId, attempt, timestamp: Date.now() });
+      }
     }
     if (signal?.aborted) return;
     if (failure instanceof CoderApiError) throw failure;
@@ -371,6 +448,15 @@ async function* streamChatEventsLoop(options) {
         cause: lastFailure
       });
     }
+    emit?.({
+      type: "ws:redial",
+      chatId,
+      attempt,
+      consecutiveFailures: failures,
+      maxConsecutiveFailures: STREAM_MAX_CONSECUTIVE_FAILURES,
+      backoffMs,
+      timestamp: Date.now()
+    });
     await sleep(backoffMs, signal);
     if (signal?.aborted) return;
     backoffMs = Math.min(backoffMs * 2, STREAM_BACKOFF_CAP_MS);
@@ -554,11 +640,18 @@ var CoderChatClient = class {
   #token;
   #fetch;
   #webSocketFactory;
+  /** The raw subscriber, forwarded to stream readers (which wrap it themselves). */
+  #onTransportEvent;
+  /** Exception-isolated emitter for this client's own HTTP events. */
+  #emitTransportEvent;
+  #httpSeq = 0;
   constructor(options) {
     this.baseUrl = options.baseUrl.replace(/\/$/, "");
     this.#token = options.token;
     this.#fetch = options.fetch ?? globalThis.fetch.bind(globalThis);
     this.#webSocketFactory = options.webSocketFactory;
+    this.#onTransportEvent = options.onTransportEvent;
+    this.#emitTransportEvent = safeTransportEmitter(options.onTransportEvent);
   }
   /**
    * Issue a request and return the raw `Response` on success (body unread). On a
@@ -574,7 +667,39 @@ var CoderChatClient = class {
     if (typeof ReadableStream !== "undefined" && opts?.body instanceof ReadableStream) {
       init.duplex = "half";
     }
-    const res = await this.#fetch(`${this.baseUrl}${path}`, init);
+    const emit = this.#emitTransportEvent;
+    let requestId = 0;
+    let startedAt = 0;
+    if (emit) {
+      requestId = ++this.#httpSeq;
+      startedAt = performance.now();
+      emit({ type: "http:request", id: requestId, method, path, timestamp: Date.now() });
+    }
+    let res;
+    try {
+      res = await this.#fetch(`${this.baseUrl}${path}`, init);
+    } catch (err) {
+      emit?.({
+        type: "http:error",
+        id: requestId,
+        method,
+        path,
+        message: err instanceof Error ? err.message : String(err),
+        durationMs: performance.now() - startedAt,
+        timestamp: Date.now()
+      });
+      throw err;
+    }
+    emit?.({
+      type: "http:response",
+      id: requestId,
+      method,
+      path,
+      status: res.status,
+      ok: res.ok,
+      durationMs: performance.now() - startedAt,
+      timestamp: Date.now()
+    });
     if (!res.ok) {
       const errObj = await this.#json(res) ?? {};
       throw new CoderApiError({
@@ -742,7 +867,8 @@ var CoderChatClient = class {
       chatId,
       afterId: opts?.afterId,
       signal: opts?.signal,
-      webSocketFactory: this.#webSocketFactory
+      webSocketFactory: this.#webSocketFactory,
+      onTransportEvent: this.#onTransportEvent
     });
   }
   /**
@@ -1162,12 +1288,21 @@ function accumulateUsage(byMessageId) {
 function jsonResult(value) {
   return value ?? {};
 }
+function joinContent(content, kind) {
+  let full = "";
+  for (const p of content) if (p.type === kind) full += p.text ?? "";
+  return full;
+}
 var TurnTranslator = class {
   #dynamicToolNames;
   #submittedToolCallIds;
   #seq = 0;
-  #text = { id: void 0, len: 0, sawDelta: false };
-  #reasoning = { id: void 0, len: 0, sawDelta: false };
+  // `pending` accumulates delta content that has been emitted but not yet
+  // attributed to a message id (deltas carry none); the next assistant
+  // snapshot claims it. It survives block closes — a closed block loses its
+  // stream id, never the record of what was emitted.
+  #text = { id: void 0, pending: "" };
+  #reasoning = { id: void 0, pending: "" };
   #currentAssistantId;
   // Whether text/reasoning deltas arrived since the last assistant `message`
   // snapshot — i.e. the next assistant snapshot is the trailing snapshot of the
@@ -1182,11 +1317,22 @@ var TurnTranslator = class {
   // the same message replaces its earlier entry instead of double-counting
   // (chatd re-sends full snapshots on revision bumps and history resets).
   #usageByMessageId = /* @__PURE__ */ new Map();
-  // Assistant snapshots already processed once. A redial replays the turn
-  // from its original cursor, so earlier messages arrive again — without this,
-  // re-running the boundary logic on them would reset the emitted-length
-  // cursors and re-emit their entire text (see #ingestMessage).
-  #snapshotSeen = /* @__PURE__ */ new Set();
+  // The emitted-content ledger: the text/reasoning this translator has emitted
+  // for each processed assistant message id. A redial replays the turn from
+  // its original cursor and chatd re-sends full snapshots on revision bumps,
+  // so already-processed messages arrive again — the ledger is what lets a
+  // byte-identical replay reconcile to a no-op while an APPENDING revision (or
+  // a commit-during-disconnect snapshot) yields exactly its missing suffix
+  // (see #ingestMessage). `substantive` records whether any processed snapshot
+  // of the message carried content (text, reasoning, tools, or sources) —
+  // false only for announce-style empty snapshots, whose in-flight deltas are
+  // still claimable by a same-id commit.
+  #emittedByMessageId = /* @__PURE__ */ new Map();
+  // Same-id revision snapshots that arrived while the NEXT step's deltas were
+  // open (latest wins). chatd sends each revision once on a healthy
+  // connection, so the suffix cannot wait for a replay — it is reconciled as
+  // soon as the next step's snapshot settles ownership of the pending deltas.
+  #deferredRevisions = /* @__PURE__ */ new Map();
   #error;
   #terminalStatus;
   #maxMessageId = 0;
@@ -1221,7 +1367,6 @@ var TurnTranslator = class {
     if (this.#reasoning.id) this.#closeReasoning(out);
     if (!this.#text.id) {
       this.#text.id = `text-${++this.#seq}`;
-      this.#text.len = 0;
       out.push({ type: "text-start", id: this.#text.id });
     }
   }
@@ -1229,14 +1374,12 @@ var TurnTranslator = class {
     if (this.#text.id) {
       out.push({ type: "text-end", id: this.#text.id });
       this.#text.id = void 0;
-      this.#text.len = 0;
     }
   }
   #openReasoning(out) {
     if (this.#text.id) this.#closeText(out);
     if (!this.#reasoning.id) {
       this.#reasoning.id = `reasoning-${++this.#seq}`;
-      this.#reasoning.len = 0;
       out.push({ type: "reasoning-start", id: this.#reasoning.id });
     }
   }
@@ -1244,31 +1387,40 @@ var TurnTranslator = class {
     if (this.#reasoning.id) {
       out.push({ type: "reasoning-end", id: this.#reasoning.id });
       this.#reasoning.id = void 0;
-      this.#reasoning.len = 0;
     }
   }
-  #emitTextUpTo(out, full) {
-    if (full.length <= this.#text.len && this.#text.id) return;
+  #emitTextDelta(out, delta) {
     this.#openText(out);
-    if (full.length > this.#text.len) {
-      out.push({
-        type: "text-delta",
-        id: this.#text.id,
-        delta: full.slice(this.#text.len)
-      });
-      this.#text.len = full.length;
-    }
+    out.push({ type: "text-delta", id: this.#text.id, delta });
   }
-  #emitReasoningUpTo(out, full) {
-    if (full.length <= this.#reasoning.len && this.#reasoning.id) return;
+  #emitReasoningDelta(out, delta) {
     this.#openReasoning(out);
-    if (full.length > this.#reasoning.len) {
-      out.push({
-        type: "reasoning-delta",
-        id: this.#reasoning.id,
-        delta: full.slice(this.#reasoning.len)
-      });
-      this.#reasoning.len = full.length;
+    out.push({ type: "reasoning-delta", id: this.#reasoning.id, delta });
+  }
+  /**
+   * Reconciles a replayed/revised snapshot of an EARLIER (non-current)
+   * assistant message against its ledger entry: an APPENDING revision emits
+   * its suffix, anything else is a no-op. The suffix is bracketed in its own
+   * block(s) — an open block belongs to the CURRENT step, and splicing another
+   * message's content into it would corrupt both — and the interrupted step's
+   * next delta simply opens a fresh block (its pending content is tracked
+   * independently of blocks).
+   */
+  #reconcileRevision(out, rec, fullText, fullReasoning) {
+    const textSuffix = fullText.length > rec.text.length && fullText.startsWith(rec.text) ? fullText.slice(rec.text.length) : "";
+    const reasoningSuffix = fullReasoning.length > rec.reasoning.length && fullReasoning.startsWith(rec.reasoning) ? fullReasoning.slice(rec.reasoning.length) : "";
+    if (!textSuffix && !reasoningSuffix) return;
+    this.#closeText(out);
+    this.#closeReasoning(out);
+    if (reasoningSuffix) {
+      this.#emitReasoningDelta(out, reasoningSuffix);
+      rec.reasoning = fullReasoning;
+      this.#closeReasoning(out);
+    }
+    if (textSuffix) {
+      this.#emitTextDelta(out, textSuffix);
+      rec.text = fullText;
+      this.#closeText(out);
     }
   }
   // --- tool helpers ---------------------------------------------------------
@@ -1392,21 +1544,19 @@ var TurnTranslator = class {
     const part = mp.part;
     switch (part.type) {
       case "text":
-        this.#text.sawDelta = true;
         this.#deltasSinceSnapshot = true;
         this.#openText(out);
         if (part.text) {
           out.push({ type: "text-delta", id: this.#text.id, delta: part.text });
-          this.#text.len += part.text.length;
+          this.#text.pending += part.text;
         }
         break;
       case "reasoning":
-        this.#reasoning.sawDelta = true;
         this.#deltasSinceSnapshot = true;
         this.#openReasoning(out);
         if (part.text) {
           out.push({ type: "reasoning-delta", id: this.#reasoning.id, delta: part.text });
-          this.#reasoning.len += part.text.length;
+          this.#reasoning.pending += part.text;
         }
         break;
       case "tool-call":
@@ -1432,42 +1582,56 @@ var TurnTranslator = class {
     }
     const content = message.content ?? [];
     if (message.role === "assistant") {
-      if (this.#snapshotSeen.has(message.id) && (message.id !== this.#currentAssistantId || this.#deltasSinceSnapshot)) {
-        for (const part of content) {
-          if (part.type === "tool-call" && !this.#isClientTool(part.tool_name))
-            this.#emitServerToolCall(out, part);
-          else if (part.type === "tool-result" && !this.#isClientTool(part.tool_name))
-            this.#emitServerToolResult(out, part);
-          else if (part.type === "source") this.#emitSource(out, part);
+      const fullText = joinContent(content, "text");
+      const fullReasoning = joinContent(content, "reasoning");
+      const known = this.#emittedByMessageId.get(message.id);
+      if (known && message.id !== this.#currentAssistantId) {
+        this.#reconcileRevision(out, known, fullText, fullReasoning);
+      } else if (known && this.#deltasSinceSnapshot && known.substantive) {
+        this.#deferredRevisions.set(message.id, { text: fullText, reasoning: fullReasoning });
+      } else {
+        if (this.#currentAssistantId !== void 0 && this.#currentAssistantId !== message.id && !this.#deltasSinceSnapshot) {
+          this.#closeText(out);
+          this.#closeReasoning(out);
         }
-        return;
-      }
-      this.#snapshotSeen.add(message.id);
-      if (this.#currentAssistantId !== void 0 && this.#currentAssistantId !== message.id && !this.#deltasSinceSnapshot) {
-        this.#closeText(out);
-        this.#closeReasoning(out);
-        this.#text.sawDelta = false;
-        this.#reasoning.sawDelta = false;
-      }
-      this.#currentAssistantId = message.id;
-      const emitSnapshotText = () => {
-        if (!this.#text.sawDelta || this.#text.id) {
-          const full = content.filter((p) => p.type === "text").map((p) => p.text ?? "").join("");
-          if (full.length > 0) this.#emitTextUpTo(out, full);
+        this.#currentAssistantId = message.id;
+        const rec = known ?? { text: "", reasoning: "", substantive: false };
+        const textAttributed = rec.text + this.#text.pending;
+        const reasoningAttributed = rec.reasoning + this.#reasoning.pending;
+        const textOk = fullText.startsWith(textAttributed);
+        const reasoningOk = fullReasoning.startsWith(reasoningAttributed);
+        let seenText = 0;
+        let seenReasoning = 0;
+        for (const p of content) {
+          if (p.type === "text") {
+            const end = seenText + (p.text ?? "").length;
+            const from = Math.max(seenText, textAttributed.length);
+            if (textOk && end > from) this.#emitTextDelta(out, fullText.slice(from, end));
+            seenText = end;
+          } else if (p.type === "reasoning") {
+            const end = seenReasoning + (p.text ?? "").length;
+            const from = Math.max(seenReasoning, reasoningAttributed.length);
+            if (reasoningOk && end > from)
+              this.#emitReasoningDelta(out, fullReasoning.slice(from, end));
+            seenReasoning = end;
+          }
         }
-      };
-      const emitSnapshotReasoning = () => {
-        if (!this.#reasoning.sawDelta || this.#reasoning.id) {
-          const full = content.filter((p) => p.type === "reasoning").map((p) => p.text ?? "").join("");
-          if (full.length > 0) this.#emitReasoningUpTo(out, full);
+        if (textOk) rec.text = fullText;
+        if (reasoningOk) rec.reasoning = fullReasoning;
+        this.#text.pending = "";
+        this.#reasoning.pending = "";
+        rec.substantive ||= content.some(
+          (p) => p.type === "text" || p.type === "reasoning" ? (p.text ?? "").length > 0 : true
+        );
+        this.#emittedByMessageId.set(message.id, rec);
+        this.#deltasSinceSnapshot = false;
+        for (const [id, deferred] of this.#deferredRevisions) {
+          if (id === message.id) continue;
+          const deferredRec = this.#emittedByMessageId.get(id);
+          if (deferredRec)
+            this.#reconcileRevision(out, deferredRec, deferred.text, deferred.reasoning);
+          this.#deferredRevisions.delete(id);
         }
-      };
-      if (this.#reasoning.id) {
-        emitSnapshotReasoning();
-        emitSnapshotText();
-      } else {
-        emitSnapshotText();
-        emitSnapshotReasoning();
       }
       for (const part of content) {
         if (part.type === "tool-call" && !this.#isClientTool(part.tool_name))
@@ -1476,7 +1640,6 @@ var TurnTranslator = class {
           this.#emitServerToolResult(out, part);
         else if (part.type === "source") this.#emitSource(out, part);
       }
-      this.#deltasSinceSnapshot = false;
     } else if (message.role === "tool") {
       for (const part of content) {
         if (part.type === "tool-result" && !this.#isClientTool(part.tool_name))
@@ -1543,11 +1706,15 @@ var CoderLanguageModel = class {
   #inFlight = false;
   /** The turn-lifetime event stream, retained across client-tool pauses. */
   #retainedStream;
+  /** Exception-isolated observability emitter for `segment:*` events. */
+  #emitTransportEvent;
+  #segmentSeq = 0;
   constructor(config) {
     assertSupportedAiVersion();
     this.#config = config;
     this.modelId = config.model ?? "chatd";
     this.#chatId = config.chatId;
+    this.#emitTransportEvent = safeTransportEmitter(config.onTransportEvent);
   }
   get chatId() {
     return this.#chatId;
@@ -1707,7 +1874,100 @@ var CoderLanguageModel = class {
     });
     return events;
   }
-  async *#runTurn(options) {
+  /**
+   * Wraps {@link #runTurnInner} with `segment:start`/`segment:settle`
+   * observability events. A pure pass-through without a subscriber — no
+   * counters, clocks, or event objects on the unobserved path. The settle
+   * event is emitted in a `finally`, so every started segment settles exactly
+   * once: cleanly (with the terminal status carried by the `finish` part that
+   * streamed through), with an `error` summary, or — when the consumer tears
+   * the stream down mid-segment — with neither. Consumer teardown has two
+   * shapes: a plain generator return (no catch runs), and a
+   * `ReadableStream.cancel()` that {@link doStream} routes through an abort to
+   * unblock a pending socket read — the latter surfaces here as an abort
+   * throw, so `isConsumerCancel` (supplied by `doStream`) reclassifies it as
+   * teardown rather than a failed segment.
+   *
+   * Two more classification wrinkles (review findings):
+   * - a streamed server `error` part is captured BEFORE being yielded —
+   *   `doGenerate()` throws on receiving it and closes this generator without
+   *   another pull, so the catch below never sees that failure;
+   * - the segment's chat id is tracked in `segmentChat` (written by
+   *   {@link #runTurnInner} once known) — a retry-safe stream failure on a
+   *   freshly created chat discards the session (clearing `this.#chatId`)
+   *   before the finally runs, and the settle must still name the chat that
+   *   the preceding `ws:*`/`http:*` events identified. The same out-param
+   *   carries the translator's terminal status and the internal-timeout
+   *   marker for generator-return exits (see {@link SegmentChatRef}).
+   */
+  async *#runTurn(options, isConsumerCancel) {
+    const emit = this.#emitTransportEvent;
+    if (!emit) {
+      yield* this.#runTurnInner(options);
+      return;
+    }
+    const segment = ++this.#segmentSeq;
+    const startedAt = performance.now();
+    const startEvent = {
+      type: "segment:start",
+      segment,
+      timestamp: Date.now()
+    };
+    if (this.#chatId !== void 0) startEvent.chatId = this.#chatId;
+    emit(startEvent);
+    const segmentChat = {};
+    let finishReason;
+    let failure;
+    let failed = false;
+    try {
+      for await (const part of this.#runTurnInner(options, segmentChat)) {
+        if (part.type === "finish") finishReason = part.finishReason;
+        else if (part.type === "error" && !failed) {
+          failure = part.error;
+          failed = true;
+        }
+        yield part;
+      }
+    } catch (err) {
+      if (!isConsumerCancel?.()) {
+        failure = err;
+        failed = true;
+      }
+      throw err;
+    } finally {
+      const settleEvent = {
+        type: "segment:settle",
+        segment,
+        durationMs: performance.now() - startedAt,
+        timestamp: Date.now()
+      };
+      const chatId = segmentChat.chatId ?? this.#chatId;
+      if (chatId !== void 0) settleEvent.chatId = chatId;
+      if (!failed && finishReason === void 0) {
+        if (segmentChat.timeoutError) {
+          failure = segmentChat.timeoutError;
+          failed = true;
+        } else if (options.abortSignal?.aborted && !isConsumerCancel?.()) {
+          failure = options.abortSignal.reason;
+          failed = true;
+        }
+      }
+      if (failed) {
+        settleEvent.error = {
+          name: failure instanceof Error ? failure.name : "Error",
+          message: failure instanceof Error ? failure.message : String(failure)
+        };
+      }
+      if (finishReason !== void 0) {
+        if (finishReason.raw !== void 0) settleEvent.status = finishReason.raw;
+        if (!failed) settleEvent.finishReason = finishReason.unified;
+      } else if (segmentChat.terminalStatus !== void 0) {
+        settleEvent.status = segmentChat.terminalStatus;
+      }
+      emit(settleEvent);
+    }
+  }
+  async *#runTurnInner(options, segmentChat) {
     if (this.#inFlight) {
       throw new CoderAgentError(
         "A generation is already in flight on this CoderAgent (single-flight). Use a separate CoderAgent instance for concurrent sessions."
@@ -1734,13 +1994,14 @@ var CoderLanguageModel = class {
       });
     };
     signal?.addEventListener("abort", interrupt, { once: true });
+    const timeoutError = () => new CoderChatError({
+      message: `Coder Agent turn exceeded its ${timeoutMs}ms requestTimeoutMs budget.`,
+      kind: "timeout",
+      retryable: true
+    });
     const throwIfAborted = () => {
       if (timeoutSignal?.aborted) {
-        throw new CoderChatError({
-          message: `Coder Agent turn exceeded its ${timeoutMs}ms requestTimeoutMs budget.`,
-          kind: "timeout",
-          retryable: true
-        });
+        throw timeoutError();
       }
       if (signal?.aborted) {
         throw externalSignal?.reason ?? new DOMException("The operation was aborted.", "AbortError");
@@ -1767,6 +2028,7 @@ var CoderLanguageModel = class {
       let turnCreatedChat = false;
       let uploadedAttachment = false;
       let chatHasWorkspace = Boolean(this.#config.workspaceId);
+      let chatHasMcpServers = Boolean(this.#config.mcpServerIds?.length);
       if (this.#chatId && this.#lastSeenMessageId === 0) {
         const { messages } = await this.#config.client.getMessages(
           this.#chatId,
@@ -1800,6 +2062,7 @@ var CoderLanguageModel = class {
           this.#chatId = chat.id;
           turnCreatedChat = true;
           if (chat.workspace_id) chatHasWorkspace = true;
+          if (chat.mcp_server_ids?.length) chatHasMcpServers = true;
           afterId = this.#lastSeenMessageId > 0 ? this.#lastSeenMessageId : void 0;
         } else {
           const resp = await this.#config.client.createChatMessage(
@@ -1826,6 +2089,7 @@ var CoderLanguageModel = class {
       }
       const chatId = this.#chatId;
       turnChatId = chatId;
+      if (segmentChat) segmentChat.chatId = chatId;
       const dynamicNames = dynamicToolNames(options.tools);
       translator = new TurnTranslator({
         dynamicToolNames: dynamicNames,
@@ -1897,7 +2161,20 @@ var CoderLanguageModel = class {
           }
           stream.consumed(next);
           if (raced.done) break;
-          for (const part of translator.ingest(raced.value)) yield part;
+          const parts = translator.ingest(raced.value);
+          if (raced.value.type === "error" && translator.error && !translator.terminalStatus) {
+            const peek = stream.read();
+            const bound = startGraceTimer(0);
+            const peeked = await raceSegment(Promise.race([peek, bound.expired])).catch(
+              () => GRACE_EXPIRED
+            );
+            bound.cancel();
+            if (peeked !== GRACE_EXPIRED && peeked !== SEGMENT_ABORTED && !peeked.done) {
+              stream.consumed(peek);
+              parts.push(...translator.ingest(peeked.value));
+            }
+          }
+          for (const part of parts) yield part;
           const status = translator.terminalStatus;
           if (status) {
             if (status !== "requires_action") break;
@@ -1912,7 +2189,7 @@ var CoderLanguageModel = class {
           if (turnCreatedChat) {
             discardSession = true;
           }
-          const effectful = chatHasWorkspace || Boolean(this.#config.mcpServerIds?.length) || uploadedAttachment;
+          const effectful = chatHasWorkspace || chatHasMcpServers || uploadedAttachment;
           if (turnCreatedChat && !effectful) throw err;
           throw new CoderStreamError({
             message: `${err.message}; automatic retry is disabled because ${turnCreatedChat ? "the turn has server-side effects a replay would repeat (workspace/MCP tools that may have executed, or freshly uploaded attachments)" : "the chat has prior state (a retry would resubmit this turn's prompt as a new user turn)"}`,
@@ -1954,6 +2231,12 @@ var CoderLanguageModel = class {
     } finally {
       if (translator && translator.maxMessageId > this.#lastSeenMessageId)
         this.#lastSeenMessageId = translator.maxMessageId;
+      if (segmentChat) {
+        if (translator?.terminalStatus !== void 0) {
+          segmentChat.terminalStatus = translator.terminalStatus;
+        }
+        if (timeoutSignal?.aborted) segmentChat.timeoutError = timeoutError();
+      }
       signal?.removeEventListener("abort", interrupt);
       if (!translator?.terminalStatus) interrupt();
       if (!streamAcquired && this.#retainedStream) {
@@ -1968,7 +2251,8 @@ var CoderLanguageModel = class {
   async doStream(options) {
     const cancelController = new AbortController();
     const abortSignal = options.abortSignal ? AbortSignal.any([options.abortSignal, cancelController.signal]) : cancelController.signal;
-    const gen = this.#runTurn({ ...options, abortSignal });
+    let consumerCancelled = false;
+    const gen = this.#runTurn({ ...options, abortSignal }, () => consumerCancelled);
     const stream = new ReadableStream({
       async pull(controller) {
         try {
@@ -1981,6 +2265,7 @@ var CoderLanguageModel = class {
         }
       },
       async cancel() {
+        consumerCancelled = !options.abortSignal?.aborted;
         cancelController.abort();
         await gen.return().catch(() => {
         });
@@ -2131,7 +2416,8 @@ var CoderAgent = class {
         baseUrl: settings.baseUrl,
         token: settings.token,
         fetch: settings.fetch,
-        webSocketFactory: settings.webSocketFactory
+        webSocketFactory: settings.webSocketFactory,
+        onTransportEvent: settings.onTransportEvent
       });
     } else {
       throw new CoderAgentError(
@@ -2157,7 +2443,8 @@ var CoderAgent = class {
       mcpServerIds: settings.mcpServerIds,
       planMode: settings.planMode,
       chatId: settings.chatId,
-      requestTimeoutMs: settings.requestTimeoutMs
+      requestTimeoutMs: settings.requestTimeoutMs,
+      onTransportEvent: settings.onTransportEvent
     });
     this.#inner = new ToolLoopAgent({
       model: this.#model,