@aigne/core 1.5.1-0 → 1.5.1-2

package/lib/esm/agents/mcp-agent.d.ts

@@ -1,7 +1,11 @@
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { Client, type ClientOptions } from "@modelcontextprotocol/sdk/client/index.js";
 import { type StdioServerParameters } from "@modelcontextprotocol/sdk/client/stdio.js";
-import type { CallToolResult, GetPromptResult, ReadResourceResult } from "@modelcontextprotocol/sdk/types.js";
+import type { RequestOptions } from "@modelcontextprotocol/sdk/shared/protocol.js";
+import type { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
+import type { CallToolResult, GetPromptResult, Implementation, ReadResourceResult, Request } from "@modelcontextprotocol/sdk/types.js";
+import { type ZodType, z } from "zod";
 import type { Context } from "../execution-engine/context.js";
+import { type PromiseOrValue } from "../utils/type-utils.js";
 import { Agent, type AgentOptions, type Message } from "./agent.js";
 export interface MCPAgentOptions extends AgentOptions {
     client: Client;
@@ -11,6 +15,16 @@ export interface MCPAgentOptions extends AgentOptions {
 export type MCPServerOptions = SSEServerParameters | StdioServerParameters;
 export type SSEServerParameters = {
     url: string;
+    /**
+     * Whether to automatically reconnect to the server if the connection is lost.
+     * @default 10 set to 0 to disable automatic reconnection
+     */
+    maxReconnects?: number;
+    /**
+     * A function that determines whether to reconnect to the server based on the error.
+     * default to reconnect on all errors.
+     */
+    shouldReconnect?: (error: Error) => boolean;
 };
 export declare class MCPAgent extends Agent {
     static from(options: MCPServerOptions): Promise<MCPAgent>;
@@ -28,12 +42,24 @@ export declare class MCPAgent extends Agent {
     process(_input: Message, _context?: Context): Promise<Message>;
     shutdown(): Promise<void>;
 }
-export interface MCPToolBaseOptions<I extends Message, O extends Message> extends AgentOptions<I, O> {
-    client: Client;
+export interface ClientWithReconnectOptions {
+    transportCreator?: () => PromiseOrValue<Transport>;
+    maxReconnects?: number;
+    shouldReconnect?: (error: Error) => boolean;
+}
+declare class ClientWithReconnect extends Client {
+    private reconnectOptions?;
+    constructor(info: Implementation, options?: ClientOptions, reconnectOptions?: ClientWithReconnectOptions | undefined);
+    private shouldReconnect;
+    private reconnect;
+    request<T extends ZodType<object>>(request: Request, resultSchema: T, options?: RequestOptions): Promise<z.infer<T>>;
+}
+export interface MCPBaseOptions<I extends Message = Message, O extends Message = Message> extends AgentOptions<I, O> {
+    client: ClientWithReconnect;
 }
 export declare abstract class MCPBase<I extends Message, O extends Message> extends Agent<I, O> {
-    constructor(options: MCPToolBaseOptions<I, O>);
-    protected client: Client;
+    constructor(options: MCPBaseOptions<I, O>);
+    protected client: ClientWithReconnect;
     protected get mcpServer(): string | undefined;
 }
 export declare class MCPTool extends MCPBase<Message, CallToolResult> {
@@ -45,7 +71,7 @@ export interface MCPPromptInput extends Message {
 export declare class MCPPrompt extends MCPBase<MCPPromptInput, GetPromptResult> {
     process(input: MCPPromptInput): Promise<GetPromptResult>;
 }
-export interface MCPResourceOptions extends MCPToolBaseOptions<MCPPromptInput, ReadResourceResult> {
+export interface MCPResourceOptions extends MCPBaseOptions<MCPPromptInput, ReadResourceResult> {
     uri: string;
 }
 export declare class MCPResource extends MCPBase<MCPPromptInput, ReadResourceResult> {
@@ -53,3 +79,4 @@ export declare class MCPResource extends MCPBase<MCPPromptInput, ReadResourceRes
     uri: string;
     process(input: MCPPromptInput): Promise<ReadResourceResult>;
 }
+export {};

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

@@ -2,6 +2,7 @@ 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 pRetry from "p-retry";
 import { z } from "zod";
 import { logger } from "../utils/logger.js";
 import { promptFromMCPPrompt, resourceFromMCPResource, toolFromMCPTool, } from "../utils/mcp-utils.js";
@@ -9,6 +10,7 @@ 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";
+const DEFAULT_MAX_RECONNECTS = 10;
 const debug = logger.base.extend("mcp");
 function isSSEServerParameters(options) {
     return "url" in options && typeof options.url === "string";
@@ -29,11 +31,11 @@ export class MCPAgent extends Agent {
     static from(options) {
         checkArguments("MCPAgent.from", mcpAgentOptionsSchema, options);
         if (isSSEServerParameters(options)) {
-            const transport = new SSEClientTransport(new URL(options.url));
+            const transport = () => new SSEClientTransport(new URL(options.url));
             return MCPAgent.fromTransport(transport, options);
         }
         if (isStdioServerParameters(options)) {
-            const transport = new StdioClientTransport({
+            const transport = () => new StdioClientTransport({
                 ...options,
                 env: {
                     ...getDefaultEnvironment(),
@@ -45,23 +47,24 @@ export class MCPAgent extends Agent {
         }
         return new MCPAgent(options);
     }
-    static async fromTransport(transport, options) {
-        const client = new Client({
+    static async fromTransport(transportCreator, options) {
+        const client = new ClientWithReconnect({
             name: MCP_AGENT_CLIENT_NAME,
             version: MCP_AGENT_CLIENT_VERSION,
-        });
+        }, undefined, isSSEServerParameters(options) ? { transportCreator, ...options } : undefined);
+        const transport = transportCreator();
         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
             ? await debug
                 .spinner(client.listTools(), `Listing tools from ${mcpServer}`, ({ tools }) => debug("%O", tools))
-                .then(({ tools }) => tools.map((tool) => toolFromMCPTool(client, tool)))
+                .then(({ tools }) => tools.map((tool) => toolFromMCPTool(tool, { client })))
             : undefined;
         const prompts = isPromptsAvailable
             ? await debug
                 .spinner(client.listPrompts(), `Listing prompts from ${mcpServer}`, ({ prompts }) => debug("%O", prompts))
-                .then(({ prompts }) => prompts.map((prompt) => promptFromMCPPrompt(client, prompt)))
+                .then(({ prompts }) => prompts.map((prompt) => promptFromMCPPrompt(prompt, { client })))
             : undefined;
         const resources = isResourcesAvailable
             ? await debug
@@ -72,7 +75,7 @@ export class MCPAgent extends Agent {
                 client.listResources().catch(() => ({ resources: [] })),
                 client.listResourceTemplates().catch(() => ({ resourceTemplates: [] })),
             ]), `Listing resources from ${mcpServer}`, ([{ resources }, { resourceTemplates }]) => debug("%O\n%O", resources, resourceTemplates))
-                .then(([{ resources }, { resourceTemplates }]) => [...resources, ...resourceTemplates].map((resource) => resourceFromMCPResource(client, resource)))
+                .then(([{ resources }, { resourceTemplates }]) => [...resources, ...resourceTemplates].map((resource) => resourceFromMCPResource(resource, { client })))
             : undefined;
         return new MCPAgent({
             name: client.getServerVersion()?.name,
@@ -104,6 +107,47 @@ export class MCPAgent extends Agent {
         await this.client.close();
     }
 }
+class ClientWithReconnect extends Client {
+    reconnectOptions;
+    constructor(info, options, reconnectOptions) {
+        super(info, options);
+        this.reconnectOptions = reconnectOptions;
+    }
+    shouldReconnect(error) {
+        const { transportCreator, shouldReconnect, maxReconnects } = this.reconnectOptions || {};
+        if (!transportCreator || maxReconnects === 0)
+            return false;
+        if (!shouldReconnect)
+            return true; // default to reconnect on all errors
+        return shouldReconnect(error);
+    }
+    async reconnect() {
+        const transportCreator = this.reconnectOptions?.transportCreator;
+        if (!transportCreator)
+            throw new Error("reconnect requires a transportCreator");
+        await pRetry(async () => {
+            await this.close();
+            await this.connect(await transportCreator());
+        }, {
+            retries: this.reconnectOptions?.maxReconnects ?? DEFAULT_MAX_RECONNECTS,
+            shouldRetry: this.shouldReconnect,
+            onFailedAttempt: (error) => debug("Reconnect attempt failed: %O", error),
+        });
+    }
+    async request(request, resultSchema, options) {
+        try {
+            return await super.request(request, resultSchema, options);
+        }
+        catch (error) {
+            if (this.shouldReconnect(error)) {
+                debug("Error occurred, reconnecting to MCP server: %O", error);
+                await this.reconnect();
+                return await super.request(request, resultSchema, options);
+            }
+            throw error;
+        }
+    }
+}
 export class MCPBase extends Agent {
     constructor(options) {
         super(options);

package/lib/esm/agents/user-agent.d.ts

@@ -1,3 +1,4 @@
+import { ReadableStream } from "node:stream/web";
 import type { Context } from "../execution-engine/context.js";
 import type { MessagePayload, MessageQueueListener, Unsubscribe } from "../execution-engine/message-queue.js";
 import { type PromiseOrValue } from "../utils/type-utils.js";

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

@@ -1,3 +1,4 @@
+import { ReadableStream } from "node:stream/web";
 import { orArrayToArray } from "../utils/type-utils.js";
 import { Agent } from "./agent.js";
 export class UserAgent extends Agent {

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

@@ -11,11 +11,18 @@ export interface ExecutionEngineOptions {
     limits?: ContextLimits;
 }
 export declare class ExecutionEngine extends EventEmitter {
+    static load({ path, ...options }: {
+        path: string;
+    } & ExecutionEngineOptions): Promise<ExecutionEngine>;
     constructor(options?: ExecutionEngineOptions);
     readonly messageQueue: MessageQueue;
     model?: ChatModel;
-    tools: Agent[];
-    private agents;
+    readonly tools: Agent<Message, Message>[] & {
+        [key: string]: Agent<Message, Message>;
+    };
+    readonly agents: Agent<Message, Message>[] & {
+        [key: string]: Agent<Message, Message>;
+    };
     limits?: ContextLimits;
     addAgent(...agents: Agent[]): void;
     newContext(): ExecutionContext;

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

@@ -1,26 +1,37 @@
 import EventEmitter from "node:events";
 import { z } from "zod";
 import { Agent } from "../agents/agent.js";
+import { load } from "../loader/index.js";
 import { ChatModel } from "../models/chat-model.js";
-import { checkArguments } from "../utils/type-utils.js";
+import { checkArguments, createAccessorArray } from "../utils/type-utils.js";
 import { ExecutionContext } from "./context.js";
 import { MessageQueue, } from "./message-queue.js";
 export class ExecutionEngine extends EventEmitter {
+    static async load({ path, ...options }) {
+        const { model, agents, tools } = await load({ path });
+        return new ExecutionEngine({
+            model,
+            ...options,
+            agents: agents.concat(options.agents ?? []),
+            tools: tools.concat(options.tools ?? []),
+        });
+    }
     constructor(options) {
         if (options)
             checkArguments("ExecutionEngine", executionEngineOptionsSchema, options);
         super();
         this.model = options?.model;
-        this.tools = options?.tools ?? [];
         this.limits = options?.limits;
+        if (options?.tools?.length)
+            this.tools.push(...options.tools);
         if (options?.agents?.length)
             this.addAgent(...options.agents);
         this.initProcessExitHandler();
     }
     messageQueue = new MessageQueue();
     model;
-    tools;
-    agents = [];
+    tools = createAccessorArray([], (arr, name) => arr.find((i) => i.name === name));
+    agents = createAccessorArray([], (arr, name) => arr.find((i) => i.name === name));
     limits;
     addAgent(...agents) {
         checkArguments("ExecutionEngine.addAgent", executionEngineAddAgentArgsSchema, agents);

package/lib/esm/loader/ai-agent.d.ts

@@ -0,0 +1,21 @@
+import { readFile } from "node:fs/promises";
+import { type ZodObject, type ZodType, z } from "zod";
+export declare function loadAgentFromYamlFile(path: string, { readFile: _readFile }?: {
+    readFile?: typeof readFile;
+}): Promise<{
+    name: string;
+    description?: string | undefined;
+    tools?: string[] | undefined;
+    instructions?: string | undefined;
+    input_schema?: ZodObject<Record<string, ZodType<any, z.ZodTypeDef, any>>, z.UnknownKeysParam, z.ZodTypeAny, {
+        [x: string]: any;
+    }, {
+        [x: string]: any;
+    }> | undefined;
+    output_schema?: ZodObject<Record<string, ZodType<any, z.ZodTypeDef, any>>, z.UnknownKeysParam, z.ZodTypeAny, {
+        [x: string]: any;
+    }, {
+        [x: string]: any;
+    }> | undefined;
+    output_key?: string | undefined;
+}>;

package/lib/esm/loader/ai-agent.js

@@ -0,0 +1,37 @@
+import { readFile } from "node:fs/promises";
+import { jsonSchemaToZod } from "@aigne/json-schema-to-zod";
+import { parse } from "yaml";
+import { z } from "zod";
+import { tryOrThrow } from "../utils/type-utils.js";
+import { inputOutputSchema } from "./schema.js";
+const agentFileSchema = z.object({
+    name: z.string(),
+    description: z
+        .string()
+        .nullish()
+        .transform((v) => v ?? undefined),
+    instructions: z
+        .string()
+        .nullish()
+        .transform((v) => v ?? undefined),
+    input_schema: inputOutputSchema
+        .nullish()
+        .transform((v) => (v ? jsonSchemaToZod(v) : undefined)),
+    output_schema: inputOutputSchema
+        .nullish()
+        .transform((v) => (v ? jsonSchemaToZod(v) : undefined)),
+    output_key: z
+        .string()
+        .nullish()
+        .transform((v) => v ?? undefined),
+    tools: z
+        .array(z.string())
+        .nullish()
+        .transform((v) => v ?? undefined),
+});
+export async function loadAgentFromYamlFile(path, { readFile: _readFile = readFile } = {}) {
+    const raw = await tryOrThrow(() => _readFile(path, "utf8"), (error) => new Error(`Failed to load agent definition from ${path}: ${error.message}`));
+    const json = await tryOrThrow(() => parse(raw), (error) => new Error(`Failed to parse agent definition from ${path}: ${error.message}`));
+    const agent = tryOrThrow(() => agentFileSchema.parse(json), (error) => new Error(`Failed to validate agent definition from ${path}: ${error.message}`));
+    return agent;
+}

package/lib/esm/loader/function-agent.d.ts

@@ -0,0 +1,21 @@
+import { type ZodObject, type ZodType, z } from "zod";
+import type { Message } from "../agents/agent.js";
+export declare function loadAgentFromJsFile(path: string, { import: _import }?: {
+    import?: (path: string) => Promise<{
+        default: unknown;
+    }>;
+}): Promise<{
+    name: string;
+    fn: (args_0: Message) => Message;
+    description?: string | undefined;
+    input_schema?: ZodObject<Record<string, ZodType<any, z.ZodTypeDef, any>>, z.UnknownKeysParam, z.ZodTypeAny, {
+        [x: string]: any;
+    }, {
+        [x: string]: any;
+    }> | undefined;
+    output_schema?: ZodObject<Record<string, ZodType<any, z.ZodTypeDef, any>>, z.UnknownKeysParam, z.ZodTypeAny, {
+        [x: string]: any;
+    }, {
+        [x: string]: any;
+    }> | undefined;
+}>;

package/lib/esm/loader/function-agent.js

@@ -0,0 +1,31 @@
+import { jsonSchemaToZod } from "@aigne/json-schema-to-zod";
+import { z } from "zod";
+import { tryOrThrow } from "../utils/type-utils.js";
+import { inputOutputSchema } from "./schema.js";
+const agentJsFileSchema = z.object({
+    name: z.string(),
+    description: z
+        .string()
+        .nullish()
+        .transform((v) => v ?? undefined),
+    input_schema: inputOutputSchema
+        .nullish()
+        .transform((v) => (v ? jsonSchemaToZod(v) : undefined)),
+    output_schema: inputOutputSchema
+        .nullish()
+        .transform((v) => (v ? jsonSchemaToZod(v) : undefined)),
+    fn: z.function(),
+});
+export async function loadAgentFromJsFile(path, { import: _import } = {}) {
+    const { default: agent } = await tryOrThrow(() => (_import ? _import(path) : import(path)), (error) => new Error(`Failed to load agent definition from ${path}: ${error.message}`));
+    if (typeof agent !== "function") {
+        throw new Error(`Agent file ${path} must export a default function, but got ${typeof agent}`);
+    }
+    return tryOrThrow(() => agentJsFileSchema.parse({
+        name: agent.name,
+        description: agent.description,
+        input_schema: agent.input_schema,
+        output_schema: agent.output_schema,
+        fn: agent,
+    }), (error) => new Error(`Failed to parse agent from ${path}: ${error.message}`));
+}

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

@@ -0,0 +1,25 @@
+import { readFile } from "node:fs/promises";
+import { type Agent } from "../agents/agent.js";
+import type { ChatModel } from "../models/chat-model.js";
+export interface LoadOptions {
+    path: string;
+}
+export declare function load(options: LoadOptions): Promise<{
+    model: ChatModel | undefined;
+    agents: Agent<import("../agents/agent.js").Message, import("../agents/agent.js").Message>[];
+    tools: Agent<import("../agents/agent.js").Message, import("../agents/agent.js").Message>[];
+}>;
+export declare function loadAgent(path: string): Promise<Agent>;
+export declare function loadAIGNEFile(path: string, { readFile: _readFile }?: {
+    readFile?: typeof readFile;
+}): Promise<{
+    tools?: string[] | null | undefined;
+    chat_model?: {
+        name?: string | null | undefined;
+        temperature?: number | null | undefined;
+        top_p?: number | null | undefined;
+        frequent_penalty?: number | null | undefined;
+        presence_penalty?: number | null | undefined;
+    } | null | undefined;
+    agents?: string[] | null | undefined;
+}>;

package/lib/esm/loader/index.js

@@ -0,0 +1,88 @@
+import { readFile } from "node:fs/promises";
+import { dirname, extname, join } from "node:path";
+import { parse } from "yaml";
+import { z } from "zod";
+import { FunctionAgent } from "../agents/agent.js";
+import { AIAgent } from "../agents/ai-agent.js";
+import { OpenAIChatModel } from "../models/openai-chat-model.js";
+import { tryOrThrow } from "../utils/type-utils.js";
+import { loadAgentFromYamlFile } from "./ai-agent.js";
+import { loadAgentFromJsFile } from "./function-agent.js";
+const AIGNE_FILE_NAME = "aigne.yaml";
+export async function load(options) {
+    const { path } = options;
+    const aigneFilePath = path.endsWith(AIGNE_FILE_NAME) ? path : join(path, AIGNE_FILE_NAME);
+    const rootDir = dirname(aigneFilePath);
+    const aigne = await loadAIGNEFile(aigneFilePath);
+    const agents = await Promise.all((aigne.agents ?? []).map((filename) => loadAgent(join(rootDir, filename))));
+    const tools = await Promise.all((aigne.tools ?? []).map((filename) => loadAgent(join(rootDir, filename))));
+    return {
+        model: await loadModel(aigne.chat_model),
+        agents,
+        tools,
+    };
+}
+export async function loadAgent(path) {
+    if (extname(path) === ".js") {
+        const agent = await loadAgentFromJsFile(path);
+        return FunctionAgent.from({
+            name: agent.name,
+            description: agent.description,
+            inputSchema: agent.input_schema,
+            outputSchema: agent.output_schema,
+            fn: agent.fn,
+        });
+    }
+    if (extname(path) === ".yaml" || extname(path) === ".yml") {
+        const agent = await loadAgentFromYamlFile(path);
+        return AIAgent.from({
+            name: agent.name,
+            description: agent.description,
+            instructions: agent.instructions,
+            inputSchema: agent.input_schema,
+            outputSchema: agent.output_schema,
+            outputKey: agent.output_key,
+            tools: await Promise.all((agent.tools ?? []).map((filename) => loadAgent(join(dirname(path), filename)))),
+        });
+    }
+    throw new Error(`Unsupported agent file type: ${path}`);
+}
+async function loadModel(model) {
+    if (!model?.name)
+        return undefined;
+    const params = {
+        model: model.name,
+        temperature: model.temperature ?? undefined,
+        topP: model.top_p ?? undefined,
+        frequencyPenalty: model.frequent_penalty ?? undefined,
+        presencePenalty: model.presence_penalty ?? undefined,
+    };
+    // TODO: add support for other models such as AutoChatModel, ClaudeChatModel, etc.
+    if (/^o1|gpt-/.test(model.name)) {
+        return new OpenAIChatModel(params);
+    }
+    throw new Error(`Unsupported model: ${model.name}`);
+}
+const aigneFileSchema = z.object({
+    chat_model: z
+        .union([
+        z.string(),
+        z.object({
+            name: z.string().nullish(),
+            temperature: z.number().min(0).max(2).nullish(),
+            top_p: z.number().min(0).nullish(),
+            frequent_penalty: z.number().min(-2).max(2).nullish(),
+            presence_penalty: z.number().min(-2).max(2).nullish(),
+        }),
+    ])
+        .nullish()
+        .transform((v) => (typeof v === "string" ? { name: v } : v)),
+    agents: z.array(z.string()).nullish(),
+    tools: z.array(z.string()).nullish(),
+});
+export async function loadAIGNEFile(path, { readFile: _readFile = readFile } = {}) {
+    const raw = await tryOrThrow(() => _readFile(path, "utf8"), (error) => new Error(`Failed to load aigne.yaml from ${path}: ${error.message}`));
+    const json = await tryOrThrow(() => parse(raw), (error) => new Error(`Failed to parse aigne.yaml from ${path}: ${error.message}`));
+    const agent = tryOrThrow(() => aigneFileSchema.parse(json), (error) => new Error(`Failed to validate aigne.yaml from ${path}: ${error.message}`));
+    return agent;
+}

package/lib/esm/loader/schema.d.ts

@@ -0,0 +1,17 @@
+import { z } from "zod";
+export declare const inputOutputSchema: z.ZodObject<{
+    type: z.ZodLiteral<"object">;
+    properties: z.ZodRecord<z.ZodString, z.ZodAny>;
+    required: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    additionalProperties: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    type: "object";
+    properties: Record<string, any>;
+    required?: string[] | undefined;
+    additionalProperties?: boolean | undefined;
+}, {
+    type: "object";
+    properties: Record<string, any>;
+    required?: string[] | undefined;
+    additionalProperties?: boolean | undefined;
+}>;

package/lib/esm/loader/schema.js

@@ -0,0 +1,7 @@
+import { z } from "zod";
+export const inputOutputSchema = z.object({
+    type: z.literal("object"),
+    properties: z.record(z.any()),
+    required: z.array(z.string()).optional(),
+    additionalProperties: z.boolean().optional(),
+});

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

@@ -57,7 +57,7 @@ export declare const claudeChatModelOptionsSchema: z.ZodObject<{
 export declare class ClaudeChatModel extends ChatModel {
     options?: ClaudeChatModelOptions | undefined;
     constructor(options?: ClaudeChatModelOptions | undefined);
-    private _client?;
+    protected _client?: Anthropic;
     get client(): Anthropic;
     get modelOptions(): ChatModelOptions | undefined;
     process(input: ChatModelInput): Promise<ChatModelOutput>;

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

@@ -30,9 +30,10 @@ export class ClaudeChatModel extends ChatModel {
     }
     _client;
     get client() {
-        if (!this.options?.apiKey)
+        const apiKey = this.options?.apiKey || process.env.CLAUDE_API_KEY;
+        if (!apiKey)
             throw new Error("Api Key is required for ClaudeChatModel");
-        this._client ??= new Anthropic({ apiKey: this.options.apiKey });
+        this._client ??= new Anthropic({ apiKey });
         return this._client;
     }
     get modelOptions() {

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

@@ -61,7 +61,7 @@ export declare const openAIChatModelOptionsSchema: z.ZodObject<{
 export declare class OpenAIChatModel extends ChatModel {
     options?: OpenAIChatModelOptions | undefined;
     constructor(options?: OpenAIChatModelOptions | undefined);
-    private _client?;
+    protected _client?: OpenAI;
     get client(): OpenAI;
     get modelOptions(): ChatModelOptions | undefined;
     process(input: ChatModelInput): Promise<ChatModelOutput>;

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

@@ -30,11 +30,12 @@ export class OpenAIChatModel extends ChatModel {
     }
     _client;
     get client() {
-        if (!this.options?.apiKey)
+        const apiKey = this.options?.apiKey || process.env.OPENAI_API_KEY;
+        if (!apiKey)
             throw new Error("Api Key is required for OpenAIChatModel");
         this._client ??= new OpenAI({
-            baseURL: this.options.baseURL,
-            apiKey: this.options.apiKey,
+            baseURL: this.options?.baseURL,
+            apiKey,
         });
         return this._client;
     }

package/lib/esm/models/xai-chat-model.d.ts

@@ -1,3 +1,4 @@
+import OpenAI from "openai";
 import type { ChatModelOptions } from "./chat-model.js";
 import { OpenAIChatModel } from "./openai-chat-model.js";
 export interface XAIChatModelOptions {
@@ -8,4 +9,5 @@ export interface XAIChatModelOptions {
 }
 export declare class XAIChatModel extends OpenAIChatModel {
     constructor(options?: XAIChatModelOptions);
+    get client(): OpenAI;
 }

package/lib/esm/models/xai-chat-model.js

@@ -1,3 +1,4 @@
+import OpenAI from "openai";
 import { OpenAIChatModel } from "./openai-chat-model.js";
 const XAI_DEFAULT_CHAT_MODEL = "grok-2-latest";
 const XAI_BASE_URL = "https://api.x.ai/v1";
@@ -9,4 +10,14 @@ export class XAIChatModel extends 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({
+            baseURL: this.options?.baseURL,
+            apiKey,
+        });
+        return this._client;
+    }
 }

package/lib/esm/utils/json-schema.js

@@ -7,7 +7,7 @@ function setAdditionPropertiesDeep(schema, additionalProperties) {
     if (Array.isArray(schema)) {
         return schema.map((s) => setAdditionPropertiesDeep(s, additionalProperties));
     }
-    if (schema && typeof schema === "object" && !Array.isArray(schema)) {
+    if (schema !== null && typeof schema === "object" && !Array.isArray(schema)) {
         return Object.entries(schema).reduce((acc, [key, value]) => {
             acc[key] = setAdditionPropertiesDeep(value, additionalProperties);
             if (acc.type === "object") {

package/lib/esm/utils/logger.d.ts

@@ -11,16 +11,10 @@ export declare const logger: debug.Debug & {
     debug: debug.Debug;
     default: debug.Debug;
 } & {
-    globalSpinner: {
-        start: (text?: string | undefined) => Promise<Ora>;
-        stop: () => Promise<Ora>;
-        fail: (text?: string | undefined) => Promise<Ora>;
-        succeed: (text?: string | undefined) => Promise<Ora>;
-    } & {
-        isSpinning: boolean;
-    };
+    globalSpinner: Ora | undefined;
     base: DebugWithSpinner;
     debug: DebugWithSpinner;
     spinner: typeof spinner;
+    setSpinner: (spinner: Ora) => void;
 };
 export {};