@xsai/shared-chat 0.5.0-beta.2 → 0.5.0-beta.3

package/dist/index.d.ts

@@ -96,7 +96,7 @@ interface CompletionToolCall {
 }
 interface CompletionToolResult {
     args: Record<string, unknown>;
-    result: ToolMessage['content'];
+    result: ToolExecuteResult;
     toolCallId: string;
     toolName: string;
 }
@@ -117,11 +117,16 @@ interface ToolExecuteOptions {
 }
 type ToolExecuteResult = object | string | unknown[];
 
-interface Usage {
+interface ChatCompletionUsage {
     completion_tokens: number;
     prompt_tokens: number;
     total_tokens: number;
 }
+interface Usage {
+    inputTokens: number;
+    outputTokens: number;
+    totalTokens: number;
+}
 
 type CompletionStep<T extends boolean = false> = (T extends true ? {
     usage: Usage;
@@ -129,12 +134,10 @@ type CompletionStep<T extends boolean = false> = (T extends true ? {
     usage?: Usage;
 }) & {
     finishReason: FinishReason;
-    stepType: CompletionStepType;
     text?: string;
     toolCalls: CompletionToolCall[];
     toolResults: CompletionToolResult[];
 };
-type CompletionStepType = 'continue' | 'done' | 'initial' | 'tool-result';
 
 type ToolChoice = AllowedTools | ToolChoiceMode | ToolChoiceTool;
 interface AllowedTools {
@@ -150,31 +153,24 @@ interface ToolChoiceTool {
     type: 'function';
 }
 
-type PrepareStep = (options: PrepareStepOptions) => PrepareStepResult | Promise<PrepareStepResult>;
-interface PrepareStepOptions {
-    messages: Message[];
+type PrepareStep<TInput = Message[], TToolChoice = ToolChoice> = (options: PrepareStepOptions<TInput>) => PrepareStepResult<TInput, TToolChoice> | Promise<PrepareStepResult<TInput, TToolChoice>>;
+interface PrepareStepOptions<TInput = Message[]> {
+    input: TInput;
     model: string;
     stepNumber: number;
     steps: CompletionStep[];
 }
-interface PrepareStepResult {
-    messages?: Message[];
+interface PrepareStepResult<TInput = Message[], TToolChoice = ToolChoice> {
+    input?: TInput;
     model?: string;
-    toolChoice?: ToolChoice;
+    toolChoice?: TToolChoice;
 }
 
-type StopCondition = (context: StopContext) => boolean;
-interface StopContext {
-    messages: readonly Message[];
-    step: StopStep;
-    steps: readonly StopStep[];
-}
-interface StopStep {
-    finishReason: FinishReason;
-    text?: string;
-    toolCalls: CompletionToolCall[];
-    toolResults: CompletionToolResult[];
-    usage?: Usage;
+type StopCondition<Input = unknown> = (context: StopContext<Input>) => boolean;
+interface StopContext<Input = unknown> {
+    input: readonly Input[];
+    step: CompletionStep;
+    steps: readonly CompletionStep[];
 }
 
 /** @see {@link https://platform.openai.com/docs/api-reference/chat/create} */
@@ -213,47 +209,45 @@ interface ChatOptions extends CommonRequestOptions {
 }
 declare const chat: <T extends WithUnknown<ChatOptions>>(options: T) => Promise<Response>;
 
-interface DetermineStepTypeOptions {
-    finishReason: FinishReason;
-    stepsLength: number;
-    toolCallsLength: number;
-    willContinue: boolean;
-}
-/** @internal */
-declare const determineStepType: ({ finishReason, stepsLength, toolCallsLength, willContinue }: DetermineStepTypeOptions) => CompletionStepType;
-
-interface ExecuteToolOptions {
+interface ExecuteToolOptions<T = ToolMessage['content']> {
     abortSignal?: AbortSignal;
     messages: Message[];
     toolCall: ToolCall;
     tools?: Tool[];
+    wrapResult?: (result: ToolExecuteResult) => T;
 }
-interface ExecuteToolResult {
+interface ExecuteToolResult<T = ToolMessage['content']> {
     completionToolCall: CompletionToolCall;
     completionToolResult: CompletionToolResult;
-    message: ToolMessage;
+    result: T;
 }
-declare const executeTool: ({ abortSignal, messages, toolCall, tools }: ExecuteToolOptions) => Promise<ExecuteToolResult>;
+declare const executeTool: <T = ToolMessage["content"]>({ abortSignal, messages, toolCall, tools, wrapResult }: ExecuteToolOptions<T>) => Promise<ExecuteToolResult<T>>;
 
-interface ResolvedStepOptions {
-    messages: Message[];
+interface ResolvePrepareStepOptions<TInput = Message[], TToolChoice = ToolChoice> {
+    input: TInput;
     model: string;
-    toolChoice: ToolChoice | undefined;
-}
-interface ResolveStepOptionsOptions extends Pick<WithUnknown<ChatOptions>, 'messages' | 'model' | 'toolChoice'> {
-    prepareStep?: PrepareStep;
+    prepareStep?: PrepareStep<TInput, TToolChoice>;
     stepNumber: number;
     steps: CompletionStep[];
+    toolChoice?: TToolChoice;
 }
-declare const resolveStepOptions: ({ messages, model, prepareStep, stepNumber, steps, toolChoice }: ResolveStepOptionsOptions) => Promise<ResolvedStepOptions>;
+interface ResolvePrepareStepResult<TInput = Message[], TToolChoice = ToolChoice> {
+    input: TInput;
+    model: string;
+    toolChoice?: TToolChoice;
+}
+declare const resolvePrepareStep: <TInput, TToolChoice>({ input, model, prepareStep, stepNumber, steps, toolChoice }: ResolvePrepareStepOptions<TInput, TToolChoice>) => Promise<ResolvePrepareStepResult<TInput, TToolChoice>>;
 
-declare const and: (...conditions: StopCondition[]) => StopCondition;
-declare const or: (...conditions: StopCondition[]) => StopCondition;
-declare const not: (condition: StopCondition) => StopCondition;
+declare const and: <Input = unknown>(...conditions: StopCondition<Input>[]) => StopCondition<Input>;
+declare const or: <Input = unknown>(...conditions: StopCondition<Input>[]) => StopCondition<Input>;
+declare const not: <Input = unknown>(condition: StopCondition<Input>) => StopCondition<Input>;
 declare const stepCountAtLeast: (count: number) => StopCondition;
 declare const hasToolCall: (name?: string) => StopCondition;
 /** @internal */
-declare const shouldStop: (stopWhen: StopCondition, context: StopContext) => boolean;
+declare const shouldStop: <Input = unknown>(stopWhen: StopCondition<Input>, context: StopContext<Input>) => boolean;
+
+declare const computeTotalUsage: (totalUsage: undefined | Usage, usage: Usage) => Usage;
+declare const normalizeChatCompletionUsage: (usage: ChatCompletionUsage) => Usage;
 
-export { and, chat, determineStepType, executeTool, hasToolCall, not, or, resolveStepOptions, shouldStop, stepCountAtLeast };
-export type { AssistantMessage, AudioContentPart, ChatOptions, CommonContentPart, CompletionStep, CompletionStepType, CompletionToolCall, CompletionToolResult, DetermineStepTypeOptions, DeveloperMessage, ExecuteToolOptions, ExecuteToolResult, FileContentPart, FinishReason, ImageContentPart, Message, PrepareStep, PrepareStepOptions, PrepareStepResult, RefusalContentPart, ResolveStepOptionsOptions, ResolvedStepOptions, StopCondition, StopContext, StopStep, SystemMessage, TextContentPart, Tool, ToolCall, ToolChoice, ToolExecuteOptions, ToolExecuteResult, ToolMessage, Usage, UserMessage };
+export { and, chat, computeTotalUsage, executeTool, hasToolCall, normalizeChatCompletionUsage, not, or, resolvePrepareStep, shouldStop, stepCountAtLeast };
+export type { AssistantMessage, AudioContentPart, ChatCompletionUsage, ChatOptions, CommonContentPart, CompletionStep, CompletionToolCall, CompletionToolResult, DeveloperMessage, ExecuteToolOptions, ExecuteToolResult, FileContentPart, FinishReason, ImageContentPart, Message, PrepareStep, PrepareStepOptions, PrepareStepResult, RefusalContentPart, ResolvePrepareStepOptions, ResolvePrepareStepResult, StopCondition, StopContext, SystemMessage, TextContentPart, Tool, ToolCall, ToolChoice, ToolExecuteOptions, ToolExecuteResult, ToolMessage, Usage, UserMessage };

package/dist/index.js

@@ -13,23 +13,11 @@ const chat = async (options) => (options.fetch ?? globalThis.fetch)(requestURL("
   signal: options.abortSignal
 }).then(responseCatch);
 
-const determineStepType = ({ finishReason, stepsLength, toolCallsLength, willContinue }) => {
-  if (stepsLength === 0) {
-    return "initial";
-  } else if (willContinue) {
-    if (toolCallsLength > 0 && ["tool-calls", "tool_calls"].includes(finishReason))
-      return "tool-result";
-    else if (!["error", "length"].includes(finishReason))
-      return "continue";
-  }
-  return "done";
-};
-
-const wrapToolResult = (result) => {
+const toToolMessageContent = (result) => {
   if (typeof result === "string")
     return result;
   if (Array.isArray(result)) {
-    if (result.every((item) => !!(typeof item === "object" && "type" in item && ["file", "image_url", "input_audio", "text"].includes(item.type)))) {
+    if (result.every((item) => item !== null && typeof item === "object" && "type" in item && ["file", "image_url", "input_audio", "text"].includes(item.type))) {
       return result;
     }
   }
@@ -50,11 +38,11 @@ const parseToolInput = (toolName, input) => {
 };
 const runTool = async (tool, options) => {
   try {
-    return wrapToolResult(await tool.execute(options.parsedArgs, {
+    return await tool.execute(options.parsedArgs, {
       abortSignal: options.abortSignal,
       messages: options.messages,
       toolCallId: options.toolCall.id
-    }));
+    });
   } catch (cause) {
     if (isAbortError(cause, options.abortSignal))
       throw cause;
@@ -66,7 +54,7 @@ const runTool = async (tool, options) => {
     });
   }
 };
-const executeTool = async ({ abortSignal, messages, toolCall, tools }) => {
+const executeTool = async ({ abortSignal, messages, toolCall, tools, wrapResult }) => {
   const toolName = toolCall.function.name;
   const toolArguments = toolCall.function.arguments;
   if (toolName == null) {
@@ -94,6 +82,7 @@ const executeTool = async ({ abortSignal, messages, toolCall, tools }) => {
   }
   const parsedArgs = parseToolInput(toolName, toolArguments);
   const result = await runTool(tool, { abortSignal, messages, parsedArgs, toolCall });
+  const wrappedResult = (wrapResult ?? toToolMessageContent)(result);
   const completionToolCall = {
     args: toolArguments,
     toolCallId: toolCall.id,
@@ -106,27 +95,22 @@ const executeTool = async ({ abortSignal, messages, toolCall, tools }) => {
     toolCallId: toolCall.id,
     toolName
   };
-  const message = {
-    content: result,
-    role: "tool",
-    tool_call_id: toolCall.id
-  };
   return {
     completionToolCall,
     completionToolResult,
-    message
+    result: wrappedResult
   };
 };
 
-const resolveStepOptions = async ({ messages, model, prepareStep, stepNumber, steps, toolChoice }) => {
+const resolvePrepareStep = async ({ input, model, prepareStep, stepNumber, steps, toolChoice }) => {
   const prepared = prepareStep == null ? void 0 : await prepareStep({
-    messages: structuredClone(messages),
+    input: structuredClone(input),
     model,
     stepNumber,
     steps: structuredClone(steps)
   });
   return {
-    messages: prepared?.messages != null ? structuredClone(prepared.messages) : messages,
+    input: prepared?.input != null ? structuredClone(prepared.input) : input,
     model: prepared?.model ?? model,
     toolChoice: prepared?.toolChoice ?? toolChoice
   };
@@ -139,4 +123,15 @@ const stepCountAtLeast = (count) => ({ steps }) => steps.length >= count;
 const hasToolCall = (name) => ({ step }) => step.toolCalls.some((toolCall) => name == null || toolCall.toolName === name);
 const shouldStop = (stopWhen, context) => stopWhen(context);
 
-export { and, chat, determineStepType, executeTool, hasToolCall, not, or, resolveStepOptions, shouldStop, stepCountAtLeast };
+const computeTotalUsage = (totalUsage, usage) => totalUsage == null ? usage : {
+  inputTokens: totalUsage.inputTokens + usage.inputTokens,
+  outputTokens: totalUsage.outputTokens + usage.outputTokens,
+  totalTokens: totalUsage.totalTokens + usage.totalTokens
+};
+const normalizeChatCompletionUsage = (usage) => ({
+  inputTokens: usage.prompt_tokens,
+  outputTokens: usage.completion_tokens,
+  totalTokens: usage.total_tokens
+});
+
+export { and, chat, computeTotalUsage, executeTool, hasToolCall, normalizeChatCompletionUsage, not, or, resolvePrepareStep, shouldStop, stepCountAtLeast };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@xsai/shared-chat",
   "type": "module",
-  "version": "0.5.0-beta.2",
+  "version": "0.5.0-beta.3",
   "description": "extra-small AI SDK.",
   "author": "Moeru AI",
   "license": "MIT",
@@ -29,7 +29,7 @@
     "dist"
   ],
   "dependencies": {
-    "@xsai/shared": "~0.5.0-beta.2"
+    "@xsai/shared": "0.5.0-beta.3"
   },
   "scripts": {
     "build": "pkgroll"