assistant-stream 0.3.29 → 0.3.30

package/dist/core/modules/tool-call.d.ts

@@ -6,6 +6,10 @@ import { AssistantStream } from "../AssistantStream.js";
 //#region src/core/modules/tool-call.d.ts
 type ToolCallStreamController = {
   argsText: TextStreamController;
+  /**
+   * Sets the tool response and settles the part. The part closes automatically
+   * and subsequent calls are ignored.
+   */
   setResponse(response: ToolResponseLike<ReadonlyJSONValue>): void;
   close(): void;
 };

package/dist/core/modules/tool-call.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tool-call.d.ts","names":[],"sources":["../../../src/core/modules/tool-call.ts"],"mappings":";;;;;;KAOY;EACV,UAAU;EAEV,YAAY,UAAU,iBAAiB;EACvC;;cA8FW,uBACX,UAAU,mBAAmB,8BAC5B;cAcU,gDAA8B,iBAAA"}
+{"version":3,"file":"tool-call.d.ts","names":[],"sources":["../../../src/core/modules/tool-call.ts"],"mappings":";;;;;;KAOY;EACV,UAAU;;;;;EAMV,YAAY,UAAU,iBAAiB;EACvC;;cA8FW,uBACX,UAAU,mBAAmB,8BAC5B;cAcU,gDAA8B,iBAAA"}

package/dist/core/modules/tool-call.js

@@ -36,6 +36,7 @@ var ToolCallStreamControllerImpl = class {
 	}
 	_argsTextController;
 	async setResponse(response) {
+		if (this._isClosed) return;
 		this._controller.enqueue({
 			type: "result",
 			path: [],
@@ -45,8 +46,7 @@ var ToolCallStreamControllerImpl = class {
 			...response.modelContent !== void 0 ? { modelContent: response.modelContent } : {},
 			...response.messages !== void 0 ? { messages: response.messages } : {}
 		});
-		this._argsTextController.close();
-		await Promise.resolve();
+		await this.close();
 	}
 	async close() {
 		if (this._isClosed) return;

package/dist/core/modules/tool-call.js.map

@@ -1 +1 @@
-{"version":3,"file":"tool-call.js","names":[],"sources":["../../../src/core/modules/tool-call.ts"],"sourcesContent":["import type { AssistantStream } from \"../AssistantStream\";\nimport type { AssistantStreamChunk } from \"../AssistantStreamChunk\";\nimport type { ToolResponseLike } from \"../tool/ToolResponse\";\nimport type { ReadonlyJSONValue } from \"../../utils/json/json-value\";\nimport type { UnderlyingReadable } from \"../utils/stream/UnderlyingReadable\";\nimport { createTextStream, type TextStreamController } from \"./text\";\n\nexport type ToolCallStreamController = {\n  argsText: TextStreamController;\n\n  setResponse(response: ToolResponseLike<ReadonlyJSONValue>): void;\n  close(): void;\n};\n\nclass ToolCallStreamControllerImpl implements ToolCallStreamController {\n  private _isClosed = false;\n\n  private _mergeTask: Promise<void>;\n  private _controller: ReadableStreamDefaultController<AssistantStreamChunk>;\n\n  constructor(\n    _controller: ReadableStreamDefaultController<AssistantStreamChunk>,\n  ) {\n    this._controller = _controller;\n    const stream = createTextStream({\n      start: (c) => {\n        this._argsTextController = c;\n      },\n    });\n\n    let hasArgsText = false;\n    this._mergeTask = stream.pipeTo(\n      new WritableStream({\n        write: (chunk) => {\n          switch (chunk.type) {\n            case \"text-delta\":\n              hasArgsText = true;\n              this._controller.enqueue(chunk);\n              break;\n\n            case \"part-finish\":\n              if (!hasArgsText) {\n                // if no argsText was provided, assume empty object\n                this._controller.enqueue({\n                  type: \"text-delta\",\n                  textDelta: \"{}\",\n                  path: [],\n                });\n              }\n              this._controller.enqueue({\n                type: \"tool-call-args-text-finish\",\n                path: [],\n              });\n              break;\n\n            default:\n              throw new Error(`Unexpected chunk type: ${chunk.type}`);\n          }\n        },\n      }),\n    );\n  }\n\n  get argsText() {\n    return this._argsTextController;\n  }\n\n  private _argsTextController!: TextStreamController;\n\n  async setResponse(response: ToolResponseLike<ReadonlyJSONValue>) {\n    this._controller.enqueue({\n      type: \"result\",\n      path: [],\n      ...(response.artifact !== undefined\n        ? { artifact: response.artifact }\n        : {}),\n      result: response.result,\n      isError: response.isError ?? false,\n      ...(response.modelContent !== undefined\n        ? { modelContent: response.modelContent }\n        : {}),\n      ...(response.messages !== undefined\n        ? { messages: response.messages }\n        : {}),\n    });\n    this._argsTextController.close();\n    await Promise.resolve(); // flush microtask queue\n    // TODO switch argsTextController to be something that doesn'#t require this\n  }\n\n  async close() {\n    if (this._isClosed) return;\n\n    this._isClosed = true;\n    this._argsTextController.close();\n    await this._mergeTask;\n\n    this._controller.enqueue({\n      type: \"part-finish\",\n      path: [],\n    });\n    this._controller.close();\n  }\n}\n\nexport const createToolCallStream = (\n  readable: UnderlyingReadable<ToolCallStreamController>,\n): AssistantStream => {\n  return new ReadableStream({\n    start(c) {\n      return readable.start?.(new ToolCallStreamControllerImpl(c));\n    },\n    pull(c) {\n      return readable.pull?.(new ToolCallStreamControllerImpl(c));\n    },\n    cancel(c) {\n      return readable.cancel?.(c);\n    },\n  });\n};\n\nexport const createToolCallStreamController = () => {\n  let controller!: ToolCallStreamController;\n  const stream = createToolCallStream({\n    start(c) {\n      controller = c;\n    },\n  });\n  return [stream, controller] as const;\n};\n"],"mappings":";;AAcA,IAAM,+BAAN,MAAuE;CACrE,YAAoB;CAEpB;CACA;CAEA,YACE,aACA;EACA,KAAK,cAAc;EACnB,MAAM,SAAS,iBAAiB,EAC9B,QAAQ,MAAM;GACZ,KAAK,sBAAsB;EAC7B,EACF,CAAC;EAED,IAAI,cAAc;EAClB,KAAK,aAAa,OAAO,OACvB,IAAI,eAAe,EACjB,QAAQ,UAAU;GAChB,QAAQ,MAAM,MAAd;IACE,KAAK;KACH,cAAc;KACd,KAAK,YAAY,QAAQ,KAAK;KAC9B;IAEF,KAAK;KACH,IAAI,CAAC,aAEH,KAAK,YAAY,QAAQ;MACvB,MAAM;MACN,WAAW;MACX,MAAM,CAAC;KACT,CAAC;KAEH,KAAK,YAAY,QAAQ;MACvB,MAAM;MACN,MAAM,CAAC;KACT,CAAC;KACD;IAEF,SACE,MAAM,IAAI,MAAM,0BAA0B,MAAM,MAAM;GAC1D;EACF,EACF,CAAC,CACH;CACF;CAEA,IAAI,WAAW;EACb,OAAO,KAAK;CACd;CAEA;CAEA,MAAM,YAAY,UAA+C;EAC/D,KAAK,YAAY,QAAQ;GACvB,MAAM;GACN,MAAM,CAAC;GACP,GAAI,SAAS,aAAa,KAAA,IACtB,EAAE,UAAU,SAAS,SAAS,IAC9B,CAAC;GACL,QAAQ,SAAS;GACjB,SAAS,SAAS,WAAW;GAC7B,GAAI,SAAS,iBAAiB,KAAA,IAC1B,EAAE,cAAc,SAAS,aAAa,IACtC,CAAC;GACL,GAAI,SAAS,aAAa,KAAA,IACtB,EAAE,UAAU,SAAS,SAAS,IAC9B,CAAC;EACP,CAAC;EACD,KAAK,oBAAoB,MAAM;EAC/B,MAAM,QAAQ,QAAQ;CAExB;CAEA,MAAM,QAAQ;EACZ,IAAI,KAAK,WAAW;EAEpB,KAAK,YAAY;EACjB,KAAK,oBAAoB,MAAM;EAC/B,MAAM,KAAK;EAEX,KAAK,YAAY,QAAQ;GACvB,MAAM;GACN,MAAM,CAAC;EACT,CAAC;EACD,KAAK,YAAY,MAAM;CACzB;AACF;AAEA,MAAa,wBACX,aACoB;CACpB,OAAO,IAAI,eAAe;EACxB,MAAM,GAAG;GACP,OAAO,SAAS,QAAQ,IAAI,6BAA6B,CAAC,CAAC;EAC7D;EACA,KAAK,GAAG;GACN,OAAO,SAAS,OAAO,IAAI,6BAA6B,CAAC,CAAC;EAC5D;EACA,OAAO,GAAG;GACR,OAAO,SAAS,SAAS,CAAC;EAC5B;CACF,CAAC;AACH;AAEA,MAAa,uCAAuC;CAClD,IAAI;CAMJ,OAAO,CALQ,qBAAqB,EAClC,MAAM,GAAG;EACP,aAAa;CACf,EACF,CACa,GAAG,UAAU;AAC5B"}
+{"version":3,"file":"tool-call.js","names":[],"sources":["../../../src/core/modules/tool-call.ts"],"sourcesContent":["import type { AssistantStream } from \"../AssistantStream\";\nimport type { AssistantStreamChunk } from \"../AssistantStreamChunk\";\nimport type { ToolResponseLike } from \"../tool/ToolResponse\";\nimport type { ReadonlyJSONValue } from \"../../utils/json/json-value\";\nimport type { UnderlyingReadable } from \"../utils/stream/UnderlyingReadable\";\nimport { createTextStream, type TextStreamController } from \"./text\";\n\nexport type ToolCallStreamController = {\n  argsText: TextStreamController;\n\n  /**\n   * Sets the tool response and settles the part. The part closes automatically\n   * and subsequent calls are ignored.\n   */\n  setResponse(response: ToolResponseLike<ReadonlyJSONValue>): void;\n  close(): void;\n};\n\nclass ToolCallStreamControllerImpl implements ToolCallStreamController {\n  private _isClosed = false;\n\n  private _mergeTask: Promise<void>;\n  private _controller: ReadableStreamDefaultController<AssistantStreamChunk>;\n\n  constructor(\n    _controller: ReadableStreamDefaultController<AssistantStreamChunk>,\n  ) {\n    this._controller = _controller;\n    const stream = createTextStream({\n      start: (c) => {\n        this._argsTextController = c;\n      },\n    });\n\n    let hasArgsText = false;\n    this._mergeTask = stream.pipeTo(\n      new WritableStream({\n        write: (chunk) => {\n          switch (chunk.type) {\n            case \"text-delta\":\n              hasArgsText = true;\n              this._controller.enqueue(chunk);\n              break;\n\n            case \"part-finish\":\n              if (!hasArgsText) {\n                // if no argsText was provided, assume empty object\n                this._controller.enqueue({\n                  type: \"text-delta\",\n                  textDelta: \"{}\",\n                  path: [],\n                });\n              }\n              this._controller.enqueue({\n                type: \"tool-call-args-text-finish\",\n                path: [],\n              });\n              break;\n\n            default:\n              throw new Error(`Unexpected chunk type: ${chunk.type}`);\n          }\n        },\n      }),\n    );\n  }\n\n  get argsText() {\n    return this._argsTextController;\n  }\n\n  private _argsTextController!: TextStreamController;\n\n  async setResponse(response: ToolResponseLike<ReadonlyJSONValue>) {\n    if (this._isClosed) return;\n\n    this._controller.enqueue({\n      type: \"result\",\n      path: [],\n      ...(response.artifact !== undefined\n        ? { artifact: response.artifact }\n        : {}),\n      result: response.result,\n      isError: response.isError ?? false,\n      ...(response.modelContent !== undefined\n        ? { modelContent: response.modelContent }\n        : {}),\n      ...(response.messages !== undefined\n        ? { messages: response.messages }\n        : {}),\n    });\n    await this.close();\n  }\n\n  async close() {\n    if (this._isClosed) return;\n\n    this._isClosed = true;\n    this._argsTextController.close();\n    await this._mergeTask;\n\n    this._controller.enqueue({\n      type: \"part-finish\",\n      path: [],\n    });\n    this._controller.close();\n  }\n}\n\nexport const createToolCallStream = (\n  readable: UnderlyingReadable<ToolCallStreamController>,\n): AssistantStream => {\n  return new ReadableStream({\n    start(c) {\n      return readable.start?.(new ToolCallStreamControllerImpl(c));\n    },\n    pull(c) {\n      return readable.pull?.(new ToolCallStreamControllerImpl(c));\n    },\n    cancel(c) {\n      return readable.cancel?.(c);\n    },\n  });\n};\n\nexport const createToolCallStreamController = () => {\n  let controller!: ToolCallStreamController;\n  const stream = createToolCallStream({\n    start(c) {\n      controller = c;\n    },\n  });\n  return [stream, controller] as const;\n};\n"],"mappings":";;AAkBA,IAAM,+BAAN,MAAuE;CACrE,YAAoB;CAEpB;CACA;CAEA,YACE,aACA;EACA,KAAK,cAAc;EACnB,MAAM,SAAS,iBAAiB,EAC9B,QAAQ,MAAM;GACZ,KAAK,sBAAsB;EAC7B,EACF,CAAC;EAED,IAAI,cAAc;EAClB,KAAK,aAAa,OAAO,OACvB,IAAI,eAAe,EACjB,QAAQ,UAAU;GAChB,QAAQ,MAAM,MAAd;IACE,KAAK;KACH,cAAc;KACd,KAAK,YAAY,QAAQ,KAAK;KAC9B;IAEF,KAAK;KACH,IAAI,CAAC,aAEH,KAAK,YAAY,QAAQ;MACvB,MAAM;MACN,WAAW;MACX,MAAM,CAAC;KACT,CAAC;KAEH,KAAK,YAAY,QAAQ;MACvB,MAAM;MACN,MAAM,CAAC;KACT,CAAC;KACD;IAEF,SACE,MAAM,IAAI,MAAM,0BAA0B,MAAM,MAAM;GAC1D;EACF,EACF,CAAC,CACH;CACF;CAEA,IAAI,WAAW;EACb,OAAO,KAAK;CACd;CAEA;CAEA,MAAM,YAAY,UAA+C;EAC/D,IAAI,KAAK,WAAW;EAEpB,KAAK,YAAY,QAAQ;GACvB,MAAM;GACN,MAAM,CAAC;GACP,GAAI,SAAS,aAAa,KAAA,IACtB,EAAE,UAAU,SAAS,SAAS,IAC9B,CAAC;GACL,QAAQ,SAAS;GACjB,SAAS,SAAS,WAAW;GAC7B,GAAI,SAAS,iBAAiB,KAAA,IAC1B,EAAE,cAAc,SAAS,aAAa,IACtC,CAAC;GACL,GAAI,SAAS,aAAa,KAAA,IACtB,EAAE,UAAU,SAAS,SAAS,IAC9B,CAAC;EACP,CAAC;EACD,MAAM,KAAK,MAAM;CACnB;CAEA,MAAM,QAAQ;EACZ,IAAI,KAAK,WAAW;EAEpB,KAAK,YAAY;EACjB,KAAK,oBAAoB,MAAM;EAC/B,MAAM,KAAK;EAEX,KAAK,YAAY,QAAQ;GACvB,MAAM;GACN,MAAM,CAAC;EACT,CAAC;EACD,KAAK,YAAY,MAAM;CACzB;AACF;AAEA,MAAa,wBACX,aACoB;CACpB,OAAO,IAAI,eAAe;EACxB,MAAM,GAAG;GACP,OAAO,SAAS,QAAQ,IAAI,6BAA6B,CAAC,CAAC;EAC7D;EACA,KAAK,GAAG;GACN,OAAO,SAAS,OAAO,IAAI,6BAA6B,CAAC,CAAC;EAC5D;EACA,OAAO,GAAG;GACR,OAAO,SAAS,SAAS,CAAC;EAC5B;CACF,CAAC;AACH;AAEA,MAAa,uCAAuC;CAClD,IAAI;CAMJ,OAAO,CALQ,qBAAqB,EAClC,MAAM,GAAG;EACP,aAAa;CACf,EACF,CACa,GAAG,UAAU;AAC5B"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "assistant-stream",
-  "version": "0.3.29",
+  "version": "0.3.30",
   "description": "Streaming utilities for AI assistants",
   "keywords": [
     "ai",

package/src/core/modules/assistant-stream.test.ts

@@ -173,6 +173,55 @@ describe("createAssistantStream task settlement", () => {
   });
 });
 
+describe("addToolCallPart with an immediate response", () => {
+  it("completes the stream without an explicit tool close", async () => {
+    const chunks = await collectChunks(
+      createAssistantStream((controller) => {
+        controller.addToolCallPart({
+          toolName: "search",
+          response: { result: "done" },
+        });
+      }),
+    );
+
+    expect(chunks.map((c) => c.type)).toContain("result");
+    expect(chunks.at(-1)?.type).toBe("part-finish");
+  });
+
+  it("completes the stream when args accompany the response", async () => {
+    const chunks = await collectChunks(
+      createAssistantStream((controller) => {
+        controller.addToolCallPart({
+          toolName: "search",
+          args: { query: "x" },
+          response: { result: "done" },
+        });
+      }),
+    );
+
+    const deltas = chunks.filter((c) => c.type === "text-delta");
+    expect(deltas.map((c) => c.textDelta).join("")).toBe('{"query":"x"}');
+    expect(chunks.filter((c) => c.type === "result")).toHaveLength(1);
+    expect(chunks.at(-1)?.type).toBe("part-finish");
+  });
+
+  it("keeps working when the caller also closes explicitly", async () => {
+    const chunks = await collectChunks(
+      createAssistantStream((controller) => {
+        const tool = controller.addToolCallPart({
+          toolName: "search",
+          response: { result: "done" },
+        });
+        tool.close();
+      }),
+    );
+
+    expect(chunks.filter((c) => c.type === "result")).toHaveLength(1);
+    expect(chunks.filter((c) => c.type === "part-finish")).toHaveLength(1);
+    expect(chunks.at(-1)?.type).toBe("part-finish");
+  });
+});
+
 describe("AssistantStreamController withParentId", () => {
   it("attaches parentId to text parts across a data-stream round trip", async () => {
     const response = createAssistantStreamResponse((controller) => {

package/src/core/modules/tool-call.test.ts

@@ -1,12 +1,28 @@
 import { describe, expect, it, vi } from "vitest";
 import { createAssistantStreamController } from "./assistant-stream";
+import { createToolCallStreamController } from "./tool-call";
 import { ToolResponse } from "../tool/ToolResponse";
 import { toolResultStream } from "../tool/toolResultStream";
 import type { ToolCallReader } from "../tool/tool-types";
+import type { AssistantStream } from "../AssistantStream";
 import type { AssistantStreamChunk } from "../AssistantStreamChunk";
 
 type Reader = ToolCallReader<Record<string, unknown>, unknown>;
 
+const collectChunks = async (
+  stream: AssistantStream,
+): Promise<AssistantStreamChunk[]> => {
+  const chunks: AssistantStreamChunk[] = [];
+  await stream.pipeTo(
+    new WritableStream({
+      write(chunk) {
+        chunks.push(chunk);
+      },
+    }),
+  );
+  return chunks;
+};
+
 describe("ToolCallStreamController", () => {
   it("delivers a backend response before an args parse failure", async () => {
     const [stream, controller] = createAssistantStreamController();
@@ -64,4 +80,38 @@ describe("ToolCallStreamController", () => {
       isError: false,
     });
   });
+
+  it("setResponse settles the part without an explicit close", async () => {
+    const [stream, controller] = createToolCallStreamController();
+    controller.setResponse({ result: "done" });
+
+    const chunks = await collectChunks(stream);
+
+    expect(chunks.map((c) => c.type)).toContain("result");
+    expect(chunks.at(-1)?.type).toBe("part-finish");
+  });
+
+  it("ignores a second setResponse after the part is settled", async () => {
+    const [stream, controller] = createToolCallStreamController();
+    controller.setResponse({ result: "first" });
+    controller.setResponse({ result: "second" });
+
+    const chunks = await collectChunks(stream);
+
+    const results = chunks.filter((c) => c.type === "result");
+    expect(results).toEqual([expect.objectContaining({ result: "first" })]);
+    expect(chunks.filter((c) => c.type === "part-finish")).toHaveLength(1);
+  });
+
+  it("ignores setResponse after an explicit close", async () => {
+    const [stream, controller] = createToolCallStreamController();
+    controller.argsText.append('{"query":"x"}');
+    controller.close();
+    controller.setResponse({ result: "late" });
+
+    const chunks = await collectChunks(stream);
+
+    expect(chunks.filter((c) => c.type === "result")).toHaveLength(0);
+    expect(chunks.at(-1)?.type).toBe("part-finish");
+  });
 });

package/src/core/modules/tool-call.ts

@@ -8,6 +8,10 @@ import { createTextStream, type TextStreamController } from "./text";
 export type ToolCallStreamController = {
   argsText: TextStreamController;
 
+  /**
+   * Sets the tool response and settles the part. The part closes automatically
+   * and subsequent calls are ignored.
+   */
   setResponse(response: ToolResponseLike<ReadonlyJSONValue>): void;
   close(): void;
 };
@@ -68,6 +72,8 @@ class ToolCallStreamControllerImpl implements ToolCallStreamController {
   private _argsTextController!: TextStreamController;
 
   async setResponse(response: ToolResponseLike<ReadonlyJSONValue>) {
+    if (this._isClosed) return;
+
     this._controller.enqueue({
       type: "result",
       path: [],
@@ -83,9 +89,7 @@ class ToolCallStreamControllerImpl implements ToolCallStreamController {
         ? { messages: response.messages }
         : {}),
     });
-    this._argsTextController.close();
-    await Promise.resolve(); // flush microtask queue
-    // TODO switch argsTextController to be something that doesn'#t require this
+    await this.close();
   }
 
   async close() {

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

@@ -0,0 +1,179 @@
+import { readFileSync } from "node:fs";
+import { describe, expect, it } from "vitest";
+import { AssistantTransportDecoder } from "./AssistantTransport";
+import { AssistantMessageAccumulator } from "../../accumulators/assistant-message-accumulator";
+import type { AssistantStreamChunk } from "../../AssistantStreamChunk";
+import type { AssistantMessage } from "../../utils/types";
+
+// Fixture produced by the Python encoder; regenerate with
+// `uv run python tests/generate_interop_fixture.py` in python/assistant-stream.
+const fixture = readFileSync(
+  new URL("./__fixtures__/python-encoder.sse", import.meta.url),
+);
+
+const EXPECTED_CHUNKS: AssistantStreamChunk[] = [
+  { type: "step-start", messageId: "msg_1", path: [] },
+  { type: "part-start", part: { type: "reasoning" }, path: [] },
+  { type: "text-delta", textDelta: "Let me check the weather.", path: [0] },
+  { type: "part-finish", path: [0] },
+  { type: "part-start", part: { type: "text" }, path: [] },
+  { type: "text-delta", textDelta: "Checking", path: [1] },
+  { type: "text-delta", textDelta: " now.", path: [1] },
+  { type: "part-finish", path: [1] },
+  {
+    type: "part-start",
+    part: { type: "tool-call", toolCallId: "call_1", toolName: "get_weather" },
+    path: [],
+  },
+  { type: "text-delta", textDelta: '{"city": ', path: [2] },
+  { type: "text-delta", textDelta: '"NYC"}', path: [2] },
+  {
+    type: "update-state",
+    operations: [{ type: "set", path: ["status"], value: "running" }],
+    path: [],
+  },
+  { type: "result", result: { temp: 70 }, isError: false, path: [2] },
+  { type: "tool-call-args-text-finish", path: [2] },
+  { type: "part-finish", path: [2] },
+  { type: "data", data: [{ progress: 1 }], path: [] },
+  {
+    type: "annotations",
+    annotations: [{ type: "citation", id: "a1" }],
+    path: [],
+  },
+  {
+    type: "part-start",
+    part: {
+      type: "source",
+      sourceType: "url",
+      id: "s1",
+      url: "https://example.com",
+      title: "Example",
+    },
+    path: [],
+  },
+  { type: "part-finish", path: [3] },
+  { type: "part-start", part: { type: "text" }, path: [] },
+  { type: "text-delta", textDelta: "It is sunny.", path: [4] },
+  { type: "part-finish", path: [4] },
+  {
+    type: "part-start",
+    part: { type: "file", data: "aGVsbG8=", mimeType: "image/png" },
+    path: [],
+  },
+  { type: "part-finish", path: [5] },
+  {
+    type: "step-finish",
+    finishReason: "stop",
+    usage: { inputTokens: 12, outputTokens: 34 },
+    isContinued: false,
+    path: [],
+  },
+];
+
+const decodeFixture = async (chunkSize: number) => {
+  const bytes = new Uint8Array(fixture);
+  const stream = new ReadableStream<Uint8Array<ArrayBuffer>>({
+    start(controller) {
+      for (let offset = 0; offset < bytes.length; offset += chunkSize) {
+        controller.enqueue(
+          new Uint8Array(bytes.slice(offset, offset + chunkSize)),
+        );
+      }
+      controller.close();
+    },
+  });
+
+  const chunks: AssistantStreamChunk[] = [];
+  const reader = stream
+    .pipeThrough(new AssistantTransportDecoder())
+    .getReader();
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    chunks.push(value);
+  }
+  return chunks;
+};
+
+describe("Python encoder interop", () => {
+  it("decodes the captured Python encoder output into canonical chunks", async () => {
+    expect(await decodeFixture(fixture.length)).toEqual(EXPECTED_CHUNKS);
+  });
+
+  it("decodes the fixture identically under network fragmentation", async () => {
+    expect(await decodeFixture(5)).toEqual(EXPECTED_CHUNKS);
+  });
+
+  it("accumulates the decoded fixture into a canonical message", async () => {
+    const decoded = await decodeFixture(fixture.length);
+    const source = new ReadableStream<AssistantStreamChunk>({
+      start(controller) {
+        for (const chunk of decoded) {
+          controller.enqueue(chunk);
+        }
+        controller.close();
+      },
+    });
+
+    const messages: AssistantMessage[] = [];
+    await source.pipeThrough(new AssistantMessageAccumulator()).pipeTo(
+      new WritableStream({
+        write(message) {
+          messages.push(message);
+        },
+      }),
+    );
+
+    const message = messages.at(-1)!;
+    expect(message.parts).toHaveLength(6);
+    expect(message.parts[0]).toMatchObject({
+      type: "reasoning",
+      text: "Let me check the weather.",
+    });
+    expect(message.parts[1]).toMatchObject({
+      type: "text",
+      text: "Checking now.",
+    });
+    expect(message.parts[2]).toMatchObject({
+      type: "tool-call",
+      toolCallId: "call_1",
+      toolName: "get_weather",
+      state: "result",
+      argsText: '{"city": "NYC"}',
+      args: { city: "NYC" },
+      result: { temp: 70 },
+      isError: false,
+    });
+    expect(message.parts[3]).toMatchObject({
+      type: "source",
+      sourceType: "url",
+      id: "s1",
+      url: "https://example.com",
+      title: "Example",
+    });
+    expect(message.parts[4]).toMatchObject({
+      type: "text",
+      text: "It is sunny.",
+    });
+    expect(message.parts[5]).toMatchObject({
+      type: "file",
+      mimeType: "image/png",
+      data: "aGVsbG8=",
+    });
+    expect(message.metadata.unstable_state).toEqual({ status: "running" });
+    expect(message.metadata.unstable_data).toEqual([{ progress: 1 }]);
+    expect(message.metadata.unstable_annotations).toEqual([
+      { type: "citation", id: "a1" },
+    ]);
+    expect(message.metadata.steps).toEqual([
+      {
+        state: "finished",
+        messageId: "msg_1",
+        finishReason: "stop",
+        usage: { inputTokens: 12, outputTokens: 34 },
+        isContinued: false,
+      },
+    ]);
+  });
+});

package/src/core/serialization/assistant-transport/__fixtures__/python-encoder.sse

@@ -0,0 +1,52 @@
+data: {"type": "step-start", "messageId": "msg_1"}
+
+data: {"type": "part-start", "part": {"type": "reasoning"}, "path": []}
+
+data: {"type": "text-delta", "textDelta": "Let me check the weather.", "path": [0]}
+
+data: {"type": "part-finish", "path": [0]}
+
+data: {"type": "part-start", "part": {"type": "text"}, "path": []}
+
+data: {"type": "text-delta", "textDelta": "Checking", "path": [1]}
+
+data: {"type": "text-delta", "textDelta": " now.", "path": [1]}
+
+data: {"type": "part-finish", "path": [1]}
+
+data: {"type": "part-start", "part": {"type": "tool-call", "toolCallId": "call_1", "toolName": "get_weather"}, "path": []}
+
+data: {"type": "text-delta", "textDelta": "{\"city\": ", "path": [2]}
+
+data: {"type": "text-delta", "textDelta": "\"NYC\"}", "path": [2]}
+
+data: {"type": "update-state", "operations": [{"type": "set", "path": ["status"], "value": "running"}]}
+
+data: {"type": "result", "result": {"temp": 70}, "isError": false, "path": [2]}
+
+data: {"type": "tool-call-args-text-finish", "path": [2]}
+
+data: {"type": "part-finish", "path": [2]}
+
+data: {"type": "data", "data": [{"progress": 1}]}
+
+data: {"type": "annotations", "annotations": [{"type": "citation", "id": "a1"}]}
+
+data: {"type": "part-start", "part": {"type": "source", "sourceType": "url", "id": "s1", "url": "https://example.com", "title": "Example"}, "path": []}
+
+data: {"type": "part-finish", "path": [3]}
+
+data: {"type": "part-start", "part": {"type": "text"}, "path": []}
+
+data: {"type": "text-delta", "textDelta": "It is sunny.", "path": [4]}
+
+data: {"type": "part-finish", "path": [4]}
+
+data: {"type": "part-start", "part": {"type": "file", "data": "aGVsbG8=", "mimeType": "image/png"}, "path": []}
+
+data: {"type": "part-finish", "path": [5]}
+
+data: {"type": "step-finish", "finishReason": "stop", "usage": {"inputTokens": 12, "outputTokens": 34}, "isContinued": false}
+
+data: [DONE]
+

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

@@ -676,6 +676,47 @@ describe("UIMessageStreamDecoder", () => {
     expect(chunks.some((c) => c.type === "result")).toBe(true);
   });
 
+  it("settles the tool part at result time instead of decoder flush", 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-call-end" }),
+      JSON.stringify({
+        type: "tool-result",
+        toolCallId: "call_abc",
+        result: { temp: 72 },
+      }),
+      JSON.stringify({ type: "text-start", id: "text_1" }),
+      JSON.stringify({ type: "text-delta", id: "text_1", delta: "Hello" }),
+      JSON.stringify({ type: "text-end" }),
+      JSON.stringify({
+        type: "finish",
+        finishReason: "stop",
+        usage: { inputTokens: 10, outputTokens: 5 },
+      }),
+      "[DONE]",
+    ];
+
+    const chunks = await collectChunks(
+      createUIMessageStream(events).pipeThrough(new UIMessageStreamDecoder()),
+    );
+
+    const toolPartFinish = chunks.findIndex(
+      (c) => c.type === "part-finish" && c.path[0] === 0,
+    );
+    const result = chunks.findIndex((c) => c.type === "result");
+    const messageFinish = chunks.findIndex((c) => c.type === "message-finish");
+    expect(result).toBeGreaterThan(-1);
+    expect(messageFinish).toBeGreaterThan(-1);
+    expect(toolPartFinish).toBeGreaterThan(result);
+    expect(toolPartFinish).toBeLessThan(messageFinish);
+  });
+
   it("keeps the active tool call writable when another call receives its result", async () => {
     const events = [
       JSON.stringify({