@xsai/stream-text 0.1.0-beta.4 → 0.1.0-beta.6

package/dist/index.d.ts

@@ -1,10 +1,12 @@
-import { FinishReason, Usage, ChatOptions } from '@xsai/shared-chat';
+import { ToolCall, FinishReason, Usage, ChatOptions, Tool, Message, CompletionToolCall, CompletionToolResult, AssistantMessage } from '@xsai/shared-chat';
 
 interface StreamTextChunkResult {
     choices: {
         delta: {
-            content: string;
+            content?: string;
+            refusal?: string;
             role: 'assistant';
+            tool_calls?: ToolCall[];
         };
         finish_reason?: FinishReason;
         index: number;
@@ -16,10 +18,34 @@ interface StreamTextChunkResult {
     system_fingerprint: string;
     usage?: Usage;
 }
+/**
+ * Options for configuring the StreamText functionality.
+ */
 interface StreamTextOptions extends ChatOptions {
-    onChunk?: (chunk: StreamTextChunkResult) => Promise<void> | void;
-    /** if you want to disable stream, use `@xsai/generate-{text,object}` */
+    /** @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 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;
+    /**
+     * If you want to disable stream, use `@xsai/generate-{text,object}`.
+     */
     stream?: never;
+    /**
+     * Options for configuring the stream.
+     */
     streamOptions?: {
         /**
          * Return usage.
@@ -28,16 +54,42 @@ interface StreamTextOptions extends ChatOptions {
          */
         usage?: boolean;
     };
+    /**
+     * List of tools to be used in the stream.
+     */
+    tools?: Tool[];
 }
 interface StreamTextResult {
     chunkStream: ReadableStream<StreamTextChunkResult>;
-    finishReason?: FinishReason;
+    stepStream: ReadableStream<StreamTextStep>;
     textStream: ReadableStream<string>;
+}
+interface StreamTextStep {
+    choices: StreamTextChoice[];
+    messages: Message[];
+    toolCalls: CompletionToolCall[];
+    toolResults: CompletionToolResult[];
     usage?: Usage;
 }
-/**
- * @experimental WIP, does not support function calling (tools).
- */
+/** @internal */
+interface StreamTextChoice {
+    finish_reason?: FinishReason | null;
+    index: number;
+    message: StreamTextMessage;
+}
+/** @internal */
+interface StreamTextMessage extends Omit<AssistantMessage, 'tool_calls'> {
+    content?: string;
+    tool_calls?: {
+        [id: string]: StreamTextToolCall;
+    };
+}
+/** @internal */
+interface StreamTextToolCall extends ToolCall {
+    function: ToolCall['function'] & {
+        parsed_arguments: Record<string, unknown>;
+    };
+}
 declare const streamText: (options: StreamTextOptions) => Promise<StreamTextResult>;
 
-export { type StreamTextChunkResult, type StreamTextOptions, type StreamTextResult, streamText };
+export { type StreamTextChunkResult, type StreamTextOptions, type StreamTextResult, type StreamTextStep, streamText };

package/dist/index.js

@@ -1,55 +1,256 @@
-import { chat } from '@xsai/shared-chat';
+// ../shared/src/error/index.ts
+var XSAIError = class extends Error {
+  response;
+  constructor(message, response) {
+    super(message);
+    this.name = "XSAIError";
+    this.response = response;
+  }
+};
 
-const chunkHeaderPrefix = "data:";
-const streamText = async (options) => chat({
-  ...options,
-  stream: true
-}).then(async (res) => {
-  const decoder = new TextDecoder();
-  let finishReason;
-  let usage;
-  const processLine = async (line, controller) => {
-    if (!line || !line.startsWith(chunkHeaderPrefix))
-      return;
-    const content = line.slice(chunkHeaderPrefix.length);
-    const data = content.startsWith(" ") ? content.slice(1) : content;
-    if (data === "[DONE]") {
-      controller.terminate();
-      return true;
+// src/index.ts
+import { chat } from "@xsai/shared-chat";
+
+// src/helper.ts
+var CHUNK_HEADER_PREFIX = "data:";
+var parseChunk = (text) => {
+  if (!text || !text.startsWith(CHUNK_HEADER_PREFIX))
+    return [void 0, false];
+  const content = text.slice(CHUNK_HEADER_PREFIX.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];
+};
+
+// src/index.ts
+var streamText = async (options) => {
+  let chunkCtrl;
+  let stepCtrl;
+  let textCtrl;
+  const chunkStream = new ReadableStream({
+    start(controller) {
+      chunkCtrl = controller;
     }
-    if (data.startsWith("{") && data.includes('"error":')) {
-      controller.error(new Error(`Error from server: ${data}`));
-      return true;
+  });
+  const stepStream = new ReadableStream({
+    start(controller) {
+      stepCtrl = controller;
     }
-    const chunk = JSON.parse(data);
-    controller.enqueue(chunk);
-    if (options.onChunk)
-      await options.onChunk(chunk);
-    if (chunk.choices[0].finish_reason !== undefined) {
-      finishReason = chunk.choices[0].finish_reason;
+  });
+  const textStream = new ReadableStream({
+    start(controller) {
+      textCtrl = controller;
     }
-    if (chunk.usage !== undefined) {
-      usage = chunk.usage;
+  });
+  const maxSteps = options.maxSteps ?? 1;
+  const decoder = new TextDecoder();
+  const steps = [];
+  const stepOne = async (options2) => {
+    const step = {
+      choices: [],
+      messages: structuredClone(options2.messages),
+      toolCalls: [],
+      toolResults: []
+    };
+    const choiceState = {};
+    let buffer = "";
+    let shouldOutputText = true;
+    const endToolCall = (state, id) => {
+      if (state.endedToolCallIDs.has(id)) {
+        return;
+      }
+      const toolCall = step.choices[state.index].message.tool_calls[id];
+      try {
+        toolCall.function.parsed_arguments = JSON.parse(toolCall.function.arguments);
+      } catch (error) {
+        state.toolCallErrors[id] = error;
+      }
+      state.endedToolCallIDs.add(id);
+      state.currentToolID = null;
+    };
+    await chat({
+      ...options2,
+      stream: true
+    }).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({
+        abort: (reason) => {
+          chunkCtrl.error(reason);
+          stepCtrl.error(reason);
+          textCtrl.error(reason);
+        },
+        // eslint-disable-next-line sonarjs/cognitive-complexity
+        write: async (chunk) => {
+          options2.onChunk?.(chunk);
+          chunkCtrl.enqueue(chunk);
+          const choice = chunk.choices[0];
+          if (!choice)
+            throw new XSAIError("no choice found");
+          if (choice.delta.tool_calls) {
+            shouldOutputText = false;
+          }
+          const { delta, finish_reason, index, ...rest } = choice;
+          const choiceSnapshot = step.choices[index] ??= {
+            finish_reason,
+            index,
+            message: {
+              role: "assistant"
+            }
+          };
+          if (finish_reason !== void 0) {
+            choiceSnapshot.finish_reason = finish_reason;
+            if (finish_reason === "length") {
+              throw new XSAIError("length exceeded");
+            }
+            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;
+          }
+          if (content !== void 0) {
+            message.content = (message.content || "") + content;
+            shouldOutputText && textCtrl?.enqueue(content);
+          }
+          for (const { function: fn, id, type } of tool_calls || []) {
+            message.tool_calls ??= {};
+            const toolCall = message.tool_calls[id] ??= {
+              function: {
+                arguments: "",
+                name: fn.name,
+                parsed_arguments: {}
+              },
+              id,
+              type
+            };
+            toolCall.function.arguments += fn.arguments;
+          }
+          const state = choiceState[index] ??= {
+            calledToolCallIDs: /* @__PURE__ */ new Set(),
+            currentToolID: null,
+            endedToolCallIDs: /* @__PURE__ */ new Set(),
+            index,
+            toolCallErrors: {},
+            toolCallResults: {}
+          };
+          if (finish_reason) {
+            if (state.currentToolID !== null) {
+              endToolCall(state, state.currentToolID);
+            }
+          }
+          for (const toolCall of delta.tool_calls || []) {
+            if (state.currentToolID !== null && state.currentToolID !== toolCall.id) {
+              endToolCall(state, state.currentToolID);
+            }
+            state.calledToolCallIDs.add(toolCall.id);
+            state.currentToolID = toolCall.id;
+          }
+        }
+      }))
+    );
+    step.messages.push({
+      content: step.choices[0]?.message.content ?? "",
+      refusal: step.choices[0]?.message.refusal,
+      role: "assistant"
+    });
+    await Promise.allSettled(step.choices.map(async (choice) => {
+      const state = choiceState[choice.index];
+      return Promise.allSettled([...state.endedToolCallIDs].map(async (id) => {
+        const toolCall = choice.message.tool_calls[id];
+        step.toolCalls.push({
+          args: toolCall.function.arguments,
+          toolCallId: id,
+          toolCallType: "function",
+          toolName: toolCall.function.name
+        });
+        if (state.toolCallResults[id]) {
+          return;
+        }
+        const tool = options2.tools?.find((tool2) => tool2.function.name === toolCall.function.name);
+        if (tool) {
+          try {
+            const ret = await tool.execute(toolCall.function.parsed_arguments, {
+              abortSignal: options2.abortSignal,
+              messages: options2.messages,
+              toolCallId: id
+            });
+            state.toolCallResults[id] = ret;
+            step.messages.push({
+              content: ret,
+              role: "tool",
+              tool_call_id: id
+            });
+            step.toolResults.push({
+              args: toolCall.function.parsed_arguments,
+              result: ret,
+              toolCallId: id,
+              toolName: toolCall.function.name
+            });
+          } catch (error) {
+            state.toolCallErrors[id] = error;
+          }
+        } else {
+          state.toolCallErrors[id] = new XSAIError(`tool ${toolCall.function.name} not found`);
+        }
+      }));
+    }));
+    steps.push(step);
+    stepCtrl.enqueue(step);
+    options2.onStepFinish?.(step);
+    if (shouldOutputText) {
+      return;
     }
+    return async () => stepOne({ ...options2, messages: step.messages });
   };
-  let buffer = "";
-  const rawChunkStream = 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) {
-        if (await processLine(line, controller))
-          break;
-      }
+  const invokeFunctionCalls = async () => {
+    for (let i = 1, ret = await stepOne(options); typeof ret === "function" && i < maxSteps; ret = await ret(), i += 1) {
+      ;
     }
-  }));
-  const [chunkStream, rawTextStream] = rawChunkStream.tee();
-  const textStream = rawTextStream.pipeThrough(new TransformStream({
-    transform: (chunk, controller) => controller.enqueue(chunk.choices[0].delta.content)
-  }));
-  return { chunkStream, finishReason, textStream, usage };
-});
-
-export { streamText };
+    options.onFinish?.(steps);
+    chunkCtrl.close();
+    stepCtrl.close();
+    textCtrl.close();
+  };
+  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.1.0-beta.4",
+  "version": "0.1.0-beta.6",
   "description": "extra-small AI SDK for Browser, Node.js, Deno, Bun or Edge Runtime.",
   "author": "Moeru AI",
   "license": "MIT",
@@ -22,10 +22,9 @@
     ".": {
       "types": "./dist/index.d.ts",
       "default": "./dist/index.js"
-    }
+    },
+    "./package.json": "./package.json"
   },
-  "main": "./dist/index.js",
-  "types": "./dist/index.d.ts",
   "files": [
     "dist"
   ],
@@ -33,13 +32,15 @@
     "@xsai/shared-chat": ""
   },
   "devDependencies": {
-    "@xsai/providers": "",
-    "@xsai/shared": ""
+    "@xsai/shared": "",
+    "@xsai/tool": "",
+    "valibot": "^1.0.0-rc.1"
   },
   "scripts": {
-    "build": "pkgroll",
-    "build:watch": "pkgroll --watch",
+    "build": "tsup",
     "test": "vitest run",
     "test:watch": "vitest"
-  }
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts"
 }