@code-yeongyu/senpi-ai 2026.10.26-1 → 2026.10.26-2

package/dist/tool-call-middleware/protocols/kimi-xtml/thinking-recovery-stream.js

@@ -1,13 +1,48 @@
+import { assistantEvents, carryAssistantCapture, dropAssistantCapture, pushAssistantProgress, } from "../../../utils/assistant-capture.js";
 import { AssistantMessageEventStream as AssistantMessageEventStreamImpl } from "../../../utils/event-stream.js";
 import { recoverKimiXtmlThinking } from "./thinking-recovery.js";
 export function wrapStreamWithKimiThinkingRecovery(innerStream) {
     const outerStream = new AssistantMessageEventStreamImpl();
+    let partial;
+    // Ended thinking index -> whether the terminal rewrite inserts a recovered response block after it.
+    const splitsByThinkingIndex = new Map();
+    // Blocks that lost a record once lose all later ones, so a block never carries records without its start.
+    const droppedIndexes = new Set();
+    // Live events keep source indices; only the terminal is rewritten. A record (event capture or control) crosses only
+    // while its source index names an existing block that no earlier split can move; otherwise it is dropped, never
+    // guessed.
+    const keepsIndex = (contentIndex) => {
+        if (!partial || contentIndex >= partial.content.length)
+            return false;
+        if (droppedIndexes.has(contentIndex))
+            return false;
+        for (let index = 0; index < contentIndex; index += 1) {
+            if (partial.content[index]?.type === "thinking" && splitsByThinkingIndex.get(index) !== false) {
+                droppedIndexes.add(contentIndex);
+                return false;
+            }
+        }
+        return true;
+    };
     void (async () => {
         try {
-            for await (const event of innerStream) {
+            // Every event but the terminal crosses unchanged: same event objects, same indices, controls in order.
+            for await (const event of assistantEvents(innerStream, (progress) => {
+                if (keepsIndex(progress.contentIndex))
+                    pushAssistantProgress(outerStream, progress);
+            })) {
+                if ("partial" in event)
+                    partial = event.partial;
+                // The same event object crosses, so public bytes stay identical; only its record is withheld.
+                if ("contentIndex" in event && !keepsIndex(event.contentIndex))
+                    dropAssistantCapture(event);
+                if (event.type === "thinking_end") {
+                    const alone = { ...event.partial, content: [{ type: "thinking", thinking: event.content }] };
+                    splitsByThinkingIndex.set(event.contentIndex, recoverKimiXtmlThinking(alone).content.length > 1);
+                }
                 if (event.type === "done") {
                     const message = recoverKimiXtmlThinking(event.message);
-                    outerStream.push({ type: "done", reason: event.reason, message });
+                    outerStream.push(carryAssistantCapture(event, { type: "done", reason: event.reason, message }, message));
                     outerStream.end();
                     return;
                 }

package/dist/tool-call-middleware/recovery-event-stream.d.ts

@@ -1,4 +1,5 @@
 import type { AssistantMessageEvent } from "../types.ts";
+import { type CaptureHint } from "../utils/assistant-capture.ts";
 import { AssistantMessageEventStream } from "../utils/event-stream.ts";
 type CancellationHandler = () => void | Promise<void>;
 /** Recovery events carry immutable snapshots and one awaitable cancellation lifecycle. */
@@ -6,10 +7,20 @@ export declare class RecoveryAssistantMessageEventStream extends AssistantMessag
     private cancellationHandler;
     private cancellationPromise;
     private sourceClosed;
+    private relaySource;
+    private relayed;
+    constructor();
     setCancellationHandler(handler: CancellationHandler): void;
     markSourceClosed(): boolean;
-    push(event: AssistantMessageEvent): void;
+    /**
+     * Runs a projection step that copies `source` 1:1 to a new index. The copy is built from source blocks read after
+     * later deltas landed, so its capture relays the source's emission-time record instead of freezing the copy. Only
+     * the step's first push of the source's type is that copy; any later one records nothing.
+     */
+    relaying<T>(source: AssistantMessageEvent, project: () => T): T;
+    push(event: AssistantMessageEvent, hint?: CaptureHint): void;
     [Symbol.asyncIterator](): AsyncIterator<AssistantMessageEvent>;
+    private withCancellation;
 }
 export {};
 //# sourceMappingURL=recovery-event-stream.d.ts.map

package/dist/tool-call-middleware/recovery-event-stream.js

@@ -1,10 +1,13 @@
+import { carryAssistantCapture, getAssistantCapture, setAssistantReader, } from "../utils/assistant-capture.js";
 import { AssistantMessageEventStream } from "../utils/event-stream.js";
 import { snapshotRecoveryEvent } from "./recovery-message-snapshot.js";
 /** Recovery events carry immutable snapshots and one awaitable cancellation lifecycle. */
 export class RecoveryAssistantMessageEventStream extends AssistantMessageEventStream {
     constructor() {
-        super(...arguments);
+        super({ captureBlocks: true });
         this.sourceClosed = false;
+        this.relayed = false;
+        setAssistantReader(this, (project) => this.withCancellation(this.mapIterator(project)));
     }
     setCancellationHandler(handler) {
         this.cancellationHandler = handler;
@@ -15,11 +18,34 @@ export class RecoveryAssistantMessageEventStream extends AssistantMessageEventSt
         this.sourceClosed = true;
         return true;
     }
-    push(event) {
-        super.push(snapshotRecoveryEvent(event));
+    /**
+     * Runs a projection step that copies `source` 1:1 to a new index. The copy is built from source blocks read after
+     * later deltas landed, so its capture relays the source's emission-time record instead of freezing the copy. Only
+     * the step's first push of the source's type is that copy; any later one records nothing.
+     */
+    relaying(source, project) {
+        this.relaySource = source;
+        this.relayed = false;
+        try {
+            return project();
+        }
+        finally {
+            this.relaySource = undefined;
+        }
+    }
+    push(event, hint) {
+        const source = this.relaySource;
+        let relay = hint;
+        if (source?.type === event.type) {
+            relay = { ...hint, carried: this.relayed ? null : (getAssistantCapture(source) ?? null) };
+            this.relayed = true;
+        }
+        super.push(carryAssistantCapture(event, snapshotRecoveryEvent(event)), relay);
     }
     [Symbol.asyncIterator]() {
-        const iterator = super[Symbol.asyncIterator]();
+        return this.withCancellation(super[Symbol.asyncIterator]());
+    }
+    withCancellation(iterator) {
         return {
             next: () => iterator.next(),
             return: async () => {

package/dist/tool-call-middleware/recovery-native-projection.d.ts

@@ -1,10 +1,13 @@
 import type { AssistantMessage, AssistantMessageEventStream, ToolCall } from "../types.ts";
+import { type AssistantProgress } from "../utils/assistant-capture.ts";
 import type { StreamParserEvent, ToolCallFormat } from "./types.ts";
 /** Maintains source-index order and native/recovered ID ownership for recovery streams. */
 export declare class RecoveryNativeProjection {
     private readonly stream;
     private readonly message;
     private readonly rangesByInnerIndex;
+    private readonly copiedInnerIndexes;
+    private readonly pendingProgress;
     private readonly nativeLifecycleByInnerIndex;
     private readonly reservedIds;
     private readonly recoveredIds;
@@ -18,12 +21,19 @@ export declare class RecoveryNativeProjection {
     synchronizeRemaining(source: AssistantMessage): boolean;
     startText(innerIndex: number, outerIndex: number): boolean;
     recordProjectedBlock(innerIndex: number, outerIndex: number): boolean;
+    /**
+     * Relays a source control to the outer block that copies its source block. Controls of a block the projection
+     * rebuilds (prose split into text and recovered calls) describe no outer block and are dropped; controls of a
+     * block not projected yet wait for it.
+     */
+    relayProgress(progress: AssistantProgress): void;
     extendText(innerIndex: number): void;
     projectNativeStart(source: AssistantMessage, innerIndex: number): "projected" | "collision" | "invalid";
     projectNativeDelta(source: AssistantMessage, innerIndex: number, delta: string): boolean;
     projectNativeEnd(innerIndex: number, toolCall: ToolCall): boolean;
     assignRecoveredIds(events: readonly StreamParserEvent[]): StreamParserEvent[];
     private appendUnannounced;
+    /** Flushes the controls held for `innerIndex`; a copied block with a start event records its range after that start. */
     private recordRange;
     private allocateRecoveredId;
 }

package/dist/tool-call-middleware/recovery-native-projection.js

@@ -1,3 +1,4 @@
+import { pushAssistantProgress } from "../utils/assistant-capture.js";
 function cloneContentBlock(block) {
     if (block.type === "toolCall")
         return { ...block, arguments: { ...block.arguments } };
@@ -10,6 +11,8 @@ function cloneToolCall(toolCall) {
 export class RecoveryNativeProjection {
     constructor(stream, message, protocol = "antml") {
         this.rangesByInnerIndex = new Map();
+        this.copiedInnerIndexes = new Set();
+        this.pendingProgress = new Map();
         this.nativeLifecycleByInnerIndex = new Map();
         this.reservedIds = new Set();
         this.recoveredIds = new Set();
@@ -45,12 +48,31 @@ export class RecoveryNativeProjection {
         return true;
     }
     startText(innerIndex, outerIndex) {
-        if (!this.recordRange(innerIndex, { start: outerIndex, end: this.message.content.length }))
+        if (!this.recordRange(innerIndex, { start: outerIndex, end: this.message.content.length }, false))
             return false;
         return true;
     }
     recordProjectedBlock(innerIndex, outerIndex) {
-        return this.recordRange(innerIndex, { start: outerIndex, end: outerIndex + 1 });
+        return this.recordRange(innerIndex, { start: outerIndex, end: outerIndex + 1 }, true);
+    }
+    /**
+     * Relays a source control to the outer block that copies its source block. Controls of a block the projection
+     * rebuilds (prose split into text and recovered calls) describe no outer block and are dropped; controls of a
+     * block not projected yet wait for it.
+     */
+    relayProgress(progress) {
+        const range = this.rangesByInnerIndex.get(progress.contentIndex);
+        if (!range) {
+            const pending = this.pendingProgress.get(progress.contentIndex);
+            if (pending)
+                pending.push(progress);
+            else
+                this.pendingProgress.set(progress.contentIndex, [progress]);
+            return;
+        }
+        if (!this.copiedInnerIndexes.has(progress.contentIndex))
+            return;
+        pushAssistantProgress(this.stream, range.start === progress.contentIndex ? progress : Object.freeze({ ...progress, contentIndex: range.start }));
     }
     extendText(innerIndex) {
         const range = this.rangesByInnerIndex.get(innerIndex);
@@ -68,11 +90,11 @@ export class RecoveryNativeProjection {
         this.reservedIds.add(block.id);
         const outerIndex = this.message.content.length;
         this.message.content.push(cloneContentBlock(block));
-        if (!this.recordRange(innerIndex, { start: outerIndex, end: outerIndex + 1 }))
-            return "invalid";
         this.nativeLifecycleByInnerIndex.set(innerIndex, "started");
         this.stream.push({ type: "toolcall_start", contentIndex: outerIndex, partial: this.message });
-        return "projected";
+        // Recorded after the start, as a thinking copy is, so controls held for the call follow its start event. The
+        // guards above already rule out both reasons recordRange refuses.
+        return this.recordRange(innerIndex, { start: outerIndex, end: outerIndex + 1 }, true) ? "projected" : "invalid";
     }
     projectNativeDelta(source, innerIndex, delta) {
         if (this.nativeLifecycleByInnerIndex.get(innerIndex) !== "started")
@@ -125,13 +147,20 @@ export class RecoveryNativeProjection {
             return false;
         const outerIndex = this.message.content.length;
         this.message.content.push(cloneContentBlock(block));
-        return this.recordRange(innerIndex, { start: outerIndex, end: outerIndex + 1 });
+        return this.recordRange(innerIndex, { start: outerIndex, end: outerIndex + 1 }, true);
     }
-    recordRange(innerIndex, range) {
+    /** Flushes the controls held for `innerIndex`; a copied block with a start event records its range after that start. */
+    recordRange(innerIndex, range, copiesSource) {
         if (this.rangesByInnerIndex.has(innerIndex) || innerIndex <= this.highestProjectedInnerIndex)
             return false;
         this.rangesByInnerIndex.set(innerIndex, range);
         this.highestProjectedInnerIndex = innerIndex;
+        if (copiesSource)
+            this.copiedInnerIndexes.add(innerIndex);
+        const pending = this.pendingProgress.get(innerIndex) ?? [];
+        this.pendingProgress.delete(innerIndex);
+        for (const progress of pending)
+            this.relayProgress(progress);
         return true;
     }
     allocateRecoveredId() {

package/dist/tool-call-middleware/recovery-stream-failure.js

@@ -1,3 +1,4 @@
+import { removeToolCalls, rewriteHint } from "./recovery-stream-terminal.js";
 const failureDetails = {
     collision: {
         diagnosticType: "text_tool_call_recovery_collision",
@@ -20,7 +21,7 @@ export function terminateRecoveryStreamForFailure(stream, projection, options) {
     const details = failureDetails[failure];
     projection.sync(source);
     const message = projection.finalize(source, false);
-    message.content = message.content.filter((block) => block.type !== "toolCall");
+    const rewrittenFrom = removeToolCalls(message);
     message.stopReason = "error";
     message.errorMessage = details.errorMessage;
     message.diagnostics = [
@@ -31,7 +32,7 @@ export function terminateRecoveryStreamForFailure(stream, projection, options) {
             details: { protocol, status: details.status },
         },
     ];
-    stream.push({ type: "error", reason: "error", error: message });
+    stream.push({ type: "error", reason: "error", error: message }, rewriteHint(rewrittenFrom));
     stream.end(message);
 }
 //# sourceMappingURL=recovery-stream-failure.js.map

package/dist/tool-call-middleware/recovery-stream-terminal.d.ts

@@ -1,5 +1,11 @@
 import type { AssistantMessage, AssistantMessageEventStream, StopReason } from "../types.ts";
 import type { StreamMessageProjection } from "./stream-wrapper-shared.ts";
+/** Removes the tool calls `removes` selects and returns the first index whose block vanished or moved, if any. */
+export declare function removeToolCalls(message: AssistantMessage, removes?: (index: number) => boolean): number | undefined;
+/** The capture hint that marks a terminal whose content no longer matches the announced blocks from an index on. */
+export declare function rewriteHint(rewrittenFrom: number | undefined): {
+    rewrittenFrom: number;
+} | undefined;
 /** Emits one terminal event after recovery projection state has been flushed. */
 export declare class RecoveryStreamTerminal {
     private emitted;

package/dist/tool-call-middleware/recovery-stream-terminal.js

@@ -2,12 +2,28 @@ import { parseServerFallbackReceipt, SERVER_FALLBACK_ABORTED_DIAGNOSTIC } from "
 function errorText(error) {
     return error instanceof Error ? error.message : String(error);
 }
+/** Removes the tool calls `removes` selects and returns the first index whose block vanished or moved, if any. */
+export function removeToolCalls(message, removes = () => true) {
+    const from = message.content.findIndex((block, index) => block.type === "toolCall" && removes(index));
+    if (from < 0)
+        return undefined;
+    message.content = message.content.filter((block, index) => block.type !== "toolCall" || !removes(index));
+    return from;
+}
+function supersededBoundary(message) {
+    return message.content.findLastIndex((block) => block.type === "providerNative" && parseServerFallbackReceipt(block.raw) !== undefined);
+}
+/** A server fallback receipt supersedes every client tool call before it. */
 function discardSupersededTools(message) {
-    const boundary = message.content.findLastIndex((block) => block.type === "providerNative" && parseServerFallbackReceipt(block.raw) !== undefined);
-    if (boundary < 0)
-        return false;
-    message.content = message.content.filter((block, index) => index > boundary || block.type !== "toolCall");
-    return true;
+    const boundary = supersededBoundary(message);
+    return removeToolCalls(message, (index) => index < boundary);
+}
+function firstIndex(left, right) {
+    return left === undefined ? right : right === undefined ? left : Math.min(left, right);
+}
+/** The capture hint that marks a terminal whose content no longer matches the announced blocks from an index on. */
+export function rewriteHint(rewrittenFrom) {
+    return rewrittenFrom === undefined ? undefined : { rewrittenFrom };
 }
 /** Emits one terminal event after recovery projection state has been flushed. */
 export class RecoveryStreamTerminal {
@@ -20,36 +36,38 @@ export class RecoveryStreamTerminal {
             return;
         projection.finalizeDanglingToolCalls();
         const message = projection.finalize(source, sawToolCall);
-        const superseded = discardSupersededTools(message);
+        const superseded = supersededBoundary(message) >= 0;
+        const rewrittenFrom = discardSupersededTools(message);
         const recovered = (!superseded && sawToolCall) || message.content.some((block) => block.type === "toolCall");
         const finalReason = recovered && (reason === "stop" || reason === "length") ? "toolUse" : reason;
         message.stopReason = finalReason;
-        this.emit({ type: "done", reason: finalReason, message });
+        this.emit({ type: "done", reason: finalReason, message }, rewrittenFrom);
     }
     sourceError(projection, source, sawToolCall, reason) {
         if (this.emitted)
             return;
+        // The forwarded source holds source indices, not the projected ones the stream announced: no index is provable.
         if (source.diagnostics?.some((entry) => entry.type === SERVER_FALLBACK_ABORTED_DIAGNOSTIC)) {
-            this.emit({ type: "error", reason, error: source });
+            this.emit({ type: "error", reason, error: source }, 0);
             return;
         }
-        discardSupersededTools(projection.message);
+        const rewrittenFrom = discardSupersededTools(projection.message);
         projection.finalizeDanglingToolCalls();
         const message = projection.finalize(source, sawToolCall);
         if (reason === "aborted") {
-            message.content = message.content.filter((block) => block.type !== "toolCall");
+            const aborted = removeToolCalls(message);
             message.stopReason = "aborted";
             message.errorMessage ??= "Request was aborted";
-            this.emit({ type: "error", reason: "aborted", error: message });
+            this.emit({ type: "error", reason: "aborted", error: message }, firstIndex(rewrittenFrom, aborted));
             return;
         }
         if (projection.hasFinalizedToolCallContent()) {
             message.stopReason = "toolUse";
-            this.emit({ type: "done", reason: "toolUse", message });
+            this.emit({ type: "done", reason: "toolUse", message }, rewrittenFrom);
             return;
         }
         message.stopReason = "error";
-        this.emit({ type: "error", reason: "error", error: message });
+        this.emit({ type: "error", reason: "error", error: message }, rewrittenFrom);
     }
     iteratorFailure(projection, error) {
         if (this.emitted)
@@ -87,16 +105,16 @@ export class RecoveryStreamTerminal {
         }
         projection.finalizeDanglingToolCalls();
         const message = projection.finalize(projection.message, false);
-        message.content = message.content.filter((block) => block.type !== "toolCall");
+        const rewrittenFrom = removeToolCalls(message);
         message.stopReason = "error";
         message.errorMessage = "Assistant message stream consumption was cancelled";
-        this.emit({ type: "error", reason: "error", error: message });
+        this.emit({ type: "error", reason: "error", error: message }, rewrittenFrom);
     }
-    emit(event) {
+    emit(event, rewrittenFrom) {
         if (this.emitted)
             return;
         this.emitted = true;
-        this.stream.push(event);
+        this.stream.push(event, rewriteHint(rewrittenFrom));
         this.stream.end();
     }
 }

package/dist/tool-call-middleware/recovery-stream-wrapper.js

@@ -1,3 +1,4 @@
+import { assistantEvents } from "../utils/assistant-capture.js";
 import { createAntmlInvokeRecoveryStreamParser } from "./protocols/antml/recovery-stream.js";
 import { RecoveryContentLifecycle } from "./recovery-content-lifecycle.js";
 import { RecoveryAssistantMessageEventStream } from "./recovery-event-stream.js";
@@ -12,13 +13,16 @@ export function wrapStreamWithInvokeRecovery(innerStream, tools, options = {}) {
     const createParser = resolvedOptions.createParser ?? createAntmlInvokeRecoveryStreamParser;
     const protocol = resolvedOptions.protocol ?? "antml";
     void (async () => {
-        const innerIterator = innerStream[Symbol.asyncIterator]();
-        const innerEvents = { [Symbol.asyncIterator]: () => innerIterator };
         let projection = null;
         let nativeProjection = null;
         let textProjection = null;
         let sawToolCall = false;
         let cancellationRequested = false;
+        const innerIterator = assistantEvents(innerStream, (progress) => {
+            if (!cancellationRequested)
+                nativeProjection?.relayProgress(progress);
+        })[Symbol.asyncIterator]();
+        const innerEvents = { [Symbol.asyncIterator]: () => innerIterator };
         const contentLifecycle = new RecoveryContentLifecycle();
         const terminal = new RecoveryStreamTerminal(outerStream);
         const finishText = () => {
@@ -167,7 +171,8 @@ export function wrapStreamWithInvokeRecovery(innerStream, tools, options = {}) {
                             return;
                         if (!prepareContentEvent(event.partial, event.contentIndex) || !nativeProjection)
                             return;
-                        const status = nativeProjection.projectNativeStart(event.partial, event.contentIndex);
+                        const native = nativeProjection;
+                        const status = outerStream.relaying(event, () => native.projectNativeStart(event.partial, event.contentIndex));
                         if (status !== "projected") {
                             terminateForFailure(event.partial, status === "collision" ? "collision" : "invalid_native_event_order");
                             return;
@@ -176,34 +181,39 @@ export function wrapStreamWithInvokeRecovery(innerStream, tools, options = {}) {
                         sawToolCall = true;
                         break;
                     }
-                    case "toolcall_delta":
+                    case "toolcall_delta": {
                         if (!isActive(event.partial, event.contentIndex, "toolCall", "invalid_native_event_order"))
                             return;
                         if (!prepareContentEvent(event.partial, event.contentIndex) || !nativeProjection)
                             return;
-                        if (!nativeProjection.projectNativeDelta(event.partial, event.contentIndex, event.delta)) {
+                        const native = nativeProjection;
+                        if (!outerStream.relaying(event, () => native.projectNativeDelta(event.partial, event.contentIndex, event.delta))) {
                             terminateForFailure(event.partial, "invalid_native_event_order");
                             return;
                         }
                         break;
-                    case "toolcall_end":
+                    }
+                    case "toolcall_end": {
                         if (!isActive(event.partial, event.contentIndex, "toolCall", "invalid_native_event_order"))
                             return;
                         if (!prepareContentEvent(event.partial, event.contentIndex) || !nativeProjection)
                             return;
-                        if (!nativeProjection.projectNativeEnd(event.contentIndex, event.toolCall)) {
+                        const native = nativeProjection;
+                        if (!outerStream.relaying(event, () => native.projectNativeEnd(event.contentIndex, event.toolCall))) {
                             terminateForFailure(event.partial, "invalid_native_event_order");
                             return;
                         }
                         contentLifecycle.end(event.contentIndex, "toolCall");
                         sawToolCall = true;
                         break;
+                    }
                     case "thinking_start": {
                         if (!canStart(event.partial, event.contentIndex, "thinking"))
                             return;
                         if (!prepareContentEvent(event.partial, event.contentIndex) || !projection || !nativeProjection)
                             return;
-                        const outerIndex = projection.startThinking(event.contentIndex, event.partial);
+                        const thinking = projection;
+                        const outerIndex = outerStream.relaying(event, () => thinking.startThinking(event.contentIndex, event.partial));
                         if (!nativeProjection.recordProjectedBlock(event.contentIndex, outerIndex)) {
                             terminateForFailure(event.partial, "invalid_native_event_order");
                             return;
@@ -211,21 +221,25 @@ export function wrapStreamWithInvokeRecovery(innerStream, tools, options = {}) {
                         contentLifecycle.start(event.contentIndex, "thinking");
                         break;
                     }
-                    case "thinking_delta":
+                    case "thinking_delta": {
                         if (!isActive(event.partial, event.contentIndex, "thinking"))
                             return;
                         if (!prepareContentEvent(event.partial, event.contentIndex) || !projection)
                             return;
-                        projection.projectThinkingDelta(event.contentIndex, event.delta, event.partial);
+                        const thinking = projection;
+                        outerStream.relaying(event, () => thinking.projectThinkingDelta(event.contentIndex, event.delta, event.partial));
                         break;
-                    case "thinking_end":
+                    }
+                    case "thinking_end": {
                         if (!isActive(event.partial, event.contentIndex, "thinking"))
                             return;
                         if (!prepareContentEvent(event.partial, event.contentIndex) || !projection)
                             return;
-                        projection.finishThinking(event.contentIndex, event.content, event.partial);
+                        const thinking = projection;
+                        outerStream.relaying(event, () => thinking.finishThinking(event.contentIndex, event.content, event.partial));
                         contentLifecycle.end(event.contentIndex, "thinking");
                         break;
+                    }
                 }
             }
             if (cancellationRequested || !outerStream.markSourceClosed())

package/dist/tool-call-middleware/stream-wrapper.js

@@ -1,7 +1,9 @@
 import { AssistantMessageEventStream as AssistantMessageEventStreamImpl } from "../utils/event-stream.js";
 import { StreamMessageProjection } from "./stream-wrapper-shared.js";
 export function wrapStreamWithToolCallMiddleware(innerStream, protocol, tools) {
-    const outerStream = new AssistantMessageEventStreamImpl();
+    // Every outer block is rebuilt from parser output and own state, never copied from a source block read late, so
+    // the outer stream captures its own pushes and no source record is forwarded.
+    const outerStream = new AssistantMessageEventStreamImpl({ captureBlocks: true });
     const parser = protocol.createStreamParser(tools);
     void (async () => {
         let projection = null;

package/dist/utils/assistant-capture.d.ts

@@ -43,6 +43,13 @@ export interface AssistantCapture {
     readonly parsedThrough?: number;
     /** The block's own index where the event's public `contentIndex` names another block; internal readers prefer it. */
     readonly contentIndex?: number;
+    /**
+     * First block index whose earlier records no longer name the terminal's blocks (block index/identity only); readers
+     * MUST drop every block record at or above it for that message; absent = no rewrite. The terminal message always
+     * wins for CONTENT: readers replace each block's content from the terminal (or the block's end event), never
+     * append-only from live records.
+     */
+    readonly rewrittenFrom?: number;
 }
 /** While held, every capture-enabled stream whose first push comes after it builds capture records. */
 export declare function subscribeAssistantCapture(): () => void;
@@ -60,6 +67,7 @@ export declare function pushAssistantCompleteBlock(owner: object, contentIndex:
 export declare function assistantRecords(source: AsyncIterable<AssistantMessageEvent>): AsyncIterable<AssistantRecord>;
 /** Events only; each progress record goes to `onProgress` as it is read, so a forwarder spends no turn on it. */
 export declare function assistantEvents(source: AsyncIterable<AssistantMessageEvent>, onProgress: (progress: AssistantProgress) => void): AsyncIterable<AssistantMessageEvent>;
+/** Internal readers address a block by `capture.contentIndex ?? event.contentIndex`; the public index can drift (Google/Vertex). */
 export declare function getAssistantCapture(event: object): AssistantCapture | undefined;
 export declare function isAssistantProgress(event: AssistantRecord): event is AssistantProgress;
 export interface CaptureHint {
@@ -69,6 +77,14 @@ export interface CaptureHint {
     readonly offset?: number;
     /** The open block's own index when the adapter's public `contentIndex` has drifted from it. */
     readonly contentIndex?: number;
+    /**
+     * Set by a wrapper that re-emits a source event 1:1 at its own index while reading the source later than it was
+     * emitted: block facts come from this source capture, usage and metadata from the relaying stream. `null` records
+     * nothing, because the source captured nothing.
+     */
+    readonly carried?: AssistantCapture | null;
+    /** A terminal's `AssistantCapture.rewrittenFrom`. */
+    readonly rewrittenFrom?: number;
 }
 export interface CapturePosition {
     offset: number;