@aigne/core 1.8.0 → 1.9.0

package/CHANGELOG.md

@@ -22,6 +22,18 @@
 * rename @aigne/core-next to @aigne/core ([3a81009](https://github.com/AIGNE-io/aigne-framework/commit/3a8100962c81813217b687ae28e8de604419c622))
 * use text resource from MCP correctly ([8b9eba8](https://github.com/AIGNE-io/aigne-framework/commit/8b9eba83352ec096a2a5d4f410d4c4bde7420bce))
 
+## [1.9.0](https://github.com/AIGNE-io/aigne-framework/compare/core-v1.8.0...core-v1.9.0) (2025-04-20)
+
+
+### Features
+
+* **core:** add model adapters for DeepSeek, Gemini, OpenRouter, and Ollama ([#53](https://github.com/AIGNE-io/aigne-framework/issues/53)) ([5d40546](https://github.com/AIGNE-io/aigne-framework/commit/5d40546bd5ddb70233d27ea3b20e5711b2af320a))
+
+
+### Bug Fixes
+
+* **dx:** custom error message for agent input/output validation ([#71](https://github.com/AIGNE-io/aigne-framework/issues/71)) ([5145673](https://github.com/AIGNE-io/aigne-framework/commit/5145673aaae2cd6665912e80b1c644e974c42b2f))
+
 ## [1.8.0](https://github.com/AIGNE-io/aigne-framework/compare/core-v1.7.0...core-v1.8.0) (2025-04-17)
 
 

package/lib/cjs/agents/agent.js

@@ -137,12 +137,12 @@ class Agent {
         if (!this.disableEvents)
             ctx.emit("agentStarted", { agent: this, input: message });
         try {
-            const parsedInput = this.inputSchema.parse(message);
+            const parsedInput = (0, type_utils_js_1.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 = (0, type_utils_js_1.checkArguments)(`Agent ${this.name} output`, this.outputSchema, output);
                 return this.includeInputInOutput ? { ...parsedInput, ...parsedOutput } : parsedOutput;
             })
                 .then((output) => {

package/lib/cjs/loader/index.js

@@ -12,6 +12,10 @@ const agent_js_1 = require("../agents/agent.js");
 const ai_agent_js_1 = require("../agents/ai-agent.js");
 const mcp_agent_js_1 = require("../agents/mcp-agent.js");
 const claude_chat_model_js_1 = require("../models/claude-chat-model.js");
+const deepseek_chat_model_js_1 = require("../models/deepseek-chat-model.js");
+const gemini_chat_model_js_1 = require("../models/gemini-chat-model.js");
+const ollama_chat_model_js_1 = require("../models/ollama-chat-model.js");
+const open_router_chat_model_js_1 = require("../models/open-router-chat-model.js");
 const openai_chat_model_js_1 = require("../models/openai-chat-model.js");
 const xai_chat_model_js_1 = require("../models/xai-chat-model.js");
 const type_utils_js_1 = require("../utils/type-utils.js");
@@ -74,17 +78,29 @@ 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";
 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 = [openai_chat_model_js_1.OpenAIChatModel, claude_chat_model_js_1.ClaudeChatModel, xai_chat_model_js_1.XAIChatModel];
-    const M = availableModels.find((m) => m.name.toLowerCase().includes(model?.provider || MODEL_PROVIDER));
+    const availableModels = [
+        openai_chat_model_js_1.OpenAIChatModel,
+        claude_chat_model_js_1.ClaudeChatModel,
+        xai_chat_model_js_1.XAIChatModel,
+        gemini_chat_model_js_1.GeminiChatModel,
+        deepseek_chat_model_js_1.DeepSeekChatModel,
+        open_router_chat_model_js_1.OpenRouterChatModel,
+        ollama_chat_model_js_1.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/cjs/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/cjs/models/deepseek-chat-model.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeepSeekChatModel = void 0;
+const openai_chat_model_js_1 = require("./openai-chat-model.js");
+const DEEPSEEK_DEFAULT_CHAT_MODEL = "deepseek-chat";
+const DEEPSEEK_BASE_URL = "https://api.deepseek.com";
+class DeepSeekChatModel extends openai_chat_model_js_1.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;
+}
+exports.DeepSeekChatModel = DeepSeekChatModel;

package/lib/cjs/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/cjs/models/gemini-chat-model.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GeminiChatModel = void 0;
+const openai_chat_model_js_1 = require("./openai-chat-model.js");
+const GEMINI_BASE_URL = "https://generativelanguage.googleapis.com/v1beta/openai";
+const GEMINI_DEFAULT_CHAT_MODEL = "gemini-2.0-flash";
+class GeminiChatModel extends openai_chat_model_js_1.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;
+}
+exports.GeminiChatModel = GeminiChatModel;

package/lib/cjs/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/cjs/models/ollama-chat-model.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OllamaChatModel = void 0;
+const openai_chat_model_js_1 = require("./openai-chat-model.js");
+const OLLAMA_DEFAULT_BASE_URL = "http://localhost:11434/v1";
+const OLLAMA_DEFAULT_CHAT_MODEL = "llama3.2";
+class OllamaChatModel extends openai_chat_model_js_1.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";
+}
+exports.OllamaChatModel = OllamaChatModel;

package/lib/cjs/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/cjs/models/open-router-chat-model.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenRouterChatModel = void 0;
+const openai_chat_model_js_1 = require("./openai-chat-model.js");
+const OPEN_ROUTER_DEFAULT_CHAT_MODEL = "openai/gpt-4o";
+const OPEN_ROUTER_BASE_URL = "https://openrouter.ai/api/v1";
+class OpenRouterChatModel extends openai_chat_model_js_1.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";
+}
+exports.OpenRouterChatModel = OpenRouterChatModel;

package/lib/cjs/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/cjs/models/openai-chat-model.js

@@ -3,11 +3,17 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.OpenAIChatModel = exports.openAIChatModelOptionsSchema = void 0;
+exports.ROLE_MAP = exports.OpenAIChatModel = exports.openAIChatModelOptionsSchema = void 0;
+exports.contentsFromInputMessages = contentsFromInputMessages;
+exports.toolsFromInputTools = toolsFromInputTools;
+exports.jsonSchemaToOpenAIJsonSchema = jsonSchemaToOpenAIJsonSchema;
+exports.extractResultFromStream = extractResultFromStream;
 const nanoid_1 = require("nanoid");
 const openai_1 = __importDefault(require("openai"));
 const zod_1 = require("zod");
 const json_schema_js_1 = require("../utils/json-schema.js");
+const model_utils_js_1 = require("../utils/model-utils.js");
+const prompts_js_1 = require("../utils/prompts.js");
 const type_utils_js_1 = require("../utils/type-utils.js");
 const chat_model_js_1 = require("./chat-model.js");
 const CHAT_MODEL_OPENAI_DEFAULT_MODEL = "gpt-4o-mini";
@@ -29,16 +35,23 @@ exports.openAIChatModelOptionsSchema = zod_1.z.object({
 class OpenAIChatModel extends chat_model_js_1.ChatModel {
     options;
     constructor(options) {
-        if (options)
-            (0, type_utils_js_1.checkArguments)("OpenAIChatModel", exports.openAIChatModelOptionsSchema, options);
         super();
         this.options = options;
+        if (options)
+            (0, type_utils_js_1.checkArguments)(this.name, exports.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_1.default({
             baseURL: this.options?.baseURL,
             apiKey,
@@ -49,86 +62,99 @@ class OpenAIChatModel extends chat_model_js_1.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 || (0, nanoid_1.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: (0, model_utils_js_1.mergeUsage)(result.usage, output.usage) };
         }
-        const result = {
-            usage,
-            model,
-        };
-        if (input.responseFormat?.type === "json_schema" && text) {
-            result.json = (0, json_schema_js_1.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: (0, prompts_js_1.getJsonOutputPrompt)(input.responseFormat.jsonSchema.schema),
+            });
         }
-        if (toolCalls.length) {
-            result.toolCalls = toolCalls.map(({ args, ...c }) => ({
-                ...c,
-                function: { ...c.function, arguments: (0, json_schema_js_1.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);
     }
 }
 exports.OpenAIChatModel = OpenAIChatModel;
-const ROLE_MAP = {
+exports.ROLE_MAP = {
     system: "system",
     user: "user",
     agent: "assistant",
@@ -136,7 +162,7 @@ const ROLE_MAP = {
 };
 async function contentsFromInputMessages(messages) {
     return messages.map((i) => ({
-        role: ROLE_MAP[i.role],
+        role: exports.ROLE_MAP[i.role],
         content: typeof i.content === "string"
             ? i.content
             : i.content
@@ -163,16 +189,22 @@ async function contentsFromInputMessages(messages) {
         name: i.name,
     }));
 }
-function toolsFromInputTools(tools) {
+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) {
@@ -200,3 +232,75 @@ function jsonSchemaToOpenAIJsonSchema(schema) {
     }
     return schema;
 }
+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 = (0, json_schema_js_1.parseJSON)(text);
+    }
+    else {
+        result.text = text;
+    }
+    if (toolCalls.length) {
+        result.toolCalls = toolCalls.map(({ args, ...c }) => ({
+            ...c,
+            function: { ...c.function, arguments: (0, json_schema_js_1.parseJSON)(args) },
+        }));
+    }
+    return result;
+}
+function handleToolCallDelta(toolCalls, call) {
+    toolCalls[call.index] ??= {
+        id: call.id || (0, nanoid_1.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 || (0, nanoid_1.nanoid)(),
+        type: "function",
+        function: {
+            name: call.function?.name || "",
+            arguments: (0, json_schema_js_1.parseJSON)(call.function?.arguments || "{}"),
+        },
+        args: call.function?.arguments || "",
+    });
+}

package/lib/cjs/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/cjs/models/xai-chat-model.js

@@ -1,10 +1,6 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.XAIChatModel = void 0;
-const openai_1 = __importDefault(require("openai"));
 const openai_chat_model_js_1 = require("./openai-chat-model.js");
 const XAI_DEFAULT_CHAT_MODEL = "grok-2-latest";
 const XAI_BASE_URL = "https://api.x.ai/v1";
@@ -16,15 +12,6 @@ class XAIChatModel extends openai_chat_model_js_1.OpenAIChatModel {
             baseURL: options?.baseURL || XAI_BASE_URL,
         });
     }
-    get client() {
-        const apiKey = this.options?.apiKey || process.env.XAI_API_KEY;
-        if (!apiKey)
-            throw new Error("Api Key is required for XAIChatModel");
-        this._client ??= new openai_1.default({
-            baseURL: this.options?.baseURL,
-            apiKey,
-        });
-        return this._client;
-    }
+    apiKeyEnvName = "XAI_API_KEY";
 }
 exports.XAIChatModel = XAIChatModel;

package/lib/cjs/prompt/prompt-builder.js

@@ -132,6 +132,7 @@ class PromptBuilder {
             },
         }));
         let toolChoice;
+        const modelOptions = {};
         // use manual choice if configured in the agent
         const manualChoice = options.agent?.toolChoice;
         if (manualChoice) {
@@ -146,6 +147,7 @@ class PromptBuilder {
             }
             else if (manualChoice === "router") {
                 toolChoice = "required";
+                modelOptions.parallelToolCalls = false;
             }
             else {
                 toolChoice = manualChoice;
@@ -159,6 +161,7 @@ class PromptBuilder {
             toolAgents: toolAgents.length ? toolAgents : undefined,
             tools: tools.length ? tools : undefined,
             toolChoice,
+            modelOptions: Object.keys(modelOptions).length ? modelOptions : undefined,
         };
     }
 }

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

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

package/lib/cjs/utils/prompts.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getJsonOutputPrompt = getJsonOutputPrompt;
+function getJsonOutputPrompt(schema) {
+    let prompt = "Provide your output as a JSON containing the following fields:";
+    if (typeof schema === "string") {
+        prompt += `\n<json_fields>\n${schema}\n</json_fields>`;
+    }
+    else {
+        prompt += `\n<json_fields>\n${JSON.stringify(schema)}\n</json_fields>`;
+    }
+    return prompt;
+}

package/lib/cjs/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;