@coder/ai-sdk-agent 0.6.2 → 0.7.0

package/dist/index.js

@@ -185,6 +185,11 @@ function httpToWs(baseUrl) {
   if (baseUrl.startsWith("http://")) return `ws://${baseUrl.slice("http://".length)}`;
   return baseUrl;
 }
+var readerSeq = 0;
+function nextStreamReaderId() {
+  readerSeq += 1;
+  return readerSeq;
+}
 var STREAM_BACKOFF_INITIAL_MS = 1e3;
 var STREAM_BACKOFF_CAP_MS = 3e4;
 var STREAM_MAX_CONSECUTIVE_FAILURES = 5;
@@ -197,7 +202,8 @@ function streamChatEvents(options) {
     if (external.aborted) chain();
     else external.addEventListener("abort", chain, { once: true });
   }
-  const inner = streamChatEventsLoop({ ...options, signal: controller.signal });
+  const reader = options.reader ?? nextStreamReaderId();
+  const inner = streamChatEventsLoop({ ...options, reader, signal: controller.signal });
   const detach = () => external?.removeEventListener("abort", chain);
   const finish = async () => {
     controller.abort();
@@ -240,7 +246,7 @@ function streamChatEvents(options) {
   };
 }
 async function* streamChatEventsLoop(options) {
-  const { baseUrl, token, chatId, signal } = options;
+  const { baseUrl, token, chatId, signal, reader } = options;
   const factory = options.webSocketFactory ?? defaultFactory;
   const emit = safeTransportEmitter(options.onTransportEvent);
   let attempt = 0;
@@ -269,15 +275,15 @@ async function* streamChatEventsLoop(options) {
       resolveNext = void 0;
     };
     attempt += 1;
-    emit?.({ type: "ws:dial", chatId, attempt, url, timestamp: Date.now() });
+    emit?.({ type: "ws:dial", chatId, reader, attempt, url, timestamp: Date.now() });
     let ws;
     try {
       ws = factory(url, { headers: { "Coder-Session-Token": token } });
     } catch (err) {
       if (emit) {
         const message = err instanceof Error ? err.message : String(err);
-        emit({ type: "ws:error", chatId, attempt, message, timestamp: Date.now() });
-        emit({ type: "ws:close", chatId, attempt, timestamp: Date.now() });
+        emit({ type: "ws:error", chatId, reader, attempt, message, timestamp: Date.now() });
+        emit({ type: "ws:close", chatId, reader, attempt, timestamp: Date.now() });
       }
       throw err;
     }
@@ -307,6 +313,7 @@ async function* streamChatEventsLoop(options) {
         emit?.({
           type: "ws:error",
           chatId,
+          reader,
           attempt,
           message: "failed to parse chat stream frame",
           timestamp: Date.now()
@@ -323,6 +330,7 @@ async function* streamChatEventsLoop(options) {
           emit?.({
             type: "ws:event",
             chatId,
+            reader,
             attempt,
             event: e,
             timestamp: Date.now()
@@ -333,6 +341,7 @@ async function* streamChatEventsLoop(options) {
         emit?.({
           type: "ws:event",
           chatId,
+          reader,
           attempt,
           event: batch,
           timestamp: Date.now()
@@ -343,7 +352,7 @@ async function* streamChatEventsLoop(options) {
     const onError = (ev) => {
       if (finished) return;
       const message = ev && typeof ev === "object" && "message" in ev ? String(ev.message) : "chat stream socket error";
-      emit?.({ type: "ws:error", chatId, attempt, message, timestamp: Date.now() });
+      emit?.({ type: "ws:error", chatId, reader, attempt, message, timestamp: Date.now() });
       const status = upgradeStatus(message);
       failure = status !== void 0 && status >= 400 && status < 500 && !TRANSIENT_UPGRADE_STATUSES.has(status) ? new CoderApiError({ status, method: "GET", path, message }) : new CoderAgentError(message);
       finished = true;
@@ -355,6 +364,7 @@ async function* streamChatEventsLoop(options) {
         const closeEvent = {
           type: "ws:close",
           chatId,
+          reader,
           attempt,
           timestamp: Date.now()
         };
@@ -365,7 +375,7 @@ async function* streamChatEventsLoop(options) {
       finished = true;
       wake();
     };
-    const onOpen = emit ? () => emit({ type: "ws:open", chatId, attempt, timestamp: Date.now() }) : void 0;
+    const onOpen = emit ? () => emit({ type: "ws:open", chatId, reader, attempt, timestamp: Date.now() }) : void 0;
     if (onOpen) ws.addEventListener("open", onOpen);
     ws.addEventListener("message", onMessage);
     ws.addEventListener("error", onError);
@@ -426,7 +436,7 @@ async function* streamChatEventsLoop(options) {
       }
       if (emit && !closeEmitted) {
         closeEmitted = true;
-        emit({ type: "ws:close", chatId, attempt, timestamp: Date.now() });
+        emit({ type: "ws:close", chatId, reader, attempt, timestamp: Date.now() });
       }
     }
     if (signal?.aborted) return;
@@ -451,6 +461,7 @@ async function* streamChatEventsLoop(options) {
     emit?.({
       type: "ws:redial",
       chatId,
+      reader,
       attempt,
       consecutiveFailures: failures,
       maxConsecutiveFailures: STREAM_MAX_CONSECUTIVE_FAILURES,
@@ -867,6 +878,7 @@ var CoderChatClient = class {
       chatId,
       afterId: opts?.afterId,
       signal: opts?.signal,
+      reader: opts?.reader,
       webSocketFactory: this.#webSocketFactory,
       onTransportEvent: this.#onTransportEvent
     });
@@ -1145,6 +1157,12 @@ function dynamicToolNames(tools) {
 // src/model/session-stream.ts
 var SessionChatStream = class {
   chatId;
+  /**
+   * The reader id stamped on the wrapped reader's `ws:*` transport events —
+   * the model stamps it on `segment:settle` so segments correlate with the
+   * connection that served them (issue #94).
+   */
+  reader;
   #events;
   #controller = new AbortController();
   #pending;
@@ -1153,6 +1171,7 @@ var SessionChatStream = class {
   #closePromise;
   constructor(opts) {
     this.chatId = opts.chatId;
+    this.reader = opts.reader;
     this.#events = opts.open(this.#controller.signal);
   }
   get closed() {
@@ -1328,10 +1347,12 @@ var TurnTranslator = class {
   // 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.
+  // Same-id revision snapshots (their full wire content) 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, or flushed by finish() when the segment ends without
+  // one (see #78).
   #deferredRevisions = /* @__PURE__ */ new Map();
   #error;
   #terminalStatus;
@@ -1406,22 +1427,34 @@ var TurnTranslator = class {
    * 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;
+  #reconcileRevision(out, rec, content) {
+    const fullText = joinContent(content, "text");
+    const fullReasoning = joinContent(content, "reasoning");
+    const textOk = fullText.length > rec.text.length && fullText.startsWith(rec.text);
+    const reasoningOk = fullReasoning.length > rec.reasoning.length && fullReasoning.startsWith(rec.reasoning);
+    if (!textOk && !reasoningOk) 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);
+    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, rec.text.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, rec.reasoning.length);
+        if (reasoningOk && end > from)
+          this.#emitReasoningDelta(out, fullReasoning.slice(from, end));
+        seenReasoning = end;
+      }
     }
+    if (textOk) rec.text = fullText;
+    if (reasoningOk) rec.reasoning = fullReasoning;
+    this.#closeText(out);
+    this.#closeReasoning(out);
   }
   // --- tool helpers ---------------------------------------------------------
   #isClientTool(name) {
@@ -1504,6 +1537,7 @@ var TurnTranslator = class {
         for (const tc of ev.action_required?.tool_calls ?? []) {
           if (this.#clientToolCalls.has(tc.tool_call_id)) continue;
           if (this.#submittedToolCallIds.has(tc.tool_call_id)) continue;
+          this.#flushDeferredRevisions(out);
           this.#closeText(out);
           this.#closeReasoning(out);
           this.#clientToolCalls.add(tc.tool_call_id);
@@ -1521,6 +1555,7 @@ var TurnTranslator = class {
       case "error":
         if (ev.error) {
           this.#error = ev.error;
+          this.#flushDeferredRevisions(out);
           out.push({ type: "error", error: new CoderChatError(ev.error) });
         }
         break;
@@ -1586,9 +1621,9 @@ var TurnTranslator = class {
       const fullReasoning = joinContent(content, "reasoning");
       const known = this.#emittedByMessageId.get(message.id);
       if (known && message.id !== this.#currentAssistantId) {
-        this.#reconcileRevision(out, known, fullText, fullReasoning);
+        this.#reconcileRevision(out, known, content);
       } else if (known && this.#deltasSinceSnapshot && known.substantive) {
-        this.#deferredRevisions.set(message.id, { text: fullText, reasoning: fullReasoning });
+        this.#deferredRevisions.set(message.id, content);
       } else {
         if (this.#currentAssistantId !== void 0 && this.#currentAssistantId !== message.id && !this.#deltasSinceSnapshot) {
           this.#closeText(out);
@@ -1628,8 +1663,7 @@ var TurnTranslator = class {
         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);
+          if (deferredRec) this.#reconcileRevision(out, deferredRec, deferred);
           this.#deferredRevisions.delete(id);
         }
       }
@@ -1649,8 +1683,27 @@ var TurnTranslator = class {
     }
   }
   // --- finish ---------------------------------------------------------------
+  /**
+   * Flushes revisions still deferred behind a delta-ownership race that never
+   * settled — the racing step ended terminally without committing a snapshot,
+   * so the drain in #ingestMessage never ran. chatd sent each revision once;
+   * this is the segment's last chance to emit its suffix (#78). Attribution
+   * care: the pending deltas' owner never committed, so they attribute to no
+   * one — reconciliation is against the ledger alone, and only
+   * ledger-extension suffixes may emit. Runs at finish() and, because
+   * doGenerate() throws on a streamed error part and closes the generator
+   * before finish() (issue #72), ahead of the error part in ingest().
+   */
+  #flushDeferredRevisions(out) {
+    for (const [id, deferred] of this.#deferredRevisions) {
+      const rec = this.#emittedByMessageId.get(id);
+      if (rec) this.#reconcileRevision(out, rec, deferred);
+    }
+    this.#deferredRevisions.clear();
+  }
   finish() {
     const out = [];
+    this.#flushDeferredRevisions(out);
     this.#closeText(out);
     this.#closeReasoning(out);
     let unified;
@@ -1777,9 +1830,11 @@ var CoderLanguageModel = class {
     }
     this.#retainedStream = void 0;
     if (retained) void retained.close();
+    const reader = nextStreamReaderId();
     const created = new SessionChatStream({
       chatId,
-      open: (streamSignal) => this.#config.client.streamEvents(chatId, { afterId, signal: streamSignal })
+      reader,
+      open: (streamSignal) => this.#config.client.streamEvents(chatId, { afterId, signal: streamSignal, reader })
     });
     this.#retainedStream = created;
     return created;
@@ -1943,6 +1998,7 @@ var CoderLanguageModel = class {
       };
       const chatId = segmentChat.chatId ?? this.#chatId;
       if (chatId !== void 0) settleEvent.chatId = chatId;
+      if (segmentChat.reader !== void 0) settleEvent.reader = segmentChat.reader;
       if (!failed && finishReason === void 0) {
         if (segmentChat.timeoutError) {
           failure = segmentChat.timeoutError;
@@ -2106,6 +2162,7 @@ var CoderLanguageModel = class {
       let recoveryAttempted = false;
       const stream = this.#acquireStream(action.kind === "resume", chatId, afterId);
       streamAcquired = true;
+      if (segmentChat) segmentChat.reader = stream.reader;
       let onSegmentAbort;
       const segmentAborted = signal ? new Promise((resolve) => {
         onSegmentAbort = () => resolve(SEGMENT_ABORTED);