@wyatex/xsai-shared-chat 0.4.3-fix-1

package/dist/index.d.ts

@@ -0,0 +1,217 @@
+import { WithUnknown, CommonRequestOptions } from '@xsai/shared';
+
+type FinishReason = 'content_filter' | 'error' | 'length' | 'other' | 'stop' | 'tool-calls' | (string & {});
+
+interface AudioContentPart {
+    input_audio: {
+        data: string;
+        format: 'mp3' | 'wav';
+    };
+    type: 'input_audio';
+}
+/** @internal */
+type CommonContentPart = AudioContentPart | FileContentPart | ImageContentPart | TextContentPart;
+interface FileContentPart {
+    file: {
+        file_data?: string;
+        file_id?: string;
+        filename?: string;
+    };
+    type: 'file';
+}
+interface ImageContentPart {
+    image_url: {
+        detail?: 'auto' | 'high' | 'low';
+        url: string;
+    };
+    type: 'image_url';
+}
+interface RefusalContentPart {
+    refusal: string;
+    type: 'refusal';
+}
+interface TextContentPart {
+    text: string;
+    type: 'text';
+}
+
+interface ToolCall {
+    function: ToolCallFunction | ToolCallFunctionWithoutArguments | ToolCallFunctionWithoutName;
+    id: string;
+    type: 'function';
+}
+interface ToolCallFunction {
+    arguments: string;
+    name: string;
+}
+interface ToolCallFunctionWithoutArguments {
+    arguments?: never;
+    name: string;
+}
+interface ToolCallFunctionWithoutName {
+    arguments: string;
+    name?: never;
+}
+
+interface AssistantMessage {
+    content?: (RefusalContentPart | TextContentPart)[] | string;
+    name?: string;
+    /** @see {@link https://cookbook.openai.com/articles/gpt-oss/handle-raw-cot#chat-completions-api} */
+    reasoning?: string;
+    /** @remarks OpenAI doesn't support this, but some providers do. */
+    reasoning_content?: string;
+    refusal?: string;
+    role: 'assistant';
+    tool_calls?: ToolCall[];
+}
+interface DeveloperMessage {
+    content: string | TextContentPart[];
+    name?: string;
+    /** @remarks Before using, confirm that your model supports this. */
+    role: 'developer';
+}
+type Message = AssistantMessage | DeveloperMessage | SystemMessage | ToolMessage | UserMessage;
+interface SystemMessage {
+    content: string | TextContentPart[];
+    name?: string;
+    role: 'system';
+}
+interface ToolMessage {
+    /** @remarks considering the support of ecosystems (such as MCP), we have relaxed this type. */
+    content: CommonContentPart[] | string;
+    role: 'tool';
+    tool_call_id: string;
+}
+interface UserMessage {
+    content: CommonContentPart[] | string;
+    name?: string;
+    role: 'user';
+}
+
+interface CompletionToolCall {
+    args: string;
+    toolCallId: string;
+    toolCallType: 'function';
+    toolName: string;
+}
+interface CompletionToolResult {
+    args: Record<string, unknown>;
+    result: ToolMessage['content'];
+    toolCallId: string;
+    toolName: string;
+}
+interface Tool {
+    execute: (input: unknown, options: ToolExecuteOptions) => Promise<ToolExecuteResult> | ToolExecuteResult;
+    function: {
+        description?: string;
+        name: string;
+        parameters: Record<string, unknown>;
+        strict?: boolean;
+    };
+    /**
+     * Default support for 'function', extended to include custom types such as 'builtin_function'.
+     *
+     * @see Issue #269
+     */
+    type: 'function' | 'builtin_function' | string;
+}
+interface ToolExecuteOptions {
+    abortSignal?: AbortSignal;
+    messages: Message[];
+    toolCallId: string;
+}
+type ToolExecuteResult = object | string | unknown[];
+
+interface Usage {
+    completion_tokens: number;
+    prompt_tokens: number;
+    total_tokens: number;
+}
+
+type CompletionStep<T extends boolean = false> = (T extends true ? {
+    usage: Usage;
+} : {
+    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 {
+    mode: 'auto' | 'required';
+    tools: ToolChoiceTool[];
+    type: 'allowed_tools';
+}
+type ToolChoiceMode = 'auto' | 'none' | 'required';
+interface ToolChoiceTool {
+    function: {
+        name: string;
+    };
+    type: 'function';
+}
+
+/** @see {@link https://platform.openai.com/docs/api-reference/chat/create} */
+interface ChatOptions extends CommonRequestOptions {
+    /**
+     * number between -2.0 and 2.0.
+     * @default 0
+     */
+    frequencyPenalty?: number;
+    messages: Message[];
+    /** Whether to enable parallel function calling during tool use. */
+    parallelToolCalls?: boolean;
+    /**
+     * number between -2.0 and 2.0.
+     * @default 0
+     */
+    presencePenalty?: number;
+    /** Constrains effort on reasoning for reasoning models. */
+    reasoningEffort?: 'high' | 'medium' | 'minimal' | 'none' | 'xhigh';
+    seed?: number;
+    /** up to 4 sequences where the API will stop generating further tokens. */
+    stop?: [string, string, string, string] | [string, string, string] | [string, string] | [string] | string;
+    /**
+     * what sampling temperature to use, between 0 and 2.
+     * @default 1
+     */
+    temperature?: number;
+    /** Controls which (if any) tool is called by the model. */
+    toolChoice?: ToolChoice;
+    /** A list of tools the model may call. */
+    tools?: Tool[];
+    /** @remarks OpenAI doesn't support this, but some providers do. */
+    topK?: number;
+    /** @default 1 */
+    topP?: number;
+}
+declare const chat: <T extends WithUnknown<ChatOptions>>(options: T) => Promise<Response>;
+
+interface DetermineStepTypeOptions {
+    finishReason: FinishReason;
+    maxSteps: number;
+    stepsLength: number;
+    toolCallsLength: number;
+}
+/** @internal */
+declare const determineStepType: ({ finishReason, maxSteps, stepsLength, toolCallsLength }: DetermineStepTypeOptions) => CompletionStepType;
+
+interface ExecuteToolOptions {
+    abortSignal?: AbortSignal;
+    messages: Message[];
+    toolCall: ToolCall;
+    tools?: Tool[];
+}
+interface ExecuteToolResult {
+    completionToolCall: CompletionToolCall;
+    completionToolResult: CompletionToolResult;
+    message: ToolMessage;
+}
+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 };

package/dist/index.js

@@ -0,0 +1,89 @@
+import { requestURL, requestHeaders, requestBody, clean, responseCatch } 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
+      }),
+      /**
+       * Fix #269: Dynamically read the tool type instead of hardcoding it, to support extension types like 'builtin_function'.
+       */
+      type: tool.type ?? "function"
+    }))
+  }),
+  headers: requestHeaders({
+    "Content-Type": "application/json",
+    ...options.headers
+  }, options.apiKey),
+  method: "POST",
+  signal: options.abortSignal
+}).then(responseCatch);
+
+const determineStepType = ({ finishReason, maxSteps, stepsLength, toolCallsLength }) => {
+  if (stepsLength === 0) {
+    return "initial";
+  } else if (stepsLength < maxSteps) {
+    if (toolCallsLength > 0 && finishReason === "tool_calls")
+      return "tool-result";
+    else if (!["error", "length"].includes(finishReason))
+      return "continue";
+  }
+  return "done";
+};
+
+const wrapToolResult = (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)))) {
+      return result;
+    }
+  }
+  return JSON.stringify(result);
+};
+
+const executeTool = async ({ abortSignal, messages, toolCall, tools }) => {
+  const tool = tools?.find((tool2) => tool2.function.name === toolCall.function.name);
+  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}.`);
+  }
+  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.trim() || "{}");
+  const result = wrapToolResult(await tool.execute(parsedArgs, {
+    abortSignal,
+    messages,
+    toolCallId: toolCall.id
+  }));
+  const completionToolCall = {
+    args: toolCall.function.arguments,
+    toolCallId: toolCall.id,
+    toolCallType: toolCall.type,
+    toolName: toolCall.function.name
+  };
+  const completionToolResult = {
+    args: parsedArgs,
+    result,
+    toolCallId: toolCall.id,
+    toolName: toolCall.function.name
+  };
+  const message = {
+    content: result,
+    role: "tool",
+    tool_call_id: toolCall.id
+  };
+  return {
+    completionToolCall,
+    completionToolResult,
+    message
+  };
+};
+
+export { chat, determineStepType, executeTool };

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@wyatex/xsai-shared-chat",
+  "type": "module",
+  "version": "0.4.3-fix-1",
+  "description": "extra-small AI SDK.",
+  "author": "Moeru AI",
+  "license": "MIT",
+  "homepage": "https://xsai.js.org",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/moeru-ai/xsai.git",
+    "directory": "packages/shared-chat"
+  },
+  "bugs": "https://github.com/moeru-ai/xsai/issues",
+  "keywords": [
+    "xsai",
+    "openai",
+    "ai"
+  ],
+  "sideEffects": false,
+  "exports": "./src/index.ts",
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "exports": {
+      ".": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "./package.json": "./package.json"
+    },
+    "main": "./dist/index.js",
+    "types": "./dist/index.d.ts"
+  },
+  "scripts": {
+    "build": "pkgroll"
+  },
+  "dependencies": {
+    "@xsai/shared": "workspace:~"
+  }
+}