@aigne/core 1.4.0 → 1.4.1-0

package/lib/dts/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/dts/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/dts/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/dts/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/dts/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/dts/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/dts/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/esm/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/esm/agents/ai-agent.js

@@ -1,12 +1,38 @@
+import { z } from "zod";
+import { ChatModel } from "../models/chat-model.js";
 import { MESSAGE_KEY, PromptBuilder } from "../prompt/prompt-builder.js";
 import { AgentMessageTemplate, ToolMessageTemplate } from "../prompt/template.js";
 import { Agent } from "./agent.js";
 import { isTransferAgentOutput } from "./types.js";
+export const aiAgentToolChoiceSchema = z.union([
+    z.literal("auto"),
+    z.literal("none"),
+    z.literal("required"),
+    z.literal("router"),
+    z.instanceof(Agent),
+], { message: "aiAgentToolChoice must be 'auto', 'none', 'required', 'router', or an Agent" });
+export const aiAgentOptionsSchema = z.object({
+    model: z.instanceof(ChatModel).optional(),
+    instructions: z.union([z.string(), z.instanceof(PromptBuilder)]).optional(),
+    outputKey: z.string().optional(),
+    toolChoice: aiAgentToolChoiceSchema.optional(),
+    enableHistory: z.boolean().optional(),
+    maxHistoryMessages: z.number().optional(),
+    includeInputInOutput: z.boolean().optional(),
+    subscribeTopic: z.union([z.string(), z.array(z.string())]).optional(),
+    publishTopic: z.union([z.string(), z.array(z.string()), z.function()]).optional(),
+    name: z.string().optional(),
+    description: z.string().optional(),
+    tools: z.array(z.union([z.instanceof(Agent), z.function()])).optional(),
+    disableLogging: z.boolean().optional(),
+    memory: z.union([z.boolean(), z.any(), z.any()]).optional(),
+});
 export class AIAgent extends Agent {
     static from(options) {
         return new AIAgent(options);
     }
     constructor(options) {
+        aiAgentOptionsSchema.parse(options);
         super(options);
         this.model = options.model;
         this.instructions =

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

@@ -2,9 +2,10 @@ import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
 import { StdioClientTransport, getDefaultEnvironment, } from "@modelcontextprotocol/sdk/client/stdio.js";
 import { UriTemplate } from "@modelcontextprotocol/sdk/shared/uriTemplate.js";
+import { z } from "zod";
 import { logger } from "../utils/logger.js";
 import { promptFromMCPPrompt, resourceFromMCPResource, toolFromMCPTool, } from "../utils/mcp-utils.js";
-import { createAccessorArray } from "../utils/type-utils.js";
+import { checkArguments, createAccessorArray } from "../utils/type-utils.js";
 import { Agent } from "./agent.js";
 const MCP_AGENT_CLIENT_NAME = "MCPAgent";
 const MCP_AGENT_CLIENT_VERSION = "0.0.1";
@@ -15,11 +16,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";
+}
 export class MCPAgent extends Agent {
     static from(options) {
+        checkArguments("MCPAgent.from", mcpAgentOptionsSchema, options);
         if (isSSEServerParameters(options)) {
             const transport = new SSEClientTransport(new URL(options.url));
-            return MCPAgent.fromTransport(transport);
+            return MCPAgent.fromTransport(transport, options);
         }
         if (isStdioServerParameters(options)) {
             const transport = new StdioClientTransport({
@@ -30,16 +41,16 @@ export class MCPAgent extends 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 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
@@ -134,3 +145,18 @@ function getMCPServerName(client) {
     const { name, version } = info;
     return `${name}@${version}`;
 }
+const mcpAgentOptionsSchema = z.union([
+    z.object({
+        client: z.instanceof(Client),
+        prompts: z.array(z.instanceof(MCPPrompt)).optional(),
+        resources: z.array(z.instanceof(MCPResource)).optional(),
+    }),
+    z.object({
+        url: z.string(),
+    }),
+    z.object({
+        command: z.string(),
+        args: z.array(z.string()).optional(),
+        env: z.record(z.string()).optional(),
+    }),
+]);

package/lib/esm/agents/memory.js

@@ -1,6 +1,8 @@
-import { orArrayToArray } from "../utils/type-utils.js";
+import { z } from "zod";
+import { checkArguments, orArrayToArray } from "../utils/type-utils.js";
 export class AgentMemory {
     constructor(options) {
+        checkArguments("AgentMemory", agentMemoryOptionsSchema, options);
         this.enabled = options.enabled ?? true;
         this.subscribeTopic = options.subscribeTopic;
         this.maxMemoriesInChat = options.maxMemoriesInChat;
@@ -32,3 +34,8 @@ export class AgentMemory {
         this.subscriptions = [];
     }
 }
+const agentMemoryOptionsSchema = z.object({
+    enabled: z.boolean().optional(),
+    subscribeTopic: z.union([z.string(), z.array(z.string())]).optional(),
+    maxMemoriesInChat: z.number().optional(),
+});

package/lib/esm/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/esm/execution-engine/execution-engine.js

@@ -1,12 +1,17 @@
 import EventEmitter from "node:events";
 import { isNil } from "lodash-es";
+import { z } from "zod";
 import { Agent } from "../agents/agent.js";
 import { isTransferAgentOutput, transferAgentOutputKey } from "../agents/types.js";
 import { UserAgent } from "../agents/user-agent.js";
+import { ChatModel } from "../models/chat-model.js";
 import { createMessage } from "../prompt/prompt-builder.js";
+import { checkArguments } from "../utils/type-utils.js";
 import { MessageQueue, } from "./message-queue.js";
 export class ExecutionEngine extends EventEmitter {
     constructor(options) {
+        if (options)
+            checkArguments("ExecutionEngine", executionEngineOptionsSchema, options);
         super();
         this.model = options?.model;
         this.tools = options?.tools ?? [];
@@ -19,6 +24,7 @@ export class ExecutionEngine extends EventEmitter {
     tools;
     agents = [];
     addAgent(...agents) {
+        checkArguments("ExecutionEngine.addAgent", executionEngineAddAgentArgsSchema, agents);
         for (const agent of agents) {
             this.agents.push(agent);
             agent.attach(this);
@@ -34,6 +40,11 @@ export class ExecutionEngine extends EventEmitter {
      * @param from the agent who publish the message, if not provided, it will be treated as a user message
      */
     publish(topic, message, from) {
+        checkArguments("ExecutionEngine.publish", executionEnginePublishArgsSchema, {
+            topic,
+            message,
+            from,
+        });
         const request = {
             role: !from || from instanceof UserAgent ? "user" : "agent",
             source: from?.name,
@@ -42,6 +53,11 @@ export class ExecutionEngine extends EventEmitter {
         this.messageQueue.publish(topic, request);
     }
     call(agent, message, options) {
+        checkArguments("ExecutionEngine.call", executionEngineCallArgsSchema, {
+            agent,
+            message,
+            options,
+        });
         if (isNil(message)) {
             let activeAgent = agent;
             return UserAgent.from({
@@ -76,9 +92,17 @@ export class ExecutionEngine extends EventEmitter {
         return { output, agent: activeAgent };
     }
     subscribe(topic, listener) {
+        checkArguments("ExecutionEngine.subscribe", executionEngineSubscribeArgsSchema, {
+            topic,
+            listener,
+        });
         return this.messageQueue.subscribe(topic, listener);
     }
     unsubscribe(topic, listener) {
+        checkArguments("ExecutionEngine.unsubscribe", executionEngineUnsubscribeArgsSchema, {
+            topic,
+            listener,
+        });
         this.messageQueue.unsubscribe(topic, listener);
     }
     async callAgent(agent, input) {
@@ -127,3 +151,27 @@ export class ExecutionEngine extends EventEmitter {
         process.on("exit", shutdownAndExit);
     }
 }
+const executionEngineOptionsSchema = z.object({
+    model: z.instanceof(ChatModel).optional(),
+    tools: z.array(z.instanceof(Agent)).optional(),
+    agents: z.array(z.instanceof(Agent)).optional(),
+});
+const executionEngineAddAgentArgsSchema = z.array(z.instanceof(Agent));
+const executionEnginePublishArgsSchema = z.object({
+    topic: z.union([z.string(), z.array(z.string())]),
+    message: z.union([z.string(), z.record(z.unknown())]),
+    from: z.instanceof(Agent).optional(),
+});
+const executionEngineCallArgsSchema = z.object({
+    agent: z.union([z.function(), z.instanceof(Agent)]),
+    message: z.union([z.record(z.unknown()), z.string()]).optional(),
+    options: z.object({ returnActiveAgent: z.boolean().optional() }).optional(),
+});
+const executionEngineSubscribeArgsSchema = z.object({
+    topic: z.string(),
+    listener: z.function(z.tuple([z.any()]), z.any()).optional(),
+});
+const executionEngineUnsubscribeArgsSchema = z.object({
+    topic: z.string(),
+    listener: z.function(z.tuple([z.any()]), z.any()),
+});

package/lib/esm/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/esm/execution-engine/utils.js

@@ -1,4 +1,8 @@
+import { z } from "zod";
+import { Agent } from "../agents/agent.js";
+import { checkArguments } from "../utils/type-utils.js";
 export function sequential(..._agents) {
+    checkArguments("sequential", agentArraySchema, _agents);
     let agents = [..._agents];
     return async (input, context) => {
         if (!context)
@@ -16,6 +20,7 @@ export function sequential(..._agents) {
     };
 }
 export function parallel(..._agents) {
+    checkArguments("parallel", agentArraySchema, _agents);
     let agents = [..._agents];
     return async (input, context) => {
         if (!context)
@@ -26,3 +31,4 @@ export function parallel(..._agents) {
         return Object.assign({}, ...outputs);
     };
 }
+const agentArraySchema = z.array(z.union([z.function(), z.instanceof(Agent)]));

package/lib/esm/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/esm/index.js

@@ -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/esm/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/esm/models/claude-chat-model.js

@@ -1,13 +1,30 @@
 import Anthropic from "@anthropic-ai/sdk";
 import { isEmpty } from "lodash-es";
+import { z } from "zod";
 import { parseJSON } from "../utils/json-schema.js";
 import { logger } from "../utils/logger.js";
-import { isNonNullable } from "../utils/type-utils.js";
+import { checkArguments, isNonNullable } from "../utils/type-utils.js";
 import { ChatModel, } from "./chat-model.js";
 const CHAT_MODEL_CLAUDE_DEFAULT_MODEL = "claude-3-7-sonnet-latest";
+export const claudeChatModelOptionsSchema = z.object({
+    apiKey: z.string().optional(),
+    model: z.string().optional(),
+    modelOptions: z
+        .object({
+        model: z.string().optional(),
+        temperature: z.number().optional(),
+        topP: z.number().optional(),
+        frequencyPenalty: z.number().optional(),
+        presencePenalty: z.number().optional(),
+        parallelToolCalls: z.boolean().optional().default(true),
+    })
+        .optional(),
+});
 export class ClaudeChatModel extends ChatModel {
     options;
     constructor(options) {
+        if (options)
+            checkArguments("ClaudeChatModel", claudeChatModelOptionsSchema, options);
         super();
         this.options = options;
     }