@xsai/stream-text 0.3.0-beta.6 → 0.3.0-beta.7

package/dist/case-PdS00lUs.js

@@ -0,0 +1,4 @@
+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

@@ -0,0 +1,55 @@
+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

@@ -0,0 +1,215 @@
+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 };

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { ToolMessagePart, FinishReason, Usage, ToolCall, ChatOptions, AssistantMessage, Message, StepType, CompletionToolCall, CompletionToolResult, Tool } from '@xsai/shared-chat';
+import { ToolMessagePart, FinishReason, Usage, ToolCall, ChatOptions, AssistantMessage, Message, CompletionStepType, CompletionToolCall, CompletionToolResult } from '@xsai/shared-chat';
 
 type StreamTextEvent = {
     error: unknown;
@@ -87,10 +87,6 @@ interface StreamTextOptions extends ChatOptions {
          */
         includeUsage?: boolean;
     };
-    /**
-     * List of tools to be used in the stream.
-     */
-    tools?: Tool[];
 }
 interface StreamTextResult {
     chunkStream: ReadableStream<StreamTextChunkResult>;
@@ -101,7 +97,7 @@ interface StreamTextStep {
     choices: StreamTextChoice[];
     finishReason: FinishReason;
     messages: Message[];
-    stepType: StepType;
+    stepType: CompletionStepType;
     toolCalls: CompletionToolCall[];
     toolResults: CompletionToolResult[];
     usage?: Usage;

package/dist/index.js

@@ -1,4 +1,5 @@
 import { chat, executeTool, determineStepType } from '@xsai/shared-chat';
+import { o as objCamelToSnake } from './case-PdS00lUs.js';
 
 class XSAIError extends Error {
   response;
@@ -9,9 +10,6 @@ class XSAIError extends Error {
   }
 }
 
-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 CHUNK_HEADER_PREFIX = "data:";
 const parseChunk = (text) => {
   if (!text || !text.startsWith(CHUNK_HEADER_PREFIX))
@@ -226,7 +224,7 @@ const streamText = async (options) => {
           type: "tool-call"
         });
         try {
-          const { parsedArgs, result, toolName } = await executeTool({
+          const { completionToolResult, message, parsedArgs, result } = await executeTool({
             abortSignal: options2.abortSignal,
             messages: options2.messages,
             toolCall,
@@ -234,17 +232,8 @@ const streamText = async (options) => {
           });
           toolCall.function.parsedArguments = parsedArgs;
           state.toolCallResults[toolCall.id] = result;
-          step.messages.push({
-            content: result,
-            role: "tool",
-            tool_call_id: toolCall.id
-          });
-          step.toolResults.push({
-            args: parsedArgs,
-            result,
-            toolCallId: toolCall.id,
-            toolName
-          });
+          step.messages.push(message);
+          step.toolResults.push(completionToolResult);
           options2.onEvent?.({
             id: toolCall.id,
             result,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@xsai/stream-text",
   "type": "module",
-  "version": "0.3.0-beta.6",
+  "version": "0.3.0-beta.7",
   "description": "extra-small AI SDK.",
   "author": "Moeru AI",
   "license": "MIT",
@@ -23,18 +23,22 @@
       "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.6"
+    "@xsai/shared-chat": "~0.3.0-beta.7"
   },
   "devDependencies": {
     "valibot": "^1.0.0",
-    "@xsai/shared": "~0.3.0-beta.6",
-    "@xsai/tool": "~0.3.0-beta.6"
+    "@xsai/shared": "~0.3.0-beta.7",
+    "@xsai/tool": "~0.3.0-beta.7"
   },
   "scripts": {
     "build": "pkgroll",