@aigne/core 1.3.0 → 1.4.0

package/lib/dts/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/dts/models/claude-chat-model.d.ts

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

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

@@ -1,14 +1,15 @@
-import { ChatModel, type ChatModelInput, type ChatModelOutput } from "./chat-model.js";
+import { ChatModel, type ChatModelInput, type ChatModelOptions, type ChatModelOutput } from "./chat-model.js";
+export interface OpenAIChatModelOptions {
+    apiKey?: string;
+    baseURL?: string;
+    model?: string;
+    modelOptions?: ChatModelOptions;
+}
 export declare class OpenAIChatModel extends ChatModel {
-    config?: {
-        apiKey?: string;
-        model?: string;
-    } | undefined;
-    constructor(config?: {
-        apiKey?: string;
-        model?: string;
-    } | undefined);
+    options?: OpenAIChatModelOptions | undefined;
+    constructor(options?: OpenAIChatModelOptions | undefined);
     private _client?;
     private get client();
+    get modelOptions(): ChatModelOptions | undefined;
     process(input: ChatModelInput): Promise<ChatModelOutput>;
 }

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

@@ -0,0 +1,12 @@
+import type { ChatModelOptions } from "./chat-model.js";
+import { OpenAIChatModel } from "./openai-chat-model.js";
+export interface XAIChatModelOptions {
+    apiKey?: string;
+    model?: string;
+    modelOptions?: ChatModelOptions;
+    baseURL?: string;
+}
+export declare class XAIChatModel extends OpenAIChatModel {
+    options?: XAIChatModelOptions | undefined;
+    constructor(options?: XAIChatModelOptions | undefined);
+}

package/lib/dts/prompt/prompt-builder.d.ts

@@ -1,5 +1,5 @@
 import type { GetPromptResult } from "@modelcontextprotocol/sdk/types.js";
-import { Agent, type AgentOptions, type Message } from "../agents/agent.js";
+import { Agent, type Message } from "../agents/agent.js";
 import type { AIAgent } from "../agents/ai-agent.js";
 import type { AgentMemory } from "../agents/memory.js";
 import type { Context } from "../execution-engine/context.js";
@@ -18,7 +18,7 @@ export interface PromptBuilderBuildOptions {
     agent?: AIAgent;
     input?: Message;
     model?: ChatModel;
-    outputSchema?: AgentOptions["outputSchema"];
+    outputSchema?: Agent["outputSchema"];
 }
 export declare class PromptBuilder {
     static from(instructions: string): PromptBuilder;

package/lib/dts/utils/json-schema.d.ts

@@ -1,3 +1,12 @@
-import type { ZodType } from "zod";
+import type { ZodType, z } from "zod";
 import type { Message } from "../agents/agent.js";
 export declare function outputSchemaToResponseFormatSchema(agentOutput: ZodType<Message>): Record<string, unknown>;
+export declare function parseJSON(json: string): any;
+/**
+ * Ensure that the union array has at least 1 item.
+ * NOTE: the zod union requires at least 2 items (just type definition, not runtime behavior)
+ * so we need to ensure that the union has at least 1 item.
+ * @param union - The union array
+ * @returns The union array with at least 1 item (but the type is at least 2 items for z.union)
+ */
+export declare function ensureZodUnionArray<T extends z.ZodType>(union: T[]): [T, T, ...T[]];

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

@@ -8,12 +8,12 @@ export class Agent {
     constructor({ inputSchema, outputSchema, ...options }) {
         this.name = options.name || this.constructor.name;
         this.description = options.description;
-        if ((inputSchema && !(inputSchema instanceof ZodObject)) ||
-            (outputSchema && !(outputSchema instanceof ZodObject))) {
-            throw new Error("inputSchema must be a Zod object");
-        }
-        this.inputSchema = (inputSchema || z.object({})).passthrough();
-        this.outputSchema = (outputSchema || 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;
@@ -38,8 +38,20 @@ export 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 || z.object({});
+        checkAgentInputOutputSchema(schema);
+        return schema.passthrough();
+    }
+    get outputSchema() {
+        const s = this._outputSchema;
+        const schema = typeof s === "function" ? s(this) : s || z.object({});
+        checkAgentInputOutputSchema(schema);
+        return schema.passthrough();
+    }
     includeInputInOutput;
     subscribeTopic;
     publishTopic;
@@ -94,6 +106,11 @@ export class Agent {
         this.memory?.detach();
     }
 }
+function checkAgentInputOutputSchema(schema) {
+    if (!(schema instanceof ZodObject) && typeof schema !== "function") {
+        throw new Error("schema must be a zod object or function return a zod object ");
+    }
+}
 export class FunctionAgent extends Agent {
     static from(options) {
         return typeof options === "function" ? functionToAgent(options) : new FunctionAgent(options);

package/lib/esm/index.d.ts

@@ -8,7 +8,9 @@ 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";

package/lib/esm/index.js

@@ -8,7 +8,9 @@ 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";

package/lib/esm/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/esm/models/chat-model.js

@@ -64,6 +64,7 @@ const chatModelOptionsSchema = z.object({
     topP: z.number().optional(),
     frequencyPenalty: z.number().optional(),
     presencePenalty: z.number().optional(),
+    parallelToolCalls: z.boolean().optional().default(true),
 });
 const chatModelInputSchema = z.object({
     messages: z.array(chatModelInputMessageSchema),

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

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

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

@@ -1,30 +1,38 @@
 import Anthropic from "@anthropic-ai/sdk";
+import { isEmpty } from "lodash-es";
+import { parseJSON } from "../utils/json-schema.js";
+import { logger } from "../utils/logger.js";
 import { isNonNullable } from "../utils/type-utils.js";
 import { ChatModel, } from "./chat-model.js";
 const CHAT_MODEL_CLAUDE_DEFAULT_MODEL = "claude-3-7-sonnet-latest";
 export class ClaudeChatModel extends ChatModel {
-    config;
-    constructor(config) {
+    options;
+    constructor(options) {
         super();
-        this.config = config;
+        this.options = options;
     }
     _client;
     get client() {
-        if (!this.config?.apiKey)
+        if (!this.options?.apiKey)
             throw new Error("Api Key is required for ClaudeChatModel");
-        this._client ??= new Anthropic({ apiKey: this.config.apiKey });
+        this._client ??= new Anthropic({ apiKey: this.options.apiKey });
         return this._client;
     }
+    get modelOptions() {
+        return this.options?.modelOptions;
+    }
     async process(input) {
-        const model = this.config?.model || CHAT_MODEL_CLAUDE_DEFAULT_MODEL;
+        const model = this.options?.model || CHAT_MODEL_CLAUDE_DEFAULT_MODEL;
+        const disableParallelToolUse = input.modelOptions?.parallelToolCalls === false ||
+            this.modelOptions?.parallelToolCalls === false;
         const body = {
             model,
-            temperature: input.modelOptions?.temperature,
-            top_p: input.modelOptions?.topP,
+            temperature: input.modelOptions?.temperature ?? this.modelOptions?.temperature,
+            top_p: input.modelOptions?.topP ?? this.modelOptions?.topP,
             // TODO: make dynamic based on model https://docs.anthropic.com/en/docs/about-claude/models/all-models
             max_tokens: /claude-3-[5|7]/.test(model) ? 8192 : 4096,
             ...convertMessages(input),
-            ...convertTools(input),
+            ...convertTools({ ...input, disableParallelToolUse }),
         };
         const stream = this.client.messages.stream({
             ...body,
@@ -39,41 +47,53 @@ export class ClaudeChatModel extends ChatModel {
         return result;
     }
     async extractResultFromClaudeStream(stream) {
-        let text = "";
-        const toolCalls = [];
-        for await (const chunk of stream) {
-            // handle streaming text
-            if (chunk.type === "content_block_delta" && chunk.delta.type === "text_delta") {
-                text += chunk.delta.text;
+        const logs = [];
+        try {
+            let text = "";
+            const toolCalls = [];
+            for await (const chunk of stream) {
+                logs.push(JSON.stringify(chunk));
+                // handle streaming text
+                if (chunk.type === "content_block_delta" && chunk.delta.type === "text_delta") {
+                    text += chunk.delta.text;
+                }
+                if (chunk.type === "content_block_start" && chunk.content_block.type === "tool_use") {
+                    toolCalls[chunk.index] = {
+                        type: "function",
+                        id: chunk.content_block.id,
+                        function: {
+                            name: chunk.content_block.name,
+                            arguments: {},
+                        },
+                        args: "",
+                    };
+                }
+                if (chunk.type === "content_block_delta" && chunk.delta.type === "input_json_delta") {
+                    const call = toolCalls[chunk.index];
+                    if (!call)
+                        throw new Error("Tool call not found");
+                    call.args += chunk.delta.partial_json;
+                }
             }
-            if (chunk.type === "content_block_start" && chunk.content_block.type === "tool_use") {
-                toolCalls[chunk.index] = {
-                    type: "function",
-                    id: chunk.content_block.id,
+            const result = { text };
+            if (toolCalls.length) {
+                result.toolCalls = toolCalls
+                    .map(({ args, ...c }) => ({
+                    ...c,
                     function: {
-                        name: chunk.content_block.name,
-                        arguments: {},
+                        ...c.function,
+                        // NOTE: claude may return a blank string for empty object (the tool's input schema is a empty object)
+                        arguments: args.trim() ? parseJSON(args) : {},
                     },
-                    args: "",
-                };
-            }
-            if (chunk.type === "content_block_delta" && chunk.delta.type === "input_json_delta") {
-                const call = toolCalls[chunk.index];
-                if (!call)
-                    throw new Error("Tool call not found");
-                call.args += chunk.delta.partial_json;
+                }))
+                    .filter(isNonNullable);
             }
+            return result;
         }
-        const result = { text };
-        if (toolCalls.length) {
-            result.toolCalls = toolCalls
-                .map(({ args, ...c }) => ({
-                ...c,
-                function: { ...c.function, arguments: JSON.parse(args) },
-            }))
-                .filter(isNonNullable);
+        catch (error) {
+            logger.debug("Failed to process Claude stream", { error, logs });
+            throw error;
         }
-        return result;
     }
     async requestStructuredOutput(body, responseFormat) {
         if (responseFormat?.type !== "json_schema") {
@@ -125,7 +145,7 @@ function convertMessages({ messages, responseFormat }) {
         else if (msg.role === "user") {
             if (!msg.content)
                 throw new Error("User message must have content");
-            msgs.push({ role: "user", content: contentBlockParamFromContent(msg.content) });
+            msgs.push({ role: "user", content: convertContent(msg.content) });
         }
         else if (msg.role === "agent") {
             if (msg.toolCalls?.length) {
@@ -140,7 +160,7 @@ function convertMessages({ messages, responseFormat }) {
                 });
             }
             else if (msg.content) {
-                msgs.push({ role: "assistant", content: contentBlockParamFromContent(msg.content) });
+                msgs.push({ role: "assistant", content: convertContent(msg.content) });
             }
             else {
                 throw new Error("Agent message must have content or toolCalls");
@@ -150,9 +170,16 @@ function convertMessages({ messages, responseFormat }) {
     if (responseFormat?.type === "json_schema") {
         systemMessages.push(`You should provide a json response with schema: ${JSON.stringify(responseFormat.jsonSchema.schema)}`);
     }
-    return { messages: msgs, system: systemMessages.join("\n").trim() || undefined };
+    const system = systemMessages.join("\n").trim() || undefined;
+    // Claude requires at least one message, so we add a system message if there are no messages
+    if (msgs.length === 0) {
+        if (!system)
+            throw new Error("No messages provided");
+        return { messages: [{ role: "user", content: system }] };
+    }
+    return { messages: msgs, system };
 }
-function contentBlockParamFromContent(content) {
+function convertContent(content) {
     if (typeof content === "string")
         return content;
     if (Array.isArray(content)) {
@@ -162,19 +189,20 @@ function contentBlockParamFromContent(content) {
     }
     throw new Error("Invalid chat message content");
 }
-function convertTools({ tools, toolChoice, }) {
+function convertTools({ tools, toolChoice, disableParallelToolUse, }) {
     let choice;
     if (typeof toolChoice === "object" && "type" in toolChoice && toolChoice.type === "function") {
         choice = {
             type: "tool",
             name: toolChoice.function.name,
+            disable_parallel_tool_use: disableParallelToolUse,
         };
     }
     else if (toolChoice === "required") {
-        choice = { type: "any" };
+        choice = { type: "any", disable_parallel_tool_use: disableParallelToolUse };
     }
     else if (toolChoice === "auto") {
-        choice = { type: "auto" };
+        choice = { type: "auto", disable_parallel_tool_use: disableParallelToolUse };
     }
     else if (toolChoice === "none") {
         choice = { type: "none" };
@@ -184,7 +212,9 @@ function convertTools({ tools, toolChoice, }) {
             ? tools.map((i) => ({
                 name: i.function.name,
                 description: i.function.description,
-                input_schema: i.function.parameters,
+                input_schema: isEmpty(i.function.parameters)
+                    ? { type: "object" }
+                    : i.function.parameters,
             }))
             : undefined,
         tool_choice: choice,

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

@@ -1,14 +1,15 @@
-import { ChatModel, type ChatModelInput, type ChatModelOutput } from "./chat-model.js";
+import { ChatModel, type ChatModelInput, type ChatModelOptions, type ChatModelOutput } from "./chat-model.js";
+export interface OpenAIChatModelOptions {
+    apiKey?: string;
+    baseURL?: string;
+    model?: string;
+    modelOptions?: ChatModelOptions;
+}
 export declare class OpenAIChatModel extends ChatModel {
-    config?: {
-        apiKey?: string;
-        model?: string;
-    } | undefined;
-    constructor(config?: {
-        apiKey?: string;
-        model?: string;
-    } | undefined);
+    options?: OpenAIChatModelOptions | undefined;
+    constructor(options?: OpenAIChatModelOptions | undefined);
     private _client?;
     private get client();
+    get modelOptions(): ChatModelOptions | undefined;
     process(input: ChatModelInput): Promise<ChatModelOutput>;
 }

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

@@ -1,31 +1,41 @@
 import { nanoid } from "nanoid";
 import OpenAI from "openai";
+import { parseJSON } from "../utils/json-schema.js";
 import { isNonNullable } from "../utils/type-utils.js";
 import { ChatModel, } from "./chat-model.js";
 const CHAT_MODEL_OPENAI_DEFAULT_MODEL = "gpt-4o-mini";
 export class OpenAIChatModel extends ChatModel {
-    config;
-    constructor(config) {
+    options;
+    constructor(options) {
         super();
-        this.config = config;
+        this.options = options;
     }
     _client;
     get client() {
-        if (!this.config?.apiKey)
+        if (!this.options?.apiKey)
             throw new Error("Api Key is required for OpenAIChatModel");
-        this._client ??= new OpenAI({ apiKey: this.config.apiKey });
+        this._client ??= new OpenAI({
+            baseURL: this.options.baseURL,
+            apiKey: this.options.apiKey,
+        });
         return this._client;
     }
+    get modelOptions() {
+        return this.options?.modelOptions;
+    }
     async process(input) {
         const res = await this.client.chat.completions.create({
-            model: this.config?.model || CHAT_MODEL_OPENAI_DEFAULT_MODEL,
-            temperature: input.modelOptions?.temperature,
-            top_p: input.modelOptions?.topP,
-            frequency_penalty: input.modelOptions?.frequencyPenalty,
-            presence_penalty: input.modelOptions?.presencePenalty,
+            model: this.options?.model || CHAT_MODEL_OPENAI_DEFAULT_MODEL,
+            temperature: input.modelOptions?.temperature ?? this.modelOptions?.temperature,
+            top_p: input.modelOptions?.topP ?? this.modelOptions?.topP,
+            frequency_penalty: input.modelOptions?.frequencyPenalty ?? this.modelOptions?.frequencyPenalty,
+            presence_penalty: input.modelOptions?.presencePenalty ?? this.modelOptions?.presencePenalty,
             messages: await contentsFromInputMessages(input.messages),
             tools: toolsFromInputTools(input.tools),
             tool_choice: input.toolChoice,
+            parallel_tool_calls: !input.tools?.length
+                ? undefined
+                : (input.modelOptions?.parallelToolCalls ?? this.modelOptions?.parallelToolCalls),
             response_format: input.responseFormat?.type === "json_schema"
                 ? {
                     type: "json_schema",
@@ -63,7 +73,7 @@ export class OpenAIChatModel extends ChatModel {
         }
         const result = {};
         if (input.responseFormat?.type === "json_schema" && text) {
-            result.json = JSON.parse(text);
+            result.json = parseJSON(text);
         }
         else {
             result.text = text;
@@ -71,7 +81,7 @@ export class OpenAIChatModel extends ChatModel {
         if (toolCalls.length) {
             result.toolCalls = toolCalls.map(({ args, ...c }) => ({
                 ...c,
-                function: { ...c.function, arguments: JSON.parse(args) },
+                function: { ...c.function, arguments: parseJSON(args) },
             }));
         }
         return result;

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

@@ -0,0 +1,12 @@
+import type { ChatModelOptions } from "./chat-model.js";
+import { OpenAIChatModel } from "./openai-chat-model.js";
+export interface XAIChatModelOptions {
+    apiKey?: string;
+    model?: string;
+    modelOptions?: ChatModelOptions;
+    baseURL?: string;
+}
+export declare class XAIChatModel extends OpenAIChatModel {
+    options?: XAIChatModelOptions | undefined;
+    constructor(options?: XAIChatModelOptions | undefined);
+}

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

@@ -0,0 +1,14 @@
+import { OpenAIChatModel } from "./openai-chat-model.js";
+const XAI_DEFAULT_CHAT_MODEL = "grok-2-latest";
+const XAI_BASE_URL = "https://api.x.ai/v1";
+export class XAIChatModel extends OpenAIChatModel {
+    options;
+    constructor(options) {
+        super({
+            ...options,
+            model: options?.model || XAI_DEFAULT_CHAT_MODEL,
+            baseURL: options?.baseURL || XAI_BASE_URL,
+        });
+        this.options = options;
+    }
+}

package/lib/esm/package.json

@@ -0,0 +1 @@
+{"type": "module"}

package/lib/esm/prompt/prompt-builder.d.ts

@@ -1,5 +1,5 @@
 import type { GetPromptResult } from "@modelcontextprotocol/sdk/types.js";
-import { Agent, type AgentOptions, type Message } from "../agents/agent.js";
+import { Agent, type Message } from "../agents/agent.js";
 import type { AIAgent } from "../agents/ai-agent.js";
 import type { AgentMemory } from "../agents/memory.js";
 import type { Context } from "../execution-engine/context.js";
@@ -18,7 +18,7 @@ export interface PromptBuilderBuildOptions {
     agent?: AIAgent;
     input?: Message;
     model?: ChatModel;
-    outputSchema?: AgentOptions["outputSchema"];
+    outputSchema?: Agent["outputSchema"];
 }
 export declare class PromptBuilder {
     static from(instructions: string): PromptBuilder;

package/lib/esm/utils/json-schema.d.ts

@@ -1,3 +1,12 @@
-import type { ZodType } from "zod";
+import type { ZodType, z } from "zod";
 import type { Message } from "../agents/agent.js";
 export declare function outputSchemaToResponseFormatSchema(agentOutput: ZodType<Message>): Record<string, unknown>;
+export declare function parseJSON(json: string): any;
+/**
+ * Ensure that the union array has at least 1 item.
+ * NOTE: the zod union requires at least 2 items (just type definition, not runtime behavior)
+ * so we need to ensure that the union has at least 1 item.
+ * @param union - The union array
+ * @returns The union array with at least 1 item (but the type is at least 2 items for z.union)
+ */
+export declare function ensureZodUnionArray<T extends z.ZodType>(union: T[]): [T, T, ...T[]];

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

@@ -1,5 +1,6 @@
 import { isObject } from "lodash-es";
 import { zodToJsonSchema } from "zod-to-json-schema";
+import { logger } from "./logger.js";
 export function outputSchemaToResponseFormatSchema(agentOutput) {
     return setAdditionPropertiesDeep(zodToJsonSchema(agentOutput), false);
 }
@@ -18,3 +19,25 @@ function setAdditionPropertiesDeep(schema, additionalProperties) {
     }
     return schema;
 }
+export function parseJSON(json) {
+    try {
+        return JSON.parse(json);
+    }
+    catch (error) {
+        logger.debug("Failed to parse JSON", { json, error });
+        throw new Error(`Failed to parse JSON ${error.message}`);
+    }
+}
+/**
+ * Ensure that the union array has at least 1 item.
+ * NOTE: the zod union requires at least 2 items (just type definition, not runtime behavior)
+ * so we need to ensure that the union has at least 1 item.
+ * @param union - The union array
+ * @returns The union array with at least 1 item (but the type is at least 2 items for z.union)
+ */
+export function ensureZodUnionArray(union) {
+    if (!(union.length >= 1)) {
+        throw new Error(`Union must have at least 1 item, but got ${union.length}`);
+    }
+    return union;
+}