assistant-stream 0.2.46 → 0.2.47

package/dist/core/index.d.ts

@@ -6,6 +6,7 @@ export type { AssistantStreamChunk } from "./AssistantStreamChunk.js";
 export { DataStreamDecoder, DataStreamEncoder, } from "./serialization/data-stream/DataStream.js";
 export { PlainTextDecoder, PlainTextEncoder } from "./serialization/PlainText.js";
 export { AssistantTransportDecoder, AssistantTransportEncoder, } from "./serialization/assistant-transport/AssistantTransport.js";
+export { UIMessageStreamDecoder, type UIMessageStreamChunk, type UIMessageStreamDataChunk, type UIMessageStreamDecoderOptions, } from "./serialization/ui-message-stream/UIMessageStream.js";
 export { AssistantMessageStream } from "./accumulators/AssistantMessageStream.js";
 export type { AssistantMessage } from "./utils/types.js";
 export * from "./tool/index.js";

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,sCAAmC;AACpC,OAAO,EACL,2BAA2B,EAC3B,oBAAoB,IAAI,6BAA6B,GACtD,wDAAqD;AACtD,OAAO,EAAE,eAAe,EAAE,6BAA0B;AACpD,YAAY,EAAE,yBAAyB,EAAE,sCAAmC;AAC5E,YAAY,EAAE,oBAAoB,EAAE,kCAA+B;AACnE,OAAO,EACL,iBAAiB,EACjB,iBAAiB,GAClB,kDAA+C;AAChD,OAAO,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,qCAAkC;AAC/E,OAAO,EACL,yBAAyB,EACzB,yBAAyB,GAC1B,kEAA+D;AAChE,OAAO,EAAE,sBAAsB,EAAE,iDAA8C;AAC/E,YAAY,EAAE,gBAAgB,EAAE,yBAAsB;AAEtD,gCAAuB;AACvB,YAAY,EAAE,oBAAoB,EAAE,0BAAuB;AAC3D,YAAY,EAAE,wBAAwB,EAAE,+BAA4B;AAEpE,OAAO,EAAE,kBAAkB,EAAE,uCAAoC;AACjE,OAAO,EACL,oBAAoB,EACpB,wBAAwB,GACzB,yCAAsC;AACvC,YAAY,EAAE,iBAAiB,EAAE,0BAAuB"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/core/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,qBAAqB,EACrB,6BAA6B,EAC7B,+BAA+B,GAChC,sCAAmC;AACpC,OAAO,EACL,2BAA2B,EAC3B,oBAAoB,IAAI,6BAA6B,GACtD,wDAAqD;AACtD,OAAO,EAAE,eAAe,EAAE,6BAA0B;AACpD,YAAY,EAAE,yBAAyB,EAAE,sCAAmC;AAC5E,YAAY,EAAE,oBAAoB,EAAE,kCAA+B;AACnE,OAAO,EACL,iBAAiB,EACjB,iBAAiB,GAClB,kDAA+C;AAChD,OAAO,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,qCAAkC;AAC/E,OAAO,EACL,yBAAyB,EACzB,yBAAyB,GAC1B,kEAA+D;AAChE,OAAO,EACL,sBAAsB,EACtB,KAAK,oBAAoB,EACzB,KAAK,wBAAwB,EAC7B,KAAK,6BAA6B,GACnC,6DAA0D;AAC3D,OAAO,EAAE,sBAAsB,EAAE,iDAA8C;AAC/E,YAAY,EAAE,gBAAgB,EAAE,yBAAsB;AAEtD,gCAAuB;AACvB,YAAY,EAAE,oBAAoB,EAAE,0BAAuB;AAC3D,YAAY,EAAE,wBAAwB,EAAE,+BAA4B;AAEpE,OAAO,EAAE,kBAAkB,EAAE,uCAAoC;AACjE,OAAO,EACL,oBAAoB,EACpB,wBAAwB,GACzB,yCAAsC;AACvC,YAAY,EAAE,iBAAiB,EAAE,0BAAuB"}

package/dist/core/index.js

@@ -4,6 +4,7 @@ export { AssistantStream } from "./AssistantStream.js";
 export { DataStreamDecoder, DataStreamEncoder, } from "./serialization/data-stream/DataStream.js";
 export { PlainTextDecoder, PlainTextEncoder } from "./serialization/PlainText.js";
 export { AssistantTransportDecoder, AssistantTransportEncoder, } from "./serialization/assistant-transport/AssistantTransport.js";
+export { UIMessageStreamDecoder, } from "./serialization/ui-message-stream/UIMessageStream.js";
 export { AssistantMessageStream } from "./accumulators/AssistantMessageStream.js";
 export * from "./tool/index.js";
 export { createObjectStream } from "./object/createObjectStream.js";

package/dist/core/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/core/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,qBAAqB,EACrB,6BAA6B,EAC7B,+BAA+B,GAChC,sCAAmC;AACpC,OAAO,EACL,2BAA2B,EAC3B,oBAAoB,IAAI,6BAA6B,GACtD,wDAAqD;AACtD,OAAO,EAAE,eAAe,EAAE,6BAA0B;AAGpD,OAAO,EACL,iBAAiB,EACjB,iBAAiB,GAClB,kDAA+C;AAChD,OAAO,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,qCAAkC;AAC/E,OAAO,EACL,yBAAyB,EACzB,yBAAyB,GAC1B,kEAA+D;AAChE,OAAO,EAAE,sBAAsB,EAAE,iDAA8C;AAG/E,gCAAuB;AAIvB,OAAO,EAAE,kBAAkB,EAAE,uCAAoC;AACjE,OAAO,EACL,oBAAoB,EACpB,wBAAwB,GACzB,yCAAsC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/core/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,qBAAqB,EACrB,6BAA6B,EAC7B,+BAA+B,GAChC,sCAAmC;AACpC,OAAO,EACL,2BAA2B,EAC3B,oBAAoB,IAAI,6BAA6B,GACtD,wDAAqD;AACtD,OAAO,EAAE,eAAe,EAAE,6BAA0B;AAGpD,OAAO,EACL,iBAAiB,EACjB,iBAAiB,GAClB,kDAA+C;AAChD,OAAO,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,qCAAkC;AAC/E,OAAO,EACL,yBAAyB,EACzB,yBAAyB,GAC1B,kEAA+D;AAChE,OAAO,EACL,sBAAsB,GAIvB,6DAA0D;AAC3D,OAAO,EAAE,sBAAsB,EAAE,iDAA8C;AAG/E,gCAAuB;AAIvB,OAAO,EAAE,kBAAkB,EAAE,uCAAoC;AACjE,OAAO,EACL,oBAAoB,EACpB,wBAAwB,GACzB,yCAAsC"}

package/dist/core/serialization/ui-message-stream/UIMessageStream.d.ts

@@ -0,0 +1,19 @@
+import type { AssistantStreamChunk } from "../../AssistantStreamChunk.js";
+import { PipeableTransformStream } from "../../utils/stream/PipeableTransformStream.js";
+import { type UIMessageStreamChunk, type UIMessageStreamDataChunk } from "./chunk-types.js";
+export type { UIMessageStreamChunk, UIMessageStreamDataChunk };
+export type UIMessageStreamDecoderOptions = {
+    onData?: (data: {
+        type: string;
+        name: string;
+        data: unknown;
+        transient?: boolean;
+    }) => void;
+};
+/**
+ * Decodes AI SDK v6 UI Message Stream format into AssistantStreamChunks.
+ */
+export declare class UIMessageStreamDecoder extends PipeableTransformStream<Uint8Array<ArrayBuffer>, AssistantStreamChunk> {
+    constructor(options?: UIMessageStreamDecoderOptions);
+}
+//# sourceMappingURL=UIMessageStream.d.ts.map

package/dist/core/serialization/ui-message-stream/UIMessageStream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UIMessageStream.d.ts","sourceRoot":"","sources":["../../../../src/core/serialization/ui-message-stream/UIMessageStream.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,sCAAmC;AAIvE,OAAO,EAAE,uBAAuB,EAAE,sDAAmD;AAErF,OAAO,EACL,KAAK,oBAAoB,EACzB,KAAK,wBAAwB,EAC9B,yBAAsB;AAGvB,YAAY,EAAE,oBAAoB,EAAE,wBAAwB,EAAE,CAAC;AAE/D,MAAM,MAAM,6BAA6B,GAAG;IAC1C,MAAM,CAAC,EAAE,CAAC,IAAI,EAAE;QACd,IAAI,EAAE,MAAM,CAAC;QACb,IAAI,EAAE,MAAM,CAAC;QACb,IAAI,EAAE,OAAO,CAAC;QACd,SAAS,CAAC,EAAE,OAAO,CAAC;KACrB,KAAK,IAAI,CAAC;CACZ,CAAC;AAwEF;;GAEG;AACH,qBAAa,sBAAuB,SAAQ,uBAAuB,CACjE,UAAU,CAAC,WAAW,CAAC,EACvB,oBAAoB,CACrB;gBACa,OAAO,GAAE,6BAAkC;CAuMxD"}

package/dist/core/serialization/ui-message-stream/UIMessageStream.js

@@ -0,0 +1,231 @@
+import { AssistantTransformStream } from "../../utils/stream/AssistantTransformStream.js";
+import { PipeableTransformStream } from "../../utils/stream/PipeableTransformStream.js";
+import { LineDecoderStream } from "../../utils/stream/LineDecoderStream.js";
+import { generateId } from "../../utils/generateId.js";
+class SSEEventStream 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,
+                    });
+                }
+            },
+        });
+    }
+}
+const isDataChunk = (chunk) => chunk.type.startsWith("data-");
+/**
+ * Decodes AI SDK v6 UI Message Stream format into AssistantStreamChunks.
+ */
+export class UIMessageStreamDecoder extends PipeableTransformStream {
+    constructor(options = {}) {
+        super((readable) => {
+            const toolCallControllers = new Map();
+            let activeToolCallArgsText;
+            let currentMessageId;
+            let receivedDone = false;
+            const transform = new AssistantTransformStream({
+                transform(chunk, controller) {
+                    const type = chunk.type;
+                    if (isDataChunk(chunk)) {
+                        const name = chunk.type.slice(5);
+                        if (options.onData) {
+                            options.onData({
+                                type: chunk.type,
+                                name,
+                                data: chunk.data,
+                                ...(chunk.transient !== undefined && {
+                                    transient: chunk.transient,
+                                }),
+                            });
+                        }
+                        if (!chunk.transient) {
+                            controller.enqueue({
+                                type: "data",
+                                path: [],
+                                data: [{ name, data: chunk.data }],
+                            });
+                        }
+                        return;
+                    }
+                    switch (type) {
+                        case "start":
+                            currentMessageId = chunk.messageId;
+                            controller.enqueue({
+                                type: "step-start",
+                                path: [],
+                                messageId: chunk.messageId,
+                            });
+                            break;
+                        case "text-start":
+                        case "text-end":
+                        case "reasoning-start":
+                        case "reasoning-end":
+                            break;
+                        case "text-delta":
+                            controller.appendText(chunk.textDelta);
+                            break;
+                        case "reasoning-delta":
+                            controller.appendReasoning(chunk.delta);
+                            break;
+                        case "source":
+                            controller.appendSource({
+                                type: "source",
+                                sourceType: chunk.source.sourceType,
+                                id: chunk.source.id,
+                                url: chunk.source.url,
+                                ...(chunk.source.title && { title: chunk.source.title }),
+                            });
+                            break;
+                        case "file":
+                            controller.appendFile({
+                                type: "file",
+                                mimeType: chunk.file.mimeType,
+                                data: chunk.file.data,
+                            });
+                            break;
+                        case "tool-call-start": {
+                            activeToolCallArgsText?.close();
+                            activeToolCallArgsText = undefined;
+                            if (toolCallControllers.has(chunk.toolCallId)) {
+                                throw new Error(`Encountered duplicate tool call id: ${chunk.toolCallId}`);
+                            }
+                            const toolCallController = controller.addToolCallPart({
+                                toolCallId: chunk.toolCallId,
+                                toolName: chunk.toolName,
+                            });
+                            toolCallControllers.set(chunk.toolCallId, toolCallController);
+                            activeToolCallArgsText = toolCallController.argsText;
+                            break;
+                        }
+                        case "tool-call-delta":
+                            activeToolCallArgsText?.append(chunk.argsText);
+                            break;
+                        case "tool-call-end":
+                            activeToolCallArgsText?.close();
+                            activeToolCallArgsText = undefined;
+                            break;
+                        case "tool-result": {
+                            const toolCallController = toolCallControllers.get(chunk.toolCallId);
+                            if (!toolCallController) {
+                                throw new Error(`Encountered tool result with unknown id: ${chunk.toolCallId}`);
+                            }
+                            toolCallController.setResponse({
+                                result: chunk.result,
+                                isError: chunk.isError ?? false,
+                            });
+                            break;
+                        }
+                        case "start-step":
+                            controller.enqueue({
+                                type: "step-start",
+                                path: [],
+                                messageId: chunk.messageId ?? currentMessageId ?? generateId(),
+                            });
+                            break;
+                        case "finish-step":
+                            controller.enqueue({
+                                type: "step-finish",
+                                path: [],
+                                finishReason: chunk.finishReason,
+                                usage: chunk.usage,
+                                isContinued: chunk.isContinued,
+                            });
+                            break;
+                        case "finish":
+                            controller.enqueue({
+                                type: "message-finish",
+                                path: [],
+                                finishReason: chunk.finishReason,
+                                usage: chunk.usage,
+                            });
+                            break;
+                        case "error":
+                            controller.enqueue({
+                                type: "error",
+                                path: [],
+                                error: chunk.errorText,
+                            });
+                            break;
+                        default:
+                            // ignore unknown types for forward compatibility
+                            break;
+                    }
+                },
+                flush() {
+                    activeToolCallArgsText?.close();
+                    toolCallControllers.forEach((ctrl) => ctrl.close());
+                    toolCallControllers.clear();
+                },
+            });
+            return readable
+                .pipeThrough(new TextDecoderStream())
+                .pipeThrough(new LineDecoderStream())
+                .pipeThrough(new SSEEventStream())
+                .pipeThrough(new TransformStream({
+                transform(event, controller) {
+                    if (event.event !== "message") {
+                        throw new Error(`Unknown SSE event type: ${event.event}`);
+                    }
+                    if (event.data === "[DONE]") {
+                        receivedDone = true;
+                        controller.terminate();
+                        return;
+                    }
+                    controller.enqueue(JSON.parse(event.data));
+                },
+                flush() {
+                    if (!receivedDone) {
+                        throw new Error("Stream ended abruptly without receiving [DONE] marker");
+                    }
+                },
+            }))
+                .pipeThrough(transform);
+        });
+    }
+}
+//# sourceMappingURL=UIMessageStream.js.map

package/dist/core/serialization/ui-message-stream/UIMessageStream.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"UIMessageStream.js","sourceRoot":"","sources":["../../../../src/core/serialization/ui-message-stream/UIMessageStream.ts"],"names":[],"mappings":"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"}

package/dist/core/serialization/ui-message-stream/chunk-types.d.ts

@@ -0,0 +1,78 @@
+import type { ReadonlyJSONValue } from "../../../utils/json/json-value.js";
+type FinishReason = "stop" | "length" | "content-filter" | "tool-calls" | "error" | "other" | "unknown";
+type Usage = {
+    promptTokens: number;
+    completionTokens: number;
+};
+export type UIMessageStreamChunk = {
+    type: "start";
+    messageId: string;
+} | {
+    type: "text-start";
+    id: string;
+} | {
+    type: "text-delta";
+    textDelta: string;
+} | {
+    type: "text-end";
+} | {
+    type: "reasoning-start";
+    id: string;
+} | {
+    type: "reasoning-delta";
+    delta: string;
+} | {
+    type: "reasoning-end";
+} | {
+    type: "source";
+    source: {
+        sourceType: "url";
+        id: string;
+        url: string;
+        title?: string;
+    };
+} | {
+    type: "file";
+    file: {
+        mimeType: string;
+        data: string;
+    };
+} | {
+    type: "tool-call-start";
+    id: string;
+    toolCallId: string;
+    toolName: string;
+} | {
+    type: "tool-call-delta";
+    argsText: string;
+} | {
+    type: "tool-call-end";
+} | {
+    type: "tool-result";
+    toolCallId: string;
+    result: ReadonlyJSONValue;
+    isError?: boolean;
+} | {
+    type: "start-step";
+    messageId?: string;
+} | {
+    type: "finish-step";
+    finishReason: FinishReason;
+    usage: Usage;
+    isContinued: boolean;
+} | {
+    type: "finish";
+    finishReason: FinishReason;
+    usage: Usage;
+} | {
+    type: "error";
+    errorText: string;
+} | UIMessageStreamDataChunk;
+export type UIMessageStreamDataChunk = {
+    type: `data-${string}`;
+    id?: string;
+    data: ReadonlyJSONValue;
+    transient?: boolean;
+};
+export {};
+//# sourceMappingURL=chunk-types.d.ts.map

package/dist/core/serialization/ui-message-stream/chunk-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk-types.d.ts","sourceRoot":"","sources":["../../../../src/core/serialization/ui-message-stream/chunk-types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,0CAAuC;AAExE,KAAK,YAAY,GACb,MAAM,GACN,QAAQ,GACR,gBAAgB,GAChB,YAAY,GACZ,OAAO,GACP,OAAO,GACP,SAAS,CAAC;AAEd,KAAK,KAAK,GAAG;IACX,YAAY,EAAE,MAAM,CAAC;IACrB,gBAAgB,EAAE,MAAM,CAAC;CAC1B,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAC5B;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,GACpC;IAAE,IAAI,EAAE,YAAY,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,GAClC;IAAE,IAAI,EAAE,YAAY,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,GACzC;IAAE,IAAI,EAAE,UAAU,CAAA;CAAE,GACpB;IAAE,IAAI,EAAE,iBAAiB,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,GACvC;IAAE,IAAI,EAAE,iBAAiB,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAC1C;IAAE,IAAI,EAAE,eAAe,CAAA;CAAE,GACzB;IACE,IAAI,EAAE,QAAQ,CAAC;IACf,MAAM,EAAE;QAAE,UAAU,EAAE,KAAK,CAAC;QAAC,EAAE,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;CACxE,GACD;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAA;CAAE,GAC1D;IACE,IAAI,EAAE,iBAAiB,CAAC;IACxB,EAAE,EAAE,MAAM,CAAC;IACX,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;CAClB,GACD;IAAE,IAAI,EAAE,iBAAiB,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,GAC7C;IAAE,IAAI,EAAE,eAAe,CAAA;CAAE,GACzB;IACE,IAAI,EAAE,aAAa,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,iBAAiB,CAAC;IAC1B,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB,GACD;IAAE,IAAI,EAAE,YAAY,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE,GAC1C;IACE,IAAI,EAAE,aAAa,CAAC;IACpB,YAAY,EAAE,YAAY,CAAC;IAC3B,KAAK,EAAE,KAAK,CAAC;IACb,WAAW,EAAE,OAAO,CAAC;CACtB,GACD;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,YAAY,EAAE,YAAY,CAAC;IAAC,KAAK,EAAE,KAAK,CAAA;CAAE,GAC5D;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,GACpC,wBAAwB,CAAC;AAE7B,MAAM,MAAM,wBAAwB,GAAG;IACrC,IAAI,EAAE,QAAQ,MAAM,EAAE,CAAC;IACvB,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,iBAAiB,CAAC;IACxB,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB,CAAC"}

package/dist/core/serialization/ui-message-stream/chunk-types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=chunk-types.js.map

package/dist/core/serialization/ui-message-stream/chunk-types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk-types.js","sourceRoot":"","sources":["../../../../src/core/serialization/ui-message-stream/chunk-types.ts"],"names":[],"mappings":""}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "assistant-stream",
-  "version": "0.2.46",
+  "version": "0.2.47",
   "description": "Streaming utilities for AI assistants",
   "keywords": [
     "ai",
@@ -37,12 +37,12 @@
   "sideEffects": false,
   "dependencies": {
     "@standard-schema/spec": "^1.1.0",
-    "nanoid": "5.1.6",
+    "nanoid": "^5.1.6",
     "secure-json-parse": "^4.1.0"
   },
   "devDependencies": {
     "@types/json-schema": "^7.0.15",
-    "vitest": "^4.0.16",
+    "vitest": "^4.0.17",
     "@assistant-ui/x-buildutils": "0.0.1"
   },
   "publishConfig": {

package/src/core/index.ts

@@ -19,6 +19,12 @@ export {
   AssistantTransportDecoder,
   AssistantTransportEncoder,
 } from "./serialization/assistant-transport/AssistantTransport";
+export {
+  UIMessageStreamDecoder,
+  type UIMessageStreamChunk,
+  type UIMessageStreamDataChunk,
+  type UIMessageStreamDecoderOptions,
+} from "./serialization/ui-message-stream/UIMessageStream";
 export { AssistantMessageStream } from "./accumulators/AssistantMessageStream";
 export type { AssistantMessage } from "./utils/types";
 

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

@@ -0,0 +1,370 @@
+import { describe, expect, it, vi } from "vitest";
+import { UIMessageStreamDecoder } from "./UIMessageStream";
+import type { 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 create a UI Message Stream from events
+function createUIMessageStream(events: string[]): ReadableStream<Uint8Array> {
+  const encoder = new TextEncoder();
+  const sseText = events.map((e) => `data: ${e}\n\n`).join("");
+
+  return new ReadableStream({
+    start(controller) {
+      controller.enqueue(encoder.encode(sseText));
+      controller.close();
+    },
+  });
+}
+
+describe("UIMessageStreamDecoder", () => {
+  it("should decode text deltas", async () => {
+    const events = [
+      JSON.stringify({ type: "start", messageId: "msg_123" }),
+      JSON.stringify({ type: "text-start", id: "text_1" }),
+      JSON.stringify({ type: "text-delta", textDelta: "Hello" }),
+      JSON.stringify({ type: "text-delta", textDelta: " world" }),
+      JSON.stringify({ type: "text-end" }),
+      JSON.stringify({
+        type: "finish",
+        finishReason: "stop",
+        usage: { promptTokens: 10, completionTokens: 5 },
+      }),
+      "[DONE]",
+    ];
+
+    const stream = createUIMessageStream(events);
+    const decodedStream = stream.pipeThrough(new UIMessageStreamDecoder());
+    const chunks = await collectChunks(decodedStream);
+
+    // Find text-delta chunks
+    const textDeltas = chunks.filter(
+      (c): c is AssistantStreamChunk & { type: "text-delta" } =>
+        c.type === "text-delta",
+    );
+    expect(textDeltas).toHaveLength(2);
+    expect(textDeltas[0]?.textDelta).toBe("Hello");
+    expect(textDeltas[1]?.textDelta).toBe(" world");
+  });
+
+  it("should decode reasoning parts", async () => {
+    const events = [
+      JSON.stringify({ type: "start", messageId: "msg_123" }),
+      JSON.stringify({ type: "reasoning-start", id: "reasoning_1" }),
+      JSON.stringify({ type: "reasoning-delta", delta: "Let me think..." }),
+      JSON.stringify({ type: "reasoning-end" }),
+      JSON.stringify({
+        type: "finish",
+        finishReason: "stop",
+        usage: { promptTokens: 10, completionTokens: 5 },
+      }),
+      "[DONE]",
+    ];
+
+    const stream = createUIMessageStream(events);
+    const decodedStream = stream.pipeThrough(new UIMessageStreamDecoder());
+    const chunks = await collectChunks(decodedStream);
+
+    // Find part-start for reasoning
+    const partStarts = chunks.filter(
+      (c): c is AssistantStreamChunk & { type: "part-start" } =>
+        c.type === "part-start",
+    );
+    expect(partStarts.some((p) => p.part.type === "reasoning")).toBe(true);
+  });
+
+  it("should decode tool calls", async () => {
+    const events = [
+      JSON.stringify({ type: "start", messageId: "msg_123" }),
+      JSON.stringify({
+        type: "tool-call-start",
+        id: "tc_1",
+        toolCallId: "call_abc",
+        toolName: "weather",
+      }),
+      JSON.stringify({ type: "tool-call-delta", argsText: '{"city":' }),
+      JSON.stringify({ type: "tool-call-delta", argsText: '"NYC"}' }),
+      JSON.stringify({ type: "tool-call-end" }),
+      JSON.stringify({
+        type: "tool-result",
+        toolCallId: "call_abc",
+        result: { temp: 72 },
+      }),
+      JSON.stringify({
+        type: "finish",
+        finishReason: "stop",
+        usage: { promptTokens: 10, completionTokens: 5 },
+      }),
+      "[DONE]",
+    ];
+
+    const stream = createUIMessageStream(events);
+    const decodedStream = stream.pipeThrough(new UIMessageStreamDecoder());
+    const chunks = await collectChunks(decodedStream);
+
+    // Find tool-call part-start
+    const toolCallStart = chunks.find(
+      (c): c is AssistantStreamChunk & { type: "part-start" } =>
+        c.type === "part-start" && c.part.type === "tool-call",
+    );
+    expect(toolCallStart).toBeDefined();
+    if (toolCallStart?.part.type === "tool-call") {
+      expect(toolCallStart.part.toolName).toBe("weather");
+      expect(toolCallStart.part.toolCallId).toBe("call_abc");
+    }
+
+    // Find result
+    const result = chunks.find(
+      (c): c is AssistantStreamChunk & { type: "result" } =>
+        c.type === "result",
+    );
+    expect(result).toBeDefined();
+    expect(result?.result).toEqual({ temp: 72 });
+  });
+
+  it("should decode source parts", async () => {
+    const events = [
+      JSON.stringify({ type: "start", messageId: "msg_123" }),
+      JSON.stringify({
+        type: "source",
+        source: {
+          sourceType: "url",
+          id: "src_1",
+          url: "https://example.com",
+          title: "Example",
+        },
+      }),
+      JSON.stringify({
+        type: "finish",
+        finishReason: "stop",
+        usage: { promptTokens: 10, completionTokens: 5 },
+      }),
+      "[DONE]",
+    ];
+
+    const stream = createUIMessageStream(events);
+    const decodedStream = stream.pipeThrough(new UIMessageStreamDecoder());
+    const chunks = await collectChunks(decodedStream);
+
+    const sourceStart = chunks.find(
+      (c): c is AssistantStreamChunk & { type: "part-start" } =>
+        c.type === "part-start" && c.part.type === "source",
+    );
+    expect(sourceStart).toBeDefined();
+    if (sourceStart?.part.type === "source") {
+      expect(sourceStart.part.url).toBe("https://example.com");
+      expect(sourceStart.part.title).toBe("Example");
+    }
+  });
+
+  it("should decode file parts", async () => {
+    const events = [
+      JSON.stringify({ type: "start", messageId: "msg_123" }),
+      JSON.stringify({
+        type: "file",
+        file: {
+          mimeType: "image/png",
+          data: "base64data...",
+        },
+      }),
+      JSON.stringify({
+        type: "finish",
+        finishReason: "stop",
+        usage: { promptTokens: 10, completionTokens: 5 },
+      }),
+      "[DONE]",
+    ];
+
+    const stream = createUIMessageStream(events);
+    const decodedStream = stream.pipeThrough(new UIMessageStreamDecoder());
+    const chunks = await collectChunks(decodedStream);
+
+    const fileStart = chunks.find(
+      (c): c is AssistantStreamChunk & { type: "part-start" } =>
+        c.type === "part-start" && c.part.type === "file",
+    );
+    expect(fileStart).toBeDefined();
+    if (fileStart?.part.type === "file") {
+      expect(fileStart.part.mimeType).toBe("image/png");
+      expect(fileStart.part.data).toBe("base64data...");
+    }
+  });
+
+  it("should handle data-* chunks", async () => {
+    const onData = vi.fn();
+    const events = [
+      JSON.stringify({ type: "start", messageId: "msg_123" }),
+      JSON.stringify({
+        type: "data-weather",
+        data: { temp: 72, city: "NYC" },
+      }),
+      JSON.stringify({
+        type: "finish",
+        finishReason: "stop",
+        usage: { promptTokens: 10, completionTokens: 5 },
+      }),
+      "[DONE]",
+    ];
+
+    const stream = createUIMessageStream(events);
+    const decodedStream = stream.pipeThrough(
+      new UIMessageStreamDecoder({ onData }),
+    );
+    await collectChunks(decodedStream);
+
+    expect(onData).toHaveBeenCalledWith({
+      type: "data-weather",
+      name: "weather",
+      data: { temp: 72, city: "NYC" },
+      transient: undefined,
+    });
+  });
+
+  it("should handle transient data-* chunks", async () => {
+    const onData = vi.fn();
+    const events = [
+      JSON.stringify({ type: "start", messageId: "msg_123" }),
+      JSON.stringify({
+        type: "data-progress",
+        transient: true,
+        data: { percent: 50 },
+      }),
+      JSON.stringify({
+        type: "finish",
+        finishReason: "stop",
+        usage: { promptTokens: 10, completionTokens: 5 },
+      }),
+      "[DONE]",
+    ];
+
+    const stream = createUIMessageStream(events);
+    const decodedStream = stream.pipeThrough(
+      new UIMessageStreamDecoder({ onData }),
+    );
+    const chunks = await collectChunks(decodedStream);
+
+    // Transient data should call onData
+    expect(onData).toHaveBeenCalledWith({
+      type: "data-progress",
+      name: "progress",
+      data: { percent: 50 },
+      transient: true,
+    });
+
+    // Transient data should NOT emit a data chunk
+    const dataChunks = chunks.filter((c) => c.type === "data");
+    expect(dataChunks).toHaveLength(0);
+  });
+
+  it("should handle step lifecycle", async () => {
+    const events = [
+      JSON.stringify({ type: "start", messageId: "msg_123" }),
+      JSON.stringify({ type: "start-step", messageId: "step_1" }),
+      JSON.stringify({ type: "text-start", id: "text_1" }),
+      JSON.stringify({ type: "text-delta", textDelta: "Hello" }),
+      JSON.stringify({ type: "text-end" }),
+      JSON.stringify({
+        type: "finish-step",
+        finishReason: "stop",
+        usage: { promptTokens: 10, completionTokens: 5 },
+        isContinued: false,
+      }),
+      JSON.stringify({
+        type: "finish",
+        finishReason: "stop",
+        usage: { promptTokens: 10, completionTokens: 5 },
+      }),
+      "[DONE]",
+    ];
+
+    const stream = createUIMessageStream(events);
+    const decodedStream = stream.pipeThrough(new UIMessageStreamDecoder());
+    const chunks = await collectChunks(decodedStream);
+
+    // Find step-start chunks
+    const stepStarts = chunks.filter((c) => c.type === "step-start");
+    expect(stepStarts.length).toBeGreaterThanOrEqual(1);
+
+    // Find step-finish
+    const stepFinish = chunks.find(
+      (c): c is AssistantStreamChunk & { type: "step-finish" } =>
+        c.type === "step-finish",
+    );
+    expect(stepFinish).toBeDefined();
+    expect(stepFinish?.finishReason).toBe("stop");
+  });
+
+  it("should handle errors", async () => {
+    const events = [
+      JSON.stringify({ type: "start", messageId: "msg_123" }),
+      JSON.stringify({ type: "error", errorText: "Something went wrong" }),
+      "[DONE]",
+    ];
+
+    const stream = createUIMessageStream(events);
+    const decodedStream = stream.pipeThrough(new UIMessageStreamDecoder());
+    const chunks = await collectChunks(decodedStream);
+
+    const errorChunk = chunks.find(
+      (c): c is AssistantStreamChunk & { type: "error" } => c.type === "error",
+    );
+    expect(errorChunk).toBeDefined();
+    expect(errorChunk?.error).toBe("Something went wrong");
+  });
+
+  it("should throw when stream ends without [DONE]", async () => {
+    const encoder = new TextEncoder();
+    const sseText =
+      'data: {"type":"text-delta","textDelta":"Hello"}\n\n' +
+      'data: {"type":"text-delta","textDelta":" world"}\n\n';
+
+    const stream = new ReadableStream<Uint8Array>({
+      start(controller) {
+        controller.enqueue(encoder.encode(sseText));
+        controller.close();
+      },
+    });
+
+    const decodedStream = stream.pipeThrough(new UIMessageStreamDecoder());
+
+    await expect(collectChunks(decodedStream)).rejects.toThrow(
+      "Stream ended abruptly without receiving [DONE] marker",
+    );
+  });
+
+  it("should ignore unknown chunk types for forward compatibility", async () => {
+    const events = [
+      JSON.stringify({ type: "start", messageId: "msg_123" }),
+      JSON.stringify({ type: "unknown-future-type", data: {} }),
+      JSON.stringify({
+        type: "finish",
+        finishReason: "stop",
+        usage: { promptTokens: 10, completionTokens: 5 },
+      }),
+      "[DONE]",
+    ];
+
+    const stream = createUIMessageStream(events);
+    const decodedStream = stream.pipeThrough(new UIMessageStreamDecoder());
+    const chunks = await collectChunks(decodedStream);
+
+    // Should not throw, should complete successfully
+    expect(chunks.some((c) => c.type === "message-finish")).toBe(true);
+  });
+});

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

@@ -0,0 +1,300 @@
+import type { AssistantStreamChunk } from "../../AssistantStreamChunk";
+import type { ToolCallStreamController } from "../../modules/tool-call";
+import type { TextStreamController } from "../../modules/text";
+import { AssistantTransformStream } from "../../utils/stream/AssistantTransformStream";
+import { PipeableTransformStream } from "../../utils/stream/PipeableTransformStream";
+import { LineDecoderStream } from "../../utils/stream/LineDecoderStream";
+import {
+  type UIMessageStreamChunk,
+  type UIMessageStreamDataChunk,
+} from "./chunk-types";
+import { generateId } from "../../utils/generateId";
+
+export type { UIMessageStreamChunk, UIMessageStreamDataChunk };
+
+export type UIMessageStreamDecoderOptions = {
+  onData?: (data: {
+    type: string;
+    name: string;
+    data: unknown;
+    transient?: boolean;
+  }) => void;
+};
+
+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;
+
+        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,
+          });
+        }
+      },
+    });
+  }
+}
+
+const isDataChunk = (
+  chunk: UIMessageStreamChunk,
+): chunk is UIMessageStreamDataChunk => chunk.type.startsWith("data-");
+
+/**
+ * Decodes AI SDK v6 UI Message Stream format into AssistantStreamChunks.
+ */
+export class UIMessageStreamDecoder extends PipeableTransformStream<
+  Uint8Array<ArrayBuffer>,
+  AssistantStreamChunk
+> {
+  constructor(options: UIMessageStreamDecoderOptions = {}) {
+    super((readable) => {
+      const toolCallControllers = new Map<string, ToolCallStreamController>();
+      let activeToolCallArgsText: TextStreamController | undefined;
+      let currentMessageId: string | undefined;
+      let receivedDone = false;
+
+      const transform = new AssistantTransformStream<UIMessageStreamChunk>({
+        transform(chunk, controller) {
+          const type = chunk.type;
+
+          if (isDataChunk(chunk)) {
+            const name = chunk.type.slice(5);
+
+            if (options.onData) {
+              options.onData({
+                type: chunk.type,
+                name,
+                data: chunk.data,
+                ...(chunk.transient !== undefined && {
+                  transient: chunk.transient,
+                }),
+              });
+            }
+
+            if (!chunk.transient) {
+              controller.enqueue({
+                type: "data",
+                path: [],
+                data: [{ name, data: chunk.data }],
+              });
+            }
+            return;
+          }
+
+          switch (type) {
+            case "start":
+              currentMessageId = chunk.messageId;
+              controller.enqueue({
+                type: "step-start",
+                path: [],
+                messageId: chunk.messageId,
+              });
+              break;
+
+            case "text-start":
+            case "text-end":
+            case "reasoning-start":
+            case "reasoning-end":
+              break;
+
+            case "text-delta":
+              controller.appendText(chunk.textDelta);
+              break;
+
+            case "reasoning-delta":
+              controller.appendReasoning(chunk.delta);
+              break;
+
+            case "source":
+              controller.appendSource({
+                type: "source",
+                sourceType: chunk.source.sourceType,
+                id: chunk.source.id,
+                url: chunk.source.url,
+                ...(chunk.source.title && { title: chunk.source.title }),
+              });
+              break;
+
+            case "file":
+              controller.appendFile({
+                type: "file",
+                mimeType: chunk.file.mimeType,
+                data: chunk.file.data,
+              });
+              break;
+
+            case "tool-call-start": {
+              activeToolCallArgsText?.close();
+              activeToolCallArgsText = undefined;
+
+              if (toolCallControllers.has(chunk.toolCallId)) {
+                throw new Error(
+                  `Encountered duplicate tool call id: ${chunk.toolCallId}`,
+                );
+              }
+
+              const toolCallController = controller.addToolCallPart({
+                toolCallId: chunk.toolCallId,
+                toolName: chunk.toolName,
+              });
+              toolCallControllers.set(chunk.toolCallId, toolCallController);
+              activeToolCallArgsText = toolCallController.argsText;
+              break;
+            }
+
+            case "tool-call-delta":
+              activeToolCallArgsText?.append(chunk.argsText);
+              break;
+
+            case "tool-call-end":
+              activeToolCallArgsText?.close();
+              activeToolCallArgsText = undefined;
+              break;
+
+            case "tool-result": {
+              const toolCallController = toolCallControllers.get(
+                chunk.toolCallId,
+              );
+              if (!toolCallController) {
+                throw new Error(
+                  `Encountered tool result with unknown id: ${chunk.toolCallId}`,
+                );
+              }
+              toolCallController.setResponse({
+                result: chunk.result,
+                isError: chunk.isError ?? false,
+              });
+              break;
+            }
+
+            case "start-step":
+              controller.enqueue({
+                type: "step-start",
+                path: [],
+                messageId: chunk.messageId ?? currentMessageId ?? generateId(),
+              });
+              break;
+
+            case "finish-step":
+              controller.enqueue({
+                type: "step-finish",
+                path: [],
+                finishReason: chunk.finishReason,
+                usage: chunk.usage,
+                isContinued: chunk.isContinued,
+              });
+              break;
+
+            case "finish":
+              controller.enqueue({
+                type: "message-finish",
+                path: [],
+                finishReason: chunk.finishReason,
+                usage: chunk.usage,
+              });
+              break;
+
+            case "error":
+              controller.enqueue({
+                type: "error",
+                path: [],
+                error: chunk.errorText,
+              });
+              break;
+
+            default:
+              // ignore unknown types for forward compatibility
+              break;
+          }
+        },
+        flush() {
+          activeToolCallArgsText?.close();
+          toolCallControllers.forEach((ctrl) => ctrl.close());
+          toolCallControllers.clear();
+        },
+      });
+
+      return readable
+        .pipeThrough(new TextDecoderStream())
+        .pipeThrough(new LineDecoderStream())
+        .pipeThrough(new SSEEventStream())
+        .pipeThrough(
+          new TransformStream<SSEEvent, UIMessageStreamChunk>({
+            transform(event, controller) {
+              if (event.event !== "message") {
+                throw new Error(`Unknown SSE event type: ${event.event}`);
+              }
+
+              if (event.data === "[DONE]") {
+                receivedDone = true;
+                controller.terminate();
+                return;
+              }
+
+              controller.enqueue(JSON.parse(event.data));
+            },
+            flush() {
+              if (!receivedDone) {
+                throw new Error(
+                  "Stream ended abruptly without receiving [DONE] marker",
+                );
+              }
+            },
+          }),
+        )
+        .pipeThrough(transform);
+    });
+  }
+}

package/src/core/serialization/ui-message-stream/chunk-types.ts

@@ -0,0 +1,60 @@
+import type { ReadonlyJSONValue } from "../../../utils/json/json-value";
+
+type FinishReason =
+  | "stop"
+  | "length"
+  | "content-filter"
+  | "tool-calls"
+  | "error"
+  | "other"
+  | "unknown";
+
+type Usage = {
+  promptTokens: number;
+  completionTokens: number;
+};
+
+export type UIMessageStreamChunk =
+  | { type: "start"; messageId: string }
+  | { type: "text-start"; id: string }
+  | { type: "text-delta"; textDelta: string }
+  | { type: "text-end" }
+  | { type: "reasoning-start"; id: string }
+  | { type: "reasoning-delta"; delta: string }
+  | { type: "reasoning-end" }
+  | {
+      type: "source";
+      source: { sourceType: "url"; id: string; url: string; title?: string };
+    }
+  | { type: "file"; file: { mimeType: string; data: string } }
+  | {
+      type: "tool-call-start";
+      id: string;
+      toolCallId: string;
+      toolName: string;
+    }
+  | { type: "tool-call-delta"; argsText: string }
+  | { type: "tool-call-end" }
+  | {
+      type: "tool-result";
+      toolCallId: string;
+      result: ReadonlyJSONValue;
+      isError?: boolean;
+    }
+  | { type: "start-step"; messageId?: string }
+  | {
+      type: "finish-step";
+      finishReason: FinishReason;
+      usage: Usage;
+      isContinued: boolean;
+    }
+  | { type: "finish"; finishReason: FinishReason; usage: Usage }
+  | { type: "error"; errorText: string }
+  | UIMessageStreamDataChunk;
+
+export type UIMessageStreamDataChunk = {
+  type: `data-${string}`;
+  id?: string;
+  data: ReadonlyJSONValue;
+  transient?: boolean;
+};