@aigne/core 1.8.0 → 1.9.0

package/lib/cjs/utils/type-utils.js

@@ -54,7 +54,7 @@ function createAccessorArray(array, accessor) {
 }
 function checkArguments(prefix, schema, args) {
     try {
-        schema.parse(args, {
+        return schema.parse(args, {
             errorMap: (issue, ctx) => {
                 if (issue.code === "invalid_union") {
                     // handle all issues that are not invalid_type

package/lib/dts/models/deepseek-chat-model.d.ts

@@ -0,0 +1,7 @@
+import { OpenAIChatModel, type OpenAIChatModelOptions } from "./openai-chat-model.js";
+export declare class DeepSeekChatModel extends OpenAIChatModel {
+    constructor(options?: OpenAIChatModelOptions);
+    protected apiKeyEnvName: string;
+    protected supportsNativeStructuredOutputs: boolean;
+    protected supportsToolsEmptyParameters: boolean;
+}

package/lib/dts/models/gemini-chat-model.d.ts

@@ -0,0 +1,8 @@
+import { OpenAIChatModel, type OpenAIChatModelOptions } from "./openai-chat-model.js";
+export declare class GeminiChatModel extends OpenAIChatModel {
+    constructor(options?: OpenAIChatModelOptions);
+    protected apiKeyEnvName: string;
+    protected supportsEndWithSystemMessage: boolean;
+    protected supportsToolsUseWithJsonSchema: boolean;
+    protected supportsParallelToolCalls: boolean;
+}

package/lib/dts/models/ollama-chat-model.d.ts

@@ -0,0 +1,6 @@
+import { OpenAIChatModel, type OpenAIChatModelOptions } from "./openai-chat-model.js";
+export declare class OllamaChatModel extends OpenAIChatModel {
+    constructor(options?: OpenAIChatModelOptions);
+    protected apiKeyEnvName: string;
+    protected apiKeyDefault: string;
+}

package/lib/dts/models/open-router-chat-model.d.ts

@@ -0,0 +1,5 @@
+import { OpenAIChatModel, type OpenAIChatModelOptions } from "./openai-chat-model.js";
+export declare class OpenRouterChatModel extends OpenAIChatModel {
+    constructor(options?: OpenAIChatModelOptions);
+    protected apiKeyEnvName: string;
+}

package/lib/dts/models/openai-chat-model.d.ts

@@ -1,6 +1,8 @@
 import OpenAI from "openai";
+import type { ChatCompletionMessageParam, ChatCompletionTool } from "openai/resources";
+import type { Stream } from "openai/streaming.js";
 import { z } from "zod";
-import { ChatModel, type ChatModelInput, type ChatModelOptions, type ChatModelOutput } from "./chat-model.js";
+import { ChatModel, type ChatModelInput, type ChatModelInputMessage, type ChatModelInputTool, type ChatModelOptions, type ChatModelOutput, type Role } from "./chat-model.js";
 export interface OpenAIChatModelOptions {
     apiKey?: string;
     baseURL?: string;
@@ -62,7 +64,27 @@ export declare class OpenAIChatModel extends ChatModel {
     options?: OpenAIChatModelOptions | undefined;
     constructor(options?: OpenAIChatModelOptions | undefined);
     protected _client?: OpenAI;
+    protected apiKeyEnvName: string;
+    protected apiKeyDefault: string | undefined;
+    protected supportsNativeStructuredOutputs: boolean;
+    protected supportsEndWithSystemMessage: boolean;
+    protected supportsToolsUseWithJsonSchema: boolean;
+    protected supportsParallelToolCalls: boolean;
+    protected supportsToolsEmptyParameters: boolean;
     get client(): OpenAI;
     get modelOptions(): ChatModelOptions | undefined;
     process(input: ChatModelInput): Promise<ChatModelOutput>;
+    private getParallelToolCalls;
+    private getRunMessages;
+    private getRunResponseFormat;
+    private requestStructuredOutput;
 }
+export declare const ROLE_MAP: {
+    [key in Role]: ChatCompletionMessageParam["role"];
+};
+export declare function contentsFromInputMessages(messages: ChatModelInputMessage[]): Promise<ChatCompletionMessageParam[]>;
+export declare function toolsFromInputTools(tools?: ChatModelInputTool[], options?: {
+    addTypeToEmptyParameters?: boolean;
+}): ChatCompletionTool[] | undefined;
+export declare function jsonSchemaToOpenAIJsonSchema(schema: Record<string, unknown>): Record<string, unknown>;
+export declare function extractResultFromStream(stream: Stream<OpenAI.Chat.Completions.ChatCompletionChunk>, jsonMode?: boolean): Promise<ChatModelOutput>;

package/lib/dts/models/xai-chat-model.d.ts

@@ -1,13 +1,5 @@
-import OpenAI from "openai";
-import type { ChatModelOptions } from "./chat-model.js";
-import { OpenAIChatModel } from "./openai-chat-model.js";
-export interface XAIChatModelOptions {
-    apiKey?: string;
-    model?: string;
-    modelOptions?: ChatModelOptions;
-    baseURL?: string;
-}
+import { OpenAIChatModel, type OpenAIChatModelOptions } from "./openai-chat-model.js";
 export declare class XAIChatModel extends OpenAIChatModel {
-    constructor(options?: XAIChatModelOptions);
-    get client(): OpenAI;
+    constructor(options?: OpenAIChatModelOptions);
+    protected apiKeyEnvName: string;
 }

package/lib/dts/utils/prompts.d.ts

@@ -0,0 +1 @@
+export declare function getJsonOutputPrompt(schema: Record<string, unknown> | string): string;

package/lib/dts/utils/type-utils.d.ts

@@ -11,5 +11,5 @@ export declare function orArrayToArray<T>(value?: T | T[]): T[];
 export declare function createAccessorArray<T>(array: T[], accessor: (array: T[], name: string) => T | undefined): T[] & {
     [key: string]: T;
 };
-export declare function checkArguments<T>(prefix: string, schema: ZodType<T>, args: T): void;
+export declare function checkArguments<T>(prefix: string, schema: ZodType<T>, args: T): T;
 export declare function tryOrThrow<P extends PromiseOrValue<unknown>>(fn: () => P, error: string | Error | ((error: Error) => Error)): P;

package/lib/esm/agents/agent.js

@@ -2,7 +2,7 @@ import { inspect } from "node:util";
 import { ZodObject, z } from "zod";
 import { createMessage } from "../prompt/prompt-builder.js";
 import { logger } from "../utils/logger.js";
-import { createAccessorArray, orArrayToArray, } from "../utils/type-utils.js";
+import { checkArguments, createAccessorArray, orArrayToArray, } from "../utils/type-utils.js";
 import { AgentMemory } from "./memory.js";
 import { replaceTransferAgentToName, transferToAgentOutput, } from "./types.js";
 export class Agent {
@@ -101,12 +101,12 @@ export class Agent {
         if (!this.disableEvents)
             ctx.emit("agentStarted", { agent: this, input: message });
         try {
-            const parsedInput = this.inputSchema.parse(message);
+            const parsedInput = checkArguments(`Agent ${this.name} input`, this.inputSchema, message);
             this.preprocess(parsedInput, ctx);
             this.checkContextStatus(ctx);
             const output = await this.process(parsedInput, ctx)
                 .then((output) => {
-                const parsedOutput = this.outputSchema.parse(output);
+                const parsedOutput = checkArguments(`Agent ${this.name} output`, this.outputSchema, output);
                 return this.includeInputInOutput ? { ...parsedInput, ...parsedOutput } : parsedOutput;
             })
                 .then((output) => {

package/lib/esm/loader/index.js

@@ -6,6 +6,10 @@ import { FunctionAgent } from "../agents/agent.js";
 import { AIAgent } from "../agents/ai-agent.js";
 import { MCPAgent } from "../agents/mcp-agent.js";
 import { ClaudeChatModel } from "../models/claude-chat-model.js";
+import { DeepSeekChatModel } from "../models/deepseek-chat-model.js";
+import { GeminiChatModel } from "../models/gemini-chat-model.js";
+import { OllamaChatModel } from "../models/ollama-chat-model.js";
+import { OpenRouterChatModel } from "../models/open-router-chat-model.js";
 import { OpenAIChatModel } from "../models/openai-chat-model.js";
 import { XAIChatModel } from "../models/xai-chat-model.js";
 import { tryOrThrow } from "../utils/type-utils.js";
@@ -68,17 +72,29 @@ export async function loadAgent(path) {
     }
     throw new Error(`Unsupported agent file type: ${path}`);
 }
-const { MODEL_PROVIDER = "openai", MODEL_NAME = "gpt-4o-mini" } = process.env;
+const { MODEL_PROVIDER, MODEL_NAME } = process.env;
+const DEFAULT_MODEL_PROVIDER = "openai";
+const DEFAULT_MODEL_NAME = "gpt-4o-mini";
 export async function loadModel(model, modelOptions) {
     const params = {
-        model: model?.name ?? MODEL_NAME,
+        model: MODEL_NAME ?? model?.name ?? DEFAULT_MODEL_NAME,
         temperature: model?.temperature ?? undefined,
         topP: model?.top_p ?? undefined,
         frequencyPenalty: model?.frequent_penalty ?? undefined,
         presencePenalty: model?.presence_penalty ?? undefined,
     };
-    const availableModels = [OpenAIChatModel, ClaudeChatModel, XAIChatModel];
-    const M = availableModels.find((m) => m.name.toLowerCase().includes(model?.provider || MODEL_PROVIDER));
+    const availableModels = [
+        OpenAIChatModel,
+        ClaudeChatModel,
+        XAIChatModel,
+        GeminiChatModel,
+        DeepSeekChatModel,
+        OpenRouterChatModel,
+        OllamaChatModel,
+    ];
+    const M = availableModels.find((m) => m.name
+        .toLowerCase()
+        .includes((MODEL_PROVIDER ?? model?.provider ?? DEFAULT_MODEL_PROVIDER).toLowerCase()));
     if (!M)
         throw new Error(`Unsupported model: ${model?.provider} ${model?.name}`);
     return new M({ model: params.model, modelOptions: { ...params, ...modelOptions } });

package/lib/esm/models/deepseek-chat-model.d.ts

@@ -0,0 +1,7 @@
+import { OpenAIChatModel, type OpenAIChatModelOptions } from "./openai-chat-model.js";
+export declare class DeepSeekChatModel extends OpenAIChatModel {
+    constructor(options?: OpenAIChatModelOptions);
+    protected apiKeyEnvName: string;
+    protected supportsNativeStructuredOutputs: boolean;
+    protected supportsToolsEmptyParameters: boolean;
+}

package/lib/esm/models/deepseek-chat-model.js

@@ -0,0 +1,15 @@
+import { OpenAIChatModel } from "./openai-chat-model.js";
+const DEEPSEEK_DEFAULT_CHAT_MODEL = "deepseek-chat";
+const DEEPSEEK_BASE_URL = "https://api.deepseek.com";
+export class DeepSeekChatModel extends OpenAIChatModel {
+    constructor(options) {
+        super({
+            ...options,
+            model: options?.model || DEEPSEEK_DEFAULT_CHAT_MODEL,
+            baseURL: options?.baseURL || DEEPSEEK_BASE_URL,
+        });
+    }
+    apiKeyEnvName = "DEEPSEEK_API_KEY";
+    supportsNativeStructuredOutputs = false;
+    supportsToolsEmptyParameters = false;
+}

package/lib/esm/models/gemini-chat-model.d.ts

@@ -0,0 +1,8 @@
+import { OpenAIChatModel, type OpenAIChatModelOptions } from "./openai-chat-model.js";
+export declare class GeminiChatModel extends OpenAIChatModel {
+    constructor(options?: OpenAIChatModelOptions);
+    protected apiKeyEnvName: string;
+    protected supportsEndWithSystemMessage: boolean;
+    protected supportsToolsUseWithJsonSchema: boolean;
+    protected supportsParallelToolCalls: boolean;
+}

package/lib/esm/models/gemini-chat-model.js

@@ -0,0 +1,16 @@
+import { OpenAIChatModel } from "./openai-chat-model.js";
+const GEMINI_BASE_URL = "https://generativelanguage.googleapis.com/v1beta/openai";
+const GEMINI_DEFAULT_CHAT_MODEL = "gemini-2.0-flash";
+export class GeminiChatModel extends OpenAIChatModel {
+    constructor(options) {
+        super({
+            ...options,
+            model: options?.model || GEMINI_DEFAULT_CHAT_MODEL,
+            baseURL: options?.baseURL || GEMINI_BASE_URL,
+        });
+    }
+    apiKeyEnvName = "GEMINI_API_KEY";
+    supportsEndWithSystemMessage = false;
+    supportsToolsUseWithJsonSchema = false;
+    supportsParallelToolCalls = false;
+}

package/lib/esm/models/ollama-chat-model.d.ts

@@ -0,0 +1,6 @@
+import { OpenAIChatModel, type OpenAIChatModelOptions } from "./openai-chat-model.js";
+export declare class OllamaChatModel extends OpenAIChatModel {
+    constructor(options?: OpenAIChatModelOptions);
+    protected apiKeyEnvName: string;
+    protected apiKeyDefault: string;
+}

package/lib/esm/models/ollama-chat-model.js

@@ -0,0 +1,14 @@
+import { OpenAIChatModel } from "./openai-chat-model.js";
+const OLLAMA_DEFAULT_BASE_URL = "http://localhost:11434/v1";
+const OLLAMA_DEFAULT_CHAT_MODEL = "llama3.2";
+export class OllamaChatModel extends OpenAIChatModel {
+    constructor(options) {
+        super({
+            ...options,
+            model: options?.model || OLLAMA_DEFAULT_CHAT_MODEL,
+            baseURL: options?.baseURL || process.env.OLLAMA_BASE_URL || OLLAMA_DEFAULT_BASE_URL,
+        });
+    }
+    apiKeyEnvName = "OLLAMA_API_KEY";
+    apiKeyDefault = "ollama";
+}

package/lib/esm/models/open-router-chat-model.d.ts

@@ -0,0 +1,5 @@
+import { OpenAIChatModel, type OpenAIChatModelOptions } from "./openai-chat-model.js";
+export declare class OpenRouterChatModel extends OpenAIChatModel {
+    constructor(options?: OpenAIChatModelOptions);
+    protected apiKeyEnvName: string;
+}

package/lib/esm/models/open-router-chat-model.js

@@ -0,0 +1,13 @@
+import { OpenAIChatModel } from "./openai-chat-model.js";
+const OPEN_ROUTER_DEFAULT_CHAT_MODEL = "openai/gpt-4o";
+const OPEN_ROUTER_BASE_URL = "https://openrouter.ai/api/v1";
+export class OpenRouterChatModel extends OpenAIChatModel {
+    constructor(options) {
+        super({
+            ...options,
+            model: options?.model || OPEN_ROUTER_DEFAULT_CHAT_MODEL,
+            baseURL: options?.baseURL || OPEN_ROUTER_BASE_URL,
+        });
+    }
+    apiKeyEnvName = "OPEN_ROUTER_API_KEY";
+}

package/lib/esm/models/openai-chat-model.d.ts

@@ -1,6 +1,8 @@
 import OpenAI from "openai";
+import type { ChatCompletionMessageParam, ChatCompletionTool } from "openai/resources";
+import type { Stream } from "openai/streaming.js";
 import { z } from "zod";
-import { ChatModel, type ChatModelInput, type ChatModelOptions, type ChatModelOutput } from "./chat-model.js";
+import { ChatModel, type ChatModelInput, type ChatModelInputMessage, type ChatModelInputTool, type ChatModelOptions, type ChatModelOutput, type Role } from "./chat-model.js";
 export interface OpenAIChatModelOptions {
     apiKey?: string;
     baseURL?: string;
@@ -62,7 +64,27 @@ export declare class OpenAIChatModel extends ChatModel {
     options?: OpenAIChatModelOptions | undefined;
     constructor(options?: OpenAIChatModelOptions | undefined);
     protected _client?: OpenAI;
+    protected apiKeyEnvName: string;
+    protected apiKeyDefault: string | undefined;
+    protected supportsNativeStructuredOutputs: boolean;
+    protected supportsEndWithSystemMessage: boolean;
+    protected supportsToolsUseWithJsonSchema: boolean;
+    protected supportsParallelToolCalls: boolean;
+    protected supportsToolsEmptyParameters: boolean;
     get client(): OpenAI;
     get modelOptions(): ChatModelOptions | undefined;
     process(input: ChatModelInput): Promise<ChatModelOutput>;
+    private getParallelToolCalls;
+    private getRunMessages;
+    private getRunResponseFormat;
+    private requestStructuredOutput;
 }
+export declare const ROLE_MAP: {
+    [key in Role]: ChatCompletionMessageParam["role"];
+};
+export declare function contentsFromInputMessages(messages: ChatModelInputMessage[]): Promise<ChatCompletionMessageParam[]>;
+export declare function toolsFromInputTools(tools?: ChatModelInputTool[], options?: {
+    addTypeToEmptyParameters?: boolean;
+}): ChatCompletionTool[] | undefined;
+export declare function jsonSchemaToOpenAIJsonSchema(schema: Record<string, unknown>): Record<string, unknown>;
+export declare function extractResultFromStream(stream: Stream<OpenAI.Chat.Completions.ChatCompletionChunk>, jsonMode?: boolean): Promise<ChatModelOutput>;

package/lib/esm/models/openai-chat-model.js

@@ -2,6 +2,8 @@ import { nanoid } from "nanoid";
 import OpenAI from "openai";
 import { z } from "zod";
 import { parseJSON } from "../utils/json-schema.js";
+import { mergeUsage } from "../utils/model-utils.js";
+import { getJsonOutputPrompt } from "../utils/prompts.js";
 import { checkArguments, isNonNullable } from "../utils/type-utils.js";
 import { ChatModel, } from "./chat-model.js";
 const CHAT_MODEL_OPENAI_DEFAULT_MODEL = "gpt-4o-mini";
@@ -23,16 +25,23 @@ export const openAIChatModelOptionsSchema = z.object({
 export class OpenAIChatModel extends ChatModel {
     options;
     constructor(options) {
-        if (options)
-            checkArguments("OpenAIChatModel", openAIChatModelOptionsSchema, options);
         super();
         this.options = options;
+        if (options)
+            checkArguments(this.name, openAIChatModelOptionsSchema, options);
     }
     _client;
+    apiKeyEnvName = "OPENAI_API_KEY";
+    apiKeyDefault;
+    supportsNativeStructuredOutputs = true;
+    supportsEndWithSystemMessage = true;
+    supportsToolsUseWithJsonSchema = true;
+    supportsParallelToolCalls = true;
+    supportsToolsEmptyParameters = true;
     get client() {
-        const apiKey = this.options?.apiKey || process.env.OPENAI_API_KEY;
+        const apiKey = this.options?.apiKey || process.env[this.apiKeyEnvName] || this.apiKeyDefault;
         if (!apiKey)
-            throw new Error("Api Key is required for OpenAIChatModel");
+            throw new Error(`Api Key is required for ${this.name}`);
         this._client ??= new OpenAI({
             baseURL: this.options?.baseURL,
             apiKey,
@@ -43,91 +52,104 @@ export class OpenAIChatModel extends ChatModel {
         return this.options?.modelOptions;
     }
     async process(input) {
-        const res = await this.client.chat.completions.create({
+        const body = {
             model: this.options?.model || CHAT_MODEL_OPENAI_DEFAULT_MODEL,
             temperature: input.modelOptions?.temperature ?? this.modelOptions?.temperature,
             top_p: input.modelOptions?.topP ?? this.modelOptions?.topP,
             frequency_penalty: input.modelOptions?.frequencyPenalty ?? this.modelOptions?.frequencyPenalty,
             presence_penalty: input.modelOptions?.presencePenalty ?? this.modelOptions?.presencePenalty,
-            messages: await contentsFromInputMessages(input.messages),
-            tools: toolsFromInputTools(input.tools),
-            tool_choice: input.toolChoice,
-            parallel_tool_calls: !input.tools?.length
-                ? undefined
-                : (input.modelOptions?.parallelToolCalls ?? this.modelOptions?.parallelToolCalls),
-            response_format: input.responseFormat?.type === "json_schema"
-                ? {
-                    type: "json_schema",
-                    json_schema: {
-                        ...input.responseFormat.jsonSchema,
-                        schema: jsonSchemaToOpenAIJsonSchema(input.responseFormat.jsonSchema.schema),
-                    },
-                }
-                : undefined,
+            messages: await this.getRunMessages(input),
             stream_options: {
                 include_usage: true,
             },
             stream: true,
+        };
+        const { jsonMode, responseFormat } = await this.getRunResponseFormat(input);
+        const stream = await this.client.chat.completions.create({
+            ...body,
+            tools: toolsFromInputTools(input.tools, {
+                addTypeToEmptyParameters: !this.supportsToolsEmptyParameters,
+            }),
+            tool_choice: input.toolChoice,
+            parallel_tool_calls: this.getParallelToolCalls(input),
+            response_format: responseFormat,
         });
-        let text = "";
-        const toolCalls = [];
-        let usage;
-        let model;
-        for await (const chunk of res) {
-            const choice = chunk.choices?.[0];
-            model ??= chunk.model;
-            if (choice?.delta.tool_calls?.length) {
-                for (const call of choice.delta.tool_calls) {
-                    toolCalls[call.index] ??= {
-                        id: call.id || nanoid(),
-                        type: "function",
-                        function: { name: "", arguments: {} },
-                        args: "",
-                    };
-                    const c = toolCalls[call.index];
-                    if (!c)
-                        throw new Error("Tool call not found");
-                    if (call.type)
-                        c.type = call.type;
-                    c.function.name = c.function.name + (call.function?.name || "");
-                    c.args = c.args.concat(call.function?.arguments || "");
-                }
-            }
-            if (choice?.delta.content)
-                text += choice.delta.content;
-            if (chunk.usage) {
-                usage = {
-                    inputTokens: chunk.usage.prompt_tokens,
-                    outputTokens: chunk.usage.completion_tokens,
-                };
-            }
+        const result = await extractResultFromStream(stream, jsonMode);
+        if (!this.supportsToolsUseWithJsonSchema &&
+            !result.toolCalls?.length &&
+            input.responseFormat?.type === "json_schema" &&
+            result.text) {
+            const output = await this.requestStructuredOutput(body, input.responseFormat);
+            return { ...output, usage: mergeUsage(result.usage, output.usage) };
         }
-        const result = {
-            usage,
-            model,
-        };
-        if (input.responseFormat?.type === "json_schema" && text) {
-            result.json = parseJSON(text);
+        return result;
+    }
+    getParallelToolCalls(input) {
+        if (!this.supportsParallelToolCalls)
+            return undefined;
+        if (!input.tools?.length)
+            return undefined;
+        return input.modelOptions?.parallelToolCalls ?? this.modelOptions?.parallelToolCalls;
+    }
+    async getRunMessages(input) {
+        const messages = await contentsFromInputMessages(input.messages);
+        if (!this.supportsEndWithSystemMessage && messages.at(-1)?.role !== "user") {
+            messages.push({ role: "user", content: "" });
         }
-        else {
-            result.text = text;
+        if (!this.supportsToolsUseWithJsonSchema && input.tools?.length)
+            return messages;
+        if (this.supportsNativeStructuredOutputs)
+            return messages;
+        if (input.responseFormat?.type === "json_schema") {
+            messages.unshift({
+                role: "system",
+                content: getJsonOutputPrompt(input.responseFormat.jsonSchema.schema),
+            });
         }
-        if (toolCalls.length) {
-            result.toolCalls = toolCalls.map(({ args, ...c }) => ({
-                ...c,
-                function: { ...c.function, arguments: parseJSON(args) },
-            }));
+        return messages;
+    }
+    async getRunResponseFormat(input) {
+        if (!this.supportsToolsUseWithJsonSchema && input.tools?.length)
+            return { jsonMode: false, responseFormat: undefined };
+        if (!this.supportsNativeStructuredOutputs) {
+            const jsonMode = input.responseFormat?.type === "json_schema";
+            return { jsonMode, responseFormat: jsonMode ? { type: "json_object" } : undefined };
         }
-        return result;
+        if (input.responseFormat?.type === "json_schema") {
+            return {
+                jsonMode: true,
+                responseFormat: {
+                    type: "json_schema",
+                    json_schema: {
+                        ...input.responseFormat.jsonSchema,
+                        schema: jsonSchemaToOpenAIJsonSchema(input.responseFormat.jsonSchema.schema),
+                    },
+                },
+            };
+        }
+        return { jsonMode: false, responseFormat: undefined };
+    }
+    async requestStructuredOutput(body, responseFormat) {
+        if (responseFormat?.type !== "json_schema") {
+            throw new Error("Expected json_schema response format");
+        }
+        const { jsonMode, responseFormat: resolvedResponseFormat } = await this.getRunResponseFormat({
+            responseFormat,
+        });
+        const res = await this.client.chat.completions.create({
+            ...body,
+            response_format: resolvedResponseFormat,
+        });
+        return extractResultFromStream(res, jsonMode);
     }
 }
-const ROLE_MAP = {
+export const ROLE_MAP = {
     system: "system",
     user: "user",
     agent: "assistant",
     tool: "tool",
 };
-async function contentsFromInputMessages(messages) {
+export async function contentsFromInputMessages(messages) {
     return messages.map((i) => ({
         role: ROLE_MAP[i.role],
         content: typeof i.content === "string"
@@ -156,19 +178,25 @@ async function contentsFromInputMessages(messages) {
         name: i.name,
     }));
 }
-function toolsFromInputTools(tools) {
+export function toolsFromInputTools(tools, options) {
     return tools?.length
-        ? tools.map((i) => ({
-            type: "function",
-            function: {
-                name: i.function.name,
-                description: i.function.description,
-                parameters: i.function.parameters,
-            },
-        }))
+        ? tools.map((i) => {
+            const parameters = i.function.parameters;
+            if (options?.addTypeToEmptyParameters && Object.keys(parameters).length === 0) {
+                parameters.type = "object";
+            }
+            return {
+                type: "function",
+                function: {
+                    name: i.function.name,
+                    description: i.function.description,
+                    parameters,
+                },
+            };
+        })
         : undefined;
 }
-function jsonSchemaToOpenAIJsonSchema(schema) {
+export function jsonSchemaToOpenAIJsonSchema(schema) {
     if (schema?.type === "object") {
         const { required, properties } = schema;
         return {
@@ -193,3 +221,75 @@ function jsonSchemaToOpenAIJsonSchema(schema) {
     }
     return schema;
 }
+export async function extractResultFromStream(stream, jsonMode = false) {
+    let text = "";
+    const toolCalls = [];
+    let usage;
+    let model;
+    for await (const chunk of stream) {
+        const choice = chunk.choices?.[0];
+        model ??= chunk.model;
+        if (choice?.delta.tool_calls?.length) {
+            for (const call of choice.delta.tool_calls) {
+                // Gemini not support tool call delta
+                if (call.index !== undefined) {
+                    handleToolCallDelta(toolCalls, call);
+                }
+                else {
+                    handleCompleteToolCall(toolCalls, call);
+                }
+            }
+        }
+        if (choice?.delta.content)
+            text += choice.delta.content;
+        if (chunk.usage) {
+            usage = {
+                inputTokens: chunk.usage.prompt_tokens,
+                outputTokens: chunk.usage.completion_tokens,
+            };
+        }
+    }
+    const result = {
+        usage,
+        model,
+    };
+    if (jsonMode && text) {
+        result.json = parseJSON(text);
+    }
+    else {
+        result.text = text;
+    }
+    if (toolCalls.length) {
+        result.toolCalls = toolCalls.map(({ args, ...c }) => ({
+            ...c,
+            function: { ...c.function, arguments: parseJSON(args) },
+        }));
+    }
+    return result;
+}
+function handleToolCallDelta(toolCalls, call) {
+    toolCalls[call.index] ??= {
+        id: call.id || nanoid(),
+        type: "function",
+        function: { name: "", arguments: {} },
+        args: "",
+    };
+    const c = toolCalls[call.index];
+    if (!c)
+        throw new Error("Tool call not found");
+    if (call.type)
+        c.type = call.type;
+    c.function.name = c.function.name + (call.function?.name || "");
+    c.args = c.args.concat(call.function?.arguments || "");
+}
+function handleCompleteToolCall(toolCalls, call) {
+    toolCalls.push({
+        id: call.id || nanoid(),
+        type: "function",
+        function: {
+            name: call.function?.name || "",
+            arguments: parseJSON(call.function?.arguments || "{}"),
+        },
+        args: call.function?.arguments || "",
+    });
+}

package/lib/esm/models/xai-chat-model.d.ts

@@ -1,13 +1,5 @@
-import OpenAI from "openai";
-import type { ChatModelOptions } from "./chat-model.js";
-import { OpenAIChatModel } from "./openai-chat-model.js";
-export interface XAIChatModelOptions {
-    apiKey?: string;
-    model?: string;
-    modelOptions?: ChatModelOptions;
-    baseURL?: string;
-}
+import { OpenAIChatModel, type OpenAIChatModelOptions } from "./openai-chat-model.js";
 export declare class XAIChatModel extends OpenAIChatModel {
-    constructor(options?: XAIChatModelOptions);
-    get client(): OpenAI;
+    constructor(options?: OpenAIChatModelOptions);
+    protected apiKeyEnvName: string;
 }