assistant-stream 0.2.37 → 0.2.39

package/dist/core/index.d.ts

@@ -5,6 +5,7 @@ export type { AssistantStreamController } from "./modules/assistant-stream";
 export type { AssistantStreamChunk } from "./AssistantStreamChunk";
 export { DataStreamDecoder, DataStreamEncoder, } from "./serialization/data-stream/DataStream";
 export { PlainTextDecoder, PlainTextEncoder } from "./serialization/PlainText";
+export { AssistantTransportDecoder, AssistantTransportEncoder, } from "./serialization/assistant-transport/AssistantTransport";
 export { AssistantMessageStream } from "./accumulators/AssistantMessageStream";
 export type { AssistantMessage } from "./utils/types";
 export * from "./tool";

package/dist/core/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/core/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,qBAAqB,EACrB,6BAA6B,EAC7B,+BAA+B,GAChC,MAAM,4BAA4B,CAAC;AACpC,OAAO,EACL,2BAA2B,EAC3B,oBAAoB,IAAI,6BAA6B,GACtD,MAAM,8CAA8C,CAAC;AACtD,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,YAAY,EAAE,yBAAyB,EAAE,MAAM,4BAA4B,CAAC;AAC5E,YAAY,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AACnE,OAAO,EACL,iBAAiB,EACjB,iBAAiB,GAClB,MAAM,wCAAwC,CAAC;AAChD,OAAO,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAC/E,OAAO,EAAE,sBAAsB,EAAE,MAAM,uCAAuC,CAAC;AAC/E,YAAY,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAEtD,cAAc,QAAQ,CAAC;AACvB,YAAY,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AAC3D,YAAY,EAAE,wBAAwB,EAAE,MAAM,qBAAqB,CAAC;AAEpE,OAAO,EAAE,kBAAkB,EAAE,MAAM,6BAA6B,CAAC;AACjE,OAAO,EACL,oBAAoB,EACpB,wBAAwB,GACzB,MAAM,+BAA+B,CAAC;AACvC,YAAY,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/core/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,qBAAqB,EACrB,6BAA6B,EAC7B,+BAA+B,GAChC,MAAM,4BAA4B,CAAC;AACpC,OAAO,EACL,2BAA2B,EAC3B,oBAAoB,IAAI,6BAA6B,GACtD,MAAM,8CAA8C,CAAC;AACtD,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,YAAY,EAAE,yBAAyB,EAAE,MAAM,4BAA4B,CAAC;AAC5E,YAAY,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AACnE,OAAO,EACL,iBAAiB,EACjB,iBAAiB,GAClB,MAAM,wCAAwC,CAAC;AAChD,OAAO,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAC/E,OAAO,EACL,yBAAyB,EACzB,yBAAyB,GAC1B,MAAM,wDAAwD,CAAC;AAChE,OAAO,EAAE,sBAAsB,EAAE,MAAM,uCAAuC,CAAC;AAC/E,YAAY,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAEtD,cAAc,QAAQ,CAAC;AACvB,YAAY,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AAC3D,YAAY,EAAE,wBAAwB,EAAE,MAAM,qBAAqB,CAAC;AAEpE,OAAO,EAAE,kBAAkB,EAAE,MAAM,6BAA6B,CAAC;AACjE,OAAO,EACL,oBAAoB,EACpB,wBAAwB,GACzB,MAAM,+BAA+B,CAAC;AACvC,YAAY,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/core/index.js

@@ -14,6 +14,10 @@ import {
   DataStreamEncoder
 } from "./serialization/data-stream/DataStream.js";
 import { PlainTextDecoder, PlainTextEncoder } from "./serialization/PlainText.js";
+import {
+  AssistantTransportDecoder,
+  AssistantTransportEncoder
+} from "./serialization/assistant-transport/AssistantTransport.js";
 import { AssistantMessageStream } from "./accumulators/AssistantMessageStream.js";
 export * from "./tool/index.js";
 import { createObjectStream } from "./object/createObjectStream.js";
@@ -25,6 +29,8 @@ export {
   AssistantMessageAccumulator,
   AssistantMessageStream,
   AssistantStream,
+  AssistantTransportDecoder,
+  AssistantTransportEncoder,
   DataStreamDecoder,
   DataStreamEncoder,
   ObjectStreamResponse,

package/dist/core/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/core/index.ts"],"sourcesContent":["export {\n  createAssistantStream,\n  createAssistantStreamResponse,\n  createAssistantStreamController,\n} from \"./modules/assistant-stream\";\nexport {\n  AssistantMessageAccumulator,\n  createInitialMessage as unstable_createInitialMessage,\n} from \"./accumulators/assistant-message-accumulator\";\nexport { AssistantStream } from \"./AssistantStream\";\nexport type { AssistantStreamController } from \"./modules/assistant-stream\";\nexport type { AssistantStreamChunk } from \"./AssistantStreamChunk\";\nexport {\n  DataStreamDecoder,\n  DataStreamEncoder,\n} from \"./serialization/data-stream/DataStream\";\nexport { PlainTextDecoder, PlainTextEncoder } from \"./serialization/PlainText\";\nexport { AssistantMessageStream } from \"./accumulators/AssistantMessageStream\";\nexport type { AssistantMessage } from \"./utils/types\";\n\nexport * from \"./tool\";\nexport type { TextStreamController } from \"./modules/text\";\nexport type { ToolCallStreamController } from \"./modules/tool-call\";\n\nexport { createObjectStream } from \"./object/createObjectStream\";\nexport {\n  ObjectStreamResponse,\n  fromObjectStreamResponse,\n} from \"./object/ObjectStreamResponse\";\nexport type { ObjectStreamChunk } from \"./object/types\";\n"],"mappings":";AAAA;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP;AAAA,EACE;AAAA,EACwB;AAAA,OACnB;AACP,SAAS,uBAAuB;AAGhC;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP,SAAS,kBAAkB,wBAAwB;AACnD,SAAS,8BAA8B;AAGvC,cAAc;AAId,SAAS,0BAA0B;AACnC;AAAA,EACE;AAAA,EACA;AAAA,OACK;","names":[]}
+{"version":3,"sources":["../../src/core/index.ts"],"sourcesContent":["export {\n  createAssistantStream,\n  createAssistantStreamResponse,\n  createAssistantStreamController,\n} from \"./modules/assistant-stream\";\nexport {\n  AssistantMessageAccumulator,\n  createInitialMessage as unstable_createInitialMessage,\n} from \"./accumulators/assistant-message-accumulator\";\nexport { AssistantStream } from \"./AssistantStream\";\nexport type { AssistantStreamController } from \"./modules/assistant-stream\";\nexport type { AssistantStreamChunk } from \"./AssistantStreamChunk\";\nexport {\n  DataStreamDecoder,\n  DataStreamEncoder,\n} from \"./serialization/data-stream/DataStream\";\nexport { PlainTextDecoder, PlainTextEncoder } from \"./serialization/PlainText\";\nexport {\n  AssistantTransportDecoder,\n  AssistantTransportEncoder,\n} from \"./serialization/assistant-transport/AssistantTransport\";\nexport { AssistantMessageStream } from \"./accumulators/AssistantMessageStream\";\nexport type { AssistantMessage } from \"./utils/types\";\n\nexport * from \"./tool\";\nexport type { TextStreamController } from \"./modules/text\";\nexport type { ToolCallStreamController } from \"./modules/tool-call\";\n\nexport { createObjectStream } from \"./object/createObjectStream\";\nexport {\n  ObjectStreamResponse,\n  fromObjectStreamResponse,\n} from \"./object/ObjectStreamResponse\";\nexport type { ObjectStreamChunk } from \"./object/types\";\n"],"mappings":";AAAA;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP;AAAA,EACE;AAAA,EACwB;AAAA,OACnB;AACP,SAAS,uBAAuB;AAGhC;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP,SAAS,kBAAkB,wBAAwB;AACnD;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP,SAAS,8BAA8B;AAGvC,cAAc;AAId,SAAS,0BAA0B;AACnC;AAAA,EACE;AAAA,EACA;AAAA,OACK;","names":[]}

package/dist/core/serialization/assistant-transport/AssistantTransport.d.ts

@@ -0,0 +1,19 @@
+import { AssistantStreamChunk } from "../../AssistantStreamChunk";
+import { PipeableTransformStream } from "../../utils/stream/PipeableTransformStream";
+import { AssistantStreamEncoder } from "../../AssistantStream";
+/**
+ * AssistantTransportEncoder encodes AssistantStreamChunks into SSE format
+ * and emits [DONE] when the stream completes.
+ */
+export declare class AssistantTransportEncoder extends PipeableTransformStream<AssistantStreamChunk, Uint8Array<ArrayBuffer>> implements AssistantStreamEncoder {
+    headers: Headers;
+    constructor();
+}
+/**
+ * AssistantTransportDecoder decodes SSE format into AssistantStreamChunks.
+ * It stops decoding when it encounters [DONE].
+ */
+export declare class AssistantTransportDecoder extends PipeableTransformStream<Uint8Array<ArrayBuffer>, AssistantStreamChunk> {
+    constructor();
+}
+//# sourceMappingURL=AssistantTransport.d.ts.map

package/dist/core/serialization/assistant-transport/AssistantTransport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AssistantTransport.d.ts","sourceRoot":"","sources":["../../../../src/core/serialization/assistant-transport/AssistantTransport.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,4BAA4B,CAAC;AAClE,OAAO,EAAE,uBAAuB,EAAE,MAAM,4CAA4C,CAAC;AAErF,OAAO,EAAE,sBAAsB,EAAE,MAAM,uBAAuB,CAAC;AAE/D;;;GAGG;AACH,qBAAa,yBACX,SAAQ,uBAAuB,CAAC,oBAAoB,EAAE,UAAU,CAAC,WAAW,CAAC,CAC7E,YAAW,sBAAsB;IAEjC,OAAO,UAIJ;;CAkBJ;AAoED;;;GAGG;AACH,qBAAa,yBAA0B,SAAQ,uBAAuB,CACpE,UAAU,CAAC,WAAW,CAAC,EACvB,oBAAoB,CACrB;;CAsCA"}

package/dist/core/serialization/assistant-transport/AssistantTransport.js

@@ -0,0 +1,117 @@
+// src/core/serialization/assistant-transport/AssistantTransport.ts
+import { PipeableTransformStream } from "../../utils/stream/PipeableTransformStream.js";
+import { LineDecoderStream } from "../../utils/stream/LineDecoderStream.js";
+var AssistantTransportEncoder = class extends PipeableTransformStream {
+  headers = new Headers({
+    "Content-Type": "text/event-stream",
+    "Cache-Control": "no-cache",
+    Connection: "keep-alive"
+  });
+  constructor() {
+    super((readable) => {
+      return readable.pipeThrough(
+        new TransformStream({
+          transform(chunk, controller) {
+            controller.enqueue(`data: ${JSON.stringify(chunk)}
+
+`);
+          },
+          flush(controller) {
+            controller.enqueue("data: [DONE]\n\n");
+          }
+        })
+      ).pipeThrough(new TextEncoderStream());
+    });
+  }
+};
+var SSEEventStream = class extends TransformStream {
+  constructor() {
+    let eventBuffer = {};
+    let dataLines = [];
+    super({
+      start() {
+        eventBuffer = {};
+        dataLines = [];
+      },
+      transform(line, controller) {
+        if (line.startsWith(":")) return;
+        if (line === "") {
+          if (dataLines.length > 0) {
+            controller.enqueue({
+              event: eventBuffer.event || "message",
+              data: dataLines.join("\n"),
+              id: eventBuffer.id,
+              retry: eventBuffer.retry
+            });
+          }
+          eventBuffer = {};
+          dataLines = [];
+          return;
+        }
+        const [field, ...rest] = line.split(":");
+        const value = rest.join(":").trimStart();
+        switch (field) {
+          case "event":
+            eventBuffer.event = value;
+            break;
+          case "data":
+            dataLines.push(value);
+            break;
+          case "id":
+            eventBuffer.id = value;
+            break;
+          case "retry":
+            eventBuffer.retry = Number(value);
+            break;
+        }
+      },
+      flush(controller) {
+        if (dataLines.length > 0) {
+          controller.enqueue({
+            event: eventBuffer.event || "message",
+            data: dataLines.join("\n"),
+            id: eventBuffer.id,
+            retry: eventBuffer.retry
+          });
+        }
+      }
+    });
+  }
+};
+var AssistantTransportDecoder = class extends PipeableTransformStream {
+  constructor() {
+    super((readable) => {
+      let receivedDone = false;
+      return readable.pipeThrough(new TextDecoderStream()).pipeThrough(new LineDecoderStream()).pipeThrough(new SSEEventStream()).pipeThrough(
+        new TransformStream({
+          transform(event, controller) {
+            switch (event.event) {
+              case "message":
+                if (event.data === "[DONE]") {
+                  receivedDone = true;
+                  controller.terminate();
+                } else {
+                  controller.enqueue(JSON.parse(event.data));
+                }
+                break;
+              default:
+                throw new Error(`Unknown SSE event type: ${event.event}`);
+            }
+          },
+          flush() {
+            if (!receivedDone) {
+              throw new Error(
+                "Stream ended abruptly without receiving [DONE] marker"
+              );
+            }
+          }
+        })
+      );
+    });
+  }
+};
+export {
+  AssistantTransportDecoder,
+  AssistantTransportEncoder
+};
+//# sourceMappingURL=AssistantTransport.js.map

package/dist/core/serialization/assistant-transport/AssistantTransport.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/core/serialization/assistant-transport/AssistantTransport.ts"],"sourcesContent":["import { AssistantStreamChunk } from \"../../AssistantStreamChunk\";\nimport { PipeableTransformStream } from \"../../utils/stream/PipeableTransformStream\";\nimport { LineDecoderStream } from \"../../utils/stream/LineDecoderStream\";\nimport { AssistantStreamEncoder } from \"../../AssistantStream\";\n\n/**\n * AssistantTransportEncoder encodes AssistantStreamChunks into SSE format\n * and emits [DONE] when the stream completes.\n */\nexport class AssistantTransportEncoder\n  extends PipeableTransformStream<AssistantStreamChunk, Uint8Array<ArrayBuffer>>\n  implements AssistantStreamEncoder\n{\n  headers = new Headers({\n    \"Content-Type\": \"text/event-stream\",\n    \"Cache-Control\": \"no-cache\",\n    Connection: \"keep-alive\",\n  });\n\n  constructor() {\n    super((readable) => {\n      return readable\n        .pipeThrough(\n          new TransformStream<AssistantStreamChunk, string>({\n            transform(chunk, controller) {\n              controller.enqueue(`data: ${JSON.stringify(chunk)}\\n\\n`);\n            },\n            flush(controller) {\n              controller.enqueue(\"data: [DONE]\\n\\n\");\n            },\n          }),\n        )\n        .pipeThrough(new TextEncoderStream());\n    });\n  }\n}\n\ntype SSEEvent = {\n  event: string;\n  data: string;\n  id?: string | undefined;\n  retry?: number | undefined;\n};\n\nclass SSEEventStream extends TransformStream<string, SSEEvent> {\n  constructor() {\n    let eventBuffer: Partial<SSEEvent> = {};\n    let dataLines: string[] = [];\n\n    super({\n      start() {\n        eventBuffer = {};\n        dataLines = [];\n      },\n      transform(line, controller) {\n        if (line.startsWith(\":\")) return; // Ignore comments\n\n        if (line === \"\") {\n          if (dataLines.length > 0) {\n            controller.enqueue({\n              event: eventBuffer.event || \"message\",\n              data: dataLines.join(\"\\n\"),\n              id: eventBuffer.id,\n              retry: eventBuffer.retry,\n            });\n          }\n          eventBuffer = {};\n          dataLines = [];\n          return;\n        }\n\n        const [field, ...rest] = line.split(\":\");\n        const value = rest.join(\":\").trimStart();\n\n        switch (field) {\n          case \"event\":\n            eventBuffer.event = value;\n            break;\n          case \"data\":\n            dataLines.push(value);\n            break;\n          case \"id\":\n            eventBuffer.id = value;\n            break;\n          case \"retry\":\n            eventBuffer.retry = Number(value);\n            break;\n        }\n      },\n      flush(controller) {\n        if (dataLines.length > 0) {\n          controller.enqueue({\n            event: eventBuffer.event || \"message\",\n            data: dataLines.join(\"\\n\"),\n            id: eventBuffer.id,\n            retry: eventBuffer.retry,\n          });\n        }\n      },\n    });\n  }\n}\n\n/**\n * AssistantTransportDecoder decodes SSE format into AssistantStreamChunks.\n * It stops decoding when it encounters [DONE].\n */\nexport class AssistantTransportDecoder extends PipeableTransformStream<\n  Uint8Array<ArrayBuffer>,\n  AssistantStreamChunk\n> {\n  constructor() {\n    super((readable) => {\n      let receivedDone = false;\n\n      return readable\n        .pipeThrough(new TextDecoderStream())\n        .pipeThrough(new LineDecoderStream())\n        .pipeThrough(new SSEEventStream())\n        .pipeThrough(\n          new TransformStream<SSEEvent, AssistantStreamChunk>({\n            transform(event, controller) {\n              switch (event.event) {\n                case \"message\":\n                  if (event.data === \"[DONE]\") {\n                    // Mark that we received [DONE]\n                    receivedDone = true;\n                    // Stop processing when we encounter [DONE]\n                    controller.terminate();\n                  } else {\n                    controller.enqueue(JSON.parse(event.data));\n                  }\n                  break;\n                default:\n                  throw new Error(`Unknown SSE event type: ${event.event}`);\n              }\n            },\n            flush() {\n              if (!receivedDone) {\n                throw new Error(\n                  \"Stream ended abruptly without receiving [DONE] marker\",\n                );\n              }\n            },\n          }),\n        );\n    });\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/core/serialization/assistant-transport/AssistantTransport.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=AssistantTransport.test.d.ts.map

package/dist/core/serialization/assistant-transport/AssistantTransport.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AssistantTransport.test.d.ts","sourceRoot":"","sources":["../../../../src/core/serialization/assistant-transport/AssistantTransport.test.ts"],"names":[],"mappings":""}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "assistant-stream",
-  "version": "0.2.37",
+  "version": "0.2.39",
   "license": "MIT",
   "type": "module",
   "exports": {
@@ -25,11 +25,9 @@
   "sideEffects": false,
   "devDependencies": {
     "@standard-schema/spec": "^1.0.0",
-    "@types/node": "^24.9.1",
-    "eslint": "^9",
-    "eslint-config-next": "16.0.0",
+    "@types/node": "^24.10.0",
     "tsx": "^4.20.6",
-    "vitest": "^4.0.1",
+    "vitest": "^4.0.6",
     "@assistant-ui/x-buildutils": "0.0.1"
   },
   "publishConfig": {

package/src/core/index.ts

@@ -15,6 +15,10 @@ export {
   DataStreamEncoder,
 } from "./serialization/data-stream/DataStream";
 export { PlainTextDecoder, PlainTextEncoder } from "./serialization/PlainText";
+export {
+  AssistantTransportDecoder,
+  AssistantTransportEncoder,
+} from "./serialization/assistant-transport/AssistantTransport";
 export { AssistantMessageStream } from "./accumulators/AssistantMessageStream";
 export type { AssistantMessage } from "./utils/types";
 

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

@@ -0,0 +1,185 @@
+import { describe, expect, it } from "vitest";
+import {
+  AssistantTransportEncoder,
+  AssistantTransportDecoder,
+} from "./AssistantTransport";
+import { AssistantStreamChunk } from "../../AssistantStreamChunk";
+
+// Helper function to collect all chunks from a stream
+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;
+}
+
+// Helper function to encode and decode a stream
+async function encodeAndDecode(
+  stream: ReadableStream<AssistantStreamChunk>,
+): Promise<ReadableStream<AssistantStreamChunk>> {
+  // Encode the stream to Uint8Array (simulating network transmission)
+  const encodedStream = stream.pipeThrough(new AssistantTransportEncoder());
+
+  // Collect all encoded chunks
+  const encodedChunks = await collectChunks(encodedStream);
+
+  // Create a new stream from the encoded chunks
+  const reconstructedStream = new ReadableStream<Uint8Array>({
+    start(controller) {
+      for (const chunk of encodedChunks) {
+        controller.enqueue(chunk);
+      }
+      controller.close();
+    },
+  });
+
+  // Decode the reconstructed stream
+  return reconstructedStream.pipeThrough(new AssistantTransportDecoder());
+}
+
+describe("AssistantTransportEncoder", () => {
+  it("should encode text-delta chunks to SSE format", async () => {
+    const chunks: AssistantStreamChunk[] = [
+      { type: "text-delta", textDelta: "Hello", path: [] },
+      { type: "text-delta", textDelta: " world", path: [] },
+    ];
+
+    const stream = new ReadableStream<AssistantStreamChunk>({
+      start(controller) {
+        for (const chunk of chunks) {
+          controller.enqueue(chunk);
+        }
+        controller.close();
+      },
+    });
+
+    const encodedStream = stream.pipeThrough(new AssistantTransportEncoder());
+    const encodedChunks = await collectChunks(encodedStream);
+
+    // Decode the chunks to verify format
+    const decoder = new TextDecoder();
+    const text = encodedChunks.map((chunk) => decoder.decode(chunk)).join("");
+
+    // Should contain SSE formatted data
+    expect(text).toContain('data: {"type":"text-delta"');
+    expect(text).toContain('"textDelta":"Hello"');
+    expect(text).toContain('"textDelta":" world"');
+    // Should end with [DONE]
+    expect(text).toContain("data: [DONE]");
+  });
+
+  it("should set correct headers", () => {
+    const encoder = new AssistantTransportEncoder();
+    expect(encoder.headers.get("Content-Type")).toBe("text/event-stream");
+    expect(encoder.headers.get("Cache-Control")).toBe("no-cache");
+    expect(encoder.headers.get("Connection")).toBe("keep-alive");
+  });
+});
+
+describe("AssistantTransportDecoder", () => {
+  it("should decode SSE format back to chunks", async () => {
+    const originalChunks: AssistantStreamChunk[] = [
+      { type: "text-delta", textDelta: "Hello", path: [] },
+      { type: "text-delta", textDelta: " world", path: [] },
+    ];
+
+    const stream = new ReadableStream<AssistantStreamChunk>({
+      start(controller) {
+        for (const chunk of originalChunks) {
+          controller.enqueue(chunk);
+        }
+        controller.close();
+      },
+    });
+
+    const decodedStream = await encodeAndDecode(stream);
+    const decodedChunks = await collectChunks(decodedStream);
+
+    expect(decodedChunks).toEqual(originalChunks);
+  });
+
+  it("should stop decoding at [DONE]", async () => {
+    // Manually create an SSE stream with [DONE] in the middle
+    const sseText =
+      'data: {"type":"text-delta","textDelta":"Hello","path":[]}\n\n' +
+      "data: [DONE]\n\n" +
+      'data: {"type":"text-delta","textDelta":"Should not appear","path":[]}\n\n';
+
+    const encoder = new TextEncoder();
+    const stream = new ReadableStream<Uint8Array>({
+      start(controller) {
+        controller.enqueue(encoder.encode(sseText));
+        controller.close();
+      },
+    });
+
+    const decodedStream = stream.pipeThrough(new AssistantTransportDecoder());
+    const decodedChunks = await collectChunks(decodedStream);
+
+    // Should only have the chunk before [DONE]
+    expect(decodedChunks).toHaveLength(1);
+    expect(decodedChunks[0]).toEqual({
+      type: "text-delta",
+      textDelta: "Hello",
+      path: [],
+    });
+  });
+
+  it("should handle part-start chunks", async () => {
+    const originalChunks: AssistantStreamChunk[] = [
+      {
+        type: "part-start",
+        part: { type: "text" },
+        path: [],
+      },
+      { type: "text-delta", textDelta: "Hello", path: [] },
+      { type: "part-finish", path: [] },
+    ];
+
+    const stream = new ReadableStream<AssistantStreamChunk>({
+      start(controller) {
+        for (const chunk of originalChunks) {
+          controller.enqueue(chunk);
+        }
+        controller.close();
+      },
+    });
+
+    const decodedStream = await encodeAndDecode(stream);
+    const decodedChunks = await collectChunks(decodedStream);
+
+    expect(decodedChunks).toEqual(originalChunks);
+  });
+
+  it("should throw error when stream ends without [DONE]", async () => {
+    // Manually create an SSE stream without [DONE]
+    const sseText =
+      'data: {"type":"text-delta","textDelta":"Hello","path":[]}\n\n' +
+      'data: {"type":"text-delta","textDelta":" world","path":[]}\n\n';
+
+    const encoder = new TextEncoder();
+    const stream = new ReadableStream<Uint8Array>({
+      start(controller) {
+        controller.enqueue(encoder.encode(sseText));
+        controller.close();
+      },
+    });
+
+    const decodedStream = stream.pipeThrough(new AssistantTransportDecoder());
+
+    // Should throw when trying to collect all chunks
+    await expect(collectChunks(decodedStream)).rejects.toThrow(
+      "Stream ended abruptly without receiving [DONE] marker",
+    );
+  });
+});

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

@@ -0,0 +1,149 @@
+import { AssistantStreamChunk } from "../../AssistantStreamChunk";
+import { PipeableTransformStream } from "../../utils/stream/PipeableTransformStream";
+import { LineDecoderStream } from "../../utils/stream/LineDecoderStream";
+import { AssistantStreamEncoder } from "../../AssistantStream";
+
+/**
+ * AssistantTransportEncoder encodes AssistantStreamChunks into SSE format
+ * and emits [DONE] when the stream completes.
+ */
+export class AssistantTransportEncoder
+  extends PipeableTransformStream<AssistantStreamChunk, Uint8Array<ArrayBuffer>>
+  implements AssistantStreamEncoder
+{
+  headers = new Headers({
+    "Content-Type": "text/event-stream",
+    "Cache-Control": "no-cache",
+    Connection: "keep-alive",
+  });
+
+  constructor() {
+    super((readable) => {
+      return readable
+        .pipeThrough(
+          new TransformStream<AssistantStreamChunk, string>({
+            transform(chunk, controller) {
+              controller.enqueue(`data: ${JSON.stringify(chunk)}\n\n`);
+            },
+            flush(controller) {
+              controller.enqueue("data: [DONE]\n\n");
+            },
+          }),
+        )
+        .pipeThrough(new TextEncoderStream());
+    });
+  }
+}
+
+type SSEEvent = {
+  event: string;
+  data: string;
+  id?: string | undefined;
+  retry?: number | undefined;
+};
+
+class SSEEventStream extends TransformStream<string, SSEEvent> {
+  constructor() {
+    let eventBuffer: Partial<SSEEvent> = {};
+    let dataLines: string[] = [];
+
+    super({
+      start() {
+        eventBuffer = {};
+        dataLines = [];
+      },
+      transform(line, controller) {
+        if (line.startsWith(":")) return; // Ignore comments
+
+        if (line === "") {
+          if (dataLines.length > 0) {
+            controller.enqueue({
+              event: eventBuffer.event || "message",
+              data: dataLines.join("\n"),
+              id: eventBuffer.id,
+              retry: eventBuffer.retry,
+            });
+          }
+          eventBuffer = {};
+          dataLines = [];
+          return;
+        }
+
+        const [field, ...rest] = line.split(":");
+        const value = rest.join(":").trimStart();
+
+        switch (field) {
+          case "event":
+            eventBuffer.event = value;
+            break;
+          case "data":
+            dataLines.push(value);
+            break;
+          case "id":
+            eventBuffer.id = value;
+            break;
+          case "retry":
+            eventBuffer.retry = Number(value);
+            break;
+        }
+      },
+      flush(controller) {
+        if (dataLines.length > 0) {
+          controller.enqueue({
+            event: eventBuffer.event || "message",
+            data: dataLines.join("\n"),
+            id: eventBuffer.id,
+            retry: eventBuffer.retry,
+          });
+        }
+      },
+    });
+  }
+}
+
+/**
+ * AssistantTransportDecoder decodes SSE format into AssistantStreamChunks.
+ * It stops decoding when it encounters [DONE].
+ */
+export class AssistantTransportDecoder extends PipeableTransformStream<
+  Uint8Array<ArrayBuffer>,
+  AssistantStreamChunk
+> {
+  constructor() {
+    super((readable) => {
+      let receivedDone = false;
+
+      return readable
+        .pipeThrough(new TextDecoderStream())
+        .pipeThrough(new LineDecoderStream())
+        .pipeThrough(new SSEEventStream())
+        .pipeThrough(
+          new TransformStream<SSEEvent, AssistantStreamChunk>({
+            transform(event, controller) {
+              switch (event.event) {
+                case "message":
+                  if (event.data === "[DONE]") {
+                    // Mark that we received [DONE]
+                    receivedDone = true;
+                    // Stop processing when we encounter [DONE]
+                    controller.terminate();
+                  } else {
+                    controller.enqueue(JSON.parse(event.data));
+                  }
+                  break;
+                default:
+                  throw new Error(`Unknown SSE event type: ${event.event}`);
+              }
+            },
+            flush() {
+              if (!receivedDone) {
+                throw new Error(
+                  "Stream ended abruptly without receiving [DONE] marker",
+                );
+              }
+            },
+          }),
+        );
+    });
+  }
+}