assistant-stream 0.3.26 → 0.3.28

package/src/core/serialization/assistant-transport/AssistantTransport.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, it } from "vitest";
+import { describe, expect, it, vi } from "vitest";
 import {
   AssistantTransportEncoder,
   AssistantTransportDecoder,
@@ -47,6 +47,18 @@ async function encodeAndDecode(
   return reconstructedStream.pipeThrough(new AssistantTransportDecoder());
 }
 
+function sseStream(frames: string[]): ReadableStream<AssistantStreamChunk> {
+  const sseText =
+    frames.map((frame) => `data: ${frame}\n\n`).join("") + "data: [DONE]\n\n";
+
+  return new ReadableStream<Uint8Array>({
+    start(controller) {
+      controller.enqueue(new TextEncoder().encode(sseText));
+      controller.close();
+    },
+  }).pipeThrough(new AssistantTransportDecoder());
+}
+
 describe("AssistantTransportEncoder", () => {
   it("should encode text-delta chunks to SSE format", async () => {
     const chunks: AssistantStreamChunk[] = [
@@ -223,6 +235,167 @@ describe("AssistantTransportDecoder", () => {
     );
   });
 
+  it("drops frames that are not objects", async () => {
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+    const decodedChunks = await collectChunks(
+      sseStream([
+        "null",
+        "5",
+        '"text"',
+        "[1,2]",
+        '{"type":"text-delta","textDelta":"Hello","path":[]}',
+      ]),
+    );
+
+    expect(decodedChunks).toEqual([
+      { type: "text-delta", textDelta: "Hello", path: [] },
+    ]);
+    expect(warn).toHaveBeenCalledTimes(1);
+    expect(warn).toHaveBeenCalledWith(
+      expect.stringContaining("(not-an-object)"),
+    );
+    warn.mockRestore();
+  });
+
+  it("drops frames with a missing or unknown type", async () => {
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+    const decodedChunks = await collectChunks(
+      sseStream([
+        '{"path":[]}',
+        '{"type":5,"path":[]}',
+        '{"type":"bogus","path":[]}',
+        '{"type":"toString","path":[]}',
+        '{"type":"part-finish","path":[]}',
+      ]),
+    );
+
+    expect(decodedChunks).toEqual([{ type: "part-finish", path: [] }]);
+    expect(warn).toHaveBeenCalledTimes(1);
+    warn.mockRestore();
+  });
+
+  it("drops frames with an invalid path", async () => {
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+    const decodedChunks = await collectChunks(
+      sseStream([
+        '{"type":"text-delta","textDelta":"b","path":"0"}',
+        '{"type":"text-delta","textDelta":"c","path":[-1]}',
+        '{"type":"text-delta","textDelta":"d","path":[1.5]}',
+        '{"type":"text-delta","textDelta":"e","path":["0"]}',
+        '{"type":"text-delta","textDelta":"f","path":[0]}',
+      ]),
+    );
+
+    expect(decodedChunks).toEqual([
+      { type: "text-delta", textDelta: "f", path: [0] },
+    ]);
+    expect(warn).toHaveBeenCalledTimes(1);
+    warn.mockRestore();
+  });
+
+  it("normalizes a missing path to an empty path on message-level chunks", async () => {
+    const decodedChunks = await collectChunks(
+      sseStream([
+        '{"type":"update-state","operations":[{"type":"set","path":["messages"],"value":[]}]}',
+        '{"type":"error","error":"boom"}',
+      ]),
+    );
+
+    expect(decodedChunks).toEqual([
+      {
+        type: "update-state",
+        operations: [{ type: "set", path: ["messages"], value: [] }],
+        path: [],
+      },
+      { type: "error", error: "boom", path: [] },
+    ]);
+  });
+
+  it("drops part-addressed chunks with a missing path", async () => {
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+    const decodedChunks = await collectChunks(
+      sseStream([
+        '{"type":"text-delta","textDelta":"a"}',
+        '{"type":"part-finish"}',
+        '{"type":"result","result":{"ok":true}}',
+        '{"type":"text-delta","textDelta":"ok","path":[0]}',
+      ]),
+    );
+
+    expect(decodedChunks).toEqual([
+      { type: "text-delta", textDelta: "ok", path: [0] },
+    ]);
+    expect(warn).toHaveBeenCalledTimes(3);
+    warn.mockRestore();
+  });
+
+  it("drops frames that are not valid JSON", async () => {
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+    const decodedChunks = await collectChunks(
+      sseStream([
+        '{"type":"text-delta"',
+        "not json",
+        '{"type":"text-delta","textDelta":"ok","path":[0]}',
+      ]),
+    );
+
+    expect(decodedChunks).toEqual([
+      { type: "text-delta", textDelta: "ok", path: [0] },
+    ]);
+    expect(warn).toHaveBeenCalledTimes(1);
+    warn.mockRestore();
+  });
+
+  it("drops frames missing per-type required fields", async () => {
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+    const decodedChunks = await collectChunks(
+      sseStream([
+        '{"type":"part-start","path":[]}',
+        '{"type":"part-start","part":[],"path":[]}',
+        '{"type":"text-delta","textDelta":5,"path":[0]}',
+        '{"type":"annotations","path":[]}',
+        '{"type":"data","path":[]}',
+        '{"type":"update-state","path":[]}',
+        '{"type":"message-finish","path":[]}',
+        '{"type":"step-finish","path":[]}',
+        '{"type":"error","path":[]}',
+        '{"type":"error","error":42,"path":[]}',
+        '{"type":"message-finish","finishReason":"stop","path":[]}',
+        '{"type":"error","error":"boom","path":[]}',
+      ]),
+    );
+
+    expect(decodedChunks).toEqual([
+      { type: "error", path: [] },
+      { type: "error", error: 42, path: [] },
+      { type: "message-finish", finishReason: "stop", path: [] },
+      { type: "error", error: "boom", path: [] },
+    ]);
+    expect(warn).toHaveBeenCalledTimes(7);
+    expect(warn).toHaveBeenCalledWith(
+      expect.stringContaining("(invalid-fields:part-start)"),
+    );
+    warn.mockRestore();
+  });
+
+  it("tolerates a result without isError or result but rejects a non-boolean isError", async () => {
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+    const decodedChunks = await collectChunks(
+      sseStream([
+        '{"type":"result","result":null,"path":[0]}',
+        '{"type":"result","path":[0]}',
+        '{"type":"result","result":1,"isError":"no","path":[0]}',
+      ]),
+    );
+
+    expect(decodedChunks).toEqual([
+      { type: "result", result: null, path: [0] },
+      { type: "result", path: [0] },
+    ]);
+    expect(warn).toHaveBeenCalledTimes(1);
+    warn.mockRestore();
+  });
+
   it("round-trips error chunks with code and severity", async () => {
     const originalChunks: AssistantStreamChunk[] = [
       {

package/src/core/serialization/assistant-transport/AssistantTransport.ts

@@ -1,3 +1,4 @@
+import sjson from "secure-json-parse";
 import type { AssistantStreamChunk } from "../../AssistantStreamChunk";
 import { PipeableTransformStream } from "../../utils/stream/PipeableTransformStream";
 import {
@@ -6,6 +7,70 @@ import {
 } from "../../utils/stream/SSEEventDecoderStream";
 import type { AssistantStreamEncoder } from "../../AssistantStream";
 
+type ChunkFields = Record<string, unknown>;
+
+type ChunkRule = {
+  kind: "message" | "part-addressed";
+  valid: (chunk: ChunkFields) => boolean;
+};
+
+const noFields = () => true;
+const requiredObject = (key: string) => (c: ChunkFields) => {
+  const value = c[key];
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+};
+const requiredString = (key: string) => (c: ChunkFields) =>
+  typeof c[key] === "string";
+const requiredArray = (key: string) => (c: ChunkFields) =>
+  Array.isArray(c[key]);
+const optionalBoolean = (key: string) => (c: ChunkFields) =>
+  c[key] === undefined || typeof c[key] === "boolean";
+
+const KNOWN_CHUNK_TYPES: Record<AssistantStreamChunk["type"], ChunkRule> = {
+  "part-start": { kind: "message", valid: requiredObject("part") },
+  "part-finish": { kind: "part-addressed", valid: noFields },
+  "tool-call-args-text-finish": { kind: "part-addressed", valid: noFields },
+  "text-delta": { kind: "part-addressed", valid: requiredString("textDelta") },
+  annotations: { kind: "message", valid: requiredArray("annotations") },
+  data: { kind: "message", valid: requiredArray("data") },
+  "step-start": { kind: "message", valid: noFields },
+  "step-finish": { kind: "message", valid: requiredString("finishReason") },
+  "message-finish": { kind: "message", valid: requiredString("finishReason") },
+  result: { kind: "part-addressed", valid: optionalBoolean("isError") },
+  error: { kind: "message", valid: noFields },
+  "update-state": { kind: "message", valid: requiredArray("operations") },
+};
+
+const parseChunk = (data: string): AssistantStreamChunk | string => {
+  let value: unknown;
+  try {
+    value = sjson.parse(data);
+  } catch {
+    return "unparseable";
+  }
+  if (typeof value !== "object" || value === null || Array.isArray(value))
+    return "not-an-object";
+  const { type, path } = value as { type?: unknown; path?: unknown };
+  if (
+    typeof type !== "string" ||
+    !Object.prototype.hasOwnProperty.call(KNOWN_CHUNK_TYPES, type)
+  )
+    return "unknown-type";
+  const rule = KNOWN_CHUNK_TYPES[type as AssistantStreamChunk["type"]];
+  if (!rule.valid(value as Record<string, unknown>))
+    return `invalid-fields:${type}`;
+  if (path === undefined) {
+    if (rule.kind !== "message") return `missing-path:${type}`;
+    return { ...value, path: [] } as unknown as AssistantStreamChunk;
+  }
+  if (
+    !Array.isArray(path) ||
+    !path.every((entry) => Number.isInteger(entry) && entry >= 0)
+  )
+    return "invalid-path";
+  return value as AssistantStreamChunk;
+};
+
 /**
  * AssistantTransportEncoder encodes AssistantStreamChunks into SSE format
  * and emits [DONE] when the stream completes.
@@ -49,6 +114,7 @@ export class AssistantTransportDecoder extends PipeableTransformStream<
   constructor() {
     super((readable) => {
       let receivedDone = false;
+      const warnedReasons = new Set<string>();
 
       return readable
         .pipeThrough(new TextDecoderStream())
@@ -64,7 +130,17 @@ export class AssistantTransportDecoder extends PipeableTransformStream<
                     // Stop processing when we encounter [DONE]
                     controller.terminate();
                   } else {
-                    controller.enqueue(JSON.parse(event.data));
+                    const chunk = parseChunk(event.data);
+                    if (typeof chunk === "string") {
+                      if (!warnedReasons.has(chunk)) {
+                        warnedReasons.add(chunk);
+                        console.warn(
+                          `Dropped invalid assistant-transport chunk (${chunk}): ${event.data.slice(0, 200)}`,
+                        );
+                      }
+                    } else {
+                      controller.enqueue(chunk);
+                    }
                   }
                   break;
                 default:

package/src/core/serialization/data-stream/DataStream.ts

@@ -208,7 +208,7 @@ export class DataStreamEncoder
   }
 }
 
-const TOOL_CALL_ARGS_CLOSING_CHUNKS = [
+const TOOL_CALL_ARGS_CLOSING_CHUNKS: DataStreamStreamChunkType[] = [
   DataStreamStreamChunkType.StartToolCall,
   DataStreamStreamChunkType.ToolCall,
   DataStreamStreamChunkType.TextDelta,

package/src/core/serialization/data-stream/chunk-types.ts

@@ -2,7 +2,7 @@ import type {
   ReadonlyJSONObject,
   ReadonlyJSONValue,
 } from "../../../utils/json/json-value";
-import type { ObjectStreamOperation } from "../../object/types";
+import type { GorpStreamOperation } from "../../gorp/types";
 
 export type DataStreamChunk = {
   [K in DataStreamStreamChunkType]: {
@@ -25,29 +25,31 @@ type LanguageModelV1Usage = {
   outputTokens: number;
 };
 
-export enum DataStreamStreamChunkType {
-  TextDelta = "0",
-  Data = "2",
-  Error = "3",
-  Annotation = "8",
-  ToolCall = "9",
-  ToolCallResult = "a",
-  StartToolCall = "b",
-  ToolCallArgsTextDelta = "c",
-  FinishMessage = "d",
-  FinishStep = "e",
-  StartStep = "f",
-  ReasoningDelta = "g",
-  Source = "h",
-  RedactedReasoning = "i",
-  ReasoningSignature = "j",
-  File = "k",
+export const DataStreamStreamChunkType = {
+  TextDelta: "0",
+  Data: "2",
+  Error: "3",
+  Annotation: "8",
+  ToolCall: "9",
+  ToolCallResult: "a",
+  StartToolCall: "b",
+  ToolCallArgsTextDelta: "c",
+  FinishMessage: "d",
+  FinishStep: "e",
+  StartStep: "f",
+  ReasoningDelta: "g",
+  Source: "h",
+  RedactedReasoning: "i",
+  ReasoningSignature: "j",
+  File: "k",
 
-  AuiUpdateStateOperations = "aui-state",
-  AuiTextDelta = "aui-text-delta",
-  AuiReasoningDelta = "aui-reasoning-delta",
-  AuiDataPart = "aui-data",
-}
+  AuiUpdateStateOperations: "aui-state",
+  AuiTextDelta: "aui-text-delta",
+  AuiReasoningDelta: "aui-reasoning-delta",
+  AuiDataPart: "aui-data",
+} as const;
+export type DataStreamStreamChunkType =
+  (typeof DataStreamStreamChunkType)[keyof typeof DataStreamStreamChunkType];
 type DataStreamStreamChunkValue = {
   [DataStreamStreamChunkType.TextDelta]: string;
   [DataStreamStreamChunkType.Data]: ReadonlyJSONValue[];
@@ -100,7 +102,7 @@ type DataStreamStreamChunkValue = {
   [DataStreamStreamChunkType.File]: { data: string; mimeType: string };
 
   // aui-extensions
-  [DataStreamStreamChunkType.AuiUpdateStateOperations]: ObjectStreamOperation[];
+  [DataStreamStreamChunkType.AuiUpdateStateOperations]: GorpStreamOperation[];
   [DataStreamStreamChunkType.AuiTextDelta]: {
     textDelta: string;
     parentId: string;

package/src/core/serialization/data-stream/serialization.test.ts

@@ -0,0 +1,133 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { LineDecoderStream } from "../../utils/stream/LineDecoderStream";
+import {
+  DataStreamChunkDecoder,
+  DataStreamChunkEncoder,
+} from "./serialization";
+import { type DataStreamChunk, DataStreamStreamChunkType } from "./chunk-types";
+
+async function collectChunks<T>(stream: ReadableStream<T>): Promise<T[]> {
+  const reader = stream.getReader();
+  const chunks: T[] = [];
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      chunks.push(value);
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  return chunks;
+}
+
+function createLineStream(lines: string[]): ReadableStream<string> {
+  return new ReadableStream<string>({
+    start(controller) {
+      for (const line of lines) controller.enqueue(line);
+      controller.close();
+    },
+  });
+}
+
+describe("DataStreamChunkDecoder", () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("decodes text-delta chunks", async () => {
+    const chunks = await collectChunks(
+      createLineStream(['0:"hello"', '0:" world"']).pipeThrough(
+        new DataStreamChunkDecoder(),
+      ),
+    );
+    expect(chunks).toEqual([
+      { type: DataStreamStreamChunkType.TextDelta, value: "hello" },
+      { type: DataStreamStreamChunkType.TextDelta, value: " world" },
+    ]);
+  });
+
+  it("round-trips through DataStreamChunkEncoder", async () => {
+    const values: DataStreamChunk[] = [
+      { type: DataStreamStreamChunkType.TextDelta, value: "hello" },
+      { type: DataStreamStreamChunkType.Error, value: "boom" },
+    ];
+    const source = new ReadableStream<DataStreamChunk>({
+      start(controller) {
+        for (const v of values) controller.enqueue(v);
+        controller.close();
+      },
+    });
+    const decoded = await collectChunks(
+      source
+        .pipeThrough(new DataStreamChunkEncoder())
+        .pipeThrough(new LineDecoderStream())
+        .pipeThrough(new DataStreamChunkDecoder()),
+    );
+    expect(decoded).toEqual(values);
+  });
+
+  it("drops chunks carrying prototype-pollution keys", async () => {
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+    const chunks = await collectChunks(
+      createLineStream([
+        '0:{"__proto__":{"polluted":true}}',
+        '0:{"constructor":{"prototype":{"polluted":true}}}',
+        '0:"ok"',
+      ]).pipeThrough(new DataStreamChunkDecoder()),
+    );
+    expect(warn).toHaveBeenCalledTimes(2);
+    expect(chunks).toEqual([
+      { type: DataStreamStreamChunkType.TextDelta, value: "ok" },
+    ]);
+  });
+
+  it("drops chunks that are not valid JSON", async () => {
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+    const invalid = ["0:{not json", "0:not json"];
+    const chunks = await collectChunks(
+      createLineStream([...invalid, '0:"ok"']).pipeThrough(
+        new DataStreamChunkDecoder(),
+      ),
+    );
+    expect(warn.mock.calls.map((c) => c[0])).toEqual(
+      invalid.map((l) => `Dropped invalid data-stream chunk: ${l}`),
+    );
+    expect(chunks).toEqual([
+      { type: DataStreamStreamChunkType.TextDelta, value: "ok" },
+    ]);
+  });
+
+  it("skips blank and whitespace-only lines silently", async () => {
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+    const chunks = await collectChunks(
+      createLineStream([
+        "",
+        '0:"hello"',
+        "   ",
+        "\t",
+        '0:" world"',
+      ]).pipeThrough(new DataStreamChunkDecoder()),
+    );
+    expect(warn).not.toHaveBeenCalled();
+    expect(chunks).toEqual([
+      { type: DataStreamStreamChunkType.TextDelta, value: "hello" },
+      { type: DataStreamStreamChunkType.TextDelta, value: " world" },
+    ]);
+  });
+
+  it("drops a chunk without a colon separator with a warning", async () => {
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+    const chunks = await collectChunks(
+      createLineStream(["garbage", '0:"ok"']).pipeThrough(
+        new DataStreamChunkDecoder(),
+      ),
+    );
+    expect(warn).toHaveBeenCalledWith(
+      "Dropped invalid data-stream chunk: garbage",
+    );
+    expect(chunks).toEqual([
+      { type: DataStreamStreamChunkType.TextDelta, value: "ok" },
+    ]);
+  });
+});

package/src/core/serialization/data-stream/serialization.ts

@@ -1,3 +1,4 @@
+import sjson from "secure-json-parse";
 import type { DataStreamChunk, DataStreamStreamChunkType } from "./chunk-types";
 
 export class DataStreamChunkEncoder extends TransformStream<
@@ -21,10 +22,27 @@ export class DataStreamChunkDecoder extends TransformStream<
     super({
       transform: (chunk, controller) => {
         const index = chunk.indexOf(":");
-        if (index === -1) throw new Error("Invalid stream part");
+        if (index === -1) {
+          // Blank lines are benign data-stream framing (keepalive newlines,
+          // replay-buffer separators emitted on resume/reconnect).
+          if (chunk.trim().length === 0) return;
+          console.warn(
+            `Dropped invalid data-stream chunk: ${chunk.slice(0, 200)}`,
+          );
+          return;
+        }
+        let value;
+        try {
+          value = sjson.parse(chunk.slice(index + 1));
+        } catch {
+          console.warn(
+            `Dropped invalid data-stream chunk: ${chunk.slice(0, 200)}`,
+          );
+          return;
+        }
         controller.enqueue({
           type: chunk.slice(0, index) as DataStreamStreamChunkType,
-          value: JSON.parse(chunk.slice(index + 1)),
+          value,
         });
       },
     });

package/src/core/serialization/ui-message-stream/UIMessageStream.test.ts

@@ -575,4 +575,139 @@ describe("UIMessageStreamDecoder", () => {
     // Should not throw, should complete successfully
     expect(chunks.some((c) => c.type === "message-finish")).toBe(true);
   });
+
+  it("drops frames that are not objects with a string type", async () => {
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+    const invalidFrames = [
+      "null",
+      "5",
+      '"text"',
+      "[1,2]",
+      '{"foo":1}',
+      '{"type":5}',
+    ];
+    const events = [
+      ...invalidFrames,
+      JSON.stringify({ type: "start", messageId: "msg_123" }),
+      JSON.stringify({ type: "text-delta", id: "t", delta: "ok" }),
+      "[DONE]",
+    ];
+
+    const chunks = await collectChunks(
+      createUIMessageStream(events).pipeThrough(new UIMessageStreamDecoder()),
+    );
+
+    expect(warn.mock.calls.map((c) => c[0])).toEqual(
+      invalidFrames.map((f) => `Dropped invalid UIMessageStream chunk: ${f}`),
+    );
+    expect(chunks.some((c) => c.type === "text-delta")).toBe(true);
+    warn.mockRestore();
+  });
+
+  it("drops frames carrying prototype-pollution keys", async () => {
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+    const events = [
+      '{"type":"text-delta","delta":"x","__proto__":{"polluted":true}}',
+      '{"type":"text-delta","delta":"y","constructor":{"prototype":{"polluted":true}}}',
+      JSON.stringify({ type: "start", messageId: "msg_123" }),
+      JSON.stringify({ type: "text-delta", id: "t", delta: "ok" }),
+      "[DONE]",
+    ];
+
+    const chunks = await collectChunks(
+      createUIMessageStream(events).pipeThrough(new UIMessageStreamDecoder()),
+    );
+
+    expect(warn).toHaveBeenCalledTimes(2);
+    const deltas = chunks.filter(
+      (c): c is AssistantStreamChunk & { type: "text-delta" } =>
+        c.type === "text-delta",
+    );
+    expect(deltas).toHaveLength(1);
+    expect(deltas[0]!.textDelta).toBe("ok");
+    warn.mockRestore();
+  });
+
+  it("drops frames that are not valid JSON", async () => {
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+    const invalidFrames = ['{"type":"te', "not json"];
+    const events = [
+      ...invalidFrames,
+      JSON.stringify({ type: "start", messageId: "msg_123" }),
+      JSON.stringify({ type: "text-delta", id: "t", delta: "ok" }),
+      "[DONE]",
+    ];
+
+    const chunks = await collectChunks(
+      createUIMessageStream(events).pipeThrough(new UIMessageStreamDecoder()),
+    );
+
+    expect(warn.mock.calls.map((c) => c[0])).toEqual(
+      invalidFrames.map((f) => `Dropped invalid UIMessageStream chunk: ${f}`),
+    );
+    expect(chunks.some((c) => c.type === "text-delta")).toBe(true);
+    warn.mockRestore();
+  });
+
+  it("ignores a tool-call-delta arriving after tool-result", async () => {
+    const events = [
+      JSON.stringify({ type: "start", messageId: "msg_123" }),
+      JSON.stringify({
+        type: "tool-call-start",
+        toolCallId: "call_abc",
+        toolName: "weather",
+      }),
+      JSON.stringify({ type: "tool-call-delta", argsText: '{"city":"NYC"}' }),
+      JSON.stringify({
+        type: "tool-result",
+        toolCallId: "call_abc",
+        result: { temp: 72 },
+      }),
+      JSON.stringify({ type: "tool-call-delta", argsText: '{"late":true}' }),
+      "[DONE]",
+    ];
+
+    const chunks = await collectChunks(
+      createUIMessageStream(events).pipeThrough(new UIMessageStreamDecoder()),
+    );
+
+    const argDeltas = chunks.filter((c) => c.type === "text-delta");
+    expect(argDeltas).toHaveLength(1);
+    expect(chunks.some((c) => c.type === "result")).toBe(true);
+  });
+
+  it("keeps the active tool call writable when another call receives its result", async () => {
+    const events = [
+      JSON.stringify({
+        type: "tool-call-start",
+        toolCallId: "call_a",
+        toolName: "first",
+      }),
+      JSON.stringify({
+        type: "tool-call-start",
+        toolCallId: "call_b",
+        toolName: "second",
+      }),
+      JSON.stringify({
+        type: "tool-result",
+        toolCallId: "call_a",
+        result: { ok: true },
+      }),
+      JSON.stringify({ type: "tool-call-delta", argsText: '{"x":1}' }),
+      "[DONE]",
+    ];
+
+    const chunks = await collectChunks(
+      createUIMessageStream(events).pipeThrough(new UIMessageStreamDecoder()),
+    );
+
+    const argDeltas = chunks.filter(
+      (c): c is AssistantStreamChunk & { type: "text-delta" } =>
+        c.type === "text-delta",
+    );
+    expect(argDeltas).toHaveLength(2);
+    const byPath = new Map(argDeltas.map((c) => [c.path[0], c.textDelta]));
+    expect(byPath.get(0)).toBe("{}");
+    expect(byPath.get(1)).toBe('{"x":1}');
+  });
 });