assistant-stream 0.0.0 → 0.0.2

package/dist/chunk-7CCRZC5D.mjs

@@ -0,0 +1,969 @@
+// src/core/AssistantStream.ts
+var AssistantStream = class _AssistantStream {
+  constructor(readable) {
+    this.readable = readable;
+    this.readable = readable;
+  }
+  toResponse(transformer) {
+    return new Response(this.toByteStream(transformer));
+  }
+  static fromResponse(response, transformer) {
+    return _AssistantStream.fromByteStream(response.body, transformer);
+  }
+  toByteStream(transformer) {
+    return this.readable.pipeThrough(transformer);
+  }
+  static fromByteStream(readable, transformer) {
+    return new _AssistantStream(readable.pipeThrough(transformer));
+  }
+  tee() {
+    const [readable1, readable2] = this.readable.tee();
+    return [new _AssistantStream(readable1), new _AssistantStream(readable2)];
+  }
+};
+
+// src/core/utils/generateId.tsx
+import { customAlphabet } from "nanoid/non-secure";
+var generateId = customAlphabet(
+  "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz",
+  7
+);
+
+// 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 AssistantStream(
+    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.readable.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
+    });
+  }
+  close() {
+    this._controller.close();
+  }
+};
+var createToolCallStream = (readable) => {
+  const options = {
+    toolCallId: readable.toolCallId,
+    toolName: readable.toolName
+  };
+  return new AssistantStream(
+    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.readable.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();
+  }
+  appendStep(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.appendStep(textStream);
+    return controller;
+  }
+  addToolCallPart(options) {
+    const opt = typeof options === "string" ? { toolName: options, toolCallId: generateId() } : options;
+    let controller;
+    const toolCallStream = createToolCallStream({
+      toolCallId: opt.toolCallId,
+      toolName: opt.toolName,
+      start(c) {
+        controller = c;
+      }
+    });
+    this.appendStep(toolCallStream);
+    return controller;
+  }
+};
+function createAssistantRun(callback) {
+  const controller = new RunControllerImpl();
+  const promiseOrVoid = callback(controller);
+  if (promiseOrVoid instanceof Promise) {
+    promiseOrVoid.finally(() => controller.close());
+  } else {
+    controller.close();
+  }
+  return new AssistantStream(controller.getReadable());
+}
+
+// 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) => {
+      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;
+            default:
+              const exhaustiveCheck = type;
+              throw new Error(`unsupported chunk type: ${exhaustiveCheck}`);
+          }
+        }
+      });
+      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;
+            }
+            default:
+              const exhaustiveCheck = type;
+              throw new Error(`unsupported chunk type: ${exhaustiveCheck}`);
+          }
+        }
+      });
+      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/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;
+            case "tool-call-begin":
+            case "tool-call-delta":
+            case "tool-result":
+              throw new Error(
+                `tool-call-begin and tool-call-delta are not supported in plain text serialization`
+              );
+            default:
+              const exhaustiveCheck = type;
+              throw new Error(`unsupported chunk type: ${exhaustiveCheck}`);
+          }
+        }
+      });
+      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
+function fixJson(input) {
+  const stack = ["ROOT"];
+  let lastValidIndex = -1;
+  let literalStart = null;
+  function processValueStart(char, i, swapState) {
+    {
+      switch (char) {
+        case '"': {
+          lastValidIndex = i;
+          stack.pop();
+          stack.push(swapState);
+          stack.push("INSIDE_STRING");
+          break;
+        }
+        case "f":
+        case "t":
+        case "n": {
+          lastValidIndex = i;
+          literalStart = i;
+          stack.pop();
+          stack.push(swapState);
+          stack.push("INSIDE_LITERAL");
+          break;
+        }
+        case "-": {
+          stack.pop();
+          stack.push(swapState);
+          stack.push("INSIDE_NUMBER");
+          break;
+        }
+        case "0":
+        case "1":
+        case "2":
+        case "3":
+        case "4":
+        case "5":
+        case "6":
+        case "7":
+        case "8":
+        case "9": {
+          lastValidIndex = i;
+          stack.pop();
+          stack.push(swapState);
+          stack.push("INSIDE_NUMBER");
+          break;
+        }
+        case "{": {
+          lastValidIndex = i;
+          stack.pop();
+          stack.push(swapState);
+          stack.push("INSIDE_OBJECT_START");
+          break;
+        }
+        case "[": {
+          lastValidIndex = i;
+          stack.pop();
+          stack.push(swapState);
+          stack.push("INSIDE_ARRAY_START");
+          break;
+        }
+      }
+    }
+  }
+  function processAfterObjectValue(char, i) {
+    switch (char) {
+      case ",": {
+        stack.pop();
+        stack.push("INSIDE_OBJECT_AFTER_COMMA");
+        break;
+      }
+      case "}": {
+        lastValidIndex = i;
+        stack.pop();
+        break;
+      }
+    }
+  }
+  function processAfterArrayValue(char, i) {
+    switch (char) {
+      case ",": {
+        stack.pop();
+        stack.push("INSIDE_ARRAY_AFTER_COMMA");
+        break;
+      }
+      case "]": {
+        lastValidIndex = i;
+        stack.pop();
+        break;
+      }
+    }
+  }
+  for (let i = 0; i < input.length; i++) {
+    const char = input[i];
+    const currentState = stack[stack.length - 1];
+    switch (currentState) {
+      case "ROOT":
+        processValueStart(char, i, "FINISH");
+        break;
+      case "INSIDE_OBJECT_START": {
+        switch (char) {
+          case '"': {
+            stack.pop();
+            stack.push("INSIDE_OBJECT_KEY");
+            break;
+          }
+          case "}": {
+            lastValidIndex = i;
+            stack.pop();
+            break;
+          }
+        }
+        break;
+      }
+      case "INSIDE_OBJECT_AFTER_COMMA": {
+        switch (char) {
+          case '"': {
+            stack.pop();
+            stack.push("INSIDE_OBJECT_KEY");
+            break;
+          }
+        }
+        break;
+      }
+      case "INSIDE_OBJECT_KEY": {
+        switch (char) {
+          case '"': {
+            stack.pop();
+            stack.push("INSIDE_OBJECT_AFTER_KEY");
+            break;
+          }
+        }
+        break;
+      }
+      case "INSIDE_OBJECT_AFTER_KEY": {
+        switch (char) {
+          case ":": {
+            stack.pop();
+            stack.push("INSIDE_OBJECT_BEFORE_VALUE");
+            break;
+          }
+        }
+        break;
+      }
+      case "INSIDE_OBJECT_BEFORE_VALUE": {
+        processValueStart(char, i, "INSIDE_OBJECT_AFTER_VALUE");
+        break;
+      }
+      case "INSIDE_OBJECT_AFTER_VALUE": {
+        processAfterObjectValue(char, i);
+        break;
+      }
+      case "INSIDE_STRING": {
+        switch (char) {
+          case '"': {
+            stack.pop();
+            lastValidIndex = i;
+            break;
+          }
+          case "\\": {
+            stack.push("INSIDE_STRING_ESCAPE");
+            break;
+          }
+          default: {
+            lastValidIndex = i;
+          }
+        }
+        break;
+      }
+      case "INSIDE_ARRAY_START": {
+        switch (char) {
+          case "]": {
+            lastValidIndex = i;
+            stack.pop();
+            break;
+          }
+          default: {
+            lastValidIndex = i;
+            processValueStart(char, i, "INSIDE_ARRAY_AFTER_VALUE");
+            break;
+          }
+        }
+        break;
+      }
+      case "INSIDE_ARRAY_AFTER_VALUE": {
+        switch (char) {
+          case ",": {
+            stack.pop();
+            stack.push("INSIDE_ARRAY_AFTER_COMMA");
+            break;
+          }
+          case "]": {
+            lastValidIndex = i;
+            stack.pop();
+            break;
+          }
+          default: {
+            lastValidIndex = i;
+            break;
+          }
+        }
+        break;
+      }
+      case "INSIDE_ARRAY_AFTER_COMMA": {
+        processValueStart(char, i, "INSIDE_ARRAY_AFTER_VALUE");
+        break;
+      }
+      case "INSIDE_STRING_ESCAPE": {
+        stack.pop();
+        lastValidIndex = i;
+        break;
+      }
+      case "INSIDE_NUMBER": {
+        switch (char) {
+          case "0":
+          case "1":
+          case "2":
+          case "3":
+          case "4":
+          case "5":
+          case "6":
+          case "7":
+          case "8":
+          case "9": {
+            lastValidIndex = i;
+            break;
+          }
+          case "e":
+          case "E":
+          case "-":
+          case ".": {
+            break;
+          }
+          case ",": {
+            stack.pop();
+            if (stack[stack.length - 1] === "INSIDE_ARRAY_AFTER_VALUE") {
+              processAfterArrayValue(char, i);
+            }
+            if (stack[stack.length - 1] === "INSIDE_OBJECT_AFTER_VALUE") {
+              processAfterObjectValue(char, i);
+            }
+            break;
+          }
+          case "}": {
+            stack.pop();
+            if (stack[stack.length - 1] === "INSIDE_OBJECT_AFTER_VALUE") {
+              processAfterObjectValue(char, i);
+            }
+            break;
+          }
+          case "]": {
+            stack.pop();
+            if (stack[stack.length - 1] === "INSIDE_ARRAY_AFTER_VALUE") {
+              processAfterArrayValue(char, i);
+            }
+            break;
+          }
+          default: {
+            stack.pop();
+            break;
+          }
+        }
+        break;
+      }
+      case "INSIDE_LITERAL": {
+        const partialLiteral = input.substring(literalStart, i + 1);
+        if (!"false".startsWith(partialLiteral) && !"true".startsWith(partialLiteral) && !"null".startsWith(partialLiteral)) {
+          stack.pop();
+          if (stack[stack.length - 1] === "INSIDE_OBJECT_AFTER_VALUE") {
+            processAfterObjectValue(char, i);
+          } else if (stack[stack.length - 1] === "INSIDE_ARRAY_AFTER_VALUE") {
+            processAfterArrayValue(char, i);
+          }
+        } else {
+          lastValidIndex = i;
+        }
+        break;
+      }
+    }
+  }
+  let result = input.slice(0, lastValidIndex + 1);
+  for (let i = stack.length - 1; i >= 0; i--) {
+    const state = stack[i];
+    switch (state) {
+      case "INSIDE_STRING": {
+        result += '"';
+        break;
+      }
+      case "INSIDE_OBJECT_KEY":
+      case "INSIDE_OBJECT_AFTER_KEY":
+      case "INSIDE_OBJECT_AFTER_COMMA":
+      case "INSIDE_OBJECT_START":
+      case "INSIDE_OBJECT_BEFORE_VALUE":
+      case "INSIDE_OBJECT_AFTER_VALUE": {
+        result += "}";
+        break;
+      }
+      case "INSIDE_ARRAY_START":
+      case "INSIDE_ARRAY_AFTER_COMMA":
+      case "INSIDE_ARRAY_AFTER_VALUE": {
+        result += "]";
+        break;
+      }
+      case "INSIDE_LITERAL": {
+        const partialLiteral = input.substring(literalStart, input.length);
+        if ("true".startsWith(partialLiteral)) {
+          result += "true".slice(partialLiteral.length);
+        } else if ("false".startsWith(partialLiteral)) {
+          result += "false".slice(partialLiteral.length);
+        } else if ("null".startsWith(partialLiteral)) {
+          result += "null".slice(partialLiteral.length);
+        }
+      }
+    }
+  }
+  return result;
+}
+
+// src/core/accumulators/partial-json/parse-partial-json.ts
+var parsePartialJson = (json) => {
+  try {
+    return sjson.parse(json);
+  } catch {
+    try {
+      return sjson.parse(fixJson(json));
+    } catch {
+      return void 0;
+    }
+  }
+};
+
+// src/core/accumulators/assistant-message.ts
+function createAsyncIterableStream(source, transform) {
+  const transformedStream = source.pipeThrough(transform);
+  transformedStream[Symbol.asyncIterator] = () => {
+    const reader = transformedStream.getReader();
+    return {
+      async next() {
+        const { done, value } = await reader.read();
+        return done ? { done: true, value: void 0 } : { done: false, value };
+      }
+    };
+  };
+  return transformedStream;
+}
+var toAssistantMessageStream = (stream) => {
+  let message = {
+    role: "assistant",
+    content: [],
+    status: { type: "running" },
+    metadata: {
+      steps: [],
+      custom: {}
+    }
+  };
+  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;
+        }
+      }
+    },
+    flush(controller) {
+      message = appendOrUpdateFinish(message);
+      controller.enqueue(message);
+    }
+  });
+  return createAsyncIterableStream(stream.readable, 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" }
+    };
+  } else {
+    contentParts = contentParts.slice(0, -1);
+    contentPart = {
+      type: "text",
+      text: contentPart.text + textDelta,
+      status: { type: "running" }
+    };
+  }
+  return {
+    ...message,
+    content: contentParts.concat([contentPart])
+  };
+};
+var appendToolCall = (message, toolCallId, toolName) => {
+  return {
+    ...message,
+    content: [
+      ...message.content,
+      {
+        type: "tool-call",
+        toolCallId,
+        toolName,
+        argsText: "",
+        args: {},
+        status: { type: "running", isArgsComplete: false }
+      }
+    ]
+  };
+};
+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;
+  return {
+    ...message,
+    content: [
+      ...message.content.slice(0, contentPartIdx),
+      {
+        ...contentPart,
+        argsText: newArgsText,
+        args: parsePartialJson(newArgsText)
+      },
+      ...message.content.slice(contentPartIdx + 1)
+    ]
+  };
+};
+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.`
+    );
+  return {
+    ...message,
+    content: newContentParts
+  };
+};
+var appendOrUpdateFinish = (message) => {
+  return {
+    ...message,
+    status: {
+      type: "complete",
+      reason: "unknown"
+    }
+  };
+};
+
+export {
+  AssistantStream,
+  generateId,
+  createAssistantRun,
+  DataStreamEncoder,
+  DataStreamDecoder,
+  PlainTextEncoder,
+  PlainTextDecoder,
+  toAssistantMessageStream
+};
+//# sourceMappingURL=chunk-7CCRZC5D.mjs.map