@xsai/stream-text 0.3.0-beta.8 → 0.3.0

package/dist/index.d.ts

@@ -1,85 +1,40 @@
-import { ToolMessagePart, FinishReason, Usage, ToolCall, ChatOptions, AssistantMessage, Message, CompletionStepType, CompletionToolCall, CompletionToolResult } from '@xsai/shared-chat';
+import { CompletionToolCall, CompletionToolResult, FinishReason, Usage, ChatOptions, CompletionStep, Message } from '@xsai/shared-chat';
 
-type StreamTextEvent = {
+type StreamTextEvent = (CompletionToolCall & {
+    type: 'tool-call';
+}) | (CompletionToolResult & {
+    type: 'tool-result';
+}) | {
+    argsTextDelta: string;
+    toolCallId: string;
+    toolName: string;
+    type: 'tool-call-delta';
+} | {
     error: unknown;
     type: 'error';
 } | {
-    error?: unknown;
-    id: string;
-    result?: string | ToolMessagePart[];
-    type: 'tool-call-result';
-} | {
-    finishReason?: FinishReason;
+    finishReason: FinishReason;
     type: 'finish';
     usage?: Usage;
-} | {
-    reasoning: string;
-    type: 'reasoning';
-} | {
-    refusal: string;
-    type: 'refusal';
 } | {
     text: string;
     type: 'text-delta';
 } | {
-    toolCall: ToolCall;
-    type: 'tool-call';
-} | {
-    toolCall: ToolCall;
-    type: 'tool-call-delta';
+    toolCallId: string;
+    toolName: string;
+    type: 'tool-call-streaming-start';
 };
 
-interface StreamTextChunkResult {
-    choices: {
-        delta: {
-            content?: string;
-            refusal?: string;
-            role: 'assistant';
-            tool_calls?: ToolCall[];
-        };
-        finish_reason?: FinishReason;
-        index: number;
-    }[];
-    created: number;
-    id: string;
-    model: string;
-    object: 'chat.completion.chunk';
-    system_fingerprint: string;
-    usage?: Usage;
-}
-/**
- * Options for configuring the StreamText functionality.
- */
 interface StreamTextOptions extends ChatOptions {
     /** @default 1 */
     maxSteps?: number;
-    /**
-     * Callback function that is called with each chunk of the stream.
-     * @param chunk - The current chunk of the stream.
-     */
-    onChunk?: (chunk: StreamTextChunkResult) => Promise<unknown> | unknown;
-    /**
-     * Callback function that is called with each event of the stream.
-     * @param event - The current event of the stream.
-     */
     onEvent?: (event: StreamTextEvent) => Promise<unknown> | unknown;
-    /**
-     * Callback function that is called when the stream is finished.
-     * @param result - The final result of the stream.
-     */
-    onFinish?: (steps: StreamTextStep[]) => Promise<unknown> | unknown;
-    /**
-     * Callback function that is called when a step in the stream is finished.
-     * @param step - The result of the finished step.
-     */
-    onStepFinish?: (step: StreamTextStep) => Promise<unknown> | unknown;
+    onFinish?: (step?: CompletionStep) => Promise<unknown> | unknown;
+    onStepFinish?: (step: CompletionStep) => Promise<unknown> | unknown;
     /**
      * If you want to disable stream, use `@xsai/generate-{text,object}`.
      */
     stream?: never;
-    /**
-     * Options for configuring the stream.
-     */
     streamOptions?: {
         /**
          * Return usage.
@@ -89,39 +44,12 @@ interface StreamTextOptions extends ChatOptions {
     };
 }
 interface StreamTextResult {
-    chunkStream: ReadableStream<StreamTextChunkResult>;
-    stepStream: ReadableStream<StreamTextStep>;
+    fullStream: ReadableStream<StreamTextEvent>;
+    messages: Promise<Message[]>;
+    steps: Promise<CompletionStep[]>;
     textStream: ReadableStream<string>;
-}
-interface StreamTextStep {
-    choices: StreamTextChoice[];
-    finishReason: FinishReason;
-    messages: Message[];
-    stepType: CompletionStepType;
-    toolCalls: CompletionToolCall[];
-    toolResults: CompletionToolResult[];
-    usage?: Usage;
-}
-/** @internal */
-interface StreamTextChoice {
-    finishReason?: FinishReason | null;
-    index: number;
-    message: StreamTextMessage;
-}
-/** @internal */
-interface StreamTextMessage extends Omit<AssistantMessage, 'tool_calls'> {
-    content?: string;
-    toolCalls?: {
-        [id: number]: StreamTextToolCall;
-    };
-}
-/** @internal */
-interface StreamTextToolCall extends ToolCall {
-    function: ToolCall['function'] & {
-        parsedArguments: Record<string, unknown>;
-    };
-    index: number;
+    usage: Promise<undefined | Usage>;
 }
 declare const streamText: (options: StreamTextOptions) => Promise<StreamTextResult>;
 
-export { type StreamTextChunkResult, type StreamTextEvent, type StreamTextOptions, type StreamTextResult, type StreamTextStep, streamText };
+export { type StreamTextOptions, type StreamTextResult, streamText };

package/dist/index.js

@@ -1,20 +1,52 @@
 import { chat, executeTool, determineStepType } from '@xsai/shared-chat';
-import { o as objCamelToSnake } from './case-PdS00lUs.js';
 
-class XSAIError extends Error {
-  response;
-  constructor(message, response) {
-    super(message);
-    this.name = "XSAIError";
-    this.response = response;
+const strCamelToSnake = (str) => str.replace(/[A-Z]/g, (s) => `_${s.toLowerCase()}`);
+const objCamelToSnake = (obj) => Object.fromEntries(Object.entries(obj).map(([k, v]) => [strCamelToSnake(k), v]));
+
+const trampoline = async (fn) => {
+  let result = await fn();
+  while (result instanceof Function)
+    result = await result();
+  return result;
+};
+
+class DelayedPromise {
+  get promise() {
+    if (this._promise == null) {
+      this._promise = new Promise((resolve, reject) => {
+        if (this.status.type === "resolved") {
+          resolve(this.status.value);
+        } else if (this.status.type === "rejected") {
+          reject(this.status.error);
+        }
+        this._resolve = resolve;
+        this._reject = reject;
+      });
+    }
+    return this._promise;
+  }
+  _promise;
+  _reject;
+  _resolve;
+  status = { type: "pending" };
+  reject(error) {
+    this.status = { error, type: "rejected" };
+    if (this._promise) {
+      this._reject?.(error);
+    }
+  }
+  resolve(value) {
+    this.status = { type: "resolved", value };
+    if (this._promise) {
+      this._resolve?.(value);
+    }
   }
 }
 
-const CHUNK_HEADER_PREFIX = "data:";
 const parseChunk = (text) => {
-  if (!text || !text.startsWith(CHUNK_HEADER_PREFIX))
+  if (!text || !text.startsWith("data:"))
     return [void 0, false];
-  const content = text.slice(CHUNK_HEADER_PREFIX.length);
+  const content = text.slice("data:".length);
   const data = content.startsWith(" ") ? content.slice(1) : content;
   if (data === "[DONE]") {
     return [void 0, true];
@@ -25,258 +57,166 @@ const parseChunk = (text) => {
   const chunk = JSON.parse(data);
   return [chunk, false];
 };
+const transformChunk = () => {
+  const decoder = new TextDecoder();
+  let buffer = "";
+  return new TransformStream({
+    transform: async (chunk, controller) => {
+      const text = decoder.decode(chunk, { stream: true });
+      buffer += text;
+      const lines = buffer.split("\n");
+      buffer = lines.pop() ?? "";
+      for (const line of lines) {
+        try {
+          const [chunk2, isEnd] = parseChunk(line);
+          if (isEnd)
+            break;
+          if (chunk2) {
+            controller.enqueue(chunk2);
+          }
+        } catch (error) {
+          controller.error(error);
+        }
+      }
+    }
+  });
+};
 
 const streamText = async (options) => {
-  let chunkCtrl;
-  let stepCtrl;
-  let textCtrl;
-  const chunkStream = new ReadableStream({
-    start: (controller) => chunkCtrl = controller
-  });
-  const stepStream = new ReadableStream({
-    start: (controller) => stepCtrl = controller
-  });
-  const textStream = new ReadableStream({
-    start: (controller) => textCtrl = controller
-  });
-  const maxSteps = options.maxSteps ?? 1;
-  const decoder = new TextDecoder();
   const steps = [];
-  const stepOne = async (options2) => {
-    const step = {
-      choices: [],
-      finishReason: "error",
-      messages: structuredClone(options2.messages),
-      stepType: "initial",
-      toolCalls: [],
-      toolResults: []
+  const messages = structuredClone(options.messages);
+  const maxSteps = options.maxSteps ?? 1;
+  let usage;
+  const resultSteps = new DelayedPromise();
+  const resultMessages = new DelayedPromise();
+  const resultUsage = new DelayedPromise();
+  let eventCtrl;
+  let textCtrl;
+  const eventStream = new ReadableStream({ start: (controller) => eventCtrl = controller });
+  const textStream = new ReadableStream({ start: (controller) => textCtrl = controller });
+  const pushEvent = (stepEvent) => {
+    eventCtrl?.enqueue(stepEvent);
+    void options.onEvent?.(stepEvent);
+  };
+  const pushStep = (step) => {
+    steps.push(step);
+    void options.onStepFinish?.(step);
+  };
+  const startStream = async () => {
+    const pushUsage = (u) => {
+      usage = u;
     };
-    const choiceState = {};
-    let buffer = "";
-    let finishReason;
-    let usage;
-    let shouldOutputText = true;
-    const endToolCallByIndex = (state, idx) => {
-      if (state.endedToolCallIndex.has(idx)) {
-        return;
-      }
-      state.endedToolCallIndex.add(idx);
-      state.currentToolIndex = null;
+    let text = "";
+    const pushText = (content) => {
+      textCtrl?.enqueue(content);
+      text += content;
     };
+    const tool_calls = [];
+    const toolCalls = [];
+    const toolResults = [];
+    let finishReason = "other";
     await chat({
-      ...options2,
+      ...options,
       maxSteps: void 0,
+      messages,
       stream: true,
-      streamOptions: options2.streamOptions != null ? objCamelToSnake(options2.streamOptions) : void 0
+      streamOptions: options.streamOptions != null ? objCamelToSnake(options.streamOptions) : void 0
     }).then(
-      async (res) => res.body.pipeThrough(new TransformStream({
-        transform: async (chunk, controller) => {
-          const text = decoder.decode(chunk, { stream: true });
-          buffer += text;
-          const lines = buffer.split("\n");
-          buffer = lines.pop() ?? "";
-          for (const line of lines) {
-            try {
-              const [chunk2, isEnd] = parseChunk(line);
-              if (isEnd)
-                break;
-              if (chunk2) {
-                controller.enqueue(chunk2);
-              }
-            } catch (error) {
-              controller.error(error);
-            }
-          }
-        }
-      })).pipeTo(new WritableStream({
+      async (res) => res.body.pipeThrough(transformChunk()).pipeTo(new WritableStream({
         abort: (reason) => {
-          chunkCtrl.error(reason);
-          stepCtrl.error(reason);
-          textCtrl.error(reason);
+          eventCtrl?.error(reason);
+          textCtrl?.error(reason);
         },
         close: () => {
-          options2.onEvent?.({
-            finishReason,
-            type: "finish",
-            usage
-          });
         },
-        // eslint-disable-next-line sonarjs/cognitive-complexity
-        write: async (chunk) => {
-          options2.onChunk?.(chunk);
-          chunkCtrl.enqueue(chunk);
-          usage = chunk.usage;
+        write: (chunk) => {
+          if (chunk.usage)
+            pushUsage(chunk.usage);
           if (chunk.choices == null || chunk.choices.length === 0)
             return;
           const choice = chunk.choices[0];
-          if (choice.delta.tool_calls) {
-            shouldOutputText = false;
-          }
-          const { delta, finish_reason, index, ...rest } = choice;
-          const choiceSnapshot = step.choices[index] ??= {
-            finishReason: finish_reason,
-            index,
-            message: {
-              role: "assistant"
-            }
-          };
-          if (finish_reason !== void 0) {
-            finishReason = finish_reason;
-            step.finishReason = finish_reason;
-            choiceSnapshot.finishReason = finish_reason;
-            if (finish_reason === "length") {
-              throw new XSAIError("length exceeded");
+          if (choice.finish_reason != null)
+            finishReason = choice.finish_reason;
+          if (choice.delta.tool_calls?.length === 0 || choice.delta.tool_calls == null) {
+            if (choice.delta.content != null) {
+              pushEvent({ text: choice.delta.content, type: "text-delta" });
+              pushText(choice.delta.content);
+            } else if (choice.delta.refusal != null) {
+              pushEvent({ error: choice.delta.refusal, type: "error" });
+            } else if (choice.finish_reason != null) {
+              pushEvent({ finishReason: choice.finish_reason, type: "finish", usage });
             }
-            if (finish_reason === "content_filter") {
-              throw new XSAIError("content filter");
-            }
-          }
-          Object.assign(choiceSnapshot, rest);
-          const { content, refusal, tool_calls, ...rests } = delta;
-          const message = choiceSnapshot.message;
-          Object.assign(message, rests);
-          if (refusal !== void 0) {
-            message.refusal = (message.refusal || "") + (refusal || "");
-            options2.onEvent?.({
-              refusal: message.refusal,
-              type: "refusal"
-            });
-          }
-          if (content !== void 0) {
-            message.content = (message.content || "") + (content || "");
-            shouldOutputText && textCtrl?.enqueue(content);
-            options2.onEvent?.({
-              text: content,
-              type: "text-delta"
-            });
-          }
-          for (const tool_call of tool_calls || []) {
-            options2.onEvent?.({
-              toolCall: tool_call,
-              type: "tool-call-delta"
-            });
-            const { function: fn, id, index: index2, type } = tool_call;
-            message.toolCalls ??= {};
-            const toolCall = message.toolCalls[index2] ??= {
-              function: {
-                arguments: "",
-                name: fn.name,
-                parsedArguments: {}
-              },
-              id,
-              index: index2,
-              type
-            };
-            toolCall.function.arguments += fn.arguments;
-          }
-          const state = choiceState[index] ??= {
-            calledToolCallIndex: /* @__PURE__ */ new Set(),
-            currentToolIndex: null,
-            endedToolCallIndex: /* @__PURE__ */ new Set(),
-            index,
-            toolCallErrors: {},
-            toolCallResults: {}
-          };
-          if (finish_reason) {
-            if (state.currentToolIndex !== null) {
-              endToolCallByIndex(state, state.currentToolIndex);
-            }
-          }
-          for (const toolCall of delta.tool_calls || []) {
-            if (state.currentToolIndex !== toolCall.index && state.currentToolIndex !== null) {
-              endToolCallByIndex(state, state.currentToolIndex);
+          } else {
+            for (const toolCall of choice.delta.tool_calls) {
+              const { index } = toolCall;
+              if (!tool_calls.at(index)) {
+                tool_calls[index] = toolCall;
+                pushEvent({ toolCallId: toolCall.id, toolName: toolCall.function.name, type: "tool-call-streaming-start" });
+              } else {
+                tool_calls[index].function.arguments += toolCall.function.arguments;
+                pushEvent({ argsTextDelta: toolCall.function.arguments, toolCallId: toolCall.id, toolName: toolCall.function.name, type: "tool-call-delta" });
+              }
             }
-            state.calledToolCallIndex.add(toolCall.index);
-            state.currentToolIndex = toolCall.index;
           }
         }
       }))
     );
-    step.messages.push({
-      content: step.choices[0]?.message.content ?? "",
-      refusal: step.choices[0]?.message.refusal,
-      role: "assistant",
-      tool_calls: Object.values(step.choices[0]?.message.toolCalls ?? {}).map((toolCall) => ({
-        function: {
-          arguments: toolCall.function.arguments,
-          name: toolCall.function.name
-        },
-        id: toolCall.id,
-        index: toolCall.index,
-        type: toolCall.type
-      }))
-    });
-    await Promise.allSettled(step.choices.map(async (choice) => {
-      const state = choiceState[choice.index];
-      return Promise.allSettled([...state.endedToolCallIndex].map(async (idx) => {
-        const toolCall = choice.message.toolCalls[idx];
-        step.toolCalls.push({
-          args: toolCall.function.arguments,
-          toolCallId: toolCall.id,
-          toolCallType: "function",
-          toolName: toolCall.function.name
-        });
-        if (state.toolCallResults[toolCall.id]) {
-          return;
-        }
-        options2.onEvent?.({
+    messages.push({ content: text, role: "assistant", tool_calls });
+    if (tool_calls.length !== 0) {
+      for (const toolCall of tool_calls) {
+        const { completionToolCall, completionToolResult, message } = await executeTool({
+          abortSignal: options.abortSignal,
+          messages,
           toolCall,
-          type: "tool-call"
+          tools: options.tools
         });
-        try {
-          const { completionToolResult, message, parsedArgs, result } = await executeTool({
-            abortSignal: options2.abortSignal,
-            messages: options2.messages,
-            toolCall,
-            tools: options2.tools
-          });
-          toolCall.function.parsedArguments = parsedArgs;
-          state.toolCallResults[toolCall.id] = result;
-          step.messages.push(message);
-          step.toolResults.push(completionToolResult);
-          options2.onEvent?.({
-            id: toolCall.id,
-            result,
-            type: "tool-call-result"
-          });
-        } catch (error) {
-          state.toolCallErrors[idx] = error;
-        }
-      }));
-    }));
-    step.stepType = determineStepType({
-      finishReason: step.finishReason,
-      maxSteps,
-      stepsLength: steps.length,
-      toolCallsLength: step.toolCalls.length
-    });
-    steps.push(step);
-    stepCtrl.enqueue(step);
-    options2.onStepFinish?.(step);
-    if (shouldOutputText) {
-      return;
+        toolCalls.push(completionToolCall);
+        toolResults.push(completionToolResult);
+        messages.push(message);
+        pushEvent({ ...completionToolCall, type: "tool-call" });
+        pushEvent({ ...completionToolResult, type: "tool-result" });
+      }
+    } else {
+      pushEvent({
+        finishReason,
+        type: "finish",
+        usage
+      });
     }
-    return async () => stepOne({ ...options2, messages: step.messages });
+    pushStep({
+      finishReason,
+      stepType: determineStepType({ finishReason, maxSteps, stepsLength: steps.length, toolCallsLength: toolCalls.length }),
+      text,
+      toolCalls,
+      toolResults,
+      usage
+    });
+    if (toolCalls.length !== 0 && steps.length < maxSteps)
+      return async () => startStream();
   };
-  const invokeFunctionCalls = async () => {
-    let ret = await stepOne(options);
-    while (typeof ret === "function" && steps.length < maxSteps)
-      ret = await ret();
-    options.onFinish?.(steps);
-    chunkCtrl.close();
-    stepCtrl.close();
-    textCtrl.close();
+  try {
+    await trampoline(async () => startStream());
+  } catch (err) {
+    eventCtrl?.error(err);
+    textCtrl?.error(err);
+    resultSteps.reject(err);
+    resultMessages.reject(err);
+    resultUsage.reject(err);
+  } finally {
+    eventCtrl?.close();
+    textCtrl?.close();
+    resultSteps.resolve(steps);
+    resultMessages.resolve(messages);
+    resultUsage.resolve(usage);
+    void options.onFinish?.(steps.at(-1));
+  }
+  return {
+    fullStream: eventStream,
+    messages: resultMessages.promise,
+    steps: resultSteps.promise,
+    textStream,
+    usage: resultUsage.promise
   };
-  void invokeFunctionCalls().catch((error) => {
-    chunkCtrl.error(error);
-    stepCtrl.error(error);
-    textCtrl.error(error);
-  });
-  return Promise.resolve({
-    chunkStream,
-    stepStream,
-    textStream
-  });
 };
 
 export { streamText };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@xsai/stream-text",
   "type": "module",
-  "version": "0.3.0-beta.8",
+  "version": "0.3.0",
   "description": "extra-small AI SDK.",
   "author": "Moeru AI",
   "license": "MIT",
@@ -23,22 +23,18 @@
       "types": "./dist/index.d.ts",
       "default": "./dist/index.js"
     },
-    "./experimental": {
-      "types": "./dist/experimental/index.d.ts",
-      "default": "./dist/experimental/index.js"
-    },
     "./package.json": "./package.json"
   },
   "files": [
     "dist"
   ],
   "dependencies": {
-    "@xsai/shared-chat": "~0.3.0-beta.8"
+    "@xsai/shared-chat": "~0.3.0"
   },
   "devDependencies": {
     "valibot": "^1.0.0",
-    "@xsai/shared": "~0.3.0-beta.8",
-    "@xsai/tool": "~0.3.0-beta.8"
+    "@xsai/shared": "~0.3.0",
+    "@xsai/tool": "~0.3.0"
   },
   "scripts": {
     "build": "pkgroll",

package/dist/case-PdS00lUs.js

@@ -1,4 +0,0 @@
-const strCamelToSnake = (str) => str.replace(/[A-Z]/g, (s) => `_${s.toLowerCase()}`);
-const objCamelToSnake = (obj) => Object.fromEntries(Object.entries(obj).map(([k, v]) => [strCamelToSnake(k), v]));
-
-export { objCamelToSnake as o };

package/dist/experimental/index.d.ts

@@ -1,55 +0,0 @@
-import { CompletionToolCall, CompletionToolResult, FinishReason, Usage, ChatOptions, CompletionStep, Message } from '@xsai/shared-chat';
-
-type StreamTextEvent = (CompletionToolCall & {
-    type: 'tool-call';
-}) | (CompletionToolResult & {
-    type: 'tool-result';
-}) | {
-    argsTextDelta: string;
-    toolCallId: string;
-    toolName: string;
-    type: 'tool-call-delta';
-} | {
-    error: unknown;
-    type: 'error';
-} | {
-    finishReason: FinishReason;
-    type: 'finish';
-    usage?: Usage;
-} | {
-    text: string;
-    type: 'text-delta';
-} | {
-    toolCallId: string;
-    toolName: string;
-    type: 'tool-call-streaming-start';
-};
-
-interface StreamTextOptions extends ChatOptions {
-    /** @default 1 */
-    maxSteps?: number;
-    onEvent?: (event: StreamTextEvent) => Promise<unknown> | unknown;
-    onFinish?: (step?: CompletionStep) => Promise<unknown> | unknown;
-    onStepFinish?: (step: CompletionStep) => Promise<unknown> | unknown;
-    /**
-     * If you want to disable stream, use `@xsai/generate-{text,object}`.
-     */
-    stream?: never;
-    streamOptions?: {
-        /**
-         * Return usage.
-         * @default `undefined`
-         */
-        includeUsage?: boolean;
-    };
-}
-interface StreamTextResult {
-    fullStream: ReadableStream<StreamTextEvent>;
-    messages: Promise<Message[]>;
-    steps: Promise<CompletionStep[]>;
-    textStream: ReadableStream<string>;
-    usage: Promise<undefined | Usage>;
-}
-declare const streamText: (options: StreamTextOptions) => Promise<StreamTextResult>;
-
-export { type StreamTextOptions, type StreamTextResult, streamText };

package/dist/experimental/index.js

@@ -1,215 +0,0 @@
-import { chat, executeTool, determineStepType } from '@xsai/shared-chat';
-import { o as objCamelToSnake } from '../case-PdS00lUs.js';
-
-const trampoline = async (fn) => {
-  let result = await fn();
-  while (result instanceof Function)
-    result = await result();
-  return result;
-};
-
-const parseChunk = (text) => {
-  if (!text || !text.startsWith("data:"))
-    return [void 0, false];
-  const content = text.slice("data:".length);
-  const data = content.startsWith(" ") ? content.slice(1) : content;
-  if (data === "[DONE]") {
-    return [void 0, true];
-  }
-  if (data.startsWith("{") && data.includes('"error":')) {
-    throw new Error(`Error from server: ${data}`);
-  }
-  const chunk = JSON.parse(data);
-  return [chunk, false];
-};
-const transformChunk = () => {
-  const decoder = new TextDecoder();
-  let buffer = "";
-  return new TransformStream({
-    transform: async (chunk, controller) => {
-      const text = decoder.decode(chunk, { stream: true });
-      buffer += text;
-      const lines = buffer.split("\n");
-      buffer = lines.pop() ?? "";
-      for (const line of lines) {
-        try {
-          const [chunk2, isEnd] = parseChunk(line);
-          if (isEnd)
-            break;
-          if (chunk2) {
-            controller.enqueue(chunk2);
-          }
-        } catch (error) {
-          controller.error(error);
-        }
-      }
-    }
-  });
-};
-
-class DelayedPromise {
-  get promise() {
-    if (this._promise == null) {
-      this._promise = new Promise((resolve, reject) => {
-        if (this.status.type === "resolved") {
-          resolve(this.status.value);
-        } else if (this.status.type === "rejected") {
-          reject(this.status.error);
-        }
-        this._resolve = resolve;
-        this._reject = reject;
-      });
-    }
-    return this._promise;
-  }
-  _promise;
-  _reject;
-  _resolve;
-  status = { type: "pending" };
-  reject(error) {
-    this.status = { error, type: "rejected" };
-    if (this._promise) {
-      this._reject?.(error);
-    }
-  }
-  resolve(value) {
-    this.status = { type: "resolved", value };
-    if (this._promise) {
-      this._resolve?.(value);
-    }
-  }
-}
-
-const streamText = async (options) => {
-  const steps = [];
-  const messages = structuredClone(options.messages);
-  const maxSteps = options.maxSteps ?? 1;
-  let usage;
-  const resultSteps = new DelayedPromise();
-  const resultMessages = new DelayedPromise();
-  const resultUsage = new DelayedPromise();
-  let eventCtrl;
-  let textCtrl;
-  const eventStream = new ReadableStream({ start: (controller) => eventCtrl = controller });
-  const textStream = new ReadableStream({ start: (controller) => textCtrl = controller });
-  const pushEvent = (stepEvent) => {
-    eventCtrl?.enqueue(stepEvent);
-    void options.onEvent?.(stepEvent);
-  };
-  const pushStep = (step) => {
-    steps.push(step);
-    void options.onStepFinish?.(step);
-  };
-  const startStream = async () => {
-    const pushUsage = (u) => {
-      usage = u;
-    };
-    let text = "";
-    const pushText = (content) => {
-      textCtrl?.enqueue(content);
-      text += content;
-    };
-    const tool_calls = [];
-    const toolCalls = [];
-    const toolResults = [];
-    let finishReason = "other";
-    await chat({
-      ...options,
-      maxSteps: void 0,
-      messages,
-      stream: true,
-      streamOptions: options.streamOptions != null ? objCamelToSnake(options.streamOptions) : void 0
-    }).then(
-      async (res) => res.body.pipeThrough(transformChunk()).pipeTo(new WritableStream({
-        abort: (reason) => {
-          eventCtrl?.error(reason);
-          textCtrl?.error(reason);
-        },
-        close: () => {
-        },
-        write: (chunk) => {
-          if (chunk.usage)
-            pushUsage(chunk.usage);
-          if (chunk.choices == null || chunk.choices.length === 0)
-            return;
-          const choice = chunk.choices[0];
-          if (choice.finish_reason != null)
-            finishReason = choice.finish_reason;
-          if (choice.delta.tool_calls?.length === 0 || choice.delta.tool_calls == null) {
-            if (choice.delta.content != null) {
-              pushEvent({ text: choice.delta.content, type: "text-delta" });
-              pushText(choice.delta.content);
-            } else if (choice.delta.refusal != null) {
-              pushEvent({ error: choice.delta.refusal, type: "error" });
-            } else if (choice.finish_reason != null) {
-              pushEvent({ finishReason: choice.finish_reason, type: "finish", usage });
-            }
-          } else {
-            for (const toolCall of choice.delta.tool_calls) {
-              const { index } = toolCall;
-              if (!tool_calls.at(index)) {
-                tool_calls[index] = toolCall;
-                pushEvent({ toolCallId: toolCall.id, toolName: toolCall.function.name, type: "tool-call-streaming-start" });
-              } else {
-                tool_calls[index].function.arguments += toolCall.function.arguments;
-                pushEvent({ argsTextDelta: toolCall.function.arguments, toolCallId: toolCall.id, toolName: toolCall.function.name, type: "tool-call-delta" });
-              }
-            }
-          }
-        }
-      }))
-    );
-    if (tool_calls.length !== 0) {
-      for (const toolCall of tool_calls) {
-        const { completionToolCall, completionToolResult, message } = await executeTool({
-          abortSignal: options.abortSignal,
-          messages,
-          toolCall,
-          tools: options.tools
-        });
-        pushEvent({ ...completionToolCall, type: "tool-call" });
-        pushEvent({ ...completionToolResult, type: "tool-result" });
-        toolCalls.push(completionToolCall);
-        toolResults.push(completionToolResult);
-        messages.push(message);
-      }
-    } else {
-      messages.push({ content: text, role: "assistant" });
-    }
-    pushStep({
-      finishReason,
-      stepType: determineStepType({ finishReason, maxSteps, stepsLength: steps.length, toolCallsLength: toolCalls.length }),
-      text,
-      toolCalls,
-      toolResults,
-      usage
-    });
-    if (toolCalls.length !== 0 && steps.length < maxSteps)
-      return async () => startStream();
-  };
-  try {
-    await trampoline(async () => startStream());
-  } catch (err) {
-    eventCtrl?.error(err);
-    textCtrl?.error(err);
-    resultSteps.reject(err);
-    resultMessages.reject(err);
-    resultUsage.reject(err);
-  } finally {
-    eventCtrl?.close();
-    textCtrl?.close();
-    resultSteps.resolve(steps);
-    resultMessages.resolve(messages);
-    resultUsage.resolve(usage);
-    void options.onFinish?.(steps.at(-1));
-  }
-  return {
-    fullStream: eventStream,
-    messages: resultMessages.promise,
-    steps: resultSteps.promise,
-    textStream,
-    usage: resultUsage.promise
-  };
-};
-
-export { streamText };