@xsai/stream-text 0.2.0-beta.4 → 0.2.0-beta.5

package/dist/index.d.ts

@@ -74,22 +74,23 @@ interface StreamTextStep {
 }
 /** @internal */
 interface StreamTextChoice {
-    finish_reason?: FinishReason | null;
+    finishReason?: FinishReason | null;
     index: number;
     message: StreamTextMessage;
 }
 /** @internal */
 interface StreamTextMessage extends Omit<AssistantMessage, 'tool_calls'> {
     content?: string;
-    tool_calls?: {
-        [id: string]: StreamTextToolCall;
+    toolCalls?: {
+        [id: number]: StreamTextToolCall;
     };
 }
 /** @internal */
 interface StreamTextToolCall extends ToolCall {
     function: ToolCall['function'] & {
-        parsed_arguments: Record<string, unknown>;
+        parsedArguments: Record<string, unknown>;
     };
+    index: number;
 }
 declare const streamText: (options: StreamTextOptions) => Promise<StreamTextResult>;
 

package/dist/index.js

@@ -62,12 +62,12 @@ const streamText = async (options) => {
     const choiceState = {};
     let buffer = "";
     let shouldOutputText = true;
-    const endToolCall = (state, id) => {
-      if (state.endedToolCallIDs.has(id)) {
+    const endToolCallByIndex = (state, idx) => {
+      if (state.endedToolCallIndex.has(idx)) {
         return;
       }
-      state.endedToolCallIDs.add(id);
-      state.currentToolID = null;
+      state.endedToolCallIndex.add(idx);
+      state.currentToolIndex = null;
     };
     await chat({
       ...options2,
@@ -111,7 +111,7 @@ const streamText = async (options) => {
           }
           const { delta, finish_reason, index, ...rest } = choice;
           const choiceSnapshot = step.choices[index] ??= {
-            finish_reason,
+            finishReason: finish_reason,
             index,
             message: {
               role: "assistant"
@@ -119,7 +119,7 @@ const streamText = async (options) => {
           };
           if (finish_reason !== void 0) {
             step.finishReason = finish_reason;
-            choiceSnapshot.finish_reason = finish_reason;
+            choiceSnapshot.finishReason = finish_reason;
             if (finish_reason === "length") {
               throw new XSAIError("length exceeded");
             }
@@ -132,44 +132,45 @@ const streamText = async (options) => {
           const message = choiceSnapshot.message;
           Object.assign(message, rests);
           if (refusal !== void 0) {
-            message.refusal = (message.refusal || "") + refusal;
+            message.refusal = (message.refusal || "") + (refusal || "");
           }
           if (content !== void 0) {
-            message.content = (message.content || "") + content;
+            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] ??= {
+          for (const { function: fn, id, index: index2, type } of tool_calls || []) {
+            message.toolCalls ??= {};
+            const toolCall = message.toolCalls[index2] ??= {
               function: {
                 arguments: "",
                 name: fn.name,
-                parsed_arguments: {}
+                parsedArguments: {}
               },
               id,
+              index: index2,
               type
             };
             toolCall.function.arguments += fn.arguments;
           }
           const state = choiceState[index] ??= {
-            calledToolCallIDs: /* @__PURE__ */ new Set(),
-            currentToolID: null,
-            endedToolCallIDs: /* @__PURE__ */ new Set(),
+            calledToolCallIndex: /* @__PURE__ */ new Set(),
+            currentToolIndex: null,
+            endedToolCallIndex: /* @__PURE__ */ new Set(),
             index,
             toolCallErrors: {},
             toolCallResults: {}
           };
           if (finish_reason) {
-            if (state.currentToolID !== null) {
-              endToolCall(state, state.currentToolID);
+            if (state.currentToolIndex !== null) {
+              endToolCallByIndex(state, state.currentToolIndex);
             }
           }
           for (const toolCall of delta.tool_calls || []) {
-            if (state.currentToolID !== null && state.currentToolID !== toolCall.id) {
-              endToolCall(state, state.currentToolID);
+            if (state.currentToolIndex !== toolCall.index && state.currentToolIndex !== null) {
+              endToolCallByIndex(state, state.currentToolIndex);
             }
-            state.calledToolCallIDs.add(toolCall.id);
-            state.currentToolID = toolCall.id;
+            state.calledToolCallIndex.add(toolCall.index);
+            state.currentToolIndex = toolCall.index;
           }
         }
       }))
@@ -177,19 +178,28 @@ const streamText = async (options) => {
     step.messages.push({
       content: step.choices[0]?.message.content ?? "",
       refusal: step.choices[0]?.message.refusal,
-      role: "assistant"
+      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.endedToolCallIDs].map(async (id) => {
-        const toolCall = choice.message.tool_calls[id];
+      return Promise.allSettled([...state.endedToolCallIndex].map(async (idx) => {
+        const toolCall = choice.message.toolCalls[idx];
         step.toolCalls.push({
           args: toolCall.function.arguments,
-          toolCallId: id,
+          toolCallId: toolCall.id,
           toolCallType: "function",
           toolName: toolCall.function.name
         });
-        if (state.toolCallResults[id]) {
+        if (state.toolCallResults[toolCall.id]) {
           return;
         }
         try {
@@ -199,21 +209,21 @@ const streamText = async (options) => {
             toolCall,
             tools: options2.tools
           });
-          toolCall.function.parsed_arguments = parsedArgs;
-          state.toolCallResults[id] = result;
+          toolCall.function.parsedArguments = parsedArgs;
+          state.toolCallResults[toolCall.id] = result;
           step.messages.push({
             content: result,
             role: "tool",
-            tool_call_id: id
+            tool_call_id: toolCall.id
           });
           step.toolResults.push({
             args: parsedArgs,
             result,
-            toolCallId: id,
+            toolCallId: toolCall.id,
             toolName
           });
         } catch (error) {
-          state.toolCallErrors[id] = error;
+          state.toolCallErrors[idx] = error;
         }
       }));
     }));

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@xsai/stream-text",
   "type": "module",
-  "version": "0.2.0-beta.4",
-  "description": "extra-small AI SDK for Browser, Node.js, Deno, Bun or Edge Runtime.",
+  "version": "0.2.0-beta.5",
+  "description": "extra-small AI SDK.",
   "author": "Moeru AI",
   "license": "MIT",
   "homepage": "https://xsai.js.org",