assistant-stream 0.1.5 → 0.1.7

package/dist/index.mjs

@@ -1,958 +1,3 @@
-import {
-  AssistantMetaTransformStream,
-  AssistantStream,
-  AssistantTransformStream,
-  DataStreamDecoder,
-  DataStreamEncoder,
-  PipeableTransformStream,
-  createAssistantStream,
-  createAssistantStreamResponse,
-  generateId,
-  promiseWithResolvers
-} from "./chunk-EDE6WQ2R.mjs";
-import {
-  getPartialJsonObjectFieldState,
-  parsePartialJsonObject
-} from "./chunk-PQLDKUPN.mjs";
-
-// 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;
-    }
-  };
-};
-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;
-      }
-    };
-  } 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, (part) => {
-    if (part.type !== "tool-call") {
-      throw new Error("Last is not a tool call");
-    }
-    return {
-      ...part,
-      state: "call"
-    };
-  });
-};
-var handlePartFinish = (message, chunk) => {
-  return updatePartForPath(message, chunk, (part) => ({
-    ...part,
-    status: { type: "complete", reason: "unknown" }
-  }));
-};
-var handleTextDelta = (message, chunk) => {
-  return updatePartForPath(message, chunk, (part) => {
-    if (part.type === "text" || part.type === "reasoning") {
-      return { ...part, text: part.text + chunk.textDelta };
-    } else if (part.type === "tool-call") {
-      const newArgsText = part.argsText + chunk.textDelta;
-      const newArgs = parsePartialJsonObject(newArgsText) ?? part.args;
-      return { ...part, argsText: newArgsText, args: newArgs };
-    } else {
-      throw new Error(
-        "text-delta received but part is neither text nor tool-call"
-      );
-    }
-  });
-};
-var handleResult = (message, chunk) => {
-  return updatePartForPath(message, chunk, (part) => {
-    if (part.type === "tool-call") {
-      return {
-        ...part,
-        state: "result",
-        artifact: chunk.artifact,
-        result: chunk.result,
-        isError: chunk.isError ?? false,
-        status: { type: "complete", reason: "stop" }
-      };
-    } else {
-      throw new Error("Result chunk received but 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 {
-    return {
-      type: "incomplete",
-      reason: chunk.finishReason
-    };
-  }
-};
-var handleAnnotations = (message, chunk) => {
-  return {
-    ...message,
-    metadata: {
-      ...message.metadata,
-      unstable_annotations: [
-        ...message.metadata.unstable_annotations,
-        ...chunk.annotations
-      ]
-    }
-  };
-};
-var handleData = (message, chunk) => {
-  return {
-    ...message,
-    metadata: {
-      ...message.metadata,
-      unstable_data: [...message.metadata.unstable_data, ...chunk.data]
-    }
-  };
-};
-var handleStepStart = (message, chunk) => {
-  return {
-    ...message,
-    metadata: {
-      ...message.metadata,
-      steps: [
-        ...message.metadata.steps,
-        { state: "started", messageId: chunk.messageId }
-      ]
-    }
-  };
-};
-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,
-    metadata: {
-      ...message.metadata,
-      steps
-    }
-  };
-};
-var handleErrorChunk = (message, chunk) => {
-  return {
-    ...message,
-    status: { type: "incomplete", reason: "error", error: chunk.error }
-  };
-};
-var AssistantMessageAccumulator = class extends TransformStream {
-  constructor({
-    initialMessage
-  } = {}) {
-    let message = initialMessage ?? createInitialMessage();
-    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);
-      },
-      flush(controller) {
-        if (message.status?.type === "running") {
-          const requiresAction = message.parts?.at(-1)?.type === "tool-call";
-          message = handleMessageFinish(message, {
-            type: "message-finish",
-            path: [],
-            finishReason: requiresAction ? "tool-calls" : "unknown",
-            usage: {
-              promptTokens: 0,
-              completionTokens: 0
-            }
-          });
-          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 {
-  constructor(readable) {
-    this.readable = readable;
-    this.readable = readable;
-  }
-  static fromAssistantStream(stream) {
-    return new _AssistantMessageStream(
-      stream.pipeThrough(new AssistantMessageAccumulator())
-    );
-  }
-  async unstable_result() {
-    let last;
-    for await (const chunk of this) {
-      last = chunk;
-    }
-    if (!last) {
-      return {
-        role: "assistant",
-        status: { type: "complete", reason: "unknown" },
-        parts: [],
-        content: [],
-        metadata: {
-          unstable_data: [],
-          unstable_annotations: [],
-          steps: [],
-          custom: {}
-        }
-      };
-    }
-    return last;
-  }
-  [Symbol.asyncIterator]() {
-    const reader = this.readable.getReader();
-    return {
-      async next() {
-        const { done, value } = await reader.read();
-        return done ? { done: true, value: void 0 } : { done: false, value };
-      }
-    };
-  }
-  tee() {
-    const [readable1, readable2] = this.readable.tee();
-    return [
-      new _AssistantMessageStream(readable1),
-      new _AssistantMessageStream(readable2)
-    ];
-  }
-};
-
-// src/core/tool/ToolResponse.ts
-var TOOL_RESPONSE_SYMBOL = Symbol.for("aui.tool-response");
-var ToolResponse = class {
-  get [TOOL_RESPONSE_SYMBOL]() {
-    return true;
-  }
-  artifact;
-  result;
-  isError;
-  constructor(options) {
-    this.artifact = options.artifact;
-    this.result = options.result;
-    this.isError = options.isError ?? false;
-  }
-  static [Symbol.hasInstance](obj) {
-    return typeof obj === "object" && obj !== null && TOOL_RESPONSE_SYMBOL in obj;
-  }
-};
-
-// src/core/tool/ToolExecutionStream.ts
-import sjson from "secure-json-parse";
-
-// src/core/utils/withPromiseOrValue.ts
-function withPromiseOrValue(callback, thenHandler, catchHandler) {
-  try {
-    const promiseOrValue = callback();
-    if (typeof promiseOrValue === "object" && promiseOrValue !== null && "then" in promiseOrValue) {
-      return promiseOrValue.then(thenHandler, catchHandler);
-    } else {
-      thenHandler(promiseOrValue);
-    }
-  } catch (e) {
-    catchHandler(e);
-  }
-}
-
-// src/core/tool/ToolCallReader.ts
-function getField(obj, fieldPath) {
-  let current = obj;
-  for (const key of fieldPath) {
-    if (current === void 0 || current === null) {
-      return void 0;
-    }
-    current = current[key];
-  }
-  return current;
-}
-var GetHandle = class {
-  resolve;
-  reject;
-  disposed = false;
-  fieldPath;
-  constructor(resolve, reject, fieldPath) {
-    this.resolve = resolve;
-    this.reject = reject;
-    this.fieldPath = fieldPath;
-  }
-  update(args) {
-    if (this.disposed) return;
-    try {
-      if (getPartialJsonObjectFieldState(
-        args,
-        this.fieldPath
-      ) === "complete") {
-        const value = getField(args, this.fieldPath);
-        if (value !== void 0) {
-          this.resolve(value);
-          this.dispose();
-        }
-      }
-    } catch (e) {
-      this.reject(e);
-      this.dispose();
-    }
-  }
-  dispose() {
-    this.disposed = true;
-  }
-};
-var StreamValuesHandle = class {
-  controller;
-  disposed = false;
-  fieldPath;
-  constructor(controller, fieldPath) {
-    this.controller = controller;
-    this.fieldPath = fieldPath;
-  }
-  update(args) {
-    if (this.disposed) return;
-    try {
-      const value = getField(args, this.fieldPath);
-      if (value !== void 0) {
-        this.controller.enqueue(value);
-      }
-      if (getPartialJsonObjectFieldState(
-        args,
-        this.fieldPath
-      ) === "complete") {
-        this.controller.close();
-        this.dispose();
-      }
-    } catch (e) {
-      this.controller.error(e);
-      this.dispose();
-    }
-  }
-  dispose() {
-    this.disposed = true;
-  }
-};
-var StreamTextHandle = class {
-  controller;
-  disposed = false;
-  fieldPath;
-  lastValue = void 0;
-  constructor(controller, fieldPath) {
-    this.controller = controller;
-    this.fieldPath = fieldPath;
-  }
-  update(args) {
-    if (this.disposed) return;
-    try {
-      const value = getField(args, this.fieldPath);
-      if (value !== void 0 && typeof value === "string") {
-        const delta = value.substring(this.lastValue?.length || 0);
-        this.lastValue = value;
-        this.controller.enqueue(delta);
-      }
-      if (getPartialJsonObjectFieldState(
-        args,
-        this.fieldPath
-      ) === "complete") {
-        this.controller.close();
-        this.dispose();
-      }
-    } catch (e) {
-      this.controller.error(e);
-      this.dispose();
-    }
-  }
-  dispose() {
-    this.disposed = true;
-  }
-};
-var ForEachHandle = class {
-  controller;
-  disposed = false;
-  fieldPath;
-  processedIndexes = /* @__PURE__ */ new Set();
-  constructor(controller, fieldPath) {
-    this.controller = controller;
-    this.fieldPath = fieldPath;
-  }
-  update(args) {
-    if (this.disposed) return;
-    try {
-      const array = getField(args, this.fieldPath);
-      if (!Array.isArray(array)) {
-        return;
-      }
-      for (let i = 0; i < array.length; i++) {
-        if (!this.processedIndexes.has(i)) {
-          const elementPath = [...this.fieldPath, i];
-          if (getPartialJsonObjectFieldState(
-            args,
-            elementPath
-          ) === "complete") {
-            this.controller.enqueue(array[i]);
-            this.processedIndexes.add(i);
-          }
-        }
-      }
-      if (getPartialJsonObjectFieldState(
-        args,
-        this.fieldPath
-      ) === "complete") {
-        this.controller.close();
-        this.dispose();
-      }
-    } catch (e) {
-      this.controller.error(e);
-      this.dispose();
-    }
-  }
-  dispose() {
-    this.disposed = true;
-  }
-};
-var ToolCallArgsReaderImpl = class {
-  argTextDeltas;
-  handles = /* @__PURE__ */ new Set();
-  args = parsePartialJsonObject("");
-  constructor(argTextDeltas) {
-    this.argTextDeltas = argTextDeltas;
-    this.processStream();
-  }
-  async processStream() {
-    try {
-      let accumulatedText = "";
-      const reader = this.argTextDeltas.getReader();
-      while (true) {
-        const { value, done } = await reader.read();
-        if (done) break;
-        accumulatedText += value;
-        const parsedArgs = parsePartialJsonObject(accumulatedText);
-        if (parsedArgs !== void 0) {
-          this.args = parsedArgs;
-          for (const handle of this.handles) {
-            handle.update(parsedArgs);
-          }
-        }
-      }
-    } catch (error) {
-      console.error("Error processing argument stream:", error);
-      for (const handle of this.handles) {
-        handle.dispose();
-      }
-    }
-  }
-  get(...fieldPath) {
-    return new Promise((resolve, reject) => {
-      const handle = new GetHandle(resolve, reject, fieldPath);
-      if (this.args && getPartialJsonObjectFieldState(
-        this.args,
-        fieldPath
-      ) === "complete") {
-        const value = getField(this.args, fieldPath);
-        if (value !== void 0) {
-          resolve(value);
-          return;
-        }
-      }
-      this.handles.add(handle);
-      handle.update(this.args);
-    });
-  }
-  streamValues(...fieldPath) {
-    const simplePath = fieldPath;
-    const stream = new ReadableStream({
-      start: (controller) => {
-        const handle = new StreamValuesHandle(controller, simplePath);
-        this.handles.add(handle);
-        handle.update(this.args);
-      },
-      cancel: () => {
-        for (const handle of this.handles) {
-          if (handle instanceof StreamValuesHandle) {
-            handle.dispose();
-            this.handles.delete(handle);
-            break;
-          }
-        }
-      }
-    });
-    return stream;
-  }
-  streamText(...fieldPath) {
-    const simplePath = fieldPath;
-    const stream = new ReadableStream({
-      start: (controller) => {
-        const handle = new StreamTextHandle(controller, simplePath);
-        this.handles.add(handle);
-        handle.update(this.args);
-      },
-      cancel: () => {
-        for (const handle of this.handles) {
-          if (handle instanceof StreamTextHandle) {
-            handle.dispose();
-            this.handles.delete(handle);
-            break;
-          }
-        }
-      }
-    });
-    return stream;
-  }
-  forEach(...fieldPath) {
-    const simplePath = fieldPath;
-    const stream = new ReadableStream({
-      start: (controller) => {
-        const handle = new ForEachHandle(controller, simplePath);
-        this.handles.add(handle);
-        handle.update(this.args);
-      },
-      cancel: () => {
-        for (const handle of this.handles) {
-          if (handle instanceof ForEachHandle) {
-            handle.dispose();
-            this.handles.delete(handle);
-            break;
-          }
-        }
-      }
-    });
-    return stream;
-  }
-};
-var ToolCallResponseReaderImpl = class {
-  constructor(promise) {
-    this.promise = promise;
-  }
-  get() {
-    return this.promise;
-  }
-};
-var ToolCallReaderImpl = class {
-  args;
-  response;
-  writable;
-  resolve;
-  argsText = "";
-  constructor() {
-    const stream = new TransformStream();
-    this.writable = stream.writable;
-    this.args = new ToolCallArgsReaderImpl(stream.readable);
-    const { promise, resolve } = promiseWithResolvers();
-    this.resolve = resolve;
-    this.response = new ToolCallResponseReaderImpl(promise);
-  }
-  async appendArgsTextDelta(text) {
-    const writer = this.writable.getWriter();
-    try {
-      await writer.write(text);
-    } catch (err) {
-      console.warn(err);
-    } finally {
-      writer.releaseLock();
-    }
-    this.argsText += text;
-  }
-  setResponse(value) {
-    this.resolve(value);
-  }
-  result = {
-    get: async () => {
-      const response = await this.response.get();
-      return response.result;
-    }
-  };
-};
-
-// src/core/tool/ToolExecutionStream.ts
-var ToolExecutionStream = class extends PipeableTransformStream {
-  constructor(options) {
-    const toolCallPromises = /* @__PURE__ */ new Map();
-    const toolCallControllers = /* @__PURE__ */ new Map();
-    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 "part-start":
-              if (chunk.part.type === "tool-call") {
-                const reader = new ToolCallReaderImpl();
-                toolCallControllers.set(chunk.part.toolCallId, reader);
-                options.streamCall({
-                  reader,
-                  toolCallId: chunk.part.toolCallId,
-                  toolName: chunk.part.toolName
-                });
-              }
-              break;
-            case "text-delta": {
-              if (chunk.meta.type === "tool-call") {
-                const toolCallId = chunk.meta.toolCallId;
-                const controller2 = toolCallControllers.get(toolCallId);
-                if (!controller2)
-                  throw new Error("No controller found for tool call");
-                controller2.appendArgsTextDelta(chunk.textDelta);
-              }
-              break;
-            }
-            case "tool-call-args-text-finish": {
-              if (chunk.meta.type !== "tool-call") break;
-              const { toolCallId, toolName } = chunk.meta;
-              const streamController = toolCallControllers.get(toolCallId);
-              if (!streamController)
-                throw new Error("No controller found for tool call");
-              const promise = withPromiseOrValue(
-                () => {
-                  if (!streamController.argsText) {
-                    console.log(
-                      "Encountered tool call without args, this should never happen"
-                    );
-                    throw new Error(
-                      "Encountered tool call without args, this is unexpected."
-                    );
-                  }
-                  let args;
-                  try {
-                    args = sjson.parse(streamController.argsText);
-                  } catch (e) {
-                    throw new Error(
-                      `Function parameter parsing failed. ${JSON.stringify(e.message)}`
-                    );
-                  }
-                  return options.execute({
-                    toolCallId,
-                    toolName,
-                    args
-                  });
-                },
-                (c) => {
-                  if (c === void 0) return;
-                  const result = new ToolResponse({
-                    artifact: c.artifact,
-                    result: c.result,
-                    isError: c.isError
-                  });
-                  streamController.setResponse(result);
-                  controller.enqueue({
-                    type: "result",
-                    path: chunk.path,
-                    ...result
-                  });
-                },
-                (e) => {
-                  const result = new ToolResponse({
-                    result: String(e),
-                    isError: true
-                  });
-                  streamController.setResponse(result);
-                  controller.enqueue({
-                    type: "result",
-                    path: chunk.path,
-                    ...result
-                  });
-                }
-              );
-              if (promise) {
-                toolCallPromises.set(toolCallId, promise);
-              }
-              break;
-            }
-            case "part-finish": {
-              if (chunk.meta.type !== "tool-call") break;
-              const { toolCallId } = chunk.meta;
-              const toolCallPromise = toolCallPromises.get(toolCallId);
-              if (toolCallPromise) {
-                toolCallPromise.then(() => {
-                  toolCallPromises.delete(toolCallId);
-                  toolCallControllers.delete(toolCallId);
-                  controller.enqueue(chunk);
-                });
-              } else {
-                controller.enqueue(chunk);
-              }
-            }
-          }
-        },
-        async flush() {
-          await Promise.all(toolCallPromises.values());
-        }
-      });
-      return readable.pipeThrough(new AssistantMetaTransformStream()).pipeThrough(transform);
-    });
-  }
-};
-
-// src/core/tool/toolResultStream.ts
-var isStandardSchemaV1 = (schema) => {
-  return typeof schema === "object" && schema !== null && "~standard" in schema && schema["~standard"].version === 1;
-};
-function getToolResponse(tools, abortSignal, toolCall) {
-  const tool = tools?.[toolCall.toolName];
-  if (!tool || !tool.execute) return void 0;
-  const getResult = async (toolExecute) => {
-    let executeFn = toolExecute;
-    if (isStandardSchemaV1(tool.parameters)) {
-      let result2 = tool.parameters["~standard"].validate(toolCall.args);
-      if (result2 instanceof Promise) result2 = await result2;
-      if (result2.issues) {
-        executeFn = tool.experimental_onSchemaValidationError ?? (() => {
-          throw new Error(
-            `Function parameter validation failed. ${JSON.stringify(result2.issues)}`
-          );
-        });
-      }
-    }
-    const result = await executeFn(toolCall.args, {
-      toolCallId: toolCall.toolCallId,
-      abortSignal
-    });
-    if (result instanceof ToolResponse) return result;
-    return new ToolResponse({
-      result: result === void 0 ? "<no result>" : result
-    });
-  };
-  return getResult(tool.execute);
-}
-function getToolStreamResponse(tools, abortSignal, reader, context) {
-  tools?.[context.toolName]?.streamCall?.(reader, {
-    toolCallId: context.toolCallId,
-    abortSignal
-  });
-}
-async function unstable_runPendingTools(message, tools, abortSignal) {
-  for (const part of message.parts) {
-    if (part.type === "tool-call") {
-      const promiseOrUndefined = getToolResponse(tools, abortSignal, part);
-      if (promiseOrUndefined) {
-        const result = await promiseOrUndefined;
-        const updatedParts = message.parts.map((p) => {
-          if (p.type === "tool-call" && p.toolCallId === part.toolCallId) {
-            return {
-              ...p,
-              state: "result",
-              artifact: result.artifact,
-              result: result.result,
-              isError: result.isError
-            };
-          }
-          return p;
-        });
-        message = {
-          ...message,
-          parts: updatedParts,
-          content: updatedParts
-        };
-      }
-    }
-  }
-  return message;
-}
-function toolResultStream(tools, abortSignal) {
-  return new ToolExecutionStream({
-    execute: (toolCall) => getToolResponse(tools, abortSignal, toolCall),
-    streamCall: ({ reader, ...context }) => getToolStreamResponse(tools, abortSignal, reader, context)
-  });
-}
-export {
-  AssistantMessageAccumulator,
-  AssistantMessageStream,
-  AssistantStream,
-  DataStreamDecoder,
-  DataStreamEncoder,
-  PlainTextDecoder,
-  PlainTextEncoder,
-  ToolExecutionStream,
-  ToolResponse,
-  createAssistantStream,
-  createAssistantStreamResponse,
-  unstable_runPendingTools,
-  toolResultStream as unstable_toolResultStream
-};
+// src/index.ts
+export * from "./core/index.mjs";
 //# sourceMappingURL=index.mjs.map