@aigne/core 1.7.0 → 1.9.0

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;

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/agents/mcp-agent.d.ts

@@ -22,7 +22,7 @@ export type SSEServerParameters = {
     opts?: SSEClientTransportOptions;
     /**
      * The timeout for requests to the server, in milliseconds.
-     * @default 10000
+     * @default 60000
      */
     timeout?: number;
     /**
@@ -41,7 +41,7 @@ export declare class MCPAgent extends Agent {
     static from(options: MCPAgentOptions): MCPAgent;
     private static fromTransport;
     constructor(options: MCPAgentOptions);
-    private client;
+    client: Client;
     readonly prompts: MCPPrompt[] & {
         [key: string]: MCPPrompt;
     };
@@ -71,7 +71,6 @@ export interface MCPBaseOptions<I extends Message = Message, O extends Message =
 export declare abstract class MCPBase<I extends Message, O extends Message> extends Agent<I, O> {
     constructor(options: MCPBaseOptions<I, O>);
     protected client: ClientWithReconnect;
-    protected get mcpServer(): string | undefined;
 }
 export declare class MCPTool extends MCPBase<Message, CallToolResult> {
     process(input: Message): Promise<CallToolResult>;

package/lib/dts/loader/agent-yaml.d.ts

@@ -10,6 +10,7 @@ export declare function loadAgentFromYamlFile(path: string): Promise<{
     }, {
         [x: string]: any;
     }> | undefined;
+    tool_choice?: "auto" | "none" | "required" | "router" | undefined;
     output_schema?: ZodObject<Record<string, ZodType<any, z.ZodTypeDef, any>>, z.UnknownKeysParam, z.ZodTypeAny, {
         [x: string]: any;
     }, {

package/lib/dts/loader/index.d.ts

@@ -1,5 +1,6 @@
+import { z } from "zod";
 import { type Agent } from "../agents/agent.js";
-import type { ChatModel } from "../models/chat-model.js";
+import type { ChatModel, ChatModelOptions } from "../models/chat-model.js";
 export interface LoadOptions {
     path: string;
 }
@@ -19,6 +20,75 @@ export declare function load(options: LoadOptions): Promise<{
     } | null | undefined;
 }>;
 export declare function loadAgent(path: string): Promise<Agent>;
+export declare function loadModel(model?: z.infer<typeof aigneFileSchema>["chat_model"], modelOptions?: ChatModelOptions): Promise<ChatModel | undefined>;
+declare const aigneFileSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    chat_model: z.ZodEffects<z.ZodOptional<z.ZodNullable<z.ZodUnion<[z.ZodString, z.ZodObject<{
+        provider: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        temperature: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        top_p: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        frequent_penalty: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        presence_penalty: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    }, "strip", z.ZodTypeAny, {
+        name?: string | null | undefined;
+        temperature?: number | null | undefined;
+        provider?: string | null | undefined;
+        top_p?: number | null | undefined;
+        frequent_penalty?: number | null | undefined;
+        presence_penalty?: number | null | undefined;
+    }, {
+        name?: string | null | undefined;
+        temperature?: number | null | undefined;
+        provider?: string | null | undefined;
+        top_p?: number | null | undefined;
+        frequent_penalty?: number | null | undefined;
+        presence_penalty?: number | null | undefined;
+    }>]>>>, {
+        name?: string | null | undefined;
+        temperature?: number | null | undefined;
+        provider?: string | null | undefined;
+        top_p?: number | null | undefined;
+        frequent_penalty?: number | null | undefined;
+        presence_penalty?: number | null | undefined;
+    } | null | undefined, string | {
+        name?: string | null | undefined;
+        temperature?: number | null | undefined;
+        provider?: string | null | undefined;
+        top_p?: number | null | undefined;
+        frequent_penalty?: number | null | undefined;
+        presence_penalty?: number | null | undefined;
+    } | null | undefined>;
+    agents: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString, "many">>>;
+    tools: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString, "many">>>;
+}, "strip", z.ZodTypeAny, {
+    description?: string | null | undefined;
+    tools?: string[] | null | undefined;
+    name?: string | null | undefined;
+    chat_model?: {
+        name?: string | null | undefined;
+        temperature?: number | null | undefined;
+        provider?: string | null | undefined;
+        top_p?: number | null | undefined;
+        frequent_penalty?: number | null | undefined;
+        presence_penalty?: number | null | undefined;
+    } | null | undefined;
+    agents?: string[] | null | undefined;
+}, {
+    description?: string | null | undefined;
+    tools?: string[] | null | undefined;
+    name?: string | null | undefined;
+    chat_model?: string | {
+        name?: string | null | undefined;
+        temperature?: number | null | undefined;
+        provider?: string | null | undefined;
+        top_p?: number | null | undefined;
+        frequent_penalty?: number | null | undefined;
+        presence_penalty?: number | null | undefined;
+    } | null | undefined;
+    agents?: string[] | null | undefined;
+}>;
 export declare function loadAIGNEFile(path: string): Promise<{
     description?: string | null | undefined;
     tools?: string[] | null | undefined;
@@ -33,3 +103,4 @@ export declare function loadAIGNEFile(path: string): Promise<{
     } | null | undefined;
     agents?: string[] | null | undefined;
 }>;
+export {};

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;