@coder/ai-sdk-agent 0.4.1 → 0.4.3

package/dist/index.js

@@ -5,6 +5,7 @@ import {
 } from "ai";
 
 // src/errors.ts
+import { APICallError } from "@ai-sdk/provider";
 var CoderAgentError = class extends Error {
   name = "CoderAgentError";
   constructor(message, options) {
@@ -27,6 +28,22 @@ var CoderApiError = class extends CoderAgentError {
     this.path = args.path;
   }
 };
+var CoderStreamError = class extends APICallError {
+  name = "CoderStreamError";
+  constructor(args) {
+    super({
+      message: args.message,
+      url: args.url,
+      requestBodyValues: void 0,
+      // Retries re-invoke the model with the SAME prompt, so the model layer
+      // downgrades this to false whenever the failed chat has prior state a
+      // re-submission would corrupt, or server-side tooling (workspace/MCP)
+      // whose effects a replay would duplicate (see #runTurn).
+      isRetryable: args.isRetryable ?? true,
+      cause: args.cause
+    });
+  }
+};
 var CoderChatError = class extends CoderAgentError {
   name = "CoderChatError";
   kind;
@@ -154,92 +171,209 @@ function httpToWs(baseUrl) {
   if (baseUrl.startsWith("http://")) return `ws://${baseUrl.slice("http://".length)}`;
   return baseUrl;
 }
-async function* streamChatEvents(options) {
-  const { baseUrl, token, chatId, afterId, signal } = options;
-  const factory = options.webSocketFactory ?? defaultFactory;
-  const wsBase = httpToWs(baseUrl);
-  const query = afterId !== void 0 ? `?after_id=${afterId}` : "";
-  const url = `${wsBase}/api/experimental/chats/${chatId}/stream${query}`;
-  const queue = [];
-  let resolveNext;
-  let finished = false;
-  let failure;
-  const wake = () => {
-    resolveNext?.();
-    resolveNext = void 0;
-  };
-  const ws = factory(url, { headers: { "Coder-Session-Token": token } });
-  const onAbort = () => {
-    finished = true;
+var STREAM_BACKOFF_INITIAL_MS = 1e3;
+var STREAM_BACKOFF_CAP_MS = 3e4;
+var STREAM_MAX_CONSECUTIVE_FAILURES = 5;
+var TRANSIENT_UPGRADE_STATUSES = /* @__PURE__ */ new Set([408, 425, 429]);
+function streamChatEvents(options) {
+  const controller = new AbortController();
+  const external = options.signal;
+  const chain = () => controller.abort(external?.reason);
+  if (external) {
+    if (external.aborted) chain();
+    else external.addEventListener("abort", chain, { once: true });
+  }
+  const inner = streamChatEventsLoop({ ...options, signal: controller.signal });
+  const detach = () => external?.removeEventListener("abort", chain);
+  const finish = async () => {
+    controller.abort();
+    detach();
     try {
-      ws.close(1e3);
+      await inner.return();
     } catch {
     }
-    wake();
   };
-  let abortListenerAdded = false;
-  if (signal) {
-    if (signal.aborted) onAbort();
-    else {
-      signal.addEventListener("abort", onAbort, { once: true });
-      abortListenerAdded = true;
+  return {
+    // Detach the signal chain once the loop settles for good (done, or a
+    // terminal failure) — the iteration protocol never calls return() on a
+    // failed iterator, and the {once} listener would otherwise pile up on a
+    // long-lived signal across re-created readers.
+    async next() {
+      try {
+        const result = await inner.next();
+        if (result.done) detach();
+        return result;
+      } catch (err) {
+        detach();
+        throw err;
+      }
+    },
+    async return() {
+      await finish();
+      return { done: true, value: void 0 };
+    },
+    async throw(err) {
+      await finish();
+      throw err;
+    },
+    [Symbol.asyncIterator]() {
+      return this;
+    },
+    // Native async generators are async-disposable; the wrapper must be too.
+    async [Symbol.asyncDispose]() {
+      await finish();
     }
-  }
-  const onMessage = (ev) => {
-    if (finished) return;
-    let batch;
-    try {
-      const data = typeof ev.data === "string" ? ev.data : String(ev.data);
-      batch = JSON.parse(data);
-    } catch (err) {
-      failure = new CoderAgentError("failed to parse chat stream frame", { cause: err });
+  };
+}
+async function* streamChatEventsLoop(options) {
+  const { baseUrl, token, chatId, signal } = options;
+  const factory = options.webSocketFactory ?? defaultFactory;
+  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;
+  let lastHistoryVersion;
+  let lastGenerationAttempt;
+  let lastSeq;
+  let sawUntrackableDelta = false;
+  let backoffMs = STREAM_BACKOFF_INITIAL_MS;
+  let failures = 0;
+  let lastFailure;
+  while (!signal?.aborted) {
+    const queue = [];
+    let resolveNext;
+    let finished = false;
+    let failure;
+    let parseFailure = false;
+    const wake = () => {
+      resolveNext?.();
+      resolveNext = void 0;
+    };
+    const ws = factory(url, { headers: { "Coder-Session-Token": token } });
+    const onAbort = () => {
       finished = true;
+      try {
+        ws.close(1e3);
+      } catch {
+      }
       wake();
-      return;
-    }
-    if (Array.isArray(batch)) {
-      for (const e of batch) queue.push(e);
-    } else if (batch && typeof batch === "object") {
-      queue.push(batch);
+    };
+    let abortListenerAdded = false;
+    if (signal) {
+      if (signal.aborted) onAbort();
+      else {
+        signal.addEventListener("abort", onAbort, { once: true });
+        abortListenerAdded = true;
+      }
     }
-    wake();
-  };
-  const onError = (ev) => {
-    if (finished) return;
-    const message = ev && typeof ev === "object" && "message" in ev ? String(ev.message) : "chat stream socket error";
-    failure = new CoderAgentError(message);
-    finished = true;
-    wake();
-  };
-  const onClose = () => {
-    finished = true;
-    wake();
-  };
-  ws.addEventListener("message", onMessage);
-  ws.addEventListener("error", onError);
-  ws.addEventListener("close", onClose);
-  try {
-    while (true) {
-      while (queue.length > 0) {
-        const next = queue.shift();
-        yield next;
+    const onMessage = (ev) => {
+      if (finished) return;
+      let batch;
+      try {
+        const data = typeof ev.data === "string" ? ev.data : String(ev.data);
+        batch = JSON.parse(data);
+      } catch (err) {
+        failure = new CoderAgentError("failed to parse chat stream frame", { cause: err });
+        parseFailure = true;
+        finished = true;
+        wake();
+        return;
+      }
+      if (Array.isArray(batch)) {
+        for (const e of batch) queue.push(e);
+      } else if (batch && typeof batch === "object") {
+        queue.push(batch);
       }
-      if (failure) throw failure;
+      wake();
+    };
+    const onError = (ev) => {
       if (finished) return;
-      await new Promise((resolve) => {
-        resolveNext = resolve;
+      const message = ev && typeof ev === "object" && "message" in ev ? String(ev.message) : "chat stream socket error";
+      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 = () => {
+      finished = true;
+      wake();
+    };
+    ws.addEventListener("message", onMessage);
+    ws.addEventListener("error", onError);
+    ws.addEventListener("close", onClose);
+    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) {
+            if (maxCommittedId === void 0 || next.message.id > maxCommittedId) {
+              maxCommittedId = next.message.id;
+              progress = true;
+              sawUntrackableDelta = false;
+            }
+          }
+          if (progress) {
+            failures = 0;
+            backoffMs = STREAM_BACKOFF_INITIAL_MS;
+          }
+          yield next;
+        }
+        if (finished) break;
+        await new Promise((resolve) => {
+          resolveNext = resolve;
+        });
+      }
+    } finally {
+      finished = true;
+      if (signal && abortListenerAdded) signal.removeEventListener("abort", onAbort);
+      ws.removeEventListener("message", onMessage);
+      ws.removeEventListener("error", onError);
+      ws.removeEventListener("close", onClose);
+      try {
+        ws.close(1e3);
+      } catch {
+      }
+    }
+    if (signal?.aborted) return;
+    if (failure instanceof CoderApiError) throw failure;
+    if (parseFailure && failure) throw failure;
+    if (sawUntrackableDelta) {
+      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
       });
     }
-  } finally {
-    finished = true;
-    if (signal && abortListenerAdded) signal.removeEventListener("abort", onAbort);
-    ws.removeEventListener("message", onMessage);
-    ws.removeEventListener("error", onError);
-    ws.removeEventListener("close", onClose);
-    try {
-      ws.close(1e3);
-    } catch {
+    if (failure) lastFailure = failure;
+    failures += 1;
+    if (failures >= STREAM_MAX_CONSECUTIVE_FAILURES) {
+      throw new CoderStreamError({
+        message: `Coder chat stream ${path} could not be (re-)established after ${failures} consecutive connection failures without progress`,
+        url,
+        cause: lastFailure
+      });
     }
+    await sleep(backoffMs, signal);
+    if (signal?.aborted) return;
+    backoffMs = Math.min(backoffMs * 2, STREAM_BACKOFF_CAP_MS);
   }
 }
 var WATCH_PATH = "/api/experimental/chats/watch";
@@ -883,11 +1017,29 @@ function dynamicToolNames(tools) {
 }
 
 // src/model/translate.ts
+function addDefined(a, b) {
+  if (b === void 0) return a;
+  return (a ?? 0) + b;
+}
+var USAGE_FIELD_KINDS = {
+  input_tokens: "sum",
+  output_tokens: "sum",
+  total_tokens: "sum",
+  reasoning_tokens: "sum",
+  cache_creation_tokens: "sum",
+  cache_read_tokens: "sum",
+  total_cost_micros: "sum",
+  total_runtime_ms: "sum",
+  context_limit: "newest"
+};
 function mapUsage(u) {
   return {
     inputTokens: {
-      total: u?.input_tokens,
-      noCache: void 0,
+      total: addDefined(
+        addDefined(u?.input_tokens, u?.cache_read_tokens),
+        u?.cache_creation_tokens
+      ),
+      noCache: u?.input_tokens,
       cacheRead: u?.cache_read_tokens,
       cacheWrite: u?.cache_creation_tokens
     },
@@ -896,11 +1048,28 @@ function mapUsage(u) {
       text: void 0,
       reasoning: u?.reasoning_tokens
     },
-    // Preserve the verbatim wire usage (snake_case) so callers can reach fields
+    // Preserve the turn's wire usage (snake_case) so callers can reach fields
     // the normalized shape has no slot for (context_limit, cost, runtime, …).
     ...u ? { raw: u } : {}
   };
 }
+function accumulateUsage(byMessageId) {
+  if (byMessageId.size === 0) return void 0;
+  const total = {};
+  const newestIdByKey = /* @__PURE__ */ new Map();
+  for (const [id, u] of byMessageId) {
+    for (const [key, value] of Object.entries(u)) {
+      if (value === void 0) continue;
+      if (USAGE_FIELD_KINDS[key] === "sum" && typeof value === "number") {
+        total[key] = (total[key] ?? 0) + value;
+      } else if (id > (newestIdByKey.get(key) ?? -1)) {
+        newestIdByKey.set(key, id);
+        total[key] = value;
+      }
+    }
+  }
+  return total;
+}
 function jsonResult(value) {
   return value ?? {};
 }
@@ -919,12 +1088,29 @@ var TurnTranslator = class {
   #clientToolCalls = /* @__PURE__ */ new Set();
   #clientToolCallSeen = false;
   #sources = /* @__PURE__ */ new Set();
-  #usage;
+  // Per-message wire usage, keyed by message id so a re-streamed revision of
+  // 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();
   #error;
   #terminalStatus;
   #maxMessageId = 0;
+  /**
+   * Messages with an id at or below this cursor belong to earlier turns (or
+   * 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.
+   */
+  #turnCursor;
   constructor(opts) {
     this.#dynamicToolNames = opts.dynamicToolNames;
+    this.#turnCursor = opts.turnCursor ?? 0;
   }
   get terminalStatus() {
     return this.#terminalStatus;
@@ -1144,11 +1330,23 @@ var TurnTranslator = class {
   }
   #ingestMessage(out, message) {
     if (message.id > this.#maxMessageId) this.#maxMessageId = message.id;
-    if (message.usage && (message.role === "assistant" || message.role === "tool")) {
-      this.#usage = message.usage;
+    if (message.id <= this.#turnCursor) return;
+    if (message.usage && message.role === "assistant") {
+      this.#usageByMessageId.set(message.id, message.usage);
     }
     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);
+        }
+        return;
+      }
+      this.#snapshotSeen.add(message.id);
       if (this.#currentAssistantId !== void 0 && this.#currentAssistantId !== message.id && !this.#deltasSinceSnapshot) {
         this.#closeText(out);
         this.#closeReasoning(out);
@@ -1156,13 +1354,24 @@ var TurnTranslator = class {
         this.#reasoning.sawDelta = false;
       }
       this.#currentAssistantId = message.id;
-      if (!this.#text.sawDelta) {
-        const full = content.filter((p) => p.type === "text").map((p) => p.text ?? "").join("");
-        if (full.length > 0) this.#emitTextUpTo(out, full);
-      }
-      if (!this.#reasoning.sawDelta) {
-        const full = content.filter((p) => p.type === "reasoning").map((p) => p.text ?? "").join("");
-        if (full.length > 0) this.#emitReasoningUpTo(out, full);
+      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);
+        }
+      };
+      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 (this.#reasoning.id) {
+        emitSnapshotReasoning();
+        emitSnapshotText();
+      } else {
+        emitSnapshotText();
+        emitSnapshotReasoning();
       }
       for (const part of content) {
         if (part.type === "tool-call" && !this.#isClientTool(part.tool_name))
@@ -1190,14 +1399,13 @@ var TurnTranslator = class {
     else if (this.#clientToolCallSeen || this.#terminalStatus === "requires_action")
       unified = "tool-calls";
     else unified = "stop";
+    const usage = accumulateUsage(this.#usageByMessageId);
     const coder = {};
-    if (this.#usage?.total_cost_micros !== void 0)
-      coder.total_cost_micros = this.#usage.total_cost_micros;
-    if (this.#usage?.total_runtime_ms !== void 0)
-      coder.total_runtime_ms = this.#usage.total_runtime_ms;
+    if (usage?.total_cost_micros !== void 0) coder.total_cost_micros = usage.total_cost_micros;
+    if (usage?.total_runtime_ms !== void 0) coder.total_runtime_ms = usage.total_runtime_ms;
     out.push({
       type: "finish",
-      usage: mapUsage(this.#usage),
+      usage: mapUsage(usage),
       finishReason: { unified, raw: this.#terminalStatus },
       ...Object.keys(coder).length > 0 ? { providerMetadata: { coder } } : {}
     });
@@ -1206,6 +1414,15 @@ var TurnTranslator = class {
 };
 
 // src/model/language-model.ts
+var ACTION_REQUIRED_GRACE_MS = 2e3;
+var GRACE_EXPIRED = /* @__PURE__ */ Symbol("action-required-grace-expired");
+function startGraceTimer(ms) {
+  let timer;
+  const expired = new Promise((resolve) => {
+    timer = setTimeout(() => resolve(GRACE_EXPIRED), ms);
+  });
+  return { expired, cancel: () => clearTimeout(timer) };
+}
 var EMPTY_USAGE = {
   inputTokens: {
     total: void 0,
@@ -1259,17 +1476,74 @@ var CoderLanguageModel = class {
    * id, so this runs before the chat exists). Pre-uploaded files carried via
    * `providerOptions.coder.fileId` are referenced without re-uploading.
    */
-  #buildContent(content, signal) {
+  #buildContent(content, signal, onUpload) {
     const uploadFile = async (f) => {
       const uploaded = await this.#config.client.uploadChatFile(
         this.#config.organizationId,
         { content: dataContentToFileContent(f.data), mediaType: f.mediaType, name: f.filename },
         signal
       );
+      onUpload?.();
       return uploaded.id;
     };
     return userContentToInputParts(content, uploadFile);
   }
+  /**
+   * REST fallback for a `requires_action` segment whose `action_required`
+   * event never arrived: recover the turn's pending client tool calls from
+   * committed chat history (`GET /chats/{id}/messages`) — the same history
+   * chatd itself derives `action_required` from server-side. Returns synthetic
+   * stream events for the translator: the turn's message snapshots first (so
+   * text, usage, and the message cursor stay consistent even if the stream
+   * also missed a commit — the translator's id-keyed dedup makes re-ingesting
+   * already-delivered ones a no-op), then one `action_required` event carrying
+   * the unresolved dynamic tool calls. Returns `[]` when history shows no
+   * pending calls — nothing to recover, the caller keeps waiting on the
+   * stream, bounded by `requestTimeoutMs`/abort.
+   */
+  async #recoverRequiresAction(chatId, dynamicNames, afterId, 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 lastAssistant = turnMessages.findLast((m) => m.role === "assistant");
+    if (!lastAssistant) return [];
+    const handled = /* @__PURE__ */ new Set();
+    for (const message of turnMessages) {
+      if (message.id <= lastAssistant.id) continue;
+      for (const part of message.content ?? []) {
+        if (part.type === "tool-result" && part.tool_call_id) handled.add(part.tool_call_id);
+      }
+    }
+    const toolCalls = [];
+    for (const part of lastAssistant.content ?? []) {
+      if (part.type !== "tool-call" || part.provider_executed) continue;
+      if (!part.tool_call_id || !part.tool_name) continue;
+      if (!dynamicNames.has(part.tool_name)) continue;
+      if (handled.has(part.tool_call_id)) continue;
+      if (this.#submittedToolCallIds.has(part.tool_call_id)) continue;
+      toolCalls.push({
+        tool_call_id: part.tool_call_id,
+        tool_name: part.tool_name,
+        // `action_required` carries args as their raw JSON text (chatd sends
+        // `string(part.Args)` of the history part's json.RawMessage);
+        // re-encoding the snapshot's parsed JSON value reconstructs it. A
+        // JSON `null` is a legitimate argument value and must survive; only
+        // an ABSENT args field falls back to empty-object args.
+        args: JSON.stringify(part.args === void 0 ? {} : part.args)
+      });
+    }
+    if (toolCalls.length === 0) return [];
+    const events = turnMessages.map((message) => ({
+      type: "message",
+      chat_id: chatId,
+      message
+    }));
+    events.push({
+      type: "action_required",
+      chat_id: chatId,
+      action_required: { tool_calls: toolCalls }
+    });
+    return events;
+  }
   async *#runTurn(options) {
     if (this.#inFlight) {
       throw new CoderAgentError(
@@ -1284,7 +1558,8 @@ var CoderLanguageModel = class {
       (s) => s !== void 0
     );
     const signal = sources.length > 0 ? AbortSignal.any(sources) : void 0;
-    const translator = new TurnTranslator({ dynamicToolNames: dynamicToolNames(options.tools) });
+    let translator;
+    let discardSession = false;
     let interruptSent = false;
     const interrupt = () => {
       const id = this.#chatId;
@@ -1324,10 +1599,23 @@ var CoderLanguageModel = class {
         );
       }
       let afterId;
+      let turnCreatedChat = false;
+      let uploadedAttachment = false;
+      let chatHasWorkspace = Boolean(this.#config.workspaceId);
+      if (this.#chatId && this.#lastSeenMessageId === 0) {
+        const { messages } = await this.#config.client.getMessages(
+          this.#chatId,
+          { limit: 1 },
+          signal
+        );
+        this.#lastSeenMessageId = messages[0]?.id ?? 0;
+      }
       if (action.kind === "new-turn") {
         const [modelConfigId, content] = await Promise.all([
           this.#resolveModelConfigId(signal),
-          this.#buildContent(action.content, signal)
+          this.#buildContent(action.content, signal, () => {
+            uploadedAttachment = true;
+          })
         ]);
         if (!this.#chatId) {
           const req = {
@@ -1345,6 +1633,8 @@ var CoderLanguageModel = class {
           if (this.#config.planMode) req.plan_mode = this.#config.planMode;
           const chat = await this.#config.client.createChat(req, signal);
           this.#chatId = chat.id;
+          turnCreatedChat = true;
+          if (chat.workspace_id) chatHasWorkspace = true;
           afterId = this.#lastSeenMessageId > 0 ? this.#lastSeenMessageId : void 0;
         } else {
           const resp = await this.#config.client.createChatMessage(
@@ -1370,10 +1660,58 @@ var CoderLanguageModel = class {
         afterId = this.#lastSeenMessageId;
       }
       const chatId = this.#chatId;
+      const dynamicNames = dynamicToolNames(options.tools);
+      translator = new TurnTranslator({
+        dynamicToolNames: dynamicNames,
+        turnCursor: afterId ?? 0
+      });
       let sinceRequiresAction = 0;
+      let grace;
+      let recovery;
+      let recoveryAbort;
+      let recoveryAttempted = false;
+      const stream = this.#config.client.streamEvents(chatId, { afterId, signal });
       try {
-        for await (const ev of this.#config.client.streamEvents(chatId, { afterId, signal })) {
-          for (const part of translator.ingest(ev)) yield part;
+        let next = stream.next();
+        for (; ; ) {
+          let result;
+          const awaitingActionRequired = translator.terminalStatus === "requires_action" && !translator.clientToolCallSeen;
+          if (awaitingActionRequired && !recoveryAttempted) {
+            grace ??= startGraceTimer(ACTION_REQUIRED_GRACE_MS);
+            const raced = await Promise.race([next, grace.expired]);
+            if (raced === GRACE_EXPIRED) {
+              recoveryAttempted = true;
+              throwIfAborted();
+              recoveryAbort = new AbortController();
+              recovery = this.#recoverRequiresAction(
+                chatId,
+                dynamicNames,
+                afterId,
+                signal ? AbortSignal.any([signal, recoveryAbort.signal]) : recoveryAbort.signal
+              ).catch(() => []);
+              continue;
+            }
+            result = raced;
+          } else if (awaitingActionRequired && recovery) {
+            const raced = await 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;
+              }
+              continue;
+            }
+            result = raced;
+          } else {
+            result = await next;
+          }
+          if (result.done) break;
+          next = stream.next();
+          for (const part of translator.ingest(result.value)) yield part;
           const status = translator.terminalStatus;
           if (status) {
             if (status !== "requires_action") break;
@@ -1383,6 +1721,19 @@ var CoderLanguageModel = class {
         }
       } catch (err) {
         throwIfAborted();
+        if (err instanceof CoderStreamError) {
+          if (turnCreatedChat) {
+            discardSession = true;
+          }
+          const effectful = chatHasWorkspace || Boolean(this.#config.mcpServerIds?.length) || 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)"}`,
+            url: err.url,
+            cause: err,
+            isRetryable: false
+          });
+        }
         if (err instanceof CoderAgentError && !(err instanceof CoderApiError) && !(err instanceof CoderChatError)) {
           throw new CoderChatError({
             message: `Coder chat stream failed mid-turn: ${err.message}`,
@@ -1391,6 +1742,11 @@ var CoderLanguageModel = class {
           });
         }
         throw err;
+      } finally {
+        grace?.cancel();
+        recoveryAbort?.abort();
+        await stream.return(void 0).catch(() => {
+        });
       }
       throwIfAborted();
       if (!translator.terminalStatus && !translator.error) {
@@ -1405,10 +1761,11 @@ var CoderLanguageModel = class {
       throwIfAborted();
       throw err;
     } finally {
-      if (translator.maxMessageId > this.#lastSeenMessageId)
+      if (translator && translator.maxMessageId > this.#lastSeenMessageId)
         this.#lastSeenMessageId = translator.maxMessageId;
       signal?.removeEventListener("abort", interrupt);
-      if (!translator.terminalStatus) interrupt();
+      if (!translator?.terminalStatus) interrupt();
+      if (discardSession) this.resetSession();
       this.#inFlight = false;
     }
   }
@@ -1734,7 +2091,7 @@ var CoderAgent = class {
   async uploadToWorkspace(file) {
     if (!this.#workspaceFiles) {
       throw new CoderAgentError(
-        "uploadToWorkspace requires a `workspaceFiles` adapter. Construct the agent with `workspaceFiles` (e.g. backed by a @coder/ai-sdk-eve-sandbox session) to enable it."
+        "uploadToWorkspace requires a `workspaceFiles` adapter. Construct the agent with `workspaceFiles` (e.g. backed by a @coder/ai-sdk-sandbox workspace session) to enable it."
       );
     }
     const { path } = await this.#workspaceFiles.write({
@@ -1905,7 +2262,9 @@ export {
   CoderChatClient,
   CoderChatError,
   CoderLanguageModel,
+  CoderStreamError,
   MAX_CHAT_FILE_SIZE_BYTES,
+  TERMINAL_STATUSES,
   TurnTranslator,
   chatMessagesToUIMessages,
   classifyTurnAction,