@aigne/core 1.8.0 → 1.10.0

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,6 @@
+import { OpenAIChatModel, type OpenAIChatModelOptions } from "./openai-chat-model.js";
+export declare class OpenRouterChatModel extends OpenAIChatModel {
+    constructor(options?: OpenAIChatModelOptions);
+    protected apiKeyEnvName: string;
+    protected supportsParallelToolCalls: boolean;
+}

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

@@ -0,0 +1,18 @@
+"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";
+    supportsParallelToolCalls = false;
+}
+exports.OpenRouterChatModel = OpenRouterChatModel;

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

@@ -1,6 +1,17 @@
 import OpenAI from "openai";
+import type { ChatCompletionMessageParam, ChatCompletionTool } from "openai/resources";
 import { z } from "zod";
-import { ChatModel, type ChatModelInput, type ChatModelOptions, type ChatModelOutput } from "./chat-model.js";
+import type { AgentCallOptions, AgentResponse } from "../agents/agent.js";
+import type { Context } from "../execution-engine/context.js";
+import { ChatModel, type ChatModelInput, type ChatModelInputMessage, type ChatModelInputTool, type ChatModelOptions, type ChatModelOutput, type Role } from "./chat-model.js";
+export interface OpenAIChatModelCapabilities {
+    supportsNativeStructuredOutputs: boolean;
+    supportsEndWithSystemMessage: boolean;
+    supportsToolsUseWithJsonSchema: boolean;
+    supportsParallelToolCalls: boolean;
+    supportsToolsEmptyParameters: boolean;
+    supportsTemperature: boolean;
+}
 export interface OpenAIChatModelOptions {
     apiKey?: string;
     baseURL?: string;
@@ -62,7 +73,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;
+    protected supportsTemperature: boolean;
     get client(): OpenAI;
     get modelOptions(): ChatModelOptions | undefined;
-    process(input: ChatModelInput): Promise<ChatModelOutput>;
+    process(input: ChatModelInput, _context: Context, options?: AgentCallOptions): Promise<AgentResponse<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>;

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

@@ -3,14 +3,24 @@ 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;
 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 stream_utils_js_1 = require("../utils/stream-utils.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";
+const OPENAI_CHAT_MODEL_CAPABILITIES = {
+    "o4-mini": { supportsParallelToolCalls: false, supportsTemperature: false },
+    "o3-mini": { supportsParallelToolCalls: false, supportsTemperature: false },
+};
 exports.openAIChatModelOptionsSchema = zod_1.z.object({
     apiKey: zod_1.z.string().optional(),
     baseURL: zod_1.z.string().optional(),
@@ -29,16 +39,26 @@ 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);
+        const preset = options?.model ? OPENAI_CHAT_MODEL_CAPABILITIES[options.model] : undefined;
+        Object.assign(this, preset);
     }
     _client;
+    apiKeyEnvName = "OPENAI_API_KEY";
+    apiKeyDefault;
+    supportsNativeStructuredOutputs = true;
+    supportsEndWithSystemMessage = true;
+    supportsToolsUseWithJsonSchema = true;
+    supportsParallelToolCalls = true;
+    supportsToolsEmptyParameters = true;
+    supportsTemperature = 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,
@@ -48,87 +68,106 @@ class OpenAIChatModel extends chat_model_js_1.ChatModel {
     get modelOptions() {
         return this.options?.modelOptions;
     }
-    async process(input) {
-        const res = await this.client.chat.completions.create({
+    async process(input, _context, options) {
+        const messages = await this.getRunMessages(input);
+        const body = {
             model: this.options?.model || CHAT_MODEL_OPENAI_DEFAULT_MODEL,
-            temperature: input.modelOptions?.temperature ?? this.modelOptions?.temperature,
+            temperature: this.supportsTemperature
+                ? (input.modelOptions?.temperature ?? this.modelOptions?.temperature)
+                : undefined,
             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,
             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,
-                };
-            }
+        if (options?.streaming && input.responseFormat?.type !== "json_schema") {
+            return await extractResultFromStream(stream, false, true);
         }
-        const result = {
-            usage,
-            model,
-        };
-        if (input.responseFormat?.type === "json_schema" && text) {
-            result.json = (0, json_schema_js_1.parseJSON)(text);
+        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) };
         }
-        else {
-            result.text = 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: "" });
         }
-        if (toolCalls.length) {
-            result.toolCalls = toolCalls.map(({ args, ...c }) => ({
-                ...c,
-                function: { ...c.function, arguments: (0, json_schema_js_1.parseJSON)(args) },
-            }));
+        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),
+            });
         }
-        return result;
+        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 };
+        }
+        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 +175,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 +202,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 +245,128 @@ function jsonSchemaToOpenAIJsonSchema(schema) {
     }
     return schema;
 }
+async function extractResultFromStream(stream, jsonMode, streaming) {
+    const result = new ReadableStream({
+        async start(controller) {
+            try {
+                let text = "";
+                let refusal = "";
+                const toolCalls = [];
+                let model;
+                for await (const chunk of stream) {
+                    const choice = chunk.choices?.[0];
+                    if (!model) {
+                        model = chunk.model;
+                        controller.enqueue({
+                            delta: {
+                                json: {
+                                    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 (!jsonMode) {
+                            controller.enqueue({
+                                delta: {
+                                    text: {
+                                        text: choice.delta.content,
+                                    },
+                                },
+                            });
+                        }
+                    }
+                    if (choice?.delta.refusal) {
+                        refusal += choice.delta.refusal;
+                        if (!jsonMode) {
+                            controller.enqueue({
+                                delta: {
+                                    text: { text: choice.delta.refusal },
+                                },
+                            });
+                        }
+                    }
+                    if (chunk.usage) {
+                        controller.enqueue({
+                            delta: {
+                                json: {
+                                    usage: {
+                                        inputTokens: chunk.usage.prompt_tokens,
+                                        outputTokens: chunk.usage.completion_tokens,
+                                    },
+                                },
+                            },
+                        });
+                    }
+                }
+                text = text || refusal;
+                if (jsonMode && text) {
+                    controller.enqueue({
+                        delta: {
+                            json: {
+                                json: (0, json_schema_js_1.parseJSON)(text),
+                            },
+                        },
+                    });
+                }
+                if (toolCalls.length) {
+                    controller.enqueue({
+                        delta: {
+                            json: {
+                                toolCalls: toolCalls.map(({ args, ...c }) => ({
+                                    ...c,
+                                    function: { ...c.function, arguments: (0, json_schema_js_1.parseJSON)(args) },
+                                })),
+                            },
+                        },
+                    });
+                }
+            }
+            catch (error) {
+                controller.error(error);
+            }
+            finally {
+                controller.close();
+            }
+        },
+    });
+    return streaming ? result : await (0, stream_utils_js_1.agentResponseStreamToObject)(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/stream-utils.d.ts

@@ -0,0 +1,15 @@
+import type { AgentProcessAsyncGenerator, AgentResponseChunk, AgentResponseStream, Message } from "../agents/agent.js";
+import { type PromiseOrValue } from "./type-utils.js";
+export declare function objectToAgentResponseStream<T extends Message>(json: T): AgentResponseStream<T>;
+export declare function mergeAgentResponseChunk<T extends Message>(output: T, chunk: AgentResponseChunk<T>): T;
+export declare function agentResponseStreamToObject<T extends Message>(stream: AgentResponseStream<T> | AgentProcessAsyncGenerator<T>): Promise<T>;
+export declare function asyncGeneratorToReadableStream<T extends Message>(generator: AgentProcessAsyncGenerator<T>): AgentResponseStream<T>;
+export declare function onAgentResponseStreamEnd<T extends Message>(stream: AgentResponseStream<T>, callback: (result: T) => PromiseOrValue<Partial<T> | void>, options?: {
+    errorCallback?: (error: Error) => Error;
+    processChunk?: (chunk: AgentResponseChunk<T>) => AgentResponseChunk<T>;
+}): ReadableStream<any>;
+export declare function isAsyncGenerator<T extends AsyncGenerator>(value: AsyncGenerator | unknown): value is T;
+export declare function arrayToAgentProcessAsyncGenerator<T extends Message>(chunks: (AgentResponseChunk<T> | Error)[], result?: Partial<T>): AgentProcessAsyncGenerator<T>;
+export declare function arrayToAgentResponseStream<T>(chunks: (AgentResponseChunk<T> | Error)[]): AgentResponseStream<T>;
+export declare function readableStreamToArray<T>(stream: ReadableStream<T>): Promise<T[]>;
+export declare function readableStreamToAsyncIterator<T>(stream: ReadableStream<T>): AsyncIterable<T>;