@coder/ai-sdk-agent 0.9.2 → 0.9.4

package/README.md

@@ -1067,7 +1067,16 @@ What resuming does (and doesn't do):
   `requestTimeoutMs` waiting — it attributes nothing of the live run's output
   to itself (its window opens only when its own queued prompt materializes),
   and if it times out first, it withdraws its queued prompt rather than
-  leaving it to run unattended.
+  leaving it to run unattended. The live run's turn is guarded symmetrically:
+  the server starts the queued prompt's run **without ever emitting a
+  terminal settle for the finished one**, so the SDK settles the finishing
+  turn the moment the promoted prompt appears on its stream — nothing of the
+  next turn's output or usage leaks into it. That settle reports
+  `finishReason: "stop"` as a documented approximation: the wire doesn't
+  distinguish a run that completed into a promotion from one interrupted by
+  `busy_behavior: "interrupt"`, so an interrupted turn also settles `"stop"`
+  (with whatever partial output it committed) rather than surfacing an
+  interruption.
 
 ### Let the SDK absorb drops — and handle what it re‑throws
 

package/dist/index.d.ts

@@ -1404,6 +1404,17 @@ interface TurnTranslatorOptions {
  * the queue entry materializes as this turn's own user message, every event
  * belongs to the chat's concurrent run and is withheld (see
  * {@link QueuedSubmissionGate} and {@link TurnTranslatorOptions.queuedSubmission}).
+ *
+ * The mirror direction is the PROMOTION SETTLE BOUNDARY: a user-role
+ * `message` snapshot past the turn's effective cursor settles this turn
+ * mid-run and freezes the translator, because chatd starts the chat's next
+ * run without ever emitting a terminal status for the finished one (see
+ * {@link settledAtPromotionBoundary}, issue #120). Both behaviors key off
+ * the SAME promoted user snapshot — it is the submitting turn's anchor
+ * (turn start) and the finishing turn's boundary (turn end) — and stay
+ * independent because each keys strictly off its OWN turn's cursor: the
+ * anchor advances the submitter's cursor TO the snapshot's id, while the
+ * boundary requires an id strictly PAST the finisher's cursor.
  */
 declare class TurnTranslator {
     #private;
@@ -1415,9 +1426,10 @@ declare class TurnTranslator {
     get error(): ChatErrorPayload | undefined;
     /**
      * The turn's EFFECTIVE attribution cursor: the constructor's `turnCursor`
-     * until a queued submission anchors, the materialized user message's id
-     * after. Distinct from the stream's redial cursor, which deliberately stays
-     * the turn's original `after_id` (see `streamChatEvents`).
+     * until a queued submission anchors (the materialized user message's id
+     * after) or a zero-cursor turn adopts its own prompt's id (see
+     * #ingestMessage). Distinct from the stream's redial cursor, which
+     * deliberately stays the turn's original `after_id` (see `streamChatEvents`).
      */
     get turnCursor(): number;
     /**
@@ -1433,6 +1445,21 @@ declare class TurnTranslator {
      * fails fast instead of hanging until timeout/abort.
      */
     get queuedSubmissionDeadEnd(): ChatErrorPayload | undefined;
+    /**
+     * Whether the turn settled at a PROMOTION BOUNDARY (issue #120): a
+     * user-role `message` snapshot with an id past the turn's effective cursor
+     * arrived mid-run. chatd commits a mid-run user message only when it starts
+     * the chat's NEXT run — `FinishTurn`/`FinishInterruption` promote the queue
+     * head atomically with the previous run's finish (the chat transitions
+     * `running → running` and NO terminal status is ever emitted for the
+     * finished run), and interrupting a `requires_action` pause queues and then
+     * promotes the same way — so the snapshot is proof this turn's own run is
+     * over even though no terminal status was (or ever will be) sent for it.
+     * The segment loop settles the turn here instead of absorbing the promoted
+     * run's content, usage, and settle events; the successor run stays alive
+     * and belongs to whoever submitted it, so teardown must NOT interrupt it.
+     */
+    get settledAtPromotionBoundary(): boolean;
     ingest(ev: ChatStreamEvent): LanguageModelV4StreamPart[];
     finish(): LanguageModelV4StreamPart[];
 }

package/dist/index.js

@@ -1426,15 +1426,27 @@ var TurnTranslator = class {
    * initial sync when resuming a chat, or a mid-turn `history_reset` re-send
    * of the full history. Ingest skips them entirely so a replay can neither
    * re-emit earlier turns' content nor inflate this turn's usage. Mutable for
-   * exactly one transition: a QUEUED submission starts at the pre-turn cursor
+   * exactly two transitions, both of which pin the turn's OWN user message as
+   * the effective floor: a QUEUED submission starts at the pre-turn cursor
    * and advances to the materialized user message's id when the gate anchors
-   * (see {@link QueuedSubmissionGate}) — replayed pre-anchor tail messages
-   * then stay filtered on every redial, which reuses the turn's ORIGINAL
-   * `after_id` and therefore re-delivers them.
+   * (see {@link QueuedSubmissionGate}), and a ZERO cursor (this turn created
+   * the chat) adopts the replay's first user snapshot — this turn's own
+   * prompt — as the cursor (see #ingestMessage). Either way, replayed
+   * pre-cursor tail messages then stay filtered on every redial, which reuses
+   * the turn's ORIGINAL `after_id` and therefore re-delivers them.
    */
   #turnCursor;
   /** The queued-submission attribution gate; undefined once anchored (#114). */
   #queuedGate;
+  /**
+   * Set when the turn settled at a PROMOTION BOUNDARY (issue #120): a
+   * user-role `message` snapshot with an id past the turn's effective cursor
+   * arrived mid-run. Once set, the translator is FROZEN — every later event
+   * is the successor run's traffic and ingests as a no-op — so nothing past
+   * the boundary can leak into this turn's content, usage, or settle state.
+   * See {@link settledAtPromotionBoundary} for why the snapshot is reliable.
+   */
+  #promotionBoundary = false;
   constructor(opts) {
     this.#dynamicToolNames = opts.dynamicToolNames;
     this.#turnCursor = opts.turnCursor ?? 0;
@@ -1465,9 +1477,10 @@ var TurnTranslator = class {
   }
   /**
    * The turn's EFFECTIVE attribution cursor: the constructor's `turnCursor`
-   * until a queued submission anchors, the materialized user message's id
-   * after. Distinct from the stream's redial cursor, which deliberately stays
-   * the turn's original `after_id` (see `streamChatEvents`).
+   * until a queued submission anchors (the materialized user message's id
+   * after) or a zero-cursor turn adopts its own prompt's id (see
+   * #ingestMessage). Distinct from the stream's redial cursor, which
+   * deliberately stays the turn's original `after_id` (see `streamChatEvents`).
    */
   get turnCursor() {
     return this.#turnCursor;
@@ -1489,6 +1502,23 @@ var TurnTranslator = class {
   get queuedSubmissionDeadEnd() {
     return this.#queuedGate?.deadEnd;
   }
+  /**
+   * Whether the turn settled at a PROMOTION BOUNDARY (issue #120): a
+   * user-role `message` snapshot with an id past the turn's effective cursor
+   * arrived mid-run. chatd commits a mid-run user message only when it starts
+   * the chat's NEXT run — `FinishTurn`/`FinishInterruption` promote the queue
+   * head atomically with the previous run's finish (the chat transitions
+   * `running → running` and NO terminal status is ever emitted for the
+   * finished run), and interrupting a `requires_action` pause queues and then
+   * promotes the same way — so the snapshot is proof this turn's own run is
+   * over even though no terminal status was (or ever will be) sent for it.
+   * The segment loop settles the turn here instead of absorbing the promoted
+   * run's content, usage, and settle events; the successor run stays alive
+   * and belongs to whoever submitted it, so teardown must NOT interrupt it.
+   */
+  get settledAtPromotionBoundary() {
+    return this.#promotionBoundary;
+  }
   // --- block helpers --------------------------------------------------------
   #openText(out) {
     if (this.#reasoning.id) this.#closeReasoning(out);
@@ -1631,6 +1661,7 @@ var TurnTranslator = class {
   }
   // --- ingest ---------------------------------------------------------------
   ingest(ev) {
+    if (this.#promotionBoundary) return [];
     const gate = this.#queuedGate;
     if (gate) return this.#ingestGated(gate, ev);
     const out = [];
@@ -1794,8 +1825,18 @@ var TurnTranslator = class {
     }
   }
   #ingestMessage(out, message) {
+    if (this.#promotionBoundary) return;
     if (message.id > this.#maxMessageId) this.#maxMessageId = message.id;
     if (message.id <= this.#turnCursor) return;
+    if (message.role === "user") {
+      if (this.#turnCursor === 0) {
+        this.#turnCursor = message.id;
+        return;
+      }
+      this.#promotionBoundary = true;
+      this.#terminalStatus = void 0;
+      return;
+    }
     if (message.usage && message.role === "assistant") {
       this.#usageByMessageId.set(message.id, message.usage);
     }
@@ -1892,7 +1933,9 @@ var TurnTranslator = class {
     this.#closeReasoning(out);
     let unified;
     if (this.#error || this.#terminalStatus === "error") unified = "error";
-    else if (this.#clientToolCallSeen || this.#terminalStatus === "requires_action")
+    else if (this.#promotionBoundary) {
+      unified = "stop";
+    } else if (this.#clientToolCallSeen || this.#terminalStatus === "requires_action")
       unified = "tool-calls";
     else unified = "stop";
     const usage = accumulateUsage(this.#usageByMessageId);
@@ -2315,6 +2358,7 @@ var CoderLanguageModel = class {
     const interrupt = () => {
       const id = turnChatId ?? this.#chatId;
       if (interruptSent || !id) return;
+      if (translator?.settledAtPromotionBoundary) return;
       interruptSent = true;
       if (queuedTurn && (translator === void 0 || translator.awaitingQueuedSubmission)) {
         const entryId = queuedEntry?.id;
@@ -2532,6 +2576,7 @@ var CoderLanguageModel = class {
             }
           }
           for (const part of parts) yield part;
+          if (translator.settledAtPromotionBoundary) break;
           const status = translator.terminalStatus;
           if (status) {
             if (status !== "requires_action") break;
@@ -2579,7 +2624,7 @@ var CoderLanguageModel = class {
         }
       }
       throwIfAborted();
-      if (!translator.terminalStatus && !translator.error) {
+      if (!translator.terminalStatus && !translator.error && !translator.settledAtPromotionBoundary) {
         throw new CoderChatError({
           message: "Coder chat stream ended before the turn settled (connection closed or the server ended the stream without a terminal status).",
           kind: "stream_closed",
@@ -2600,7 +2645,7 @@ var CoderLanguageModel = class {
         if (timeoutSignal?.aborted) segmentChat.timeoutError = timeoutError();
       }
       signal?.removeEventListener("abort", interrupt);
-      if (!translator?.terminalStatus) interrupt();
+      if (!translator?.terminalStatus && !translator?.settledAtPromotionBoundary) interrupt();
       if (!streamAcquired && this.#retainedStream) {
         const stale = this.#retainedStream;
         this.#retainedStream = void 0;