assistant-stream 0.0.21 → 0.0.22

package/dist/index.mjs

@@ -1,519 +1,128 @@
 import {
+  AssistantMetaTransformStream,
+  AssistantStream,
+  AssistantTransformStream,
+  DataStreamDecoder,
+  DataStreamEncoder,
+  PipeableTransformStream,
+  createAssistantStream,
+  createAssistantStreamResponse,
   generateId
-} from "./chunk-ZSSWV6GU.mjs";
-
-// src/core/AssistantStream.ts
-var AssistantStream = {
-  toResponse(stream, transformer) {
-    return new Response(AssistantStream.toByteStream(stream, transformer));
-  },
-  fromResponse(response, transformer) {
-    return AssistantStream.fromByteStream(response.body, transformer);
-  },
-  toByteStream(stream, transformer) {
-    return stream.pipeThrough(transformer);
-  },
-  fromByteStream(readable, transformer) {
-    return readable.pipeThrough(transformer);
-  }
-};
+} from "./chunk-DISBVUTK.mjs";
 
-// 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/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) => {
+// src/core/effects/ToolExecutionStream.ts
+import sjson from "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) {
-          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}`);
+          if (chunk.type !== "part-finish" || chunk.meta.type !== "tool-call") {
+            controller.enqueue(chunk);
           }
-        }
-      });
-      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);
+          const type = chunk.type;
           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
-              });
+            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;
             }
-            case "c": {
-              const { toolCallId, argsTextDelta } = value;
-              controller.enqueue({
-                type: "tool-call-delta",
-                toolCallId,
-                argsTextDelta
-              });
+            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 = sjson.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 "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;
+            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);
+              }
             }
-            default:
-              const exhaustiveCheck = type;
-              throw new Error(`unsupported chunk type: ${exhaustiveCheck}`);
           }
+        },
+        async flush() {
+          await Promise.all(toolCallPromises);
         }
       });
-      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);
-        }
-      }
-    });
-  }
-};
-
-// src/core/modules/text.ts
-var TextStreamControllerImpl = class {
-  _controller;
-  constructor(controller) {
-    this._controller = controller;
-  }
-  append(textDelta) {
-    this._controller.enqueue({
-      type: "text-delta",
-      textDelta
-    });
-    return this;
-  }
-  close() {
-    this._controller.close();
-  }
-};
-var createTextStream = (readable) => {
-  return new ReadableStream({
-    start(c) {
-      return readable.start?.(new TextStreamControllerImpl(c));
-    },
-    pull(c) {
-      return readable.pull?.(new TextStreamControllerImpl(c));
-    },
-    cancel(c) {
-      return readable.cancel?.(c);
-    }
-  });
-};
-
-// src/core/modules/tool-call.ts
-var ToolCallStreamControllerImpl = class {
-  constructor(_controller, _options) {
-    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;
-      }
-    });
-    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
-          });
-        }
-      })
-    );
-  }
-  get toolCallId() {
-    return this._options.toolCallId;
-  }
-  get toolName() {
-    return this._options.toolName;
-  }
-  get argsText() {
-    return this._argsTextController;
-  }
-  _argsTextController;
-  setResult(result) {
-    this._controller.enqueue({
-      type: "tool-result",
-      toolCallId: this._options.toolCallId,
-      result
+      return readable.pipeThrough(new AssistantMetaTransformStream()).pipeThrough(transform);
     });
   }
-  close() {
-    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));
-    },
-    pull(c) {
-      return readable.pull?.(new ToolCallStreamControllerImpl(c, options));
-    },
-    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;
-  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({
-    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);
-      }
-    }
-  };
-};
-var RunControllerImpl = class {
-  _merge = createMergeStream();
-  _textPartController;
-  getReadable() {
-    return this._merge.stream;
-  }
-  close() {
-    this._merge.seal();
-    this._textPartController?.close();
-  }
-  merge(stream) {
-    this._merge.addStream(stream);
-  }
-  appendText(textDelta) {
-    if (!this._textPartController) {
-      this._textPartController = this.addTextPart();
-    }
-    this._textPartController.append(textDelta);
-  }
-  addTextPart() {
-    let controller;
-    const textStream = createTextStream({
-      start(c) {
-        controller = c;
-      }
-    });
-    this.merge(textStream);
-    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);
-    if (opt.args !== void 0) {
-      controller.argsText.append(JSON.stringify(opt.args));
-      controller.argsText.close();
-    }
-    if (opt !== void 0) {
-      controller.setResult(opt.result);
-    }
-    return controller;
-  }
-  addError(error) {
-    this._merge.addStream(
-      new ReadableStream({
-        start(c) {
-          c.enqueue({
-            type: "error",
-            error
-          });
-        }
-      })
-    );
-  }
-};
-function createAssistantStream(callback) {
-  const controller = new RunControllerImpl();
-  const promiseOrVoid = callback(controller);
-  if (promiseOrVoid instanceof Promise) {
-    const runTask = async () => {
-      try {
-        await promiseOrVoid;
-      } catch (e) {
-        controller.addError(e instanceof Error ? e.message : String(e));
-        throw e;
-      } finally {
-        controller.close();
-      }
-    };
-    runTask();
-  } else {
-    controller.close();
-  }
-  return controller.getReadable();
-}
-function createAssistantStreamResponse(callback) {
-  return AssistantStream.toResponse(
-    createAssistantStream(callback),
-    new DataStreamEncoder()
-  );
-}
+// src/core/utils/json/parse-partial-json.ts
+import sjson2 from "secure-json-parse";
 
-// 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) => {
-      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 {
-  _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);
-    });
-  }
-};
-
-// src/core/accumulators/partial-json/parse-partial-json.ts
-import sjson from "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;
@@ -831,176 +440,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 sjson.parse(json);
+    return sjson2.parse(json);
   } catch {
     try {
-      return sjson.parse(fixJson(json));
+      return sjson2.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 {
@@ -1010,7 +797,7 @@ var AssistantMessageStream = class _AssistantMessageStream {
   }
   static fromAssistantStream(stream) {
     return new _AssistantMessageStream(
-      stream.pipeThrough(assistantMessageAccumulator())
+      stream.pipeThrough(new AssistantMessageAccumulator())
     );
   }
   async unstable_result() {
@@ -1022,8 +809,11 @@ var AssistantMessageStream = class _AssistantMessageStream {
       return {
         role: "assistant",
         status: { type: "complete", reason: "unknown" },
+        parts: [],
         content: [],
         metadata: {
+          unstable_data: [],
+          unstable_annotations: [],
           steps: [],
           custom: {}
         }
@@ -1049,12 +839,14 @@ var AssistantMessageStream = class _AssistantMessageStream {
   }
 };
 export {
+  AssistantMessageAccumulator,
   AssistantMessageStream,
   AssistantStream,
   DataStreamDecoder,
   DataStreamEncoder,
   PlainTextDecoder,
   PlainTextEncoder,
+  ToolExecutionStream,
   createAssistantStream,
   createAssistantStreamResponse
 };