@coder/ai-sdk-agent 0.8.0 → 0.9.1

package/dist/index.js

@@ -30,6 +30,15 @@ var CoderApiError = class extends CoderAgentError {
 };
 var CoderStreamError = class extends APICallError {
   name = "CoderStreamError";
+  /**
+   * The chatd chat id the failed turn had created or attached to, when known.
+   * A fresh-chat stream failure discards the session so a retry starts on a
+   * fresh chat (`CoderAgent.chatId` becomes `undefined`), but the failed chat
+   * still exists server-side — this field names it so callers can clean it up
+   * (`CoderAgent.archive()` also retains it as the last-known cleanup target).
+   * `undefined` when the failure happened before any chat existed.
+   */
+  chatId;
   constructor(args) {
     super({
       message: args.message,
@@ -42,6 +51,7 @@ var CoderStreamError = class extends APICallError {
       isRetryable: args.isRetryable ?? true,
       cause: args.cause
     });
+    this.chatId = args.chatId;
   }
 };
 var CoderChatError = class extends CoderAgentError {
@@ -303,6 +313,52 @@ async function* streamChatEventsLoop(options) {
         abortListenerAdded = true;
       }
     }
+    const ingest = (next) => {
+      let progress = false;
+      let forwarded = true;
+      if (next.type === "message_part") {
+        const mp = next.message_part;
+        const hv = mp?.history_version;
+        const ga = mp?.generation_attempt;
+        const seq = mp?.seq;
+        if (hv !== void 0 && ga !== void 0 && seq !== void 0) {
+          if (hv === lastHistoryVersion && ga === lastGenerationAttempt && lastSeq !== void 0 && seq <= lastSeq) {
+            forwarded = false;
+          } else {
+            lastHistoryVersion = hv;
+            lastGenerationAttempt = ga;
+            lastSeq = seq;
+            progress = true;
+          }
+        } else {
+          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;
+          sawUntrackableDelta = false;
+        }
+      }
+      if (progress) {
+        failures = 0;
+        backoffMs = STREAM_BACKOFF_INITIAL_MS;
+      }
+      emit?.({
+        type: "ws:event",
+        chatId,
+        reader,
+        attempt,
+        event: next,
+        forwarded,
+        timestamp: Date.now()
+      });
+      if (forwarded) queue.push(next);
+    };
     const onMessage = (ev) => {
       if (finished) return;
       let batch;
@@ -325,27 +381,9 @@ async function* streamChatEventsLoop(options) {
         return;
       }
       if (Array.isArray(batch)) {
-        for (const e of batch) {
-          queue.push(e);
-          emit?.({
-            type: "ws:event",
-            chatId,
-            reader,
-            attempt,
-            event: e,
-            timestamp: Date.now()
-          });
-        }
+        for (const e of batch) ingest(e);
       } else if (batch && typeof batch === "object") {
-        queue.push(batch);
-        emit?.({
-          type: "ws:event",
-          chatId,
-          reader,
-          attempt,
-          event: batch,
-          timestamp: Date.now()
-        });
+        ingest(batch);
       }
       wake();
     };
@@ -383,40 +421,7 @@ async function* streamChatEventsLoop(options) {
     try {
       while (true) {
         while (queue.length > 0) {
-          const next = queue.shift();
-          let progress = false;
-          if (next.type === "message_part") {
-            const mp = next.message_part;
-            const hv = mp?.history_version;
-            const ga = mp?.generation_attempt;
-            const seq = mp?.seq;
-            if (hv !== void 0 && ga !== void 0 && seq !== void 0) {
-              if (hv === lastHistoryVersion && ga === lastGenerationAttempt && lastSeq !== void 0 && seq <= lastSeq) {
-                continue;
-              }
-              lastHistoryVersion = hv;
-              lastGenerationAttempt = ga;
-              lastSeq = seq;
-              progress = true;
-            } else {
-              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;
-              sawUntrackableDelta = false;
-            }
-          }
-          if (progress) {
-            failures = 0;
-            backoffMs = STREAM_BACKOFF_INITIAL_MS;
-          }
-          yield next;
+          yield queue.shift();
         }
         if (finished) break;
         await new Promise((resolve) => {
@@ -446,7 +451,8 @@ async function* streamChatEventsLoop(options) {
       throw new CoderStreamError({
         message: "chat stream dropped mid-turn and cannot be resumed: this server does not stamp deltas with history_version/generation_attempt/seq, so a redial would replay them",
         url,
-        cause: failure
+        cause: failure,
+        chatId
       });
     }
     if (failure) lastFailure = failure;
@@ -455,7 +461,8 @@ async function* streamChatEventsLoop(options) {
       throw new CoderStreamError({
         message: `Coder chat stream ${path} could not be (re-)established after ${failures} consecutive connection failures without progress`,
         url,
-        cause: lastFailure
+        cause: lastFailure,
+        chatId
       });
     }
     emit?.({
@@ -667,9 +674,11 @@ var CoderChatClient = class {
   /**
    * Issue a request and return the raw `Response` on success (body unread). On a
    * non-2xx status the body is consumed to build a {@link CoderApiError}. Shared
-   * by JSON requests and the raw upload/download endpoints.
+   * by JSON requests and the raw upload/download endpoints. `op` names the
+   * public client method on the exchange's `http:*` events (issue #112) — the
+   * emit site is shared, so each call site threads its own literal.
    */
-  async #send(method, path, opts) {
+  async #send(op, method, path, opts) {
     const headers = {
       "Coder-Session-Token": this.#token,
       ...opts?.headers
@@ -684,7 +693,7 @@ var CoderChatClient = class {
     if (emit) {
       requestId = ++this.#httpSeq;
       startedAt = performance.now();
-      emit({ type: "http:request", id: requestId, method, path, timestamp: Date.now() });
+      emit({ type: "http:request", id: requestId, op, method, path, timestamp: Date.now() });
     }
     let res;
     try {
@@ -693,6 +702,7 @@ var CoderChatClient = class {
       emit?.({
         type: "http:error",
         id: requestId,
+        op,
         method,
         path,
         message: err instanceof Error ? err.message : String(err),
@@ -704,6 +714,7 @@ var CoderChatClient = class {
     emit?.({
       type: "http:response",
       id: requestId,
+      op,
       method,
       path,
       status: res.status,
@@ -733,8 +744,8 @@ var CoderChatClient = class {
       return void 0;
     }
   }
-  async #request(method, path, body, signal) {
-    const res = await this.#send(method, path, {
+  async #request(op, method, path, body, signal) {
+    const res = await this.#send(op, method, path, {
       body: body === void 0 ? void 0 : JSON.stringify(body),
       headers: body === void 0 ? void 0 : { "Content-Type": "application/json" },
       signal
@@ -744,6 +755,7 @@ var CoderChatClient = class {
   // --- REST -----------------------------------------------------------------
   listModelConfigs(signal) {
     return this.#request(
+      "listModelConfigs",
       "GET",
       `${API_PREFIX}/model-configs`,
       void 0,
@@ -751,13 +763,14 @@ var CoderChatClient = class {
     );
   }
   createChat(req, signal) {
-    return this.#request("POST", API_PREFIX, req, signal);
+    return this.#request("createChat", "POST", API_PREFIX, req, signal);
   }
   getChat(chatId, signal) {
-    return this.#request("GET", `${API_PREFIX}/${chatId}`, void 0, signal);
+    return this.#request("getChat", "GET", `${API_PREFIX}/${chatId}`, void 0, signal);
   }
   createChatMessage(chatId, req, signal) {
     return this.#request(
+      "createChatMessage",
       "POST",
       `${API_PREFIX}/${chatId}/messages`,
       req,
@@ -771,6 +784,7 @@ var CoderChatClient = class {
     if (opts?.limit !== void 0) params.set("limit", String(opts.limit));
     const q = params.toString();
     return this.#request(
+      "getMessages",
       "GET",
       `${API_PREFIX}/${chatId}/messages${q ? `?${q}` : ""}`,
       void 0,
@@ -778,7 +792,13 @@ var CoderChatClient = class {
     );
   }
   submitToolResults(chatId, req, signal) {
-    return this.#request("POST", `${API_PREFIX}/${chatId}/tool-results`, req, signal);
+    return this.#request(
+      "submitToolResults",
+      "POST",
+      `${API_PREFIX}/${chatId}/tool-results`,
+      req,
+      signal
+    );
   }
   /**
    * Interrupt the chat's in-flight run (`POST /interrupt`). The server flips
@@ -797,18 +817,42 @@ var CoderChatClient = class {
     const opts = optsOrSignal instanceof AbortSignal ? { signal: optsOrSignal } : optsOrSignal;
     const query = opts?.wait ? "?wait=true" : "";
     return this.#request(
+      "interruptChat",
       "POST",
       `${API_PREFIX}/${chatId}/interrupt${query}`,
       void 0,
       opts?.signal
     );
   }
+  /**
+   * Withdraw a QUEUED (not yet materialized) message from the chat's
+   * submission queue (`DELETE /queue/{id}`). `queuedMessageId` is the
+   * queue-entry id from `CreateChatMessageResponse.queued_message` — a
+   * different id space from committed chat message ids. Rejects with a
+   * {@link CoderApiError}: 404 when the entry no longer exists (already
+   * promoted into history, or deleted), 409 when the chat has no queue.
+   */
+  deleteQueuedMessage(chatId, queuedMessageId, signal) {
+    return this.#request(
+      "deleteQueuedMessage",
+      "DELETE",
+      `${API_PREFIX}/${chatId}/queue/${queuedMessageId}`,
+      void 0,
+      signal
+    );
+  }
   updateChat(chatId, req, signal) {
-    return this.#request("PATCH", `${API_PREFIX}/${chatId}`, req, signal);
+    return this.#request("updateChat", "PATCH", `${API_PREFIX}/${chatId}`, req, signal);
   }
   /** Convenience: archive a chat (soft-hide; safe for cleanup). */
   archiveChat(chatId, signal) {
-    return this.updateChat(chatId, { archived: true }, signal);
+    return this.#request(
+      "archiveChat",
+      "PATCH",
+      `${API_PREFIX}/${chatId}`,
+      { archived: true },
+      signal
+    );
   }
   // --- Files ----------------------------------------------------------------
   /**
@@ -846,6 +890,7 @@ var CoderChatClient = class {
       headers["Content-Disposition"] = `attachment; filename="${ascii}"; filename*=UTF-8''${utf8}`;
     }
     const res = await this.#send(
+      "uploadChatFile",
       "POST",
       `${API_PREFIX}/files?organization=${encodeURIComponent(organizationId)}`,
       { body: resolved.body, headers, signal }
@@ -863,7 +908,9 @@ var CoderChatClient = class {
   }
   /** Download a chat file's bytes and media type by id. */
   async getChatFile(fileId, signal) {
-    const res = await this.#send("GET", `${API_PREFIX}/files/${fileId}`, { signal });
+    const res = await this.#send("getChatFile", "GET", `${API_PREFIX}/files/${fileId}`, {
+      signal
+    });
     const buf = await res.arrayBuffer();
     return {
       bytes: new Uint8Array(buf),
@@ -917,7 +964,13 @@ var CoderChatClient = class {
   async resolveModelConfigId(hint, signal) {
     const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
     if (UUID_RE.test(hint)) return hint;
-    const raw = await this.listModelConfigs(signal);
+    const raw = await this.#request(
+      "resolveModelConfigId",
+      "GET",
+      `${API_PREFIX}/model-configs`,
+      void 0,
+      signal
+    );
     const configs = (Array.isArray(raw) ? raw : []).filter(
       (c) => typeof c === "object" && c !== null
     );
@@ -1312,6 +1365,16 @@ function joinContent(content, kind) {
   for (const p of content) if (p.type === kind) full += p.text ?? "";
   return full;
 }
+function canonicalJson(value) {
+  if (Array.isArray(value)) return `[${value.map(canonicalJson).join(",")}]`;
+  if (value !== null && typeof value === "object") {
+    const entries = Object.entries(value);
+    entries.sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0);
+    const body = entries.map(([k, v]) => `${JSON.stringify(k)}:${canonicalJson(v)}`);
+    return `{${body.join(",")}}`;
+  }
+  return JSON.stringify(value) ?? "null";
+}
 var TurnTranslator = class {
   #dynamicToolNames;
   #submittedToolCallIds;
@@ -1362,13 +1425,30 @@ var TurnTranslator = class {
    * to a segment that already streamed) — they arrive only as replays: the
    * 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.
+   * 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
+   * 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.
    */
   #turnCursor;
+  /** The queued-submission attribution gate; undefined once anchored (#114). */
+  #queuedGate;
   constructor(opts) {
     this.#dynamicToolNames = opts.dynamicToolNames;
     this.#turnCursor = opts.turnCursor ?? 0;
     this.#submittedToolCallIds = opts.submittedToolCallIds ?? /* @__PURE__ */ new Set();
+    const queued = opts.queuedSubmission;
+    if (queued) {
+      this.#queuedGate = {
+        queuedId: queued.id,
+        expected: queued.content !== void 0 ? canonicalJson(queued.content) : void 0,
+        candidateId: void 0,
+        buffered: [],
+        deadEnd: void 0
+      };
+    }
   }
   get terminalStatus() {
     return this.#terminalStatus;
@@ -1383,6 +1463,32 @@ var TurnTranslator = class {
   get error() {
     return this.#error;
   }
+  /**
+   * 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`).
+   */
+  get turnCursor() {
+    return this.#turnCursor;
+  }
+  /**
+   * Whether a queued submission is still awaiting its own user-message
+   * snapshot (#114). While true, nothing is attributed to this turn — no
+   * content, usage, tool calls, or settle statuses — because the stream
+   * window still belongs to the chat's concurrent run.
+   */
+  get awaitingQueuedSubmission() {
+    return this.#queuedGate !== void 0;
+  }
+  /**
+   * Set when a queued submission's wait can never complete (see
+   * {@link QueuedSubmissionGate}); the model layer throws it so the turn
+   * fails fast instead of hanging until timeout/abort.
+   */
+  get queuedSubmissionDeadEnd() {
+    return this.#queuedGate?.deadEnd;
+  }
   // --- block helpers --------------------------------------------------------
   #openText(out) {
     if (this.#reasoning.id) this.#closeReasoning(out);
@@ -1525,6 +1631,8 @@ var TurnTranslator = class {
   }
   // --- ingest ---------------------------------------------------------------
   ingest(ev) {
+    const gate = this.#queuedGate;
+    if (gate) return this.#ingestGated(gate, ev);
     const out = [];
     switch (ev.type) {
       case "message_part":
@@ -1573,6 +1681,82 @@ var TurnTranslator = class {
     }
     return out;
   }
+  /**
+   * Ingest while the queued-submission gate is up (#114): the stream window
+   * still belongs to the chat's concurrent run, so nothing is attributed —
+   * this only advances cursor bookkeeping, runs the anchor correlation
+   * protocol (see {@link QueuedSubmissionGate}), and detects dead ends.
+   * Returns parts only at the anchoring transition, when buffered snapshots
+   * of this turn's own already-committed messages are replayed through the
+   * normal path.
+   */
+  #ingestGated(gate, ev) {
+    switch (ev.type) {
+      case "message": {
+        const message = ev.message;
+        if (!message) break;
+        if (message.id > this.#maxMessageId) this.#maxMessageId = message.id;
+        if (message.id <= this.#turnCursor) break;
+        if (message.role === "user" && this.#matchesQueuedContent(gate, message)) {
+          if (gate.queuedId === void 0) return this.#anchorQueuedTurn(message.id);
+          gate.candidateId = message.id;
+          gate.buffered = [];
+        } else if (gate.candidateId !== void 0) {
+          gate.buffered.push(message);
+        }
+        break;
+      }
+      case "queue_update": {
+        if (gate.queuedId === void 0) break;
+        const queue = ev.queued_messages ?? [];
+        if (queue.some((entry) => entry.id === gate.queuedId)) {
+          gate.candidateId = void 0;
+          gate.buffered = [];
+          break;
+        }
+        if (gate.candidateId !== void 0) {
+          const buffered = gate.buffered;
+          const out = this.#anchorQueuedTurn(gate.candidateId);
+          for (const message of buffered) this.#ingestMessage(out, message);
+          return out;
+        }
+        gate.deadEnd = {
+          message: "The queued submission left the chat's queue without materializing as this turn's user message (deleted externally, or its materialized form could not be correlated); this turn never started.",
+          kind: "queued_submission_lost",
+          retryable: false
+        };
+        break;
+      }
+      case "error": {
+        if (!ev.error) break;
+        gate.deadEnd = {
+          message: "The chat's active run failed while this turn's submission was queued behind it; the queued message never materialized, so this turn never started.",
+          detail: ev.error.detail ? `${ev.error.message}: ${ev.error.detail}` : ev.error.message,
+          kind: "queued_submission_lost",
+          retryable: false
+        };
+        break;
+      }
+      default:
+        break;
+    }
+    return [];
+  }
+  /** Whether a user-message snapshot's content matches the queued entry's. */
+  #matchesQueuedContent(gate, message) {
+    if (gate.expected === void 0) return true;
+    return canonicalJson(message.content ?? []) === gate.expected;
+  }
+  /**
+   * Opens the turn's attribution window at `anchorId` — this turn's own user
+   * message — and drops the gate. Replays of the pre-anchor tail (redials
+   * reuse the turn's ORIGINAL cursor) stay filtered by the advanced cursor.
+   */
+  #anchorQueuedTurn(anchorId) {
+    this.#turnCursor = anchorId;
+    this.#queuedGate = void 0;
+    return [];
+  }
   #ingestMessagePart(out, ev) {
     const mp = ev.message_part;
     if (!mp || mp.role !== "assistant" && mp.role !== "tool") return;
@@ -1752,6 +1936,25 @@ var CoderLanguageModel = class {
   supportedUrls = {};
   #config;
   #chatId;
+  /**
+   * The last chat id this model created or attached to, retained as a CLEANUP
+   * target — see {@link lastKnownChatId}. Unlike `#chatId` it survives
+   * {@link resetSession}, and is only replaced when a later turn's chat
+   * supersedes it or cleared by {@link noteChatCleanedUp} once cleanup
+   * actually succeeded against it.
+   */
+  #lastKnownChatId;
+  /**
+   * Every chat id stranded by an AUTOMATIC session discard (a stream failure
+   * on a chat the failed turn itself created) and not yet cleaned up. A
+   * single `#lastKnownChatId` slot is not enough here: each AI-SDK
+   * `maxRetries` attempt strands its own fresh chat and only the final
+   * attempt's error reaches the caller, so without this ledger every attempt
+   * before the last would leak unnamed. Drained by {@link noteChatCleanedUp}.
+   * Deliberate abandonment ({@link resetSession}) does NOT record here — the
+   * caller chose to walk away and may want the chat kept.
+   */
+  #strandedChatIds = /* @__PURE__ */ new Set();
   #lastSeenMessageId = 0;
   #resolvedModelConfigId;
   #modelResolved = false;
@@ -1767,15 +1970,80 @@ var CoderLanguageModel = class {
     this.#config = config;
     this.modelId = config.model ?? "chatd";
     this.#chatId = config.chatId;
+    this.#lastKnownChatId = config.chatId;
+    if (config.lastSeenMessageId !== void 0) {
+      if (!Number.isSafeInteger(config.lastSeenMessageId) || config.lastSeenMessageId <= 0) {
+        throw new CoderAgentError(
+          `lastSeenMessageId must be a positive integer (got ${config.lastSeenMessageId}); persist the value of the lastSeenMessageId getter and supply it verbatim.`
+        );
+      }
+      if (!config.chatId) {
+        throw new CoderAgentError(
+          "lastSeenMessageId requires chatId: a resume cursor is meaningless without the chat it belongs to."
+        );
+      }
+      this.#lastSeenMessageId = config.lastSeenMessageId;
+    }
     this.#emitTransportEvent = safeTransportEmitter(config.onTransportEvent);
   }
   get chatId() {
     return this.#chatId;
   }
+  /**
+   * The resume cursor: the newest chat message id this session has observed,
+   * or `undefined` before any turn has streamed (nothing to persist then —
+   * a fresh instance seeds from history instead). Persist it alongside
+   * {@link chatId} once a turn settles and supply both to a future instance
+   * ({@link CoderLanguageModelConfig.lastSeenMessageId}) to skip the resumed
+   * turn's pre-prompt seed GET. Read it between turns, not mid-generation:
+   * the cursor advances when a segment ends.
+   */
+  get lastSeenMessageId() {
+    return this.#lastSeenMessageId > 0 ? this.#lastSeenMessageId : void 0;
+  }
+  /**
+   * The last chat id this model created or attached to, for CLEANUP targeting
+   * only — generation always targets {@link chatId}. It survives
+   * {@link resetSession} (including the automatic session discard after a
+   * fresh-chat stream failure, which clears {@link chatId} so a retry starts
+   * fresh while the failed chat still exists server-side), is superseded when
+   * a later turn creates or attaches to another chat, and is cleared via
+   * {@link noteChatCleanedUp} once cleanup actually succeeded against it.
+   */
+  get lastKnownChatId() {
+    return this.#lastKnownChatId;
+  }
+  /**
+   * Chat ids stranded by automatic session discards and not yet cleaned up,
+   * oldest first. Each retryable fresh-chat stream failure strands one chat;
+   * under AI-SDK `maxRetries` several can accumulate while only the final
+   * attempt's error (and {@link lastKnownChatId}) names the newest —
+   * `CoderAgent.archive()` retires all of them. Ids leave the list only via
+   * {@link noteChatCleanedUp}.
+   */
+  get strandedChatIds() {
+    return [...this.#strandedChatIds];
+  }
+  /**
+   * Forgets `chatId` as a cleanup target — call it only after cleanup
+   * actually succeeded against that chat (e.g. `CoderAgent.archive()`
+   * archived it), so later cleanup calls don't re-target an already-archived
+   * chat: removes it from {@link strandedChatIds} and, when it is the
+   * last-known id, clears {@link lastKnownChatId} (match-guarded: a stale
+   * completion must not erase a newer chat's id). The session field
+   * ({@link chatId}) is deliberately untouched — archiving does not reset the
+   * session.
+   */
+  noteChatCleanedUp(chatId) {
+    this.#strandedChatIds.delete(chatId);
+    if (this.#lastKnownChatId === chatId) this.#lastKnownChatId = void 0;
+  }
   /**
    * 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).
+   * {@link lastKnownChatId} deliberately survives the reset: the dropped chat
+   * still exists server-side and cleanup must still be able to target it.
    */
   resetSession() {
     this.#chatId = void 0;
@@ -1886,9 +2154,9 @@ var CoderLanguageModel = class {
    * pending calls — nothing to recover, the caller keeps waiting on the
    * stream, bounded by `requestTimeoutMs`/abort.
    */
-  async #recoverRequiresAction(chatId, dynamicNames, afterId, signal) {
+  async #recoverRequiresAction(chatId, dynamicNames, turnCursor, signal) {
     const { messages } = await this.#config.client.getMessages(chatId, { limit: 200 }, signal);
-    const turnMessages = messages.filter((m) => m.id > (afterId ?? 0)).sort((a, b) => a.id - b.id);
+    const turnMessages = messages.filter((m) => m.id > turnCursor).sort((a, b) => a.id - b.id);
     const lastAssistant = turnMessages.findLast((m) => m.role === "assistant");
     if (!lastAssistant) return [];
     const handled = /* @__PURE__ */ new Set();
@@ -2042,10 +2310,20 @@ var CoderLanguageModel = class {
     let discardSession = false;
     let interruptSent = false;
     let turnChatId;
+    let queuedTurn = false;
+    let queuedEntry;
     const interrupt = () => {
       const id = turnChatId ?? this.#chatId;
       if (interruptSent || !id) return;
       interruptSent = true;
+      if (queuedTurn && (translator === void 0 || translator.awaitingQueuedSubmission)) {
+        const entryId = queuedEntry?.id;
+        if (entryId !== void 0) {
+          void this.#config.client.deleteQueuedMessage(id, entryId).catch(() => {
+          });
+        }
+        return;
+      }
       void this.#config.client.interruptChat(id).catch(() => {
       });
     };
@@ -2129,7 +2407,15 @@ var CoderLanguageModel = class {
             },
             signal
           );
-          afterId = resp.message?.id ?? this.#lastSeenMessageId;
+          if (resp.message) {
+            afterId = resp.message.id;
+          } else if (resp.queued) {
+            afterId = this.#lastSeenMessageId;
+            queuedTurn = true;
+            queuedEntry = resp.queued_message;
+          } else {
+            afterId = this.#lastSeenMessageId;
+          }
         }
       } else {
         if (!this.#chatId)
@@ -2145,16 +2431,24 @@ var CoderLanguageModel = class {
       }
       const chatId = this.#chatId;
       turnChatId = chatId;
+      this.#lastKnownChatId = chatId;
       if (segmentChat) segmentChat.chatId = chatId;
       const dynamicNames = dynamicToolNames(options.tools);
-      translator = new TurnTranslator({
+      const translatorOptions = {
         dynamicToolNames: dynamicNames,
         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
-      });
+      };
+      if (queuedTurn) {
+        const queuedSubmission = {};
+        if (queuedEntry?.id !== void 0) queuedSubmission.id = queuedEntry.id;
+        if (queuedEntry?.content !== void 0) queuedSubmission.content = queuedEntry.content;
+        translatorOptions.queuedSubmission = queuedSubmission;
+      }
+      translator = new TurnTranslator(translatorOptions);
       let sinceRequiresAction = 0;
       let grace;
       let recovery;
@@ -2195,7 +2489,11 @@ var CoderLanguageModel = class {
               recovery = this.#recoverRequiresAction(
                 chatId,
                 dynamicNames,
-                afterId,
+                // The turn's EFFECTIVE cursor: for a queued submission it has
+                // advanced past the materialized user message (a pause can
+                // only arm after the gate anchored), so the derivation never
+                // sees the concurrent predecessor run's tail (#114).
+                translator.turnCursor,
                 signal ? AbortSignal.any([signal, recoveryAbort.signal]) : recoveryAbort.signal
               ).catch(() => []);
               continue;
@@ -2219,6 +2517,8 @@ var CoderLanguageModel = class {
           stream.consumed(next);
           if (raced.done) break;
           const parts = translator.ingest(raced.value);
+          const deadEnd = translator.queuedSubmissionDeadEnd;
+          if (deadEnd) throw new CoderChatError(deadEnd);
           if (raced.value.type === "error" && translator.error && !translator.terminalStatus) {
             const peek = stream.read();
             const bound = startGraceTimer(0);
@@ -2243,7 +2543,11 @@ var CoderLanguageModel = class {
       } catch (err) {
         throwIfAborted();
         if (err instanceof CoderStreamError) {
+          if (err.chatId === void 0 && turnChatId !== void 0) {
+            err.chatId = turnChatId;
+          }
           if (turnCreatedChat) {
+            if (turnChatId) this.#strandedChatIds.add(turnChatId);
             discardSession = true;
           }
           const effectful = chatHasWorkspace || chatHasMcpServers || uploadedAttachment;
@@ -2252,7 +2556,8 @@ var CoderLanguageModel = class {
             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)"}`,
             url: err.url,
             cause: err,
-            isRetryable: false
+            isRetryable: false,
+            chatId: err.chatId
           });
         }
         if (err instanceof CoderAgentError && !(err instanceof CoderApiError) && !(err instanceof CoderChatError)) {
@@ -2503,6 +2808,7 @@ var CoderAgent = class {
       mcpServerIds: settings.mcpServerIds,
       planMode: settings.planMode,
       chatId: settings.chatId,
+      lastSeenMessageId: settings.lastSeenMessageId,
       requestTimeoutMs: settings.requestTimeoutMs,
       onTransportEvent: settings.onTransportEvent
     });
@@ -2531,6 +2837,39 @@ var CoderAgent = class {
   get chatId() {
     return this.#model.chatId;
   }
+  /**
+   * The session's resume cursor: the newest chat message id observed, or
+   * `undefined` before any turn has streamed. Persist it alongside
+   * {@link chatId} when a turn ends and supply both to a future instance
+   * ({@link CoderAgentSettings.lastSeenMessageId}) to skip the resumed turn's
+   * pre-prompt seed GET. Read it between turns, not mid-generation.
+   */
+  get lastSeenMessageId() {
+    return this.#model.lastSeenMessageId;
+  }
+  /**
+   * The last chat id this agent created or attached to, retained for CLEANUP
+   * even after the session was dropped — a fresh-chat stream failure discards
+   * the session ({@link CoderAgent.chatId} becomes `undefined`, so a retry
+   * starts fresh), but the failed chat still exists server-side.
+   * {@link CoderAgent.archive} and {@link CoderAgent.interrupt} fall back to
+   * this id; generation never does. Superseded when a later turn creates or
+   * attaches to another chat; cleared once {@link CoderAgent.archive}
+   * succeeds against it.
+   */
+  get lastKnownChatId() {
+    return this.#model.lastKnownChatId;
+  }
+  /**
+   * Chat ids stranded by automatic session discards and not yet cleaned up,
+   * oldest first. Each retryable fresh-chat stream failure strands one chat,
+   * so with `maxRetries` > 0 several can accumulate while only the final
+   * attempt's error (and {@link CoderAgent.lastKnownChatId}) names the
+   * newest. {@link CoderAgent.archive} retires all of them.
+   */
+  get strandedChatIds() {
+    return this.#model.strandedChatIds;
+  }
   generate(options) {
     return this.#inner.generate(options);
   }
@@ -2546,7 +2885,12 @@ var CoderAgent = class {
   listModels(signal) {
     return this.#client.listModelConfigs(signal);
   }
-  /** Start a fresh chatd chat on the next turn. */
+  /**
+   * Start a fresh chatd chat on the next turn. The dropped chat still exists
+   * server-side: {@link CoderAgent.archive} / {@link CoderAgent.interrupt}
+   * keep targeting it (via {@link CoderAgent.lastKnownChatId}) until a new
+   * chat supersedes it or an archive succeeds against it.
+   */
   resetSession() {
     this.#model.resetSession();
   }
@@ -2554,37 +2898,67 @@ var CoderAgent = class {
    * Interrupt the in-flight generation, if any. Resolves as soon as the server
    * acknowledges the interrupt — the run keeps winding down asynchronously for
    * a few seconds afterwards (see {@link CoderAgent.archive}).
+   *
+   * Targets the session's chat, or — after the session was dropped (a
+   * fresh-chat stream failure, or {@link CoderAgent.resetSession}) — the
+   * {@link CoderAgent.lastKnownChatId}, whose run may still be winding down
+   * server-side. With neither, there is nothing to interrupt and it resolves
+   * `{ interrupted: false }` without a server call (inspect the result rather
+   * than relying on a silent no-op).
    */
   async interrupt(opts) {
-    const id = this.#model.chatId;
-    if (!id) return;
+    const id = this.#model.chatId ?? this.#model.lastKnownChatId;
+    if (!id) return { interrupted: false };
     await this.#model.closePausedStream();
     await this.#client.interruptChat(id, opts?.signal);
+    return { interrupted: true, chatId: id };
   }
   /**
    * Archive the underlying chat (safe cleanup; hides it from listings).
    *
+   * Targets the session's chat, or — after the session was dropped (a
+   * fresh-chat stream failure, or {@link CoderAgent.resetSession}) — the
+   * {@link CoderAgent.lastKnownChatId}, so the stranded chat is still cleaned
+   * up; chats stranded by EARLIER automatic discards
+   * ({@link CoderAgent.strandedChatIds} — `maxRetries` can accumulate several)
+   * are retired in the same call. On success each archived id is cleared as a
+   * cleanup target; with no id at all, there is nothing to archive and it
+   * resolves `{ archived: false }` without a server call (inspect the result
+   * rather than relying on a silent no-op).
+   *
    * A freshly interrupted/settled chat can keep winding down server-side for a
    * few seconds, during which the server rejects archiving with a 409. Those
-   * 409s are retried (~1s apart, ~15s overall — see `settleDeadlineMs` /
-   * `settleRetryDelayMs`) and the last one is rethrown if the chat never
-   * settles; any other failure, including a caller abort, rethrows immediately.
+   * 409s are retried (~1s apart — see `settleRetryDelayMs`) inside ONE
+   * `settleDeadlineMs` window (~15s) shared by the whole call — however many
+   * chats it archives — and the last 409 is rethrown if the window closes
+   * first; any other failure, including a caller abort, rethrows immediately.
+   * Chats are archived oldest first, each id cleared as its archive succeeds —
+   * a mid-list failure rethrows and leaves the remaining ids targetable by a
+   * later retry.
    */
   async archive(opts) {
-    const id = this.#model.chatId;
-    if (!id) return;
+    const primary = this.#model.chatId ?? this.#model.lastKnownChatId;
+    if (!primary) return { archived: false };
     await this.#model.closePausedStream();
-    await archiveWhenSettled(this.#client, id, {
-      deadlineMs: this.#settleDeadlineMs,
-      retryDelayMs: this.#settleRetryDelayMs,
-      signal: opts?.signal
-    });
+    const targets = [.../* @__PURE__ */ new Set([...this.#model.strandedChatIds, primary])];
+    const deadline = Date.now() + this.#settleDeadlineMs;
+    for (const id of targets) {
+      await archiveWhenSettled(this.#client, id, {
+        deadlineMs: Math.max(deadline - Date.now(), 1),
+        retryDelayMs: this.#settleRetryDelayMs,
+        signal: opts?.signal
+      });
+      this.#model.noteChatCleanedUp(id);
+    }
+    return { archived: true, chatId: primary, archivedChatIds: targets };
   }
   /**
    * Clean up the chat when the agent leaves an `await using` scope, so cleanup
    * rides scope exit instead of a separate call you have to remember in a
    * `finally`. Interrupts any in-flight server run, then archives the chat
-   * (retrying while the interrupted run settles). Best-effort and bounded
+   * (retrying while the interrupted run settles) — including a chat stranded
+   * by a session discard (see {@link CoderAgent.lastKnownChatId}), which a
+   * failed `generate()` would otherwise leak. Best-effort and bounded
    * (~15s overall): disposal errors are swallowed after the bounded attempts
    * so they can't mask the scope's own error — call {@link CoderAgent.archive}
    * directly when you need guaranteed cleanup.