@coder/ai-sdk-agent 0.6.0 → 0.6.1

package/README.md

@@ -723,8 +723,12 @@ CoderAgent  (implements ai.Agent)
 - One `doStream` call advances the chat until it **settles** (`waiting`/`completed`) or
   **pauses** for a client tool (`requires_action`). The SDK loop and the server‑side loop
   mesh at the client‑tool boundary, so there's no double loop.
-- Streaming text is emitted from `message_part` deltas; fast turns that only produce a full
-  `message` snapshot are diffed against an emitted‑length cursor — so neither double‑counts.
+- Streaming text is emitted from `message_part` deltas; every `message` snapshot is then
+  reconciled against a per‑message emitted‑content ledger, so nothing double‑counts: a
+  trailing snapshot after deltas is a no‑op, a fast snapshot‑only turn emits in full, a
+  message that commits while the stream is redialing yields exactly its missing tail, and a
+  revision that appends to an earlier message yields the appended suffix (rewrites that
+  can't be expressed as deltas are safely suppressed).
 
 ## Durable workflows (Vercel Workflow, step functions, …)
 

package/dist/index.d.ts

@@ -1127,15 +1127,18 @@ declare class CoderLanguageModel implements LanguageModelV4 {
  * Translates one chatd turn's {@link ChatStreamEvent} stream into a sequence of
  * `LanguageModelV4StreamPart`s for the AI SDK.
  *
- * Two text/reasoning modes, decided per assistant message from the wire
- * behavior:
- *  - **delta mode** — chatd streamed `message_part` deltas; we emit those and
- *    treat the message's trailing full `message` snapshot as a no-op for
- *    text/reasoning. Deltas carry no message id, so "deltas arrived since the
- *    last assistant snapshot" is what marks a snapshot as trailing.
- *  - **snapshot mode** — fast turns where only full `message` snapshots arrive;
- *    we diff each snapshot's full text against what we've already emitted.
- * Both paths track an emitted-length cursor, so neither double-counts.
+ * Text/reasoning is reconciled against a per-message emitted-content ledger:
+ * `message_part` deltas are emitted as they stream (they carry no message id,
+ * so they accumulate as *pending* content), and each assistant `message`
+ * snapshot attributes the pending content to its id and emits whatever suffix
+ * of the snapshot's full content is still missing. That makes fast
+ * snapshot-only messages (everything missing), trailing snapshots after deltas
+ * (nothing missing), commit-during-disconnect snapshots (the tail the lost
+ * deltas never delivered), and append-revisions of earlier messages (the
+ * appended suffix) all the same operation — and a snapshot whose content does
+ * not extend what was emitted (a byte-identical replay, or a rewrite that
+ * cannot be expressed as deltas) is safely suppressed instead of
+ * double-emitted.
  *
  * Client (custom) tool calls are emitted from the reliable `action_required`
  * event and left for the AI SDK to execute. chatd's own server-side tools are

package/dist/index.js

@@ -249,6 +249,7 @@ async function* streamChatEventsLoop(options) {
   const query = options.afterId !== void 0 ? `?after_id=${options.afterId}` : "";
   const url = `${wsBase}${path}${query}`;
   let maxCommittedId = options.afterId;
+  const lastMessageJson = /* @__PURE__ */ new Map();
   let lastHistoryVersion;
   let lastGenerationAttempt;
   let lastSeq;
@@ -391,9 +392,13 @@ async function* streamChatEventsLoop(options) {
               sawUntrackableDelta = true;
             }
           } else if (next.type === "message" && next.message) {
+            const serialized = JSON.stringify(next.message);
+            if (lastMessageJson.get(next.message.id) !== serialized) {
+              lastMessageJson.set(next.message.id, serialized);
+              progress = true;
+            }
             if (maxCommittedId === void 0 || next.message.id > maxCommittedId) {
               maxCommittedId = next.message.id;
-              progress = true;
               sawUntrackableDelta = false;
             }
           }
@@ -1283,12 +1288,21 @@ function accumulateUsage(byMessageId) {
 function jsonResult(value) {
   return value ?? {};
 }
+function joinContent(content, kind) {
+  let full = "";
+  for (const p of content) if (p.type === kind) full += p.text ?? "";
+  return full;
+}
 var TurnTranslator = class {
   #dynamicToolNames;
   #submittedToolCallIds;
   #seq = 0;
-  #text = { id: void 0, len: 0, sawDelta: false };
-  #reasoning = { id: void 0, len: 0, sawDelta: false };
+  // `pending` accumulates delta content that has been emitted but not yet
+  // attributed to a message id (deltas carry none); the next assistant
+  // snapshot claims it. It survives block closes — a closed block loses its
+  // stream id, never the record of what was emitted.
+  #text = { id: void 0, pending: "" };
+  #reasoning = { id: void 0, pending: "" };
   #currentAssistantId;
   // Whether text/reasoning deltas arrived since the last assistant `message`
   // snapshot — i.e. the next assistant snapshot is the trailing snapshot of the
@@ -1303,11 +1317,22 @@ var TurnTranslator = class {
   // the same message replaces its earlier entry instead of double-counting
   // (chatd re-sends full snapshots on revision bumps and history resets).
   #usageByMessageId = /* @__PURE__ */ new Map();
-  // Assistant snapshots already processed once. A redial replays the turn
-  // from its original cursor, so earlier messages arrive again — without this,
-  // re-running the boundary logic on them would reset the emitted-length
-  // cursors and re-emit their entire text (see #ingestMessage).
-  #snapshotSeen = /* @__PURE__ */ new Set();
+  // The emitted-content ledger: the text/reasoning this translator has emitted
+  // for each processed assistant message id. A redial replays the turn from
+  // its original cursor and chatd re-sends full snapshots on revision bumps,
+  // so already-processed messages arrive again — the ledger is what lets a
+  // byte-identical replay reconcile to a no-op while an APPENDING revision (or
+  // a commit-during-disconnect snapshot) yields exactly its missing suffix
+  // (see #ingestMessage). `substantive` records whether any processed snapshot
+  // of the message carried content (text, reasoning, tools, or sources) —
+  // false only for announce-style empty snapshots, whose in-flight deltas are
+  // still claimable by a same-id commit.
+  #emittedByMessageId = /* @__PURE__ */ new Map();
+  // Same-id revision snapshots that arrived while the NEXT step's deltas were
+  // open (latest wins). chatd sends each revision once on a healthy
+  // connection, so the suffix cannot wait for a replay — it is reconciled as
+  // soon as the next step's snapshot settles ownership of the pending deltas.
+  #deferredRevisions = /* @__PURE__ */ new Map();
   #error;
   #terminalStatus;
   #maxMessageId = 0;
@@ -1342,7 +1367,6 @@ var TurnTranslator = class {
     if (this.#reasoning.id) this.#closeReasoning(out);
     if (!this.#text.id) {
       this.#text.id = `text-${++this.#seq}`;
-      this.#text.len = 0;
       out.push({ type: "text-start", id: this.#text.id });
     }
   }
@@ -1350,14 +1374,12 @@ var TurnTranslator = class {
     if (this.#text.id) {
       out.push({ type: "text-end", id: this.#text.id });
       this.#text.id = void 0;
-      this.#text.len = 0;
     }
   }
   #openReasoning(out) {
     if (this.#text.id) this.#closeText(out);
     if (!this.#reasoning.id) {
       this.#reasoning.id = `reasoning-${++this.#seq}`;
-      this.#reasoning.len = 0;
       out.push({ type: "reasoning-start", id: this.#reasoning.id });
     }
   }
@@ -1365,31 +1387,40 @@ var TurnTranslator = class {
     if (this.#reasoning.id) {
       out.push({ type: "reasoning-end", id: this.#reasoning.id });
       this.#reasoning.id = void 0;
-      this.#reasoning.len = 0;
     }
   }
-  #emitTextUpTo(out, full) {
-    if (full.length <= this.#text.len && this.#text.id) return;
+  #emitTextDelta(out, delta) {
     this.#openText(out);
-    if (full.length > this.#text.len) {
-      out.push({
-        type: "text-delta",
-        id: this.#text.id,
-        delta: full.slice(this.#text.len)
-      });
-      this.#text.len = full.length;
-    }
+    out.push({ type: "text-delta", id: this.#text.id, delta });
   }
-  #emitReasoningUpTo(out, full) {
-    if (full.length <= this.#reasoning.len && this.#reasoning.id) return;
+  #emitReasoningDelta(out, delta) {
     this.#openReasoning(out);
-    if (full.length > this.#reasoning.len) {
-      out.push({
-        type: "reasoning-delta",
-        id: this.#reasoning.id,
-        delta: full.slice(this.#reasoning.len)
-      });
-      this.#reasoning.len = full.length;
+    out.push({ type: "reasoning-delta", id: this.#reasoning.id, delta });
+  }
+  /**
+   * Reconciles a replayed/revised snapshot of an EARLIER (non-current)
+   * assistant message against its ledger entry: an APPENDING revision emits
+   * its suffix, anything else is a no-op. The suffix is bracketed in its own
+   * block(s) — an open block belongs to the CURRENT step, and splicing another
+   * message's content into it would corrupt both — and the interrupted step's
+   * next delta simply opens a fresh block (its pending content is tracked
+   * independently of blocks).
+   */
+  #reconcileRevision(out, rec, fullText, fullReasoning) {
+    const textSuffix = fullText.length > rec.text.length && fullText.startsWith(rec.text) ? fullText.slice(rec.text.length) : "";
+    const reasoningSuffix = fullReasoning.length > rec.reasoning.length && fullReasoning.startsWith(rec.reasoning) ? fullReasoning.slice(rec.reasoning.length) : "";
+    if (!textSuffix && !reasoningSuffix) return;
+    this.#closeText(out);
+    this.#closeReasoning(out);
+    if (reasoningSuffix) {
+      this.#emitReasoningDelta(out, reasoningSuffix);
+      rec.reasoning = fullReasoning;
+      this.#closeReasoning(out);
+    }
+    if (textSuffix) {
+      this.#emitTextDelta(out, textSuffix);
+      rec.text = fullText;
+      this.#closeText(out);
     }
   }
   // --- tool helpers ---------------------------------------------------------
@@ -1513,21 +1544,19 @@ var TurnTranslator = class {
     const part = mp.part;
     switch (part.type) {
       case "text":
-        this.#text.sawDelta = true;
         this.#deltasSinceSnapshot = true;
         this.#openText(out);
         if (part.text) {
           out.push({ type: "text-delta", id: this.#text.id, delta: part.text });
-          this.#text.len += part.text.length;
+          this.#text.pending += part.text;
         }
         break;
       case "reasoning":
-        this.#reasoning.sawDelta = true;
         this.#deltasSinceSnapshot = true;
         this.#openReasoning(out);
         if (part.text) {
           out.push({ type: "reasoning-delta", id: this.#reasoning.id, delta: part.text });
-          this.#reasoning.len += part.text.length;
+          this.#reasoning.pending += part.text;
         }
         break;
       case "tool-call":
@@ -1553,42 +1582,56 @@ var TurnTranslator = class {
     }
     const content = message.content ?? [];
     if (message.role === "assistant") {
-      if (this.#snapshotSeen.has(message.id) && (message.id !== this.#currentAssistantId || this.#deltasSinceSnapshot)) {
-        for (const part of content) {
-          if (part.type === "tool-call" && !this.#isClientTool(part.tool_name))
-            this.#emitServerToolCall(out, part);
-          else if (part.type === "tool-result" && !this.#isClientTool(part.tool_name))
-            this.#emitServerToolResult(out, part);
-          else if (part.type === "source") this.#emitSource(out, part);
+      const fullText = joinContent(content, "text");
+      const fullReasoning = joinContent(content, "reasoning");
+      const known = this.#emittedByMessageId.get(message.id);
+      if (known && message.id !== this.#currentAssistantId) {
+        this.#reconcileRevision(out, known, fullText, fullReasoning);
+      } else if (known && this.#deltasSinceSnapshot && known.substantive) {
+        this.#deferredRevisions.set(message.id, { text: fullText, reasoning: fullReasoning });
+      } else {
+        if (this.#currentAssistantId !== void 0 && this.#currentAssistantId !== message.id && !this.#deltasSinceSnapshot) {
+          this.#closeText(out);
+          this.#closeReasoning(out);
         }
-        return;
-      }
-      this.#snapshotSeen.add(message.id);
-      if (this.#currentAssistantId !== void 0 && this.#currentAssistantId !== message.id && !this.#deltasSinceSnapshot) {
-        this.#closeText(out);
-        this.#closeReasoning(out);
-        this.#text.sawDelta = false;
-        this.#reasoning.sawDelta = false;
-      }
-      this.#currentAssistantId = message.id;
-      const emitSnapshotText = () => {
-        if (!this.#text.sawDelta || this.#text.id) {
-          const full = content.filter((p) => p.type === "text").map((p) => p.text ?? "").join("");
-          if (full.length > 0) this.#emitTextUpTo(out, full);
+        this.#currentAssistantId = message.id;
+        const rec = known ?? { text: "", reasoning: "", substantive: false };
+        const textAttributed = rec.text + this.#text.pending;
+        const reasoningAttributed = rec.reasoning + this.#reasoning.pending;
+        const textOk = fullText.startsWith(textAttributed);
+        const reasoningOk = fullReasoning.startsWith(reasoningAttributed);
+        let seenText = 0;
+        let seenReasoning = 0;
+        for (const p of content) {
+          if (p.type === "text") {
+            const end = seenText + (p.text ?? "").length;
+            const from = Math.max(seenText, textAttributed.length);
+            if (textOk && end > from) this.#emitTextDelta(out, fullText.slice(from, end));
+            seenText = end;
+          } else if (p.type === "reasoning") {
+            const end = seenReasoning + (p.text ?? "").length;
+            const from = Math.max(seenReasoning, reasoningAttributed.length);
+            if (reasoningOk && end > from)
+              this.#emitReasoningDelta(out, fullReasoning.slice(from, end));
+            seenReasoning = end;
+          }
         }
-      };
-      const emitSnapshotReasoning = () => {
-        if (!this.#reasoning.sawDelta || this.#reasoning.id) {
-          const full = content.filter((p) => p.type === "reasoning").map((p) => p.text ?? "").join("");
-          if (full.length > 0) this.#emitReasoningUpTo(out, full);
+        if (textOk) rec.text = fullText;
+        if (reasoningOk) rec.reasoning = fullReasoning;
+        this.#text.pending = "";
+        this.#reasoning.pending = "";
+        rec.substantive ||= content.some(
+          (p) => p.type === "text" || p.type === "reasoning" ? (p.text ?? "").length > 0 : true
+        );
+        this.#emittedByMessageId.set(message.id, rec);
+        this.#deltasSinceSnapshot = false;
+        for (const [id, deferred] of this.#deferredRevisions) {
+          if (id === message.id) continue;
+          const deferredRec = this.#emittedByMessageId.get(id);
+          if (deferredRec)
+            this.#reconcileRevision(out, deferredRec, deferred.text, deferred.reasoning);
+          this.#deferredRevisions.delete(id);
         }
-      };
-      if (this.#reasoning.id) {
-        emitSnapshotReasoning();
-        emitSnapshotText();
-      } else {
-        emitSnapshotText();
-        emitSnapshotReasoning();
       }
       for (const part of content) {
         if (part.type === "tool-call" && !this.#isClientTool(part.tool_name))
@@ -1597,7 +1640,6 @@ var TurnTranslator = class {
           this.#emitServerToolResult(out, part);
         else if (part.type === "source") this.#emitSource(out, part);
       }
-      this.#deltasSinceSnapshot = false;
     } else if (message.role === "tool") {
       for (const part of content) {
         if (part.type === "tool-result" && !this.#isClientTool(part.tool_name))
@@ -1854,7 +1896,9 @@ var CoderLanguageModel = class {
    *   {@link #runTurnInner} once known) — a retry-safe stream failure on a
    *   freshly created chat discards the session (clearing `this.#chatId`)
    *   before the finally runs, and the settle must still name the chat that
-   *   the preceding `ws:*`/`http:*` events identified.
+   *   the preceding `ws:*`/`http:*` events identified. The same out-param
+   *   carries the translator's terminal status and the internal-timeout
+   *   marker for generator-return exits (see {@link SegmentChatRef}).
    */
   async *#runTurn(options, isConsumerCancel) {
     const emit = this.#emitTransportEvent;
@@ -1899,8 +1943,11 @@ var CoderLanguageModel = class {
       };
       const chatId = segmentChat.chatId ?? this.#chatId;
       if (chatId !== void 0) settleEvent.chatId = chatId;
-      if (!failed && finishReason === void 0 && options.abortSignal?.aborted) {
-        if (!isConsumerCancel?.()) {
+      if (!failed && finishReason === void 0) {
+        if (segmentChat.timeoutError) {
+          failure = segmentChat.timeoutError;
+          failed = true;
+        } else if (options.abortSignal?.aborted && !isConsumerCancel?.()) {
           failure = options.abortSignal.reason;
           failed = true;
         }
@@ -1914,6 +1961,8 @@ var CoderLanguageModel = class {
       if (finishReason !== void 0) {
         if (finishReason.raw !== void 0) settleEvent.status = finishReason.raw;
         if (!failed) settleEvent.finishReason = finishReason.unified;
+      } else if (segmentChat.terminalStatus !== void 0) {
+        settleEvent.status = segmentChat.terminalStatus;
       }
       emit(settleEvent);
     }
@@ -1945,13 +1994,14 @@ var CoderLanguageModel = class {
       });
     };
     signal?.addEventListener("abort", interrupt, { once: true });
+    const timeoutError = () => new CoderChatError({
+      message: `Coder Agent turn exceeded its ${timeoutMs}ms requestTimeoutMs budget.`,
+      kind: "timeout",
+      retryable: true
+    });
     const throwIfAborted = () => {
       if (timeoutSignal?.aborted) {
-        throw new CoderChatError({
-          message: `Coder Agent turn exceeded its ${timeoutMs}ms requestTimeoutMs budget.`,
-          kind: "timeout",
-          retryable: true
-        });
+        throw timeoutError();
       }
       if (signal?.aborted) {
         throw externalSignal?.reason ?? new DOMException("The operation was aborted.", "AbortError");
@@ -1978,6 +2028,7 @@ var CoderLanguageModel = class {
       let turnCreatedChat = false;
       let uploadedAttachment = false;
       let chatHasWorkspace = Boolean(this.#config.workspaceId);
+      let chatHasMcpServers = Boolean(this.#config.mcpServerIds?.length);
       if (this.#chatId && this.#lastSeenMessageId === 0) {
         const { messages } = await this.#config.client.getMessages(
           this.#chatId,
@@ -2011,6 +2062,7 @@ var CoderLanguageModel = class {
           this.#chatId = chat.id;
           turnCreatedChat = true;
           if (chat.workspace_id) chatHasWorkspace = true;
+          if (chat.mcp_server_ids?.length) chatHasMcpServers = true;
           afterId = this.#lastSeenMessageId > 0 ? this.#lastSeenMessageId : void 0;
         } else {
           const resp = await this.#config.client.createChatMessage(
@@ -2109,7 +2161,20 @@ var CoderLanguageModel = class {
           }
           stream.consumed(next);
           if (raced.done) break;
-          for (const part of translator.ingest(raced.value)) yield part;
+          const parts = translator.ingest(raced.value);
+          if (raced.value.type === "error" && translator.error && !translator.terminalStatus) {
+            const peek = stream.read();
+            const bound = startGraceTimer(0);
+            const peeked = await raceSegment(Promise.race([peek, bound.expired])).catch(
+              () => GRACE_EXPIRED
+            );
+            bound.cancel();
+            if (peeked !== GRACE_EXPIRED && peeked !== SEGMENT_ABORTED && !peeked.done) {
+              stream.consumed(peek);
+              parts.push(...translator.ingest(peeked.value));
+            }
+          }
+          for (const part of parts) yield part;
           const status = translator.terminalStatus;
           if (status) {
             if (status !== "requires_action") break;
@@ -2124,7 +2189,7 @@ var CoderLanguageModel = class {
           if (turnCreatedChat) {
             discardSession = true;
           }
-          const effectful = chatHasWorkspace || Boolean(this.#config.mcpServerIds?.length) || uploadedAttachment;
+          const effectful = chatHasWorkspace || chatHasMcpServers || uploadedAttachment;
           if (turnCreatedChat && !effectful) throw err;
           throw new CoderStreamError({
             message: `${err.message}; automatic retry is disabled because ${turnCreatedChat ? "the turn has server-side effects a replay would repeat (workspace/MCP tools that may have executed, or freshly uploaded attachments)" : "the chat has prior state (a retry would resubmit this turn's prompt as a new user turn)"}`,
@@ -2166,6 +2231,12 @@ var CoderLanguageModel = class {
     } finally {
       if (translator && translator.maxMessageId > this.#lastSeenMessageId)
         this.#lastSeenMessageId = translator.maxMessageId;
+      if (segmentChat) {
+        if (translator?.terminalStatus !== void 0) {
+          segmentChat.terminalStatus = translator.terminalStatus;
+        }
+        if (timeoutSignal?.aborted) segmentChat.timeoutError = timeoutError();
+      }
       signal?.removeEventListener("abort", interrupt);
       if (!translator?.terminalStatus) interrupt();
       if (!streamAcquired && this.#retainedStream) {