@aigne/core 1.4.0 → 1.4.1-1

package/lib/cjs/agents/ai-agent.d.ts

@@ -1,5 +1,6 @@
+import { z } from "zod";
 import type { Context } from "../execution-engine/context.js";
-import type { ChatModel } from "../models/chat-model.js";
+import { ChatModel } from "../models/chat-model.js";
 import { PromptBuilder } from "../prompt/prompt-builder.js";
 import { Agent, type AgentOptions, type Message } from "./agent.js";
 export interface AIAgentOptions<I extends Message = Message, O extends Message = Message> extends AgentOptions<I, O> {
@@ -9,6 +10,53 @@ export interface AIAgentOptions<I extends Message = Message, O extends Message =
     toolChoice?: AIAgentToolChoice;
 }
 export type AIAgentToolChoice = "auto" | "none" | "required" | "router" | Agent;
+export declare const aiAgentToolChoiceSchema: z.ZodUnion<[z.ZodLiteral<"auto">, z.ZodLiteral<"none">, z.ZodLiteral<"required">, z.ZodLiteral<"router">, z.ZodType<Agent<Message, Message>, z.ZodTypeDef, Agent<Message, Message>>]>;
+export declare const aiAgentOptionsSchema: z.ZodObject<{
+    model: z.ZodOptional<z.ZodType<ChatModel, z.ZodTypeDef, ChatModel>>;
+    instructions: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodType<PromptBuilder, z.ZodTypeDef, PromptBuilder>]>>;
+    outputKey: z.ZodOptional<z.ZodString>;
+    toolChoice: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<"auto">, z.ZodLiteral<"none">, z.ZodLiteral<"required">, z.ZodLiteral<"router">, z.ZodType<Agent<Message, Message>, z.ZodTypeDef, Agent<Message, Message>>]>>;
+    enableHistory: z.ZodOptional<z.ZodBoolean>;
+    maxHistoryMessages: z.ZodOptional<z.ZodNumber>;
+    includeInputInOutput: z.ZodOptional<z.ZodBoolean>;
+    subscribeTopic: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
+    publishTopic: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">, z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodUnknown>]>>;
+    name: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    tools: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodType<Agent<Message, Message>, z.ZodTypeDef, Agent<Message, Message>>, z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodUnknown>]>, "many">>;
+    disableLogging: z.ZodOptional<z.ZodBoolean>;
+    memory: z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodAny, z.ZodAny]>>;
+}, "strip", z.ZodTypeAny, {
+    tools?: (Agent<Message, Message> | ((...args: unknown[]) => unknown))[] | undefined;
+    toolChoice?: "auto" | "none" | "required" | Agent<Message, Message> | "router" | undefined;
+    name?: string | undefined;
+    description?: string | undefined;
+    model?: ChatModel | undefined;
+    instructions?: string | PromptBuilder | undefined;
+    outputKey?: string | undefined;
+    enableHistory?: boolean | undefined;
+    maxHistoryMessages?: number | undefined;
+    includeInputInOutput?: boolean | undefined;
+    subscribeTopic?: string | string[] | undefined;
+    publishTopic?: string | string[] | ((...args: unknown[]) => unknown) | undefined;
+    disableLogging?: boolean | undefined;
+    memory?: any;
+}, {
+    tools?: (Agent<Message, Message> | ((...args: unknown[]) => unknown))[] | undefined;
+    toolChoice?: "auto" | "none" | "required" | Agent<Message, Message> | "router" | undefined;
+    name?: string | undefined;
+    description?: string | undefined;
+    model?: ChatModel | undefined;
+    instructions?: string | PromptBuilder | undefined;
+    outputKey?: string | undefined;
+    enableHistory?: boolean | undefined;
+    maxHistoryMessages?: number | undefined;
+    includeInputInOutput?: boolean | undefined;
+    subscribeTopic?: string | string[] | undefined;
+    publishTopic?: string | string[] | ((...args: unknown[]) => unknown) | undefined;
+    disableLogging?: boolean | undefined;
+    memory?: any;
+}>;
 export declare class AIAgent<I extends Message = Message, O extends Message = Message> extends Agent<I, O> {
     static from<I extends Message, O extends Message>(options: AIAgentOptions<I, O>): AIAgent<I, O>;
     constructor(options: AIAgentOptions<I, O>);

package/lib/cjs/agents/ai-agent.js

@@ -1,15 +1,41 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AIAgent = void 0;
+exports.AIAgent = exports.aiAgentOptionsSchema = exports.aiAgentToolChoiceSchema = void 0;
+const zod_1 = require("zod");
+const chat_model_js_1 = require("../models/chat-model.js");
 const prompt_builder_js_1 = require("../prompt/prompt-builder.js");
 const template_js_1 = require("../prompt/template.js");
 const agent_js_1 = require("./agent.js");
 const types_js_1 = require("./types.js");
+exports.aiAgentToolChoiceSchema = zod_1.z.union([
+    zod_1.z.literal("auto"),
+    zod_1.z.literal("none"),
+    zod_1.z.literal("required"),
+    zod_1.z.literal("router"),
+    zod_1.z.instanceof(agent_js_1.Agent),
+], { message: "aiAgentToolChoice must be 'auto', 'none', 'required', 'router', or an Agent" });
+exports.aiAgentOptionsSchema = zod_1.z.object({
+    model: zod_1.z.instanceof(chat_model_js_1.ChatModel).optional(),
+    instructions: zod_1.z.union([zod_1.z.string(), zod_1.z.instanceof(prompt_builder_js_1.PromptBuilder)]).optional(),
+    outputKey: zod_1.z.string().optional(),
+    toolChoice: exports.aiAgentToolChoiceSchema.optional(),
+    enableHistory: zod_1.z.boolean().optional(),
+    maxHistoryMessages: zod_1.z.number().optional(),
+    includeInputInOutput: zod_1.z.boolean().optional(),
+    subscribeTopic: zod_1.z.union([zod_1.z.string(), zod_1.z.array(zod_1.z.string())]).optional(),
+    publishTopic: zod_1.z.union([zod_1.z.string(), zod_1.z.array(zod_1.z.string()), zod_1.z.function()]).optional(),
+    name: zod_1.z.string().optional(),
+    description: zod_1.z.string().optional(),
+    tools: zod_1.z.array(zod_1.z.union([zod_1.z.instanceof(agent_js_1.Agent), zod_1.z.function()])).optional(),
+    disableLogging: zod_1.z.boolean().optional(),
+    memory: zod_1.z.union([zod_1.z.boolean(), zod_1.z.any(), zod_1.z.any()]).optional(),
+});
 class AIAgent extends agent_js_1.Agent {
     static from(options) {
         return new AIAgent(options);
     }
     constructor(options) {
+        exports.aiAgentOptionsSchema.parse(options);
         super(options);
         this.model = options.model;
         this.instructions =

package/lib/cjs/agents/mcp-agent.js

@@ -5,6 +5,7 @@ const index_js_1 = require("@modelcontextprotocol/sdk/client/index.js");
 const sse_js_1 = require("@modelcontextprotocol/sdk/client/sse.js");
 const stdio_js_1 = require("@modelcontextprotocol/sdk/client/stdio.js");
 const uriTemplate_js_1 = require("@modelcontextprotocol/sdk/shared/uriTemplate.js");
+const zod_1 = require("zod");
 const logger_js_1 = require("../utils/logger.js");
 const mcp_utils_js_1 = require("../utils/mcp-utils.js");
 const type_utils_js_1 = require("../utils/type-utils.js");
@@ -18,11 +19,21 @@ function isSSEServerParameters(options) {
 function isStdioServerParameters(options) {
     return "command" in options && typeof options.command === "string";
 }
+function getMCPServerString(options) {
+    if (isSSEServerParameters(options)) {
+        return options.url;
+    }
+    if (isStdioServerParameters(options)) {
+        return `${options.command} ${options.args?.join(" ") || ""}`;
+    }
+    return "unknown";
+}
 class MCPAgent extends agent_js_1.Agent {
     static from(options) {
+        (0, type_utils_js_1.checkArguments)("MCPAgent.from", mcpAgentOptionsSchema, options);
         if (isSSEServerParameters(options)) {
             const transport = new sse_js_1.SSEClientTransport(new URL(options.url));
-            return MCPAgent.fromTransport(transport);
+            return MCPAgent.fromTransport(transport, options);
         }
         if (isStdioServerParameters(options)) {
             const transport = new stdio_js_1.StdioClientTransport({
@@ -33,16 +44,16 @@ class MCPAgent extends agent_js_1.Agent {
                 },
                 stderr: "pipe",
             });
-            return MCPAgent.fromTransport(transport);
+            return MCPAgent.fromTransport(transport, options);
         }
         return new MCPAgent(options);
     }
-    static async fromTransport(transport) {
+    static async fromTransport(transport, options) {
         const client = new index_js_1.Client({
             name: MCP_AGENT_CLIENT_NAME,
             version: MCP_AGENT_CLIENT_VERSION,
         });
-        await debug.spinner(client.connect(transport), "Connecting to MCP server");
+        await debug.spinner(client.connect(transport), `Connecting to MCP server: ${getMCPServerString(options)}`);
         const mcpServer = getMCPServerName(client);
         const { tools: isToolsAvailable, prompts: isPromptsAvailable, resources: isResourcesAvailable, } = client.getServerCapabilities() ?? {};
         const tools = isToolsAvailable
@@ -142,3 +153,18 @@ function getMCPServerName(client) {
     const { name, version } = info;
     return `${name}@${version}`;
 }
+const mcpAgentOptionsSchema = zod_1.z.union([
+    zod_1.z.object({
+        client: zod_1.z.instanceof(index_js_1.Client),
+        prompts: zod_1.z.array(zod_1.z.instanceof(MCPPrompt)).optional(),
+        resources: zod_1.z.array(zod_1.z.instanceof(MCPResource)).optional(),
+    }),
+    zod_1.z.object({
+        url: zod_1.z.string(),
+    }),
+    zod_1.z.object({
+        command: zod_1.z.string(),
+        args: zod_1.z.array(zod_1.z.string()).optional(),
+        env: zod_1.z.record(zod_1.z.string()).optional(),
+    }),
+]);

package/lib/cjs/agents/memory.js

@@ -1,9 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AgentMemory = void 0;
+const zod_1 = require("zod");
 const type_utils_js_1 = require("../utils/type-utils.js");
 class AgentMemory {
     constructor(options) {
+        (0, type_utils_js_1.checkArguments)("AgentMemory", agentMemoryOptionsSchema, options);
         this.enabled = options.enabled ?? true;
         this.subscribeTopic = options.subscribeTopic;
         this.maxMemoriesInChat = options.maxMemoriesInChat;
@@ -36,3 +38,8 @@ class AgentMemory {
     }
 }
 exports.AgentMemory = AgentMemory;
+const agentMemoryOptionsSchema = zod_1.z.object({
+    enabled: zod_1.z.boolean().optional(),
+    subscribeTopic: zod_1.z.union([zod_1.z.string(), zod_1.z.array(zod_1.z.string())]).optional(),
+    maxMemoriesInChat: zod_1.z.number().optional(),
+});

package/lib/cjs/execution-engine/execution-engine.d.ts

@@ -1,7 +1,7 @@
 import EventEmitter from "node:events";
 import { Agent, type Message } from "../agents/agent.js";
 import { UserAgent } from "../agents/user-agent.js";
-import type { ChatModel } from "../models/chat-model.js";
+import { ChatModel } from "../models/chat-model.js";
 import type { Context, Runnable } from "./context.js";
 import { type MessagePayload, MessageQueue, type MessageQueueListener, type Unsubscribe } from "./message-queue.js";
 export interface ExecutionEngineOptions {

package/lib/cjs/execution-engine/execution-engine.js

@@ -6,13 +6,18 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExecutionEngine = void 0;
 const node_events_1 = __importDefault(require("node:events"));
 const lodash_es_1 = require("lodash-es");
+const zod_1 = require("zod");
 const agent_js_1 = require("../agents/agent.js");
 const types_js_1 = require("../agents/types.js");
 const user_agent_js_1 = require("../agents/user-agent.js");
+const chat_model_js_1 = require("../models/chat-model.js");
 const prompt_builder_js_1 = require("../prompt/prompt-builder.js");
+const type_utils_js_1 = require("../utils/type-utils.js");
 const message_queue_js_1 = require("./message-queue.js");
 class ExecutionEngine extends node_events_1.default {
     constructor(options) {
+        if (options)
+            (0, type_utils_js_1.checkArguments)("ExecutionEngine", executionEngineOptionsSchema, options);
         super();
         this.model = options?.model;
         this.tools = options?.tools ?? [];
@@ -25,6 +30,7 @@ class ExecutionEngine extends node_events_1.default {
     tools;
     agents = [];
     addAgent(...agents) {
+        (0, type_utils_js_1.checkArguments)("ExecutionEngine.addAgent", executionEngineAddAgentArgsSchema, agents);
         for (const agent of agents) {
             this.agents.push(agent);
             agent.attach(this);
@@ -40,6 +46,11 @@ class ExecutionEngine extends node_events_1.default {
      * @param from the agent who publish the message, if not provided, it will be treated as a user message
      */
     publish(topic, message, from) {
+        (0, type_utils_js_1.checkArguments)("ExecutionEngine.publish", executionEnginePublishArgsSchema, {
+            topic,
+            message,
+            from,
+        });
         const request = {
             role: !from || from instanceof user_agent_js_1.UserAgent ? "user" : "agent",
             source: from?.name,
@@ -48,6 +59,11 @@ class ExecutionEngine extends node_events_1.default {
         this.messageQueue.publish(topic, request);
     }
     call(agent, message, options) {
+        (0, type_utils_js_1.checkArguments)("ExecutionEngine.call", executionEngineCallArgsSchema, {
+            agent,
+            message,
+            options,
+        });
         if ((0, lodash_es_1.isNil)(message)) {
             let activeAgent = agent;
             return user_agent_js_1.UserAgent.from({
@@ -82,9 +98,17 @@ class ExecutionEngine extends node_events_1.default {
         return { output, agent: activeAgent };
     }
     subscribe(topic, listener) {
+        (0, type_utils_js_1.checkArguments)("ExecutionEngine.subscribe", executionEngineSubscribeArgsSchema, {
+            topic,
+            listener,
+        });
         return this.messageQueue.subscribe(topic, listener);
     }
     unsubscribe(topic, listener) {
+        (0, type_utils_js_1.checkArguments)("ExecutionEngine.unsubscribe", executionEngineUnsubscribeArgsSchema, {
+            topic,
+            listener,
+        });
         this.messageQueue.unsubscribe(topic, listener);
     }
     async callAgent(agent, input) {
@@ -134,3 +158,27 @@ class ExecutionEngine extends node_events_1.default {
     }
 }
 exports.ExecutionEngine = ExecutionEngine;
+const executionEngineOptionsSchema = zod_1.z.object({
+    model: zod_1.z.instanceof(chat_model_js_1.ChatModel).optional(),
+    tools: zod_1.z.array(zod_1.z.instanceof(agent_js_1.Agent)).optional(),
+    agents: zod_1.z.array(zod_1.z.instanceof(agent_js_1.Agent)).optional(),
+});
+const executionEngineAddAgentArgsSchema = zod_1.z.array(zod_1.z.instanceof(agent_js_1.Agent));
+const executionEnginePublishArgsSchema = zod_1.z.object({
+    topic: zod_1.z.union([zod_1.z.string(), zod_1.z.array(zod_1.z.string())]),
+    message: zod_1.z.union([zod_1.z.string(), zod_1.z.record(zod_1.z.unknown())]),
+    from: zod_1.z.instanceof(agent_js_1.Agent).optional(),
+});
+const executionEngineCallArgsSchema = zod_1.z.object({
+    agent: zod_1.z.union([zod_1.z.function(), zod_1.z.instanceof(agent_js_1.Agent)]),
+    message: zod_1.z.union([zod_1.z.record(zod_1.z.unknown()), zod_1.z.string()]).optional(),
+    options: zod_1.z.object({ returnActiveAgent: zod_1.z.boolean().optional() }).optional(),
+});
+const executionEngineSubscribeArgsSchema = zod_1.z.object({
+    topic: zod_1.z.string(),
+    listener: zod_1.z.function(zod_1.z.tuple([zod_1.z.any()]), zod_1.z.any()).optional(),
+});
+const executionEngineUnsubscribeArgsSchema = zod_1.z.object({
+    topic: zod_1.z.string(),
+    listener: zod_1.z.function(zod_1.z.tuple([zod_1.z.any()]), zod_1.z.any()),
+});

package/lib/cjs/execution-engine/utils.d.ts

@@ -1,4 +1,4 @@
-import type { FunctionAgentFn } from "../agents/agent.js";
+import { type FunctionAgentFn } from "../agents/agent.js";
 import type { Runnable } from "./context.js";
 export declare function sequential(..._agents: [Runnable, ...Runnable[]]): FunctionAgentFn;
 export declare function parallel(..._agents: [Runnable, ...Runnable[]]): FunctionAgentFn;

package/lib/cjs/execution-engine/utils.js

@@ -2,7 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.sequential = sequential;
 exports.parallel = parallel;
+const zod_1 = require("zod");
+const agent_js_1 = require("../agents/agent.js");
+const type_utils_js_1 = require("../utils/type-utils.js");
 function sequential(..._agents) {
+    (0, type_utils_js_1.checkArguments)("sequential", agentArraySchema, _agents);
     let agents = [..._agents];
     return async (input, context) => {
         if (!context)
@@ -20,6 +24,7 @@ function sequential(..._agents) {
     };
 }
 function parallel(..._agents) {
+    (0, type_utils_js_1.checkArguments)("parallel", agentArraySchema, _agents);
     let agents = [..._agents];
     return async (input, context) => {
         if (!context)
@@ -30,3 +35,4 @@ function parallel(..._agents) {
         return Object.assign({}, ...outputs);
     };
 }
+const agentArraySchema = zod_1.z.array(zod_1.z.union([zod_1.z.function(), zod_1.z.instanceof(agent_js_1.Agent)]));

package/lib/cjs/index.d.ts

@@ -14,3 +14,4 @@ export * from "./prompt/template.js";
 export * from "./utils/json-schema.js";
 export * from "./utils/logger.js";
 export * from "./utils/run-chat-loop.js";
+export * from "./utils/type-utils.js";

package/lib/cjs/index.js

@@ -30,3 +30,4 @@ __exportStar(require("./prompt/template.js"), exports);
 __exportStar(require("./utils/json-schema.js"), exports);
 __exportStar(require("./utils/logger.js"), exports);
 __exportStar(require("./utils/run-chat-loop.js"), exports);
+__exportStar(require("./utils/type-utils.js"), exports);

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

@@ -1,10 +1,59 @@
 import Anthropic from "@anthropic-ai/sdk";
+import { z } from "zod";
 import { ChatModel, type ChatModelInput, type ChatModelOptions, type ChatModelOutput } from "./chat-model.js";
 export interface ClaudeChatModelOptions {
     apiKey?: string;
     model?: string;
     modelOptions?: ChatModelOptions;
 }
+export declare const claudeChatModelOptionsSchema: z.ZodObject<{
+    apiKey: z.ZodOptional<z.ZodString>;
+    model: z.ZodOptional<z.ZodString>;
+    modelOptions: z.ZodOptional<z.ZodObject<{
+        model: z.ZodOptional<z.ZodString>;
+        temperature: z.ZodOptional<z.ZodNumber>;
+        topP: z.ZodOptional<z.ZodNumber>;
+        frequencyPenalty: z.ZodOptional<z.ZodNumber>;
+        presencePenalty: z.ZodOptional<z.ZodNumber>;
+        parallelToolCalls: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    }, "strip", z.ZodTypeAny, {
+        parallelToolCalls: boolean;
+        model?: string | undefined;
+        temperature?: number | undefined;
+        topP?: number | undefined;
+        frequencyPenalty?: number | undefined;
+        presencePenalty?: number | undefined;
+    }, {
+        model?: string | undefined;
+        temperature?: number | undefined;
+        topP?: number | undefined;
+        frequencyPenalty?: number | undefined;
+        presencePenalty?: number | undefined;
+        parallelToolCalls?: boolean | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    modelOptions?: {
+        parallelToolCalls: boolean;
+        model?: string | undefined;
+        temperature?: number | undefined;
+        topP?: number | undefined;
+        frequencyPenalty?: number | undefined;
+        presencePenalty?: number | undefined;
+    } | undefined;
+    model?: string | undefined;
+    apiKey?: string | undefined;
+}, {
+    modelOptions?: {
+        model?: string | undefined;
+        temperature?: number | undefined;
+        topP?: number | undefined;
+        frequencyPenalty?: number | undefined;
+        presencePenalty?: number | undefined;
+        parallelToolCalls?: boolean | undefined;
+    } | undefined;
+    model?: string | undefined;
+    apiKey?: string | undefined;
+}>;
 export declare class ClaudeChatModel extends ChatModel {
     options?: ClaudeChatModelOptions | undefined;
     constructor(options?: ClaudeChatModelOptions | undefined);

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

@@ -3,17 +3,34 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ClaudeChatModel = void 0;
+exports.ClaudeChatModel = exports.claudeChatModelOptionsSchema = void 0;
 const sdk_1 = __importDefault(require("@anthropic-ai/sdk"));
 const lodash_es_1 = require("lodash-es");
+const zod_1 = require("zod");
 const json_schema_js_1 = require("../utils/json-schema.js");
 const logger_js_1 = require("../utils/logger.js");
 const type_utils_js_1 = require("../utils/type-utils.js");
 const chat_model_js_1 = require("./chat-model.js");
 const CHAT_MODEL_CLAUDE_DEFAULT_MODEL = "claude-3-7-sonnet-latest";
+exports.claudeChatModelOptionsSchema = zod_1.z.object({
+    apiKey: zod_1.z.string().optional(),
+    model: zod_1.z.string().optional(),
+    modelOptions: zod_1.z
+        .object({
+        model: zod_1.z.string().optional(),
+        temperature: zod_1.z.number().optional(),
+        topP: zod_1.z.number().optional(),
+        frequencyPenalty: zod_1.z.number().optional(),
+        presencePenalty: zod_1.z.number().optional(),
+        parallelToolCalls: zod_1.z.boolean().optional().default(true),
+    })
+        .optional(),
+});
 class ClaudeChatModel extends chat_model_js_1.ChatModel {
     options;
     constructor(options) {
+        if (options)
+            (0, type_utils_js_1.checkArguments)("ClaudeChatModel", exports.claudeChatModelOptionsSchema, options);
         super();
         this.options = options;
     }

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

@@ -1,3 +1,4 @@
+import { z } from "zod";
 import { ChatModel, type ChatModelInput, type ChatModelOptions, type ChatModelOutput } from "./chat-model.js";
 export interface OpenAIChatModelOptions {
     apiKey?: string;
@@ -5,6 +6,57 @@ export interface OpenAIChatModelOptions {
     model?: string;
     modelOptions?: ChatModelOptions;
 }
+export declare const openAIChatModelOptionsSchema: z.ZodObject<{
+    apiKey: z.ZodOptional<z.ZodString>;
+    baseURL: z.ZodOptional<z.ZodString>;
+    model: z.ZodOptional<z.ZodString>;
+    modelOptions: z.ZodOptional<z.ZodObject<{
+        model: z.ZodOptional<z.ZodString>;
+        temperature: z.ZodOptional<z.ZodNumber>;
+        topP: z.ZodOptional<z.ZodNumber>;
+        frequencyPenalty: z.ZodOptional<z.ZodNumber>;
+        presencePenalty: z.ZodOptional<z.ZodNumber>;
+        parallelToolCalls: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    }, "strip", z.ZodTypeAny, {
+        parallelToolCalls: boolean;
+        model?: string | undefined;
+        temperature?: number | undefined;
+        topP?: number | undefined;
+        frequencyPenalty?: number | undefined;
+        presencePenalty?: number | undefined;
+    }, {
+        model?: string | undefined;
+        temperature?: number | undefined;
+        topP?: number | undefined;
+        frequencyPenalty?: number | undefined;
+        presencePenalty?: number | undefined;
+        parallelToolCalls?: boolean | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    modelOptions?: {
+        parallelToolCalls: boolean;
+        model?: string | undefined;
+        temperature?: number | undefined;
+        topP?: number | undefined;
+        frequencyPenalty?: number | undefined;
+        presencePenalty?: number | undefined;
+    } | undefined;
+    model?: string | undefined;
+    apiKey?: string | undefined;
+    baseURL?: string | undefined;
+}, {
+    modelOptions?: {
+        model?: string | undefined;
+        temperature?: number | undefined;
+        topP?: number | undefined;
+        frequencyPenalty?: number | undefined;
+        presencePenalty?: number | undefined;
+        parallelToolCalls?: boolean | undefined;
+    } | undefined;
+    model?: string | undefined;
+    apiKey?: string | undefined;
+    baseURL?: string | undefined;
+}>;
 export declare class OpenAIChatModel extends ChatModel {
     options?: OpenAIChatModelOptions | undefined;
     constructor(options?: OpenAIChatModelOptions | undefined);

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

@@ -3,16 +3,34 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.OpenAIChatModel = void 0;
+exports.OpenAIChatModel = exports.openAIChatModelOptionsSchema = void 0;
 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 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";
+exports.openAIChatModelOptionsSchema = zod_1.z.object({
+    apiKey: zod_1.z.string().optional(),
+    baseURL: zod_1.z.string().optional(),
+    model: zod_1.z.string().optional(),
+    modelOptions: zod_1.z
+        .object({
+        model: zod_1.z.string().optional(),
+        temperature: zod_1.z.number().optional(),
+        topP: zod_1.z.number().optional(),
+        frequencyPenalty: zod_1.z.number().optional(),
+        presencePenalty: zod_1.z.number().optional(),
+        parallelToolCalls: zod_1.z.boolean().optional().default(true),
+    })
+        .optional(),
+});
 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;
     }

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

@@ -1,3 +1,4 @@
+import { type ZodType } from "zod";
 export type PromiseOrValue<T> = T | Promise<T>;
 export type Nullish<T> = T | null | undefined;
 export declare function isNonNullable<T>(value: T): value is NonNullable<T>;
@@ -9,3 +10,4 @@ export declare function get(obj: unknown, path: string | string[], type: "number
 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;

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

@@ -5,7 +5,9 @@ exports.isNotEmpty = isNotEmpty;
 exports.orArrayToArray = orArrayToArray;
 exports.get = get;
 exports.createAccessorArray = createAccessorArray;
+exports.checkArguments = checkArguments;
 const lodash_es_1 = require("lodash-es");
+const zod_1 = require("zod");
 function isNonNullable(value) {
     return !(0, lodash_es_1.isNil)(value);
 }
@@ -29,3 +31,45 @@ function createAccessorArray(array, accessor) {
         get: (t, p, r) => Reflect.get(t, p, r) ?? accessor(array, p),
     });
 }
+function checkArguments(prefix, schema, args) {
+    try {
+        schema.parse(args, {
+            errorMap: (issue, ctx) => {
+                if (issue.code === "invalid_union") {
+                    // handle all issues that are not invalid_type
+                    const otherQuestions = issue.unionErrors
+                        .map(({ issues: [issue] }) => {
+                        if (issue && issue.code !== "invalid_type") {
+                            return issue.message || zod_1.z.defaultErrorMap(issue, ctx).message;
+                        }
+                    })
+                        .filter(isNonNullable);
+                    if (otherQuestions.length) {
+                        return { message: otherQuestions.join(", ") };
+                    }
+                    // handle invalid_type issues
+                    const expected = issue.unionErrors
+                        .map(({ issues: [issue] }) => {
+                        if (issue?.code === "invalid_type") {
+                            return issue;
+                        }
+                    })
+                        .filter(isNonNullable);
+                    if (expected.length) {
+                        return {
+                            message: `Expected ${expected.map((i) => i.expected).join(" or ")}, received ${expected[0]?.received}`,
+                        };
+                    }
+                }
+                return { message: ctx.defaultError };
+            },
+        });
+    }
+    catch (error) {
+        if (error instanceof zod_1.z.ZodError) {
+            const message = error.issues.map((i) => `${i.path}: ${i.message}`).join(", ");
+            throw new Error(`${prefix} check arguments error: ${message}`);
+        }
+        throw error;
+    }
+}