@xsai/shared-chat 0.4.3 → 0.5.0-beta.1

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import { WithUnknown, CommonRequestOptions } from '@xsai/shared';
 
-type FinishReason = 'content_filter' | 'error' | 'length' | 'other' | 'stop' | 'tool-calls' | (string & {});
+type FinishReason = 'content_filter' | 'error' | 'length' | 'other' | 'stop' | 'tool-calls' | 'tool_calls' | (string & {});
 
 interface AudioContentPart {
     input_audio: {
@@ -150,6 +150,33 @@ interface ToolChoiceTool {
     type: 'function';
 }
 
+type PrepareStep = (options: PrepareStepOptions) => PrepareStepResult | Promise<PrepareStepResult>;
+interface PrepareStepOptions {
+    messages: Message[];
+    model: string;
+    stepNumber: number;
+    steps: CompletionStep[];
+}
+interface PrepareStepResult {
+    messages?: Message[];
+    model?: string;
+    toolChoice?: ToolChoice;
+}
+
+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;
+}
+
 /** @see {@link https://platform.openai.com/docs/api-reference/chat/create} */
 interface ChatOptions extends CommonRequestOptions {
     /**
@@ -188,12 +215,12 @@ declare const chat: <T extends WithUnknown<ChatOptions>>(options: T) => Promise<
 
 interface DetermineStepTypeOptions {
     finishReason: FinishReason;
-    maxSteps: number;
     stepsLength: number;
     toolCallsLength: number;
+    willContinue: boolean;
 }
 /** @internal */
-declare const determineStepType: ({ finishReason, maxSteps, stepsLength, toolCallsLength }: DetermineStepTypeOptions) => CompletionStepType;
+declare const determineStepType: ({ finishReason, stepsLength, toolCallsLength, willContinue }: DetermineStepTypeOptions) => CompletionStepType;
 
 interface ExecuteToolOptions {
     abortSignal?: AbortSignal;
@@ -208,5 +235,25 @@ interface ExecuteToolResult {
 }
 declare const executeTool: ({ abortSignal, messages, toolCall, tools }: ExecuteToolOptions) => Promise<ExecuteToolResult>;
 
-export { chat, determineStepType, executeTool };
-export type { AssistantMessage, AudioContentPart, ChatOptions, CommonContentPart, CompletionStep, CompletionStepType, CompletionToolCall, CompletionToolResult, DetermineStepTypeOptions, DeveloperMessage, ExecuteToolOptions, ExecuteToolResult, FileContentPart, FinishReason, ImageContentPart, Message, RefusalContentPart, SystemMessage, TextContentPart, Tool, ToolCall, ToolChoice, ToolExecuteOptions, ToolExecuteResult, ToolMessage, Usage, UserMessage };
+interface ResolvedStepOptions {
+    messages: Message[];
+    model: string;
+    toolChoice: ToolChoice | undefined;
+}
+interface ResolveStepOptionsOptions extends Pick<WithUnknown<ChatOptions>, 'messages' | 'model' | 'toolChoice'> {
+    prepareStep?: PrepareStep;
+    stepNumber: number;
+    steps: CompletionStep[];
+}
+declare const resolveStepOptions: ({ messages, model, prepareStep, stepNumber, steps, toolChoice }: ResolveStepOptionsOptions) => Promise<ResolvedStepOptions>;
+
+declare const and: (...conditions: StopCondition[]) => StopCondition;
+declare const or: (...conditions: StopCondition[]) => StopCondition;
+declare const not: (condition: StopCondition) => StopCondition;
+declare const stepCountAtLeast: (count: number) => StopCondition;
+declare const hasToolCall: (name?: string) => StopCondition;
+/** @internal */
+declare const shouldStop: (stopWhen: StopCondition, context: StopContext) => boolean;
+
+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 };

package/dist/index.js

@@ -1,15 +1,9 @@
-import { requestURL, requestHeaders, requestBody, clean, responseCatch } from '@xsai/shared';
+import { requestURL, requestHeaders, requestBody, responseCatch, InvalidToolCallError, InvalidToolInputError, ToolExecutionError } from '@xsai/shared';
 
 const chat = async (options) => (options.fetch ?? globalThis.fetch)(requestURL("chat/completions", options.baseURL), {
   body: requestBody({
     ...options,
-    tools: options.tools?.map((tool) => ({
-      function: clean({
-        ...tool.function,
-        returns: void 0
-      }),
-      type: "function"
-    }))
+    tools: options.tools?.map(({ execute: _execute, ...tool }) => tool)
   }),
   headers: requestHeaders({
     "Content-Type": "application/json",
@@ -19,11 +13,11 @@ const chat = async (options) => (options.fetch ?? globalThis.fetch)(requestURL("
   signal: options.abortSignal
 }).then(responseCatch);
 
-const determineStepType = ({ finishReason, maxSteps, stepsLength, toolCallsLength }) => {
+const determineStepType = ({ finishReason, stepsLength, toolCallsLength, willContinue }) => {
   if (stepsLength === 0) {
     return "initial";
-  } else if (stepsLength < maxSteps) {
-    if (toolCallsLength > 0 && finishReason === "tool_calls")
+  } else if (willContinue) {
+    if (toolCallsLength > 0 && ["tool-calls", "tool_calls"].includes(finishReason))
       return "tool-result";
     else if (!["error", "length"].includes(finishReason))
       return "continue";
@@ -42,34 +36,75 @@ const wrapToolResult = (result) => {
   return JSON.stringify(result);
 };
 
+const isAbortError = (error, abortSignal) => abortSignal?.aborted === true && error === abortSignal.reason || error instanceof Error && error.name === "AbortError";
+const parseToolInput = (toolName, input) => {
+  try {
+    return JSON.parse(input.trim() || "{}");
+  } catch (cause) {
+    throw new InvalidToolInputError(`Failed to parse tool input for "${toolName}".`, {
+      cause,
+      toolInput: input,
+      toolName
+    });
+  }
+};
+const runTool = async (tool, options) => {
+  try {
+    return wrapToolResult(await tool.execute(options.parsedArgs, {
+      abortSignal: options.abortSignal,
+      messages: options.messages,
+      toolCallId: options.toolCall.id
+    }));
+  } catch (cause) {
+    if (isAbortError(cause, options.abortSignal))
+      throw cause;
+    throw new ToolExecutionError(`Tool "${tool.function.name}" execution failed.`, {
+      cause,
+      toolCallId: options.toolCall.id,
+      toolInput: options.parsedArgs,
+      toolName: tool.function.name
+    });
+  }
+};
 const executeTool = async ({ abortSignal, messages, toolCall, tools }) => {
-  const tool = tools?.find((tool2) => tool2.function.name === toolCall.function.name);
+  const toolName = toolCall.function.name;
+  const toolArguments = toolCall.function.arguments;
+  if (toolName == null) {
+    throw new InvalidToolCallError(`Missing toolCall.function.name: ${JSON.stringify(toolCall)}`, {
+      reason: "missing_name",
+      toolCall
+    });
+  }
+  if (toolArguments == null) {
+    throw new InvalidToolCallError(`Missing toolCall.function.arguments: ${JSON.stringify(toolCall)}`, {
+      reason: "missing_arguments",
+      toolCall
+    });
+  }
+  const tool = tools?.find((tool2) => tool2.function.name === toolName);
   if (!tool) {
     const availableTools = tools?.map((tool2) => tool2.function.name);
     const availableToolsErrorMsg = availableTools == null || availableTools.length === 0 ? "No tools are available" : `Available tools: ${availableTools.join(", ")}`;
-    throw new Error(`Model tried to call unavailable tool "${toolCall.function.name}", ${availableToolsErrorMsg}.`);
+    throw new InvalidToolCallError(`Model tried to call unavailable tool "${toolName}", ${availableToolsErrorMsg}.`, {
+      availableTools,
+      reason: "unknown_tool",
+      toolCall,
+      toolName
+    });
   }
-  if (toolCall.function.name == null)
-    throw new Error(`Missing toolCall.function.name: ${JSON.stringify(toolCall)}`);
-  if (toolCall.function.arguments == null)
-    throw new Error(`Missing toolCall.function.arguments: ${JSON.stringify(toolCall)}`);
-  const parsedArgs = JSON.parse(toolCall.function.arguments);
-  const result = wrapToolResult(await tool.execute(parsedArgs, {
-    abortSignal,
-    messages,
-    toolCallId: toolCall.id
-  }));
+  const parsedArgs = parseToolInput(toolName, toolArguments);
+  const result = await runTool(tool, { abortSignal, messages, parsedArgs, toolCall });
   const completionToolCall = {
-    args: toolCall.function.arguments,
+    args: toolArguments,
     toolCallId: toolCall.id,
     toolCallType: toolCall.type,
-    toolName: toolCall.function.name
+    toolName
   };
   const completionToolResult = {
     args: parsedArgs,
     result,
     toolCallId: toolCall.id,
-    toolName: toolCall.function.name
+    toolName
   };
   const message = {
     content: result,
@@ -83,4 +118,25 @@ const executeTool = async ({ abortSignal, messages, toolCall, tools }) => {
   };
 };
 
-export { chat, determineStepType, executeTool };
+const resolveStepOptions = async ({ messages, model, prepareStep, stepNumber, steps, toolChoice }) => {
+  const prepared = prepareStep == null ? void 0 : await prepareStep({
+    messages: structuredClone(messages),
+    model,
+    stepNumber,
+    steps: structuredClone(steps)
+  });
+  return {
+    messages: prepared?.messages != null ? structuredClone(prepared.messages) : messages,
+    model: prepared?.model ?? model,
+    toolChoice: prepared?.toolChoice ?? toolChoice
+  };
+};
+
+const and = (...conditions) => (context) => conditions.every((condition) => condition(context));
+const or = (...conditions) => (context) => conditions.some((condition) => condition(context));
+const not = (condition) => (context) => !condition(context);
+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 };

package/package.json

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