@aigne/core 1.3.1 → 1.4.1-0

package/CHANGELOG.md

@@ -22,6 +22,18 @@
 * rename @aigne/core-next to @aigne/core ([3a81009](https://github.com/AIGNE-io/aigne-framework/commit/3a8100962c81813217b687ae28e8de604419c622))
 * use text resource from MCP correctly ([8b9eba8](https://github.com/AIGNE-io/aigne-framework/commit/8b9eba83352ec096a2a5d4f410d4c4bde7420bce))
 
+## [1.4.0](https://github.com/AIGNE-io/aigne-framework/compare/core-v1.3.1...core-v1.4.0) (2025-03-26)
+
+
+### Features
+
+* **core:** add xAI chat model adapter ([#34](https://github.com/AIGNE-io/aigne-framework/issues/34)) ([b228d22](https://github.com/AIGNE-io/aigne-framework/commit/b228d22b550535ab8e511f13de9e4a65dd73e3c0))
+
+
+### Bug Fixes
+
+* **orchestrator:** refactor and enhance orchestrator with step synthesis ([#31](https://github.com/AIGNE-io/aigne-framework/issues/31)) ([ba9fca0](https://github.com/AIGNE-io/aigne-framework/commit/ba9fca04fad71d49c8f4f52172b56668a94ea714))
+
 ## [1.3.1](https://github.com/AIGNE-io/aigne-framework/compare/core-v1.3.0...core-v1.3.1) (2025-03-25)
 
 

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

@@ -11,8 +11,8 @@ export interface AgentOptions<I extends Message = Message, O extends Message = M
     publishTopic?: PublishTopic<O>;
     name?: string;
     description?: string;
-    inputSchema?: ZodType<I>;
-    outputSchema?: ZodType<O>;
+    inputSchema?: AgentInputOutputSchema<I>;
+    outputSchema?: AgentInputOutputSchema<O>;
     includeInputInOutput?: boolean;
     tools?: (Agent | FunctionAgentFn)[];
     disableLogging?: boolean;
@@ -27,8 +27,10 @@ export declare abstract class Agent<I extends Message = Message, O extends Messa
      */
     get topic(): string;
     readonly description?: string;
-    readonly inputSchema: ZodType<I>;
-    readonly outputSchema: ZodType<O>;
+    private readonly _inputSchema?;
+    private readonly _outputSchema?;
+    get inputSchema(): ZodType<I>;
+    get outputSchema(): ZodType<O>;
     readonly includeInputInOutput?: boolean;
     readonly subscribeTopic?: SubscribeTopic;
     readonly publishTopic?: PublishTopic<Message>;
@@ -49,6 +51,7 @@ export declare abstract class Agent<I extends Message = Message, O extends Messa
     abstract process(input: I, context?: Context): Promise<O | TransferAgentOutput>;
     shutdown(): Promise<void>;
 }
+export type AgentInputOutputSchema<I extends Message = Message> = ZodType<I> | ((agent: Agent) => ZodType<I>);
 export interface FunctionAgentOptions<I extends Message = Message, O extends Message = Message> extends AgentOptions<I, O> {
     fn?: FunctionAgentFn<I, O>;
 }

package/lib/cjs/agents/agent.js

@@ -11,12 +11,12 @@ class Agent {
     constructor({ inputSchema, outputSchema, ...options }) {
         this.name = options.name || this.constructor.name;
         this.description = options.description;
-        if ((inputSchema && !(inputSchema instanceof zod_1.ZodObject)) ||
-            (outputSchema && !(outputSchema instanceof zod_1.ZodObject))) {
-            throw new Error("inputSchema must be a Zod object");
-        }
-        this.inputSchema = (inputSchema || zod_1.z.object({})).passthrough();
-        this.outputSchema = (outputSchema || zod_1.z.object({})).passthrough();
+        if (inputSchema)
+            checkAgentInputOutputSchema(inputSchema);
+        if (outputSchema)
+            checkAgentInputOutputSchema(outputSchema);
+        this._inputSchema = inputSchema;
+        this._outputSchema = outputSchema;
         this.includeInputInOutput = options.includeInputInOutput;
         this.subscribeTopic = options.subscribeTopic;
         this.publishTopic = options.publishTopic;
@@ -41,8 +41,20 @@ class Agent {
         return `$agent_${this.name}`;
     }
     description;
-    inputSchema;
-    outputSchema;
+    _inputSchema;
+    _outputSchema;
+    get inputSchema() {
+        const s = this._inputSchema;
+        const schema = typeof s === "function" ? s(this) : s || zod_1.z.object({});
+        checkAgentInputOutputSchema(schema);
+        return schema.passthrough();
+    }
+    get outputSchema() {
+        const s = this._outputSchema;
+        const schema = typeof s === "function" ? s(this) : s || zod_1.z.object({});
+        checkAgentInputOutputSchema(schema);
+        return schema.passthrough();
+    }
     includeInputInOutput;
     subscribeTopic;
     publishTopic;
@@ -98,6 +110,11 @@ class Agent {
     }
 }
 exports.Agent = Agent;
+function checkAgentInputOutputSchema(schema) {
+    if (!(schema instanceof zod_1.ZodObject) && typeof schema !== "function") {
+        throw new Error("schema must be a zod object or function return a zod object ");
+    }
+}
 class FunctionAgent extends Agent {
     static from(options) {
         return typeof options === "function" ? functionToAgent(options) : new FunctionAgent(options);

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

@@ -8,7 +8,10 @@ export * from "./execution-engine/index.js";
 export * from "./models/chat-model.js";
 export * from "./models/claude-chat-model.js";
 export * from "./models/openai-chat-model.js";
+export * from "./models/xai-chat-model.js";
 export * from "./prompt/prompt-builder.js";
 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

@@ -24,7 +24,10 @@ __exportStar(require("./execution-engine/index.js"), exports);
 __exportStar(require("./models/chat-model.js"), exports);
 __exportStar(require("./models/claude-chat-model.js"), exports);
 __exportStar(require("./models/openai-chat-model.js"), exports);
+__exportStar(require("./models/xai-chat-model.js"), exports);
 __exportStar(require("./prompt/prompt-builder.js"), exports);
 __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/chat-model.d.ts

@@ -65,6 +65,7 @@ export interface ChatModelOptions {
     topP?: number;
     frequencyPenalty?: number;
     presencePenalty?: number;
+    parallelToolCalls?: boolean;
 }
 export interface ChatModelOutput extends Message {
     text?: string;

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

@@ -68,6 +68,7 @@ const chatModelOptionsSchema = zod_1.z.object({
     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),
 });
 const chatModelInputSchema = zod_1.z.object({
     messages: zod_1.z.array(chatModelInputMessageSchema),

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

@@ -1,16 +1,65 @@
 import Anthropic from "@anthropic-ai/sdk";
-import { ChatModel, type ChatModelInput, type ChatModelOutput } from "./chat-model.js";
-export declare class ClaudeChatModel extends ChatModel {
-    config?: {
-        apiKey?: string;
-        model?: string;
+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;
-    constructor(config?: {
-        apiKey?: string;
-        model?: string;
-    } | 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);
     private _client?;
     get client(): Anthropic;
+    get modelOptions(): ChatModelOptions | undefined;
     process(input: ChatModelInput): Promise<ChatModelOutput>;
     private extractResultFromClaudeStream;
     private requestStructuredOutput;