assistant-stream 0.0.21 → 0.0.22

package/dist/index.js

@@ -30,12 +30,14 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  AssistantMessageAccumulator: () => AssistantMessageAccumulator,
   AssistantMessageStream: () => AssistantMessageStream,
   AssistantStream: () => AssistantStream,
   DataStreamDecoder: () => DataStreamDecoder,
   DataStreamEncoder: () => DataStreamEncoder,
   PlainTextDecoder: () => PlainTextDecoder,
   PlainTextEncoder: () => PlainTextEncoder,
+  ToolExecutionStream: () => ToolExecutionStream,
   createAssistantStream: () => createAssistantStream,
   createAssistantStreamResponse: () => createAssistantStreamResponse
 });
@@ -44,7 +46,9 @@ module.exports = __toCommonJS(index_exports);
 // src/core/AssistantStream.ts
 var AssistantStream = {
   toResponse(stream, transformer) {
-    return new Response(AssistantStream.toByteStream(stream, transformer));
+    return new Response(AssistantStream.toByteStream(stream, transformer), {
+      headers: transformer.headers ?? {}
+    });
   },
   fromResponse(response, transformer) {
     return AssistantStream.fromByteStream(response.body, transformer);
@@ -57,202 +61,118 @@ var AssistantStream = {
   }
 };
 
-// src/core/utils/PipeableTransformStream.ts
-var PipeableTransformStream = class extends TransformStream {
-  constructor(transform) {
-    super();
-    const readable = transform(super.readable);
-    Object.defineProperty(this, "readable", {
-      value: readable,
-      writable: false
-    });
-  }
+// src/core/utils/stream/merge.ts
+var promiseWithResolvers = () => {
+  let resolve;
+  let reject;
+  const promise = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return { promise, resolve, reject };
 };
-
-// src/core/serialization/DataStream.ts
-var DataStreamEncoder = class {
-  _transformStream;
-  get writable() {
-    return this._transformStream.writable;
-  }
-  get readable() {
-    return this._transformStream.readable;
-  }
-  constructor() {
-    this._transformStream = new PipeableTransformStream((readable) => {
-      const transform = new TransformStream({
-        transform(chunk, controller) {
-          const type = chunk.type;
-          switch (type) {
-            case "text-delta":
-              controller.enqueue("0:" + JSON.stringify(chunk.textDelta) + "\n");
-              break;
-            case "tool-call-begin":
-              controller.enqueue(
-                "b:" + JSON.stringify({
-                  toolCallId: chunk.toolCallId,
-                  toolName: chunk.toolName
-                }) + "\n"
-              );
-              break;
-            case "tool-call-delta":
-              controller.enqueue(
-                "c:" + JSON.stringify({
-                  toolCallId: chunk.toolCallId,
-                  argsTextDelta: chunk.argsTextDelta
-                }) + "\n"
-              );
-              break;
-            case "tool-result":
-              controller.enqueue(
-                "a:" + JSON.stringify({
-                  toolCallId: chunk.toolCallId,
-                  result: chunk.result
-                }) + "\n"
-              );
-              break;
-            case "error":
-              controller.enqueue(`3:${JSON.stringify(chunk.error)}
-`);
-              break;
-            default:
-              const exhaustiveCheck = type;
-              throw new Error(`unsupported chunk type: ${exhaustiveCheck}`);
+var createMergeStream = () => {
+  const list = [];
+  let sealed = false;
+  let controller;
+  let currentPull;
+  const handlePull = (item) => {
+    if (!item.promise) {
+      item.promise = item.reader.read().then(({ done, value }) => {
+        item.promise = void 0;
+        if (done) {
+          list.splice(list.indexOf(item), 1);
+          if (sealed && list.length === 0) {
+            controller.close();
           }
+        } else {
+          controller.enqueue(value);
         }
+        currentPull?.resolve();
+        currentPull = void 0;
+      }).catch((e) => {
+        console.error(e);
+        list.forEach((item2) => {
+          item2.reader.cancel();
+        });
+        list.length = 0;
+        controller.error(e);
+        currentPull?.reject(e);
+        currentPull = void 0;
       });
-      return readable.pipeThrough(transform).pipeThrough(new TextEncoderStream());
-    });
-  }
-};
-var decodeStreamPart = (part) => {
-  const index = part.indexOf(":");
-  if (index === -1) throw new Error("Invalid stream part");
-  return {
-    type: part.slice(0, index),
-    value: JSON.parse(part.slice(index + 1))
+    }
   };
-};
-var DataStreamDecoder = class {
-  _transformStream;
-  get writable() {
-    return this._transformStream.writable;
-  }
-  get readable() {
-    return this._transformStream.readable;
-  }
-  constructor() {
-    this._transformStream = new PipeableTransformStream((readable) => {
-      const transform = new TransformStream({
-        transform(chunk, controller) {
-          const { type, value } = decodeStreamPart(chunk);
-          switch (type) {
-            case "0":
-              controller.enqueue({
-                type: "text-delta",
-                textDelta: value
-              });
-              break;
-            case "b": {
-              const { toolCallId, toolName } = value;
-              controller.enqueue({
-                type: "tool-call-begin",
-                toolCallId,
-                toolName
-              });
-              break;
-            }
-            case "c": {
-              const { toolCallId, argsTextDelta } = value;
-              controller.enqueue({
-                type: "tool-call-delta",
-                toolCallId,
-                argsTextDelta
-              });
-              break;
-            }
-            case "a": {
-              const { toolCallId, result } = value;
-              controller.enqueue({
-                type: "tool-result",
-                toolCallId,
-                result
-              });
-              break;
-            }
-            case "9": {
-              const { toolCallId, args } = value;
-              controller.enqueue({
-                type: "tool-call-begin",
-                toolCallId,
-                toolName: toolCallId
-              });
-              controller.enqueue({
-                type: "tool-call-delta",
-                toolCallId,
-                argsTextDelta: JSON.stringify(args)
-              });
-              break;
-            }
-            case "2":
-            case "3":
-            case "8":
-            case "d":
-            case "e": {
-              break;
-            }
-            default:
-              const exhaustiveCheck = type;
-              throw new Error(`unsupported chunk type: ${exhaustiveCheck}`);
-          }
-        }
+  const readable = new ReadableStream({
+    start(c) {
+      controller = c;
+    },
+    pull() {
+      currentPull = promiseWithResolvers();
+      list.forEach((item) => {
+        handlePull(item);
       });
-      return readable.pipeThrough(new TextDecoderStream()).pipeThrough(new ChunkByLineStream()).pipeThrough(transform);
-    });
-  }
-};
-var ChunkByLineStream = class extends TransformStream {
-  buffer = "";
-  constructor() {
-    super({
-      transform: (chunk, controller) => {
-        this.buffer += chunk;
-        const lines = this.buffer.split("\n");
-        for (let i = 0; i < lines.length - 1; i++) {
-          controller.enqueue(lines[i]);
-        }
-        this.buffer = lines[lines.length - 1];
-      },
-      flush: (controller) => {
-        if (this.buffer) {
-          controller.enqueue(this.buffer);
-        }
-      }
-    });
-  }
+      return currentPull.promise;
+    },
+    cancel() {
+      list.forEach((item) => {
+        item.reader.cancel();
+      });
+      list.length = 0;
+    }
+  });
+  return {
+    readable,
+    isSealed() {
+      return sealed;
+    },
+    seal() {
+      sealed = true;
+      if (list.length === 0) controller.close();
+    },
+    addStream(stream) {
+      if (sealed)
+        throw new Error(
+          "Cannot add streams after the run callback has settled."
+        );
+      const item = { reader: stream.getReader() };
+      list.push(item);
+      handlePull(item);
+    },
+    enqueue(chunk) {
+      this.addStream(
+        new ReadableStream({
+          start(c) {
+            c.enqueue(chunk);
+            c.close();
+          }
+        })
+      );
+    }
+  };
 };
 
-// src/core/utils/generateId.tsx
-var import_non_secure = require("nanoid/non-secure");
-var generateId = (0, import_non_secure.customAlphabet)(
-  "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz",
-  7
-);
-
 // src/core/modules/text.ts
 var TextStreamControllerImpl = class {
   _controller;
+  _isClosed = false;
   constructor(controller) {
     this._controller = controller;
   }
   append(textDelta) {
     this._controller.enqueue({
       type: "text-delta",
+      path: [],
       textDelta
     });
     return this;
   }
   close() {
+    if (this._isClosed) return;
+    this._isClosed = true;
+    this._controller.enqueue({
+      type: "part-finish",
+      path: []
+    });
     this._controller.close();
   }
 };
@@ -269,17 +189,20 @@ var createTextStream = (readable) => {
     }
   });
 };
+var createTextStreamController = () => {
+  let controller;
+  const stream = createTextStream({
+    start(c) {
+      controller = c;
+    }
+  });
+  return [stream, controller];
+};
 
 // src/core/modules/tool-call.ts
 var ToolCallStreamControllerImpl = class {
-  constructor(_controller, _options) {
+  constructor(_controller) {
     this._controller = _controller;
-    this._options = _options;
-    this._controller.enqueue({
-      type: "tool-call-begin",
-      toolCallId: this._options.toolCallId,
-      toolName: this._options.toolName
-    });
     const stream = createTextStream({
       start: (c) => {
         this._argsTextController = c;
@@ -288,215 +211,750 @@ var ToolCallStreamControllerImpl = class {
     stream.pipeTo(
       new WritableStream({
         write: (chunk) => {
-          if (chunk.type !== "text-delta")
-            throw new Error("Unexpected chunk type");
-          this._controller.enqueue({
-            type: "tool-call-delta",
-            toolCallId: this._options.toolCallId,
-            argsTextDelta: chunk.textDelta
-          });
+          switch (chunk.type) {
+            case "text-delta":
+              this._controller.enqueue(chunk);
+              break;
+            case "part-finish":
+              this._controller.enqueue({
+                type: "tool-call-args-text-finish",
+                path: []
+              });
+              break;
+            default:
+              throw new Error(`Unexpected chunk type: ${chunk.type}`);
+          }
         }
       })
     );
   }
-  get toolCallId() {
-    return this._options.toolCallId;
-  }
-  get toolName() {
-    return this._options.toolName;
-  }
+  _isClosed = false;
   get argsText() {
     return this._argsTextController;
   }
   _argsTextController;
-  setResult(result) {
+  setResult(result, isError) {
     this._controller.enqueue({
-      type: "tool-result",
-      toolCallId: this._options.toolCallId,
-      result
+      type: "result",
+      path: [],
+      result,
+      isError: isError ?? false
     });
   }
   close() {
+    if (this._isClosed) return;
+    this._isClosed = true;
+    this._argsTextController.close();
+    this._controller.enqueue({
+      type: "part-finish",
+      path: []
+    });
     this._controller.close();
   }
 };
 var createToolCallStream = (readable) => {
-  const options = {
-    toolCallId: readable.toolCallId,
-    toolName: readable.toolName
-  };
   return new ReadableStream({
     start(c) {
-      return readable.start?.(new ToolCallStreamControllerImpl(c, options));
+      return readable.start?.(new ToolCallStreamControllerImpl(c));
     },
     pull(c) {
-      return readable.pull?.(new ToolCallStreamControllerImpl(c, options));
+      return readable.pull?.(new ToolCallStreamControllerImpl(c));
     },
     cancel(c) {
       return readable.cancel?.(c);
     }
   });
 };
-
-// src/core/modules/runs.ts
-var promiseWithResolvers = () => {
-  let resolve;
-  let reject;
-  const promise = new Promise((res, rej) => {
-    resolve = res;
-    reject = rej;
-  });
-  return { promise, resolve, reject };
-};
-var createMergeStream = () => {
-  const list = [];
-  let sealed = false;
+var createToolCallStreamController = () => {
   let controller;
-  let currentPull;
-  const handlePull = (item) => {
-    if (!item.promise) {
-      item.promise = item.reader.read().then(({ done, value }) => {
-        item.promise = void 0;
-        if (done) {
-          list.splice(list.indexOf(item), 1);
-          if (sealed && list.length === 0) {
-            controller.close();
-          }
-        } else {
-          controller.enqueue(value);
-        }
-        currentPull?.resolve();
-        currentPull = void 0;
-      }).catch((e) => {
-        list.forEach((item2) => {
-          item2.reader.cancel();
-        });
-        list.length = 0;
-        controller.error(e);
-        currentPull?.reject(e);
-        currentPull = void 0;
-      });
-    }
-  };
-  const readable = new ReadableStream({
+  const stream = createToolCallStream({
     start(c) {
       controller = c;
-    },
-    async pull() {
-      list.map((item) => {
-        handlePull(item);
-        return item.promise;
-      });
-      currentPull = promiseWithResolvers();
-      return currentPull.promise;
-    },
-    cancel() {
-      list.forEach((item) => {
-        item.reader.cancel();
-      });
-      list.length = 0;
     }
   });
-  return {
-    stream: readable,
-    seal() {
-      sealed = true;
-      if (list.length === 0) controller.close();
-    },
-    addStream(stream) {
-      if (sealed)
-        throw new Error(
-          "Cannot add streams after the run callback has settled."
-        );
-      const item = { reader: stream.getReader() };
-      list.push(item);
-      if (list.length === 1) {
-        handlePull(item);
+  return [stream, controller];
+};
+
+// src/core/utils/Counter.ts
+var Counter = class {
+  value = -1;
+  up() {
+    return ++this.value;
+  }
+};
+
+// src/core/utils/stream/path-utils.ts
+var PathAppendEncoder = class extends TransformStream {
+  constructor(idx) {
+    super({
+      transform(chunk, controller) {
+        controller.enqueue({
+          ...chunk,
+          path: [idx, ...chunk.path]
+        });
       }
-    }
-  };
+    });
+  }
+};
+var PathAppendDecoder = class extends TransformStream {
+  constructor(idx) {
+    super({
+      transform(chunk, controller) {
+        const {
+          path: [idx2, ...path]
+        } = chunk;
+        if (idx !== idx2)
+          throw new Error(`Path mismatch: expected ${idx}, got ${idx2}`);
+        controller.enqueue({
+          ...chunk,
+          path
+        });
+      }
+    });
+  }
+};
+var PathMergeEncoder = class extends TransformStream {
+  constructor(counter) {
+    const innerCounter = new Counter();
+    const mapping = /* @__PURE__ */ new Map();
+    super({
+      transform(chunk, controller) {
+        if (chunk.type === "part-start" && chunk.path.length === 0) {
+          mapping.set(innerCounter.up(), counter.up());
+        }
+        const [idx, ...path] = chunk.path;
+        if (idx === void 0) {
+          controller.enqueue(chunk);
+          return;
+        }
+        const mappedIdx = mapping.get(idx);
+        if (mappedIdx === void 0) throw new Error("Path not found");
+        controller.enqueue({
+          ...chunk,
+          path: [mappedIdx, ...path]
+        });
+      }
+    });
+  }
+};
+
+// src/core/utils/stream/AssistantTransformStream.ts
+var AssistantTransformStream = class extends TransformStream {
+  constructor(transformer, writableStrategy, readableStrategy) {
+    const [stream, runController] = createAssistantStreamController();
+    let runPipeTask;
+    super(
+      {
+        start(controller) {
+          runPipeTask = stream.pipeTo(
+            new WritableStream({
+              write(chunk) {
+                controller.enqueue(chunk);
+              },
+              abort(reason) {
+                controller.error(reason);
+              },
+              close() {
+                controller.terminate();
+              }
+            })
+          ).catch((error) => {
+            controller.error(error);
+          });
+          return transformer.start?.(runController);
+        },
+        transform(chunk) {
+          return transformer.transform?.(chunk, runController);
+        },
+        async flush() {
+          await transformer.flush?.(runController);
+          runController.close();
+          await runPipeTask;
+        }
+      },
+      writableStrategy,
+      readableStrategy
+    );
+  }
+};
+
+// src/core/utils/stream/PipeableTransformStream.ts
+var PipeableTransformStream = class extends TransformStream {
+  constructor(transform) {
+    super();
+    const readable = transform(super.readable);
+    Object.defineProperty(this, "readable", {
+      value: readable,
+      writable: false
+    });
+  }
+};
+
+// src/core/utils/stream/LineDecoderStream.ts
+var LineDecoderStream = class extends TransformStream {
+  buffer = "";
+  constructor() {
+    super({
+      transform: (chunk, controller) => {
+        this.buffer += chunk;
+        const lines = this.buffer.split("\n");
+        for (let i = 0; i < lines.length - 1; i++) {
+          controller.enqueue(lines[i]);
+        }
+        this.buffer = lines[lines.length - 1] || "";
+      },
+      flush: (controller) => {
+        if (this.buffer) {
+          controller.enqueue(this.buffer);
+        }
+      }
+    });
+  }
+};
+
+// src/core/serialization/data-stream/serialization.ts
+var DataStreamChunkEncoder = class extends TransformStream {
+  constructor() {
+    super({
+      transform: (chunk, controller) => {
+        controller.enqueue(`${chunk.type}:${JSON.stringify(chunk.value)}
+`);
+      }
+    });
+  }
+};
+var DataStreamChunkDecoder = class extends TransformStream {
+  constructor() {
+    super({
+      transform: (chunk, controller) => {
+        const index = chunk.indexOf(":");
+        if (index === -1) throw new Error("Invalid stream part");
+        controller.enqueue({
+          type: chunk.slice(0, index),
+          value: JSON.parse(chunk.slice(index + 1))
+        });
+      }
+    });
+  }
+};
+
+// src/core/utils/stream/AssistantMetaTransformStream.ts
+var AssistantMetaTransformStream = class extends TransformStream {
+  constructor() {
+    const parts = [];
+    super({
+      transform(chunk, controller) {
+        if (chunk.type === "part-start") {
+          if (chunk.path.length !== 0) {
+            controller.error(new Error("Nested parts are not supported"));
+            return;
+          }
+          parts.push(chunk.part);
+          controller.enqueue(chunk);
+          return;
+        }
+        if (chunk.type === "text-delta" || chunk.type === "result" || chunk.type === "part-finish" || chunk.type === "tool-call-args-text-finish") {
+          if (chunk.path.length !== 1) {
+            controller.error(
+              new Error(`${chunk.type} chunks must have a path of length 1`)
+            );
+            return;
+          }
+          const idx = chunk.path[0];
+          if (idx < 0 || idx >= parts.length) {
+            controller.error(new Error(`Invalid path index: ${idx}`));
+            return;
+          }
+          const part = parts[idx];
+          controller.enqueue({
+            ...chunk,
+            meta: part
+            // TODO
+          });
+          return;
+        }
+        controller.enqueue(chunk);
+      }
+    });
+  }
+};
+
+// src/core/serialization/data-stream/DataStream.ts
+var DataStreamEncoder = class extends PipeableTransformStream {
+  headers = new Headers({
+    "Content-Type": "text/plain; charset=utf-8",
+    "x-vercel-ai-data-stream": "v1"
+  });
+  constructor() {
+    super((readable) => {
+      const transform = new TransformStream({
+        transform(chunk, controller) {
+          const type = chunk.type;
+          switch (type) {
+            case "part-start": {
+              const part = chunk.part;
+              if (part.type === "tool-call") {
+                const { type: type2, ...value } = part;
+                controller.enqueue({
+                  type: "b" /* StartToolCall */,
+                  value
+                });
+              }
+              if (part.type === "source") {
+                const { type: type2, ...value } = part;
+                controller.enqueue({
+                  type: "h" /* Source */,
+                  value
+                });
+              }
+              break;
+            }
+            case "text-delta": {
+              const part = chunk.meta;
+              switch (part.type) {
+                case "text": {
+                  controller.enqueue({
+                    type: "0" /* TextDelta */,
+                    value: chunk.textDelta
+                  });
+                  break;
+                }
+                case "reasoning": {
+                  controller.enqueue({
+                    type: "g" /* ReasoningDelta */,
+                    value: chunk.textDelta
+                  });
+                  break;
+                }
+                case "tool-call": {
+                  controller.enqueue({
+                    type: "c" /* ToolCallDelta */,
+                    value: {
+                      toolCallId: part.toolCallId,
+                      argsTextDelta: chunk.textDelta
+                    }
+                  });
+                  break;
+                }
+                default:
+                  throw new Error(
+                    `Unsupported part type for text-delta: ${part.type}`
+                  );
+              }
+              break;
+            }
+            case "result": {
+              const part = chunk.meta;
+              if (part.type !== "tool-call") {
+                throw new Error(
+                  `Result chunk on non-tool-call part not supported: ${part.type}`
+                );
+              }
+              controller.enqueue({
+                type: "a" /* ToolCallResult */,
+                value: {
+                  toolCallId: part.toolCallId,
+                  result: chunk.result
+                }
+              });
+              break;
+            }
+            case "step-start": {
+              const { type: type2, ...value } = chunk;
+              controller.enqueue({
+                type: "f" /* StartStep */,
+                value
+              });
+              break;
+            }
+            case "step-finish": {
+              const { type: type2, ...value } = chunk;
+              controller.enqueue({
+                type: "e" /* FinishStep */,
+                value
+              });
+              break;
+            }
+            case "message-finish": {
+              const { type: type2, ...value } = chunk;
+              controller.enqueue({
+                type: "d" /* FinishMessage */,
+                value
+              });
+              break;
+            }
+            case "error": {
+              controller.enqueue({
+                type: "3" /* Error */,
+                value: chunk.error
+              });
+              break;
+            }
+            case "annotations": {
+              controller.enqueue({
+                type: "8" /* Annotation */,
+                value: chunk.annotations
+              });
+              break;
+            }
+            case "data": {
+              controller.enqueue({
+                type: "2" /* Data */,
+                value: chunk.data
+              });
+              break;
+            }
+            // TODO ignore for now
+            // in the future, we should create a handler that waits for text parts to finish before continuing
+            case "tool-call-args-text-finish":
+            case "part-finish":
+              break;
+            default: {
+              const exhaustiveCheck = type;
+              throw new Error(`Unsupported chunk type: ${exhaustiveCheck}`);
+            }
+          }
+        }
+      });
+      return readable.pipeThrough(new AssistantMetaTransformStream()).pipeThrough(transform).pipeThrough(new DataStreamChunkEncoder()).pipeThrough(new TextEncoderStream());
+    });
+  }
+};
+var TOOL_CALL_ARGS_CLOSING_CHUNKS = [
+  "b" /* StartToolCall */,
+  "9" /* ToolCall */,
+  "0" /* TextDelta */,
+  "g" /* ReasoningDelta */,
+  "h" /* Source */,
+  "3" /* Error */,
+  "e" /* FinishStep */,
+  "d" /* FinishMessage */
+];
+var DataStreamDecoder = class extends PipeableTransformStream {
+  constructor() {
+    super((readable) => {
+      const toolCallControllers = /* @__PURE__ */ new Map();
+      let activeToolCallArgsText;
+      const transform = new AssistantTransformStream({
+        transform(chunk, controller) {
+          const { type, value } = chunk;
+          if (TOOL_CALL_ARGS_CLOSING_CHUNKS.includes(type)) {
+            activeToolCallArgsText?.close();
+            activeToolCallArgsText = void 0;
+          }
+          switch (type) {
+            case "g" /* ReasoningDelta */:
+              controller.appendReasoning(value);
+              break;
+            case "0" /* TextDelta */:
+              controller.appendText(value);
+              break;
+            case "b" /* StartToolCall */: {
+              const { toolCallId, toolName } = value;
+              const toolCallController = controller.addToolCallPart({
+                toolCallId,
+                toolName
+              });
+              toolCallControllers.set(toolCallId, toolCallController);
+              activeToolCallArgsText = toolCallController.argsText;
+              break;
+            }
+            case "c" /* ToolCallDelta */: {
+              const { toolCallId, argsTextDelta } = value;
+              const toolCallController = toolCallControllers.get(toolCallId);
+              if (!toolCallController)
+                throw new Error(
+                  "Encountered tool call with unknown id: " + toolCallId
+                );
+              toolCallController.argsText.append(argsTextDelta);
+              break;
+            }
+            case "a" /* ToolCallResult */: {
+              const { toolCallId, result } = value;
+              const toolCallController = toolCallControllers.get(toolCallId);
+              if (!toolCallController)
+                throw new Error(
+                  "Encountered tool call result with unknown id: " + toolCallId
+                );
+              toolCallController.setResult(result);
+              break;
+            }
+            case "9" /* ToolCall */: {
+              const { toolCallId, toolName, args } = value;
+              const toolCallController = controller.addToolCallPart({
+                toolCallId,
+                toolName
+              });
+              toolCallControllers.set(toolCallId, toolCallController);
+              toolCallController.argsText.append(JSON.stringify(args));
+              toolCallController.argsText.close();
+              break;
+            }
+            case "d" /* FinishMessage */:
+              controller.enqueue({
+                type: "message-finish",
+                path: [],
+                ...value
+              });
+              break;
+            case "f" /* StartStep */:
+              controller.enqueue({
+                type: "step-start",
+                path: [],
+                ...value
+              });
+              break;
+            case "e" /* FinishStep */:
+              controller.enqueue({
+                type: "step-finish",
+                path: [],
+                ...value
+              });
+              break;
+            case "2" /* Data */:
+              controller.enqueue({
+                type: "data",
+                path: [],
+                data: value
+              });
+              break;
+            case "8" /* Annotation */:
+              controller.enqueue({
+                type: "annotations",
+                path: [],
+                annotations: value
+              });
+              break;
+            case "h" /* Source */:
+              controller.appendSource({
+                type: "source",
+                ...value
+              });
+              break;
+            case "3" /* Error */:
+              controller.enqueue({
+                type: "error",
+                path: [],
+                error: value
+              });
+              break;
+            case "k" /* File */:
+              controller.appendFile({
+                type: "file",
+                ...value
+              });
+              break;
+            case "j" /* ReasoningSignature */:
+            case "i" /* RedactedReasoning */:
+              break;
+            default: {
+              const exhaustiveCheck = type;
+              throw new Error(`unsupported chunk type: ${exhaustiveCheck}`);
+            }
+          }
+        },
+        flush() {
+          activeToolCallArgsText?.close();
+          activeToolCallArgsText = void 0;
+          toolCallControllers.forEach((controller) => controller.close());
+          toolCallControllers.clear();
+        }
+      });
+      return readable.pipeThrough(new TextDecoderStream()).pipeThrough(new LineDecoderStream()).pipeThrough(new DataStreamChunkDecoder()).pipeThrough(transform);
+    });
+  }
 };
-var RunControllerImpl = class {
-  _merge = createMergeStream();
-  _textPartController;
-  getReadable() {
-    return this._merge.stream;
+
+// src/core/utils/generateId.tsx
+var import_non_secure = require("nanoid/non-secure");
+var generateId = (0, import_non_secure.customAlphabet)(
+  "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz",
+  7
+);
+
+// src/core/modules/assistant-stream.ts
+var AssistantStreamControllerImpl = class {
+  _merger = createMergeStream();
+  _append;
+  _contentCounter = new Counter();
+  get __internal_isClosed() {
+    return this._merger.isSealed();
   }
-  close() {
-    this._merge.seal();
-    this._textPartController?.close();
+  __internal_getReadable() {
+    return this._merger.readable;
+  }
+  _closeSubscriber;
+  __internal_subscribeToClose(callback) {
+    this._closeSubscriber = callback;
+  }
+  _addPart(part, stream) {
+    this.enqueue({
+      type: "part-start",
+      part,
+      path: []
+    });
+    this._merger.addStream(
+      stream.pipeThrough(new PathAppendEncoder(this._contentCounter.value))
+    );
   }
   merge(stream) {
-    this._merge.addStream(stream);
+    this._merger.addStream(
+      stream.pipeThrough(new PathMergeEncoder(this._contentCounter))
+    );
   }
   appendText(textDelta) {
-    if (!this._textPartController) {
-      this._textPartController = this.addTextPart();
+    if (this._append?.kind !== "text") {
+      if (this._append) {
+        this._append.controller.close();
+      }
+      this._append = {
+        kind: "text",
+        controller: this.addTextPart()
+      };
     }
-    this._textPartController.append(textDelta);
+    this._append.controller.append(textDelta);
   }
-  addTextPart() {
-    let controller;
-    const textStream = createTextStream({
-      start(c) {
-        controller = c;
+  appendReasoning(textDelta) {
+    if (this._append?.kind !== "reasoning") {
+      if (this._append) {
+        this._append.controller.close();
       }
-    });
-    this.merge(textStream);
+      this._append = {
+        kind: "reasoning",
+        controller: this.addReasoningPart()
+      };
+    }
+    this._append.controller.append(textDelta);
+  }
+  addTextPart() {
+    const [stream, controller] = createTextStreamController();
+    this._addPart({ type: "text" }, stream);
+    return controller;
+  }
+  addReasoningPart() {
+    const [stream, controller] = createTextStreamController();
+    this._addPart({ type: "reasoning" }, stream);
     return controller;
   }
   addToolCallPart(options) {
     const opt = typeof options === "string" ? { toolName: options } : options;
-    let controller;
-    const toolCallStream = createToolCallStream({
-      toolCallId: opt.toolCallId ?? generateId(),
-      toolName: opt.toolName,
-      start(c) {
-        controller = c;
-      }
-    });
-    this.merge(toolCallStream);
+    const toolName = opt.toolName;
+    const toolCallId = opt.toolCallId ?? generateId();
+    const [stream, controller] = createToolCallStreamController();
+    this._addPart({ type: "tool-call", toolName, toolCallId }, stream);
     if (opt.args !== void 0) {
       controller.argsText.append(JSON.stringify(opt.args));
       controller.argsText.close();
     }
-    if (opt !== void 0) {
-      controller.setResult(opt.result);
+    if (opt.result !== void 0) {
+      controller.setResult(opt.result, opt.isError);
     }
     return controller;
   }
-  addError(error) {
-    this._merge.addStream(
+  appendSource(options) {
+    this._addPart(
+      options,
       new ReadableStream({
-        start(c) {
-          c.enqueue({
-            type: "error",
-            error
+        start(controller) {
+          controller.enqueue({
+            type: "part-finish",
+            path: []
           });
+          controller.close();
         }
       })
     );
   }
+  appendFile(options) {
+    this._addPart(
+      options,
+      new ReadableStream({
+        start(controller) {
+          controller.enqueue({
+            type: "part-finish",
+            path: []
+          });
+          controller.close();
+        }
+      })
+    );
+  }
+  enqueue(chunk) {
+    this._merger.enqueue(chunk);
+    if (chunk.type === "part-start" && chunk.path.length === 0) {
+      this._contentCounter.up();
+    }
+  }
+  close() {
+    this._merger.seal();
+    this._append?.controller?.close();
+    this._closeSubscriber?.();
+  }
 };
 function createAssistantStream(callback) {
-  const controller = new RunControllerImpl();
-  const promiseOrVoid = callback(controller);
+  const controller = new AssistantStreamControllerImpl();
+  let promiseOrVoid;
+  try {
+    promiseOrVoid = callback(controller);
+  } catch (e) {
+    if (!controller.__internal_isClosed) {
+      controller.enqueue({
+        type: "error",
+        path: [],
+        error: String(e)
+      });
+      controller.close();
+    }
+    throw e;
+  }
   if (promiseOrVoid instanceof Promise) {
     const runTask = async () => {
       try {
         await promiseOrVoid;
       } catch (e) {
-        controller.addError(e instanceof Error ? e.message : String(e));
+        if (!controller.__internal_isClosed) {
+          controller.enqueue({
+            type: "error",
+            path: [],
+            error: String(e)
+          });
+        }
         throw e;
       } finally {
-        controller.close();
+        if (!controller.__internal_isClosed) {
+          controller.close();
+        }
       }
     };
     runTask();
   } else {
-    controller.close();
+    if (!controller.__internal_isClosed) {
+      controller.close();
+    }
   }
-  return controller.getReadable();
+  return controller.__internal_getReadable();
+}
+var promiseWithResolvers2 = function() {
+  let resolve;
+  let reject;
+  const promise = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  if (!resolve || !reject) throw new Error("Failed to create promise");
+  return { promise, resolve, reject };
+};
+function createAssistantStreamController() {
+  const { resolve, promise } = promiseWithResolvers2();
+  let controller;
+  const stream = createAssistantStream((c) => {
+    controller = c;
+    controller.__internal_subscribeToClose(
+      resolve
+    );
+    return promise;
+  });
+  return [stream, controller];
 }
 function createAssistantStreamResponse(callback) {
   return AssistantStream.toResponse(
@@ -505,61 +963,119 @@ function createAssistantStreamResponse(callback) {
   );
 }
 
-// src/core/serialization/PlainText.ts
-var PlainTextEncoder = class {
-  _transformStream;
-  get writable() {
-    return this._transformStream.writable;
-  }
-  get readable() {
-    return this._transformStream.readable;
-  }
-  constructor() {
-    this._transformStream = new PipeableTransformStream((readable) => {
+// src/core/effects/ToolExecutionStream.ts
+var import_secure_json_parse = __toESM(require("secure-json-parse"));
+var ToolExecutionStream = class extends PipeableTransformStream {
+  constructor(toolCallback) {
+    const toolCallPromises = /* @__PURE__ */ new Map();
+    const toolCallArgsText = {};
+    super((readable) => {
       const transform = new TransformStream({
         transform(chunk, controller) {
+          if (chunk.type !== "part-finish" || chunk.meta.type !== "tool-call") {
+            controller.enqueue(chunk);
+          }
           const type = chunk.type;
           switch (type) {
-            case "text-delta":
-              controller.enqueue(chunk.textDelta);
+            case "text-delta": {
+              if (chunk.meta.type === "tool-call") {
+                const toolCallId = chunk.meta.toolCallId;
+                if (toolCallArgsText[toolCallId] === void 0) {
+                  toolCallArgsText[toolCallId] = chunk.textDelta;
+                } else {
+                  toolCallArgsText[toolCallId] += chunk.textDelta;
+                }
+              }
               break;
-            default:
-              const unsupportedType = type;
-              throw new Error(`unsupported chunk type: ${unsupportedType}`);
+            }
+            case "tool-call-args-text-finish": {
+              if (chunk.meta.type !== "tool-call") break;
+              const { toolCallId, toolName } = chunk.meta;
+              const argsText = toolCallArgsText[toolCallId];
+              if (!argsText)
+                throw new Error("Unexpected tool call without args");
+              const executeTool = () => {
+                let args;
+                try {
+                  args = import_secure_json_parse.default.parse(argsText);
+                } catch (e) {
+                  throw new Error(
+                    `Function parameter parsing failed. ${JSON.stringify(e.message)}`
+                  );
+                }
+                return toolCallback({
+                  toolCallId,
+                  toolName,
+                  args
+                });
+              };
+              let promiseOrUndefined;
+              try {
+                promiseOrUndefined = executeTool();
+              } catch (e) {
+                controller.enqueue({
+                  type: "result",
+                  path: chunk.path,
+                  result: String(e),
+                  isError: true
+                });
+                break;
+              }
+              if (promiseOrUndefined instanceof Promise) {
+                const toolCallPromise = promiseOrUndefined.then((c) => {
+                  if (c === void 0) return;
+                  controller.enqueue({
+                    type: "result",
+                    path: chunk.path,
+                    result: c,
+                    isError: false
+                  });
+                }).catch((e) => {
+                  controller.enqueue({
+                    type: "result",
+                    path: chunk.path,
+                    result: String(e),
+                    isError: true
+                  });
+                });
+                toolCallPromises.set(toolCallId, toolCallPromise);
+              } else if (promiseOrUndefined !== void 0) {
+                controller.enqueue({
+                  type: "result",
+                  path: chunk.path,
+                  result: promiseOrUndefined,
+                  isError: false
+                });
+              }
+              break;
+            }
+            case "part-finish": {
+              if (chunk.meta.type !== "tool-call") break;
+              const { toolCallId } = chunk.meta;
+              const toolCallPromise = toolCallPromises.get(toolCallId);
+              if (toolCallPromise) {
+                toolCallPromise.then(() => {
+                  controller.enqueue(chunk);
+                });
+              } else {
+                controller.enqueue(chunk);
+              }
+            }
           }
+        },
+        async flush() {
+          await Promise.all(toolCallPromises);
         }
       });
-      return readable.pipeThrough(transform).pipeThrough(new TextEncoderStream());
-    });
-  }
-};
-var PlainTextDecoder = class {
-  _transformStream;
-  get writable() {
-    return this._transformStream.writable;
-  }
-  get readable() {
-    return this._transformStream.readable;
-  }
-  constructor() {
-    this._transformStream = new PipeableTransformStream((readable) => {
-      const transform = new TransformStream({
-        transform(chunk, controller) {
-          controller.enqueue({
-            type: "text-delta",
-            textDelta: chunk
-          });
-        }
-      });
-      return readable.pipeThrough(new TextDecoderStream()).pipeThrough(transform);
+      return readable.pipeThrough(new AssistantMetaTransformStream()).pipeThrough(transform);
     });
   }
 };
 
-// src/core/accumulators/partial-json/parse-partial-json.ts
-var import_secure_json_parse = __toESM(require("secure-json-parse"));
+// src/core/utils/json/parse-partial-json.ts
+var import_secure_json_parse2 = __toESM(require("secure-json-parse"));
 
-// src/core/accumulators/partial-json/fix-json.ts
+// src/core/utils/json/fix-json.ts
 function fixJson(input) {
   const stack = ["ROOT"];
   let lastValidIndex = -1;
@@ -877,176 +1393,354 @@ function fixJson(input) {
   return result;
 }
 
-// src/core/accumulators/partial-json/parse-partial-json.ts
+// src/core/utils/json/parse-partial-json.ts
 var parsePartialJson = (json) => {
   try {
-    return import_secure_json_parse.default.parse(json);
+    return import_secure_json_parse2.default.parse(json);
   } catch {
     try {
-      return import_secure_json_parse.default.parse(fixJson(json));
+      return import_secure_json_parse2.default.parse(fixJson(json));
     } catch {
       return void 0;
     }
   }
 };
 
-// src/core/accumulators/assistantMessageAccumulator.ts
-var assistantMessageAccumulator = () => {
-  let message = {
-    role: "assistant",
-    content: [],
-    status: { type: "running" },
-    metadata: {
-      steps: [],
-      custom: {}
+// src/core/accumulators/assistant-message-accumulator.ts
+var createInitialMessage = () => ({
+  role: "assistant",
+  status: { type: "running" },
+  parts: [],
+  get content() {
+    return this.parts;
+  },
+  metadata: {
+    unstable_data: [],
+    unstable_annotations: [],
+    steps: [],
+    custom: {}
+  }
+});
+var updatePartForPath = (message, chunk, updater) => {
+  if (message.parts.length === 0) {
+    throw new Error("No parts available to update.");
+  }
+  if (chunk.path.length !== 1)
+    throw new Error("Nested paths are not supported yet.");
+  const partIndex = chunk.path[0];
+  const updatedPart = updater(message.parts[partIndex]);
+  return {
+    ...message,
+    parts: [
+      ...message.parts.slice(0, partIndex),
+      updatedPart,
+      ...message.parts.slice(partIndex + 1)
+    ],
+    get content() {
+      return this.parts;
     }
   };
-  const transformer = new TransformStream({
-    transform(chunk, controller) {
-      const { type } = chunk;
-      switch (type) {
-        case "text-delta": {
-          message = appendOrUpdateText(message, chunk.textDelta);
-          controller.enqueue(message);
-          break;
-        }
-        case "tool-call-begin": {
-          const { toolCallId, toolName } = chunk;
-          message = appendToolCall(message, toolCallId, toolName);
-          controller.enqueue(message);
-          break;
-        }
-        case "tool-call-delta": {
-          const { toolCallId, argsTextDelta } = chunk;
-          message = appendToolArgsTextDelta(message, toolCallId, argsTextDelta);
-          controller.enqueue(message);
-          break;
-        }
-        case "tool-result": {
-          const { toolCallId, result } = chunk;
-          message = setToolResult(message, toolCallId, result);
-          controller.enqueue(message);
-          break;
-        }
-        case "error": {
-          const { error } = chunk;
-          message = setError(message, error);
-          controller.enqueue(message);
-          break;
-        }
-        default: {
-          const _exhaustiveCheck = type;
-          throw new Error(`Unsupported chunk type: ${_exhaustiveCheck}`);
-        }
+};
+var handlePartStart = (message, chunk) => {
+  const partInit = chunk.part;
+  if (partInit.type === "text" || partInit.type === "reasoning") {
+    const newTextPart = {
+      type: partInit.type,
+      text: "",
+      status: { type: "running" }
+    };
+    return {
+      ...message,
+      parts: [...message.parts, newTextPart],
+      get content() {
+        return this.parts;
       }
-    },
-    flush(controller) {
-      message = appendOrUpdateFinish(message);
-      controller.enqueue(message);
+    };
+  } else if (partInit.type === "tool-call") {
+    const newToolCallPart = {
+      type: "tool-call",
+      state: "partial-call",
+      status: { type: "running", isArgsComplete: false },
+      toolCallId: partInit.toolCallId,
+      toolName: partInit.toolName,
+      argsText: "",
+      args: {}
+    };
+    return {
+      ...message,
+      parts: [...message.parts, newToolCallPart],
+      get content() {
+        return this.parts;
+      }
+    };
+  } else if (partInit.type === "source") {
+    const newSourcePart = {
+      type: "source",
+      sourceType: partInit.sourceType,
+      id: partInit.id,
+      url: partInit.url,
+      ...partInit.title ? { title: partInit.title } : void 0
+    };
+    return {
+      ...message,
+      parts: [...message.parts, newSourcePart],
+      get content() {
+        return this.parts;
+      }
+    };
+  } else if (partInit.type === "file") {
+    const newFilePart = {
+      type: "file",
+      mimeType: partInit.mimeType,
+      data: partInit.data
+    };
+    return {
+      ...message,
+      parts: [...message.parts, newFilePart],
+      get content() {
+        return this.parts;
+      }
+    };
+  } else {
+    throw new Error(`Unsupported part type: ${partInit.type}`);
+  }
+};
+var handleToolCallArgsTextFinish = (message, chunk) => {
+  return updatePartForPath(message, chunk, (lastPart) => {
+    if (lastPart.type !== "tool-call") {
+      throw new Error("Last part is not a tool call");
     }
+    return {
+      ...lastPart,
+      state: "call"
+    };
   });
-  return transformer;
 };
-var appendOrUpdateText = (message, textDelta) => {
-  let contentParts = message.content ?? [];
-  let contentPart = message.content?.at(-1);
-  if (contentPart?.type !== "text") {
-    contentPart = {
-      type: "text",
-      text: textDelta,
-      status: { type: "running" }
+var handlePartFinish = (message, chunk) => {
+  return updatePartForPath(message, chunk, (lastPart) => ({
+    ...lastPart,
+    status: { type: "complete", reason: "unknown" }
+  }));
+};
+var handleTextDelta = (message, chunk) => {
+  return updatePartForPath(message, chunk, (lastPart) => {
+    if (lastPart.type === "text") {
+      return { ...lastPart, text: lastPart.text + chunk.textDelta };
+    } else if (lastPart.type === "tool-call") {
+      const newArgsText = lastPart.argsText + chunk.textDelta;
+      let newArgs;
+      try {
+        newArgs = parsePartialJson(newArgsText);
+      } catch (err) {
+        newArgs = lastPart.args;
+      }
+      return { ...lastPart, argsText: newArgsText, args: newArgs };
+    } else {
+      throw new Error(
+        "text-delta received but last part is neither text nor tool-call"
+      );
+    }
+  });
+};
+var handleResult = (message, chunk) => {
+  return updatePartForPath(message, chunk, (lastPart) => {
+    if (lastPart.type === "tool-call") {
+      return {
+        ...lastPart,
+        state: "result",
+        result: chunk.result,
+        isError: chunk.isError ?? false,
+        status: { type: "complete", reason: "stop" }
+      };
+    } else {
+      throw new Error("Result chunk received but last part is not a tool-call");
+    }
+  });
+};
+var handleMessageFinish = (message, chunk) => {
+  const newStatus = getStatus(chunk);
+  return { ...message, status: newStatus };
+};
+var getStatus = (chunk) => {
+  if (chunk.finishReason === "tool-calls") {
+    return {
+      type: "requires-action",
+      reason: "tool-calls"
+    };
+  } else if (chunk.finishReason === "stop" || chunk.finishReason === "unknown") {
+    return {
+      type: "complete",
+      reason: chunk.finishReason
     };
   } else {
-    contentParts = contentParts.slice(0, -1);
-    contentPart = {
-      type: "text",
-      text: contentPart.text + textDelta,
-      status: { type: "running" }
+    return {
+      type: "incomplete",
+      reason: chunk.finishReason
     };
   }
-  return {
-    ...message,
-    content: contentParts.concat([contentPart])
-  };
 };
-var appendToolCall = (message, toolCallId, toolName) => {
+var handleAnnotations = (message, chunk) => {
   return {
     ...message,
-    content: [
-      ...message.content,
-      {
-        type: "tool-call",
-        toolCallId,
-        toolName,
-        argsText: "",
-        args: {},
-        status: { type: "running", isArgsComplete: false }
-      }
-    ]
+    metadata: {
+      ...message.metadata,
+      unstable_annotations: [
+        ...message.metadata.unstable_annotations,
+        ...chunk.annotations
+      ]
+    }
   };
 };
-var appendToolArgsTextDelta = (message, toolCallId, argsTextDelta) => {
-  const contentPartIdx = message.content.findIndex(
-    (part) => part.type === "tool-call" && part.toolCallId === toolCallId
-  );
-  if (contentPartIdx === -1)
-    throw new Error(
-      `Received tool call delta for unknown tool call "${toolCallId}".`
-    );
-  const contentPart = message.content[contentPartIdx];
-  const newArgsText = contentPart.argsText + argsTextDelta;
+var handleData = (message, chunk) => {
   return {
     ...message,
-    content: [
-      ...message.content.slice(0, contentPartIdx),
-      {
-        ...contentPart,
-        argsText: newArgsText,
-        args: parsePartialJson(newArgsText)
-      },
-      ...message.content.slice(contentPartIdx + 1)
-    ]
+    metadata: {
+      ...message.metadata,
+      unstable_data: [...message.metadata.unstable_data, ...chunk.data]
+    }
   };
 };
-var setToolResult = (message, toolCallId, result) => {
-  let found = false;
-  const newContentParts = message.content?.map((part) => {
-    if (part.type !== "tool-call" || part.toolCallId !== toolCallId)
-      return part;
-    found = true;
-    return {
-      ...part,
-      result
-    };
-  });
-  if (!found)
-    throw new Error(
-      `Received tool result for unknown tool call "${toolCallId}". This is likely an internal bug in assistant-ui.`
-    );
+var handleStepStart = (message, chunk) => {
   return {
     ...message,
-    content: newContentParts
+    metadata: {
+      ...message.metadata,
+      steps: [
+        ...message.metadata.steps,
+        { state: "started", messageId: chunk.messageId }
+      ]
+    }
   };
 };
-var appendOrUpdateFinish = (message) => {
+var handleStepFinish = (message, chunk) => {
+  const steps = message.metadata.steps.slice();
+  const lastIndex = steps.length - 1;
+  if (steps.length > 0 && steps[lastIndex]?.state === "started") {
+    steps[lastIndex] = {
+      ...steps[lastIndex],
+      state: "finished",
+      finishReason: chunk.finishReason,
+      usage: chunk.usage,
+      isContinued: chunk.isContinued
+    };
+  } else {
+    steps.push({
+      state: "finished",
+      messageId: generateId(),
+      finishReason: chunk.finishReason,
+      usage: chunk.usage,
+      isContinued: chunk.isContinued
+    });
+  }
   return {
     ...message,
-    status: {
-      type: "complete",
-      reason: "unknown"
+    metadata: {
+      ...message.metadata,
+      steps
     }
   };
 };
-var setError = (message, error) => {
+var handleErrorChunk = (message, chunk) => {
   return {
     ...message,
-    status: {
-      type: "incomplete",
-      reason: "error",
-      error
-    }
+    status: { type: "incomplete", reason: "error", error: chunk.error }
   };
 };
+var AssistantMessageAccumulator = class extends TransformStream {
+  constructor() {
+    let message = createInitialMessage();
+    let hadChunks = false;
+    super({
+      transform(chunk, controller) {
+        const type = chunk.type;
+        switch (type) {
+          case "part-start":
+            message = handlePartStart(message, chunk);
+            break;
+          case "tool-call-args-text-finish":
+            message = handleToolCallArgsTextFinish(message, chunk);
+            break;
+          case "part-finish":
+            message = handlePartFinish(message, chunk);
+            break;
+          case "text-delta":
+            message = handleTextDelta(message, chunk);
+            break;
+          case "result":
+            message = handleResult(message, chunk);
+            break;
+          case "message-finish":
+            message = handleMessageFinish(message, chunk);
+            break;
+          case "annotations":
+            message = handleAnnotations(message, chunk);
+            break;
+          case "data":
+            message = handleData(message, chunk);
+            break;
+          case "step-start":
+            message = handleStepStart(message, chunk);
+            break;
+          case "step-finish":
+            message = handleStepFinish(message, chunk);
+            break;
+          case "error":
+            message = handleErrorChunk(message, chunk);
+            break;
+          default: {
+            const unhandledType = type;
+            throw new Error(`Unsupported chunk type: ${unhandledType}`);
+          }
+        }
+        controller.enqueue(message);
+        hadChunks = true;
+      },
+      flush(controller) {
+        if (!hadChunks) {
+          controller.enqueue(message);
+        }
+      }
+    });
+  }
+};
+
+// src/core/serialization/PlainText.ts
+var PlainTextEncoder = class extends PipeableTransformStream {
+  headers = new Headers({
+    "Content-Type": "text/plain; charset=utf-8",
+    "x-vercel-ai-data-stream": "v1"
+  });
+  constructor() {
+    super((readable) => {
+      const transform = new TransformStream({
+        transform(chunk, controller) {
+          const type = chunk.type;
+          switch (type) {
+            case "text-delta":
+              controller.enqueue(chunk.textDelta);
+              break;
+            default:
+              const unsupportedType = type;
+              throw new Error(`unsupported chunk type: ${unsupportedType}`);
+          }
+        }
+      });
+      return readable.pipeThrough(transform).pipeThrough(new TextEncoderStream());
+    });
+  }
+};
+var PlainTextDecoder = class extends PipeableTransformStream {
+  constructor() {
+    super((readable) => {
+      const transform = new AssistantTransformStream({
+        transform(chunk, controller) {
+          controller.appendText(chunk);
+        }
+      });
+      return readable.pipeThrough(new TextDecoderStream()).pipeThrough(transform);
+    });
+  }
+};
 
 // src/core/accumulators/AssistantMessageStream.ts
 var AssistantMessageStream = class _AssistantMessageStream {
@@ -1056,7 +1750,7 @@ var AssistantMessageStream = class _AssistantMessageStream {
   }
   static fromAssistantStream(stream) {
     return new _AssistantMessageStream(
-      stream.pipeThrough(assistantMessageAccumulator())
+      stream.pipeThrough(new AssistantMessageAccumulator())
     );
   }
   async unstable_result() {
@@ -1068,8 +1762,11 @@ var AssistantMessageStream = class _AssistantMessageStream {
       return {
         role: "assistant",
         status: { type: "complete", reason: "unknown" },
+        parts: [],
         content: [],
         metadata: {
+          unstable_data: [],
+          unstable_annotations: [],
           steps: [],
           custom: {}
         }
@@ -1096,12 +1793,14 @@ var AssistantMessageStream = class _AssistantMessageStream {
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  AssistantMessageAccumulator,
   AssistantMessageStream,
   AssistantStream,
   DataStreamDecoder,
   DataStreamEncoder,
   PlainTextDecoder,
   PlainTextEncoder,
+  ToolExecutionStream,
   createAssistantStream,
   createAssistantStreamResponse
 });