@coder/ai-sdk-agent 0.4.3 → 0.6.0

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,6 +242,8 @@ 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}` : "";
@@ -246,11 +262,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 +303,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 +317,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);
@@ -344,6 +411,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 +419,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 +443,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 +635,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 +662,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 +862,8 @@ var CoderChatClient = class {
       chatId,
       afterId: opts?.afterId,
       signal: opts?.signal,
-      webSocketFactory: this.#webSocketFactory
+      webSocketFactory: this.#webSocketFactory,
+      onTransportEvent: this.#onTransportEvent
     });
   }
   /**
@@ -1016,6 +1137,95 @@ function dynamicToolNames(tools) {
   return names;
 }
 
+// src/model/session-stream.ts
+var SessionChatStream = class {
+  chatId;
+  #events;
+  #controller = new AbortController();
+  #pending;
+  #attached = true;
+  #reusable = false;
+  #closePromise;
+  constructor(opts) {
+    this.chatId = opts.chatId;
+    this.#events = opts.open(this.#controller.signal);
+  }
+  get closed() {
+    return this.#closePromise !== void 0;
+  }
+  /** Whether a segment is currently consuming this stream. */
+  get attached() {
+    return this.#attached;
+  }
+  /** Whether a resume segment for `chatId` may {@link attach}. */
+  canAttach(chatId) {
+    return !this.closed && this.#reusable && this.chatId === chatId;
+  }
+  /**
+   * The next event, memoized: repeated calls return the SAME promise until
+   * {@link consumed} acknowledges delivery, so a read abandoned by one segment
+   * is handed to the next instead of losing its event.
+   */
+  read() {
+    if (!this.#pending) {
+      if (!this.#attached && !this.closed) {
+        throw new CoderAgentError("SessionChatStream.read() without an attached segment");
+      }
+      this.#pending = this.#events.next();
+      this.#pending.catch(() => {
+      });
+    }
+    return this.#pending;
+  }
+  /**
+   * Acknowledge that the segment received `p`'s result and the next
+   * {@link read} should issue a fresh read. A no-op unless `p` is the
+   * outstanding read — a raced-out segment never consumes.
+   */
+  consumed(p) {
+    if (this.#pending === p) this.#pending = void 0;
+  }
+  /** Attach the resume segment to a stream paused at `requires_action`. */
+  attach() {
+    if (!this.canAttach(this.chatId) || this.#attached) {
+      throw new CoderAgentError("SessionChatStream.attach() on a non-reusable stream");
+    }
+    this.#attached = true;
+    this.#reusable = false;
+  }
+  /**
+   * Segment settled at a healthy `requires_action` pause: keep the stream for
+   * the tool-result resume, with a read outstanding so the reader's redial
+   * machinery stays live while the client tools execute.
+   */
+  pause() {
+    this.#attached = false;
+    if (this.closed) return;
+    this.#reusable = true;
+    if (!this.#pending) {
+      this.#pending = this.#events.next();
+      this.#pending.catch(() => {
+      });
+    }
+  }
+  /**
+   * Close the underlying reader (and socket). Idempotent; safe on a stream
+   * whose generator already ended or threw.
+   */
+  close() {
+    this.#closePromise ??= (async () => {
+      this.#attached = false;
+      this.#reusable = false;
+      this.#controller.abort();
+      try {
+        await this.#events.return(void 0);
+      } catch {
+      }
+    })();
+    return this.#closePromise;
+  }
+};
+
 // src/model/translate.ts
 function addDefined(a, b) {
   if (b === void 0) return a;
@@ -1075,6 +1285,7 @@ function jsonResult(value) {
 }
 var TurnTranslator = class {
   #dynamicToolNames;
+  #submittedToolCallIds;
   #seq = 0;
   #text = { id: void 0, len: 0, sawDelta: false };
   #reasoning = { id: void 0, len: 0, sawDelta: false };
@@ -1111,6 +1322,7 @@ var TurnTranslator = class {
   constructor(opts) {
     this.#dynamicToolNames = opts.dynamicToolNames;
     this.#turnCursor = opts.turnCursor ?? 0;
+    this.#submittedToolCallIds = opts.submittedToolCallIds ?? /* @__PURE__ */ new Set();
   }
   get terminalStatus() {
     return this.#terminalStatus;
@@ -1260,6 +1472,7 @@ var TurnTranslator = class {
       case "action_required":
         for (const tc of ev.action_required?.tool_calls ?? []) {
           if (this.#clientToolCalls.has(tc.tool_call_id)) continue;
+          if (this.#submittedToolCallIds.has(tc.tool_call_id)) continue;
           this.#closeText(out);
           this.#closeReasoning(out);
           this.#clientToolCalls.add(tc.tool_call_id);
@@ -1281,8 +1494,12 @@ var TurnTranslator = class {
         }
         break;
       case "status":
-        if (ev.status && TERMINAL_STATUSES.has(ev.status.status)) {
-          this.#terminalStatus = ev.status.status;
+        if (ev.status) {
+          if (TERMINAL_STATUSES.has(ev.status.status)) {
+            this.#terminalStatus = ev.status.status;
+          } else {
+            this.#terminalStatus = void 0;
+          }
         }
         break;
       default:
@@ -1416,6 +1633,7 @@ var TurnTranslator = class {
 // src/model/language-model.ts
 var ACTION_REQUIRED_GRACE_MS = 2e3;
 var GRACE_EXPIRED = /* @__PURE__ */ Symbol("action-required-grace-expired");
+var SEGMENT_ABORTED = /* @__PURE__ */ Symbol("segment-aborted");
 function startGraceTimer(ms) {
   let timer;
   const expired = new Promise((resolve) => {
@@ -1444,20 +1662,90 @@ var CoderLanguageModel = class {
   #modelResolved = false;
   #submittedToolCallIds = /* @__PURE__ */ new Set();
   #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;
   }
-  /** Drops the current session so the next turn creates a fresh chat. */
+  /**
+   * Drops the current session so the next turn creates a fresh chat. Also
+   * closes the retained event stream, if any (fire-and-forget — a sync reset
+   * must not wait on socket teardown, and `close()` never rejects).
+   */
   resetSession() {
     this.#chatId = void 0;
     this.#lastSeenMessageId = 0;
     this.#submittedToolCallIds.clear();
+    const stream = this.#retainedStream;
+    this.#retainedStream = void 0;
+    if (stream) void stream.close();
+  }
+  /**
+   * Closes the retained event stream, if any. The stream otherwise closes
+   * when its turn settles or fails, or when the next turn replaces it — but a
+   * turn that pauses for client tools and never resumes (e.g. the caller
+   * stopped the tool loop, or aborted between segments) leaves the socket
+   * open, so dispose (`await using`) or {@link resetSession} sessions you
+   * abandon mid-turn.
+   */
+  async [Symbol.asyncDispose]() {
+    const stream = this.#retainedStream;
+    this.#retainedStream = void 0;
+    if (stream) await stream.close();
+  }
+  /**
+   * Closes a stream retained by a client-tool pause. Called on explicit
+   * interrupts ({@link CoderAgent.interrupt}): an interrupted pause is dead —
+   * its buffer would otherwise collect the interrupt's own settle events,
+   * which a later tool-result resume would consume as if they were the
+   * resumed generation's (truncating the turn), and if the tool loop never
+   * resumes the socket would outlive the explicit interrupt. A stream a
+   * segment is actively reading is left alone: that segment observes the
+   * settle the interrupt produces and closes the stream itself.
+   */
+  async closePausedStream() {
+    const stream = this.#retainedStream;
+    if (!stream || stream.attached) return;
+    this.#retainedStream = void 0;
+    await stream.close();
+  }
+  /**
+   * The stream a segment reads: a resume segment re-attaches to the stream
+   * its predecessor left paused at `requires_action` (the whole point of
+   * retention — no re-dial per tool round trip); everything else — a new
+   * turn, or a pause the caller abandoned — replaces it with a fresh dial,
+   * because a stale buffer from a settle this client never observed must not
+   * leak into the new turn.
+   */
+  #acquireStream(resume, chatId, afterId) {
+    const retained = this.#retainedStream;
+    if (resume && retained?.canAttach(chatId)) {
+      retained.attach();
+      return retained;
+    }
+    this.#retainedStream = void 0;
+    if (retained) void retained.close();
+    const created = new SessionChatStream({
+      chatId,
+      open: (streamSignal) => this.#config.client.streamEvents(chatId, { afterId, signal: streamSignal })
+    });
+    this.#retainedStream = created;
+    return created;
+  }
+  /** Close `stream` and drop the retention slot if it still holds it. */
+  async #closeStream(stream) {
+    if (this.#retainedStream === stream) this.#retainedStream = void 0;
+    await stream.close();
   }
   async #resolveModelConfigId(signal) {
     if (this.#modelResolved) return this.#resolvedModelConfigId;
@@ -1544,7 +1832,93 @@ 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.
+   */
+  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 && options.abortSignal?.aborted) {
+        if (!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;
+      }
+      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."
@@ -1559,10 +1933,12 @@ var CoderLanguageModel = class {
     );
     const signal = sources.length > 0 ? AbortSignal.any(sources) : void 0;
     let translator;
+    let streamAcquired = false;
     let discardSession = false;
     let interruptSent = false;
+    let turnChatId;
     const interrupt = () => {
-      const id = this.#chatId;
+      const id = turnChatId ?? this.#chatId;
       if (interruptSent || !id) return;
       interruptSent = true;
       void this.#config.client.interruptChat(id).catch(() => {
@@ -1660,25 +2036,49 @@ var CoderLanguageModel = class {
         afterId = this.#lastSeenMessageId;
       }
       const chatId = this.#chatId;
+      turnChatId = chatId;
+      if (segmentChat) segmentChat.chatId = chatId;
       const dynamicNames = dynamicToolNames(options.tools);
       translator = new TurnTranslator({
         dynamicToolNames: dynamicNames,
-        turnCursor: afterId ?? 0
+        turnCursor: afterId ?? 0,
+        // The retained stream redials with the TURN's original cursor, so a
+        // reconnect can replay an earlier segment's `action_required`
+        // snapshot; calls this session already answered must not run again.
+        submittedToolCallIds: this.#submittedToolCallIds
       });
       let sinceRequiresAction = 0;
       let grace;
       let recovery;
       let recoveryAbort;
       let recoveryAttempted = false;
-      const stream = this.#config.client.streamEvents(chatId, { afterId, signal });
+      const stream = this.#acquireStream(action.kind === "resume", chatId, afterId);
+      streamAcquired = true;
+      let onSegmentAbort;
+      const segmentAborted = signal ? new Promise((resolve) => {
+        onSegmentAbort = () => resolve(SEGMENT_ABORTED);
+        if (signal.aborted) onSegmentAbort();
+        else signal.addEventListener("abort", onSegmentAbort, { once: true });
+      }) : void 0;
+      const raceSegment = (p) => segmentAborted ? Promise.race([p, segmentAborted]) : p;
+      let retainStream = false;
       try {
-        let next = stream.next();
         for (; ; ) {
-          let result;
+          const next = stream.read();
           const awaitingActionRequired = translator.terminalStatus === "requires_action" && !translator.clientToolCallSeen;
+          if (!awaitingActionRequired && (grace !== void 0 || recoveryAttempted)) {
+            grace?.cancel();
+            grace = void 0;
+            recoveryAbort?.abort();
+            recoveryAbort = void 0;
+            recovery = void 0;
+            recoveryAttempted = false;
+            sinceRequiresAction = 0;
+          }
+          let raced;
           if (awaitingActionRequired && !recoveryAttempted) {
             grace ??= startGraceTimer(ACTION_REQUIRED_GRACE_MS);
-            const raced = await Promise.race([next, grace.expired]);
+            raced = await raceSegment(Promise.race([next, grace.expired]));
             if (raced === GRACE_EXPIRED) {
               recoveryAttempted = true;
               throwIfAborted();
@@ -1691,27 +2091,25 @@ var CoderLanguageModel = class {
               ).catch(() => []);
               continue;
             }
-            result = raced;
           } else if (awaitingActionRequired && recovery) {
-            const raced = await Promise.race([next, recovery]);
+            raced = await raceSegment(Promise.race([next, recovery]));
             if (Array.isArray(raced)) {
               recovery = void 0;
               throwIfAborted();
               for (const ev of raced) for (const part of translator.ingest(ev)) yield part;
-              if (translator.clientToolCallSeen) {
-                void next.catch(() => {
-                });
-                break;
-              }
+              if (translator.clientToolCallSeen) break;
               continue;
             }
-            result = raced;
           } else {
-            result = await next;
+            raced = await raceSegment(next);
+          }
+          if (raced === SEGMENT_ABORTED) {
+            throwIfAborted();
+            throw new CoderAgentError("segment abort sentinel resolved without an abort");
           }
-          if (result.done) break;
-          next = stream.next();
-          for (const part of translator.ingest(result.value)) yield part;
+          stream.consumed(next);
+          if (raced.done) break;
+          for (const part of translator.ingest(raced.value)) yield part;
           const status = translator.terminalStatus;
           if (status) {
             if (status !== "requires_action") break;
@@ -1719,6 +2117,7 @@ var CoderLanguageModel = class {
             if (++sinceRequiresAction > 200) break;
           }
         }
+        retainStream = !signal?.aborted && translator.terminalStatus === "requires_action" && translator.clientToolCallSeen && !translator.error;
       } catch (err) {
         throwIfAborted();
         if (err instanceof CoderStreamError) {
@@ -1745,8 +2144,12 @@ var CoderLanguageModel = class {
       } finally {
         grace?.cancel();
         recoveryAbort?.abort();
-        await stream.return(void 0).catch(() => {
-        });
+        if (signal && onSegmentAbort) signal.removeEventListener("abort", onSegmentAbort);
+        if (retainStream && !signal?.aborted && !stream.closed) {
+          stream.pause();
+        } else {
+          await this.#closeStream(stream);
+        }
       }
       throwIfAborted();
       if (!translator.terminalStatus && !translator.error) {
@@ -1765,6 +2168,11 @@ var CoderLanguageModel = class {
         this.#lastSeenMessageId = translator.maxMessageId;
       signal?.removeEventListener("abort", interrupt);
       if (!translator?.terminalStatus) interrupt();
+      if (!streamAcquired && this.#retainedStream) {
+        const stale = this.#retainedStream;
+        this.#retainedStream = void 0;
+        void stale.close();
+      }
       if (discardSession) this.resetSession();
       this.#inFlight = false;
     }
@@ -1772,7 +2180,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 {
@@ -1785,6 +2194,7 @@ var CoderLanguageModel = class {
         }
       },
       async cancel() {
+        consumerCancelled = !options.abortSignal?.aborted;
         cancelController.abort();
         await gen.return().catch(() => {
         });
@@ -1935,7 +2345,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(
@@ -1961,7 +2372,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,
@@ -2014,7 +2426,9 @@ var CoderAgent = class {
    */
   async interrupt(opts) {
     const id = this.#model.chatId;
-    if (id) await this.#client.interruptChat(id, opts?.signal);
+    if (!id) return;
+    await this.#model.closePausedStream();
+    await this.#client.interruptChat(id, opts?.signal);
   }
   /**
    * Archive the underlying chat (safe cleanup; hides it from listings).
@@ -2028,6 +2442,7 @@ var CoderAgent = class {
   async archive(opts) {
     const id = this.#model.chatId;
     if (!id) return;
+    await this.#model.closePausedStream();
     await archiveWhenSettled(this.#client, id, {
       deadlineMs: this.#settleDeadlineMs,
       retryDelayMs: this.#settleRetryDelayMs,
@@ -2051,6 +2466,10 @@ var CoderAgent = class {
    * ```
    */
   async [Symbol.asyncDispose]() {
+    try {
+      await this.#model[Symbol.asyncDispose]();
+    } catch {
+    }
     const deadline = AbortSignal.timeout(this.#settleDeadlineMs);
     try {
       await this.interrupt({ signal: deadline });