@aigne/core 1.28.2 → 1.29.0

package/lib/cjs/loader/agent-yaml.js

@@ -1,123 +1,78 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.loadAgentFromYamlFile = loadAgentFromYamlFile;
 const json_schema_to_zod_1 = require("@aigne/json-schema-to-zod");
 const index_js_1 = require("@aigne/platform-helpers/nodejs/index.js");
+const camelize_ts_1 = __importDefault(require("camelize-ts"));
 const yaml_1 = require("yaml");
 const zod_1 = require("zod");
 const ai_agent_js_1 = require("../agents/ai-agent.js");
 const team_agent_js_1 = require("../agents/team-agent.js");
-const camelize_js_1 = require("../utils/camelize.js");
 const type_utils_js_1 = require("../utils/type-utils.js");
 const schema_js_1 = require("./schema.js");
-const agentFileSchema = zod_1.z.discriminatedUnion("type", [
-    zod_1.z.object({
-        type: zod_1.z.literal("ai"),
-        name: zod_1.z.string(),
-        description: zod_1.z
-            .string()
-            .nullish()
-            .transform((v) => v ?? undefined),
-        instructions: zod_1.z
-            .union([
-            zod_1.z.string(),
-            zod_1.z.object({
-                url: zod_1.z.string(),
-            }),
-        ])
-            .nullish()
-            .transform((v) => v ?? undefined),
-        input_key: zod_1.z
-            .string()
-            .nullish()
-            .transform((v) => v ?? undefined),
-        input_schema: schema_js_1.inputOutputSchema
-            .nullish()
-            .transform((v) => (v ? (0, json_schema_to_zod_1.jsonSchemaToZod)(v) : undefined)),
-        output_schema: schema_js_1.inputOutputSchema
-            .nullish()
-            .transform((v) => (v ? (0, json_schema_to_zod_1.jsonSchemaToZod)(v) : undefined)),
-        output_key: zod_1.z
-            .string()
-            .nullish()
-            .transform((v) => v ?? undefined),
-        skills: zod_1.z
-            .array(zod_1.z.string())
-            .nullish()
-            .transform((v) => v ?? undefined),
-        tool_choice: zod_1.z
-            .nativeEnum(ai_agent_js_1.AIAgentToolChoice)
-            .nullish()
-            .transform((v) => v ?? undefined),
-        memory: zod_1.z
-            .union([
-            zod_1.z.boolean(),
+async function loadAgentFromYamlFile(path) {
+    const agentSchema = zod_1.z.lazy(() => {
+        const baseAgentSchema = zod_1.z.object({
+            name: (0, schema_js_1.optionalize)(zod_1.z.string()),
+            description: (0, schema_js_1.optionalize)(zod_1.z.string()),
+            inputSchema: (0, schema_js_1.optionalize)(schema_js_1.inputOutputSchema).transform((v) => v ? (0, json_schema_to_zod_1.jsonSchemaToZod)(v) : undefined),
+            outputSchema: (0, schema_js_1.optionalize)(schema_js_1.inputOutputSchema).transform((v) => v ? (0, json_schema_to_zod_1.jsonSchemaToZod)(v) : undefined),
+            skills: (0, schema_js_1.optionalize)(zod_1.z.array(zod_1.z.union([zod_1.z.string(), agentSchema]))),
+            memory: (0, schema_js_1.optionalize)(zod_1.z.union([
+                zod_1.z.boolean(),
+                zod_1.z.object({
+                    provider: zod_1.z.string(),
+                    subscribeTopic: (0, schema_js_1.optionalize)(zod_1.z.array(zod_1.z.string())),
+                }),
+            ])),
+        });
+        return zod_1.z.discriminatedUnion("type", [
+            zod_1.z
+                .object({
+                type: zod_1.z.literal("ai"),
+                instructions: (0, schema_js_1.optionalize)(zod_1.z.union([
+                    zod_1.z.string(),
+                    zod_1.z.object({
+                        url: zod_1.z.string(),
+                    }),
+                ])).transform((v) => typeof v === "string"
+                    ? v
+                    : v && index_js_1.nodejs.fs.readFile(index_js_1.nodejs.path.join(index_js_1.nodejs.path.dirname(path), v.url), "utf8")),
+                inputKey: (0, schema_js_1.optionalize)(zod_1.z.string()),
+                outputKey: (0, schema_js_1.optionalize)(zod_1.z.string()),
+                toolChoice: (0, schema_js_1.optionalize)(zod_1.z.nativeEnum(ai_agent_js_1.AIAgentToolChoice)),
+            })
+                .extend(baseAgentSchema.shape),
             zod_1.z.object({
-                provider: zod_1.z.string(),
-                subscribe_topic: zod_1.z
-                    .array(zod_1.z.string())
-                    .nullish()
-                    .transform((v) => v ?? undefined),
+                type: zod_1.z.literal("mcp"),
+                url: (0, schema_js_1.optionalize)(zod_1.z.string()),
+                command: (0, schema_js_1.optionalize)(zod_1.z.string()),
+                args: (0, schema_js_1.optionalize)(zod_1.z.array(zod_1.z.string())),
             }),
-        ])
-            .nullish()
-            .transform((v) => v || undefined),
-    }),
-    zod_1.z.object({
-        type: zod_1.z.literal("mcp"),
-        url: zod_1.z
-            .string()
-            .nullish()
-            .transform((v) => v ?? undefined),
-        command: zod_1.z
-            .string()
-            .nullish()
-            .transform((v) => v ?? undefined),
-        args: zod_1.z
-            .array(zod_1.z.string())
-            .nullish()
-            .transform((v) => v ?? undefined),
-    }),
-    zod_1.z.object({
-        type: zod_1.z.literal("team"),
-        name: zod_1.z.string(),
-        description: zod_1.z
-            .string()
-            .nullish()
-            .transform((v) => v ?? undefined),
-        input_schema: schema_js_1.inputOutputSchema
-            .nullish()
-            .transform((v) => (v ? (0, json_schema_to_zod_1.jsonSchemaToZod)(v) : undefined)),
-        output_schema: schema_js_1.inputOutputSchema
-            .nullish()
-            .transform((v) => (v ? (0, json_schema_to_zod_1.jsonSchemaToZod)(v) : undefined)),
-        skills: zod_1.z
-            .array(zod_1.z.string())
-            .nullish()
-            .transform((v) => v ?? undefined),
-        mode: zod_1.z
-            .nativeEnum(team_agent_js_1.ProcessMode)
-            .nullish()
-            .transform((v) => v ?? undefined),
-    }),
-]);
-async function loadAgentFromYamlFile(path) {
+            zod_1.z
+                .object({
+                type: zod_1.z.literal("team"),
+                mode: (0, schema_js_1.optionalize)(zod_1.z.nativeEnum(team_agent_js_1.ProcessMode)),
+                iterateOn: (0, schema_js_1.optionalize)(zod_1.z.string()),
+            })
+                .extend(baseAgentSchema.shape),
+            zod_1.z
+                .object({
+                type: zod_1.z.literal("transform"),
+                jsonata: zod_1.z.string(),
+            })
+                .extend(baseAgentSchema.shape),
+        ]);
+    });
     const raw = await (0, type_utils_js_1.tryOrThrow)(() => index_js_1.nodejs.fs.readFile(path, "utf8"), (error) => new Error(`Failed to load agent definition from ${path}: ${error.message}`));
     const json = await (0, type_utils_js_1.tryOrThrow)(() => (0, yaml_1.parse)(raw), (error) => new Error(`Failed to parse agent definition from ${path}: ${error.message}`));
-    const agent = await (0, type_utils_js_1.tryOrThrow)(async () => (0, camelize_js_1.customCamelize)(await agentFileSchema.parseAsync({
+    const agent = await (0, type_utils_js_1.tryOrThrow)(async () => await agentSchema.parseAsync((0, camelize_ts_1.default)({
         ...json,
         type: json.type ?? "ai",
         skills: json.skills ?? json.tools,
-    }), {
-        shallowKeys: ["input_schema", "output_schema"],
-    }), (error) => new Error(`Failed to validate agent definition from ${path}: ${error.message}`));
-    if (agent.type === "ai") {
-        return {
-            ...agent,
-            instructions: typeof agent.instructions === "object" && "url" in agent.instructions
-                ? await index_js_1.nodejs.fs.readFile(index_js_1.nodejs.path.join(index_js_1.nodejs.path.dirname(path), agent.instructions.url), "utf8")
-                : agent.instructions,
-        };
-    }
+    })), (error) => new Error(`Failed to validate agent definition from ${path}: ${error.message}`));
     return agent;
 }

package/lib/cjs/loader/index.js

@@ -11,6 +11,7 @@ const agent_js_1 = require("../agents/agent.js");
 const ai_agent_js_1 = require("../agents/ai-agent.js");
 const mcp_agent_js_1 = require("../agents/mcp-agent.js");
 const team_agent_js_1 = require("../agents/team-agent.js");
+const transform_agent_js_1 = require("../agents/transform-agent.js");
 const type_utils_js_1 = require("../utils/type-utils.js");
 const agent_js_js_1 = require("./agent-js.js");
 const agent_yaml_js_1 = require("./agent-yaml.js");
@@ -42,20 +43,29 @@ async function loadAgent(path, options) {
     }
     if ([".yml", ".yaml"].includes(index_js_1.nodejs.path.extname(path))) {
         const agent = await (0, agent_yaml_js_1.loadAgentFromYamlFile)(path);
-        const skills = "skills" in agent
-            ? agent.skills &&
-                (await Promise.all(agent.skills.map((filename) => loadAgent(index_js_1.nodejs.path.join(index_js_1.nodejs.path.dirname(path), filename), options))))
-            : undefined;
-        if (agent.type === "ai") {
+        return parseAgent(path, agent, options);
+    }
+    throw new Error(`Unsupported agent file type: ${path}`);
+}
+async function parseAgent(path, agent, options) {
+    const skills = "skills" in agent
+        ? agent.skills &&
+            (await Promise.all(agent.skills.map((skill) => typeof skill === "string"
+                ? loadAgent(index_js_1.nodejs.path.join(index_js_1.nodejs.path.dirname(path), skill), options)
+                : parseAgent(path, skill, options))))
+        : undefined;
+    const memory = "memory" in agent && options?.memories?.length
+        ? await loadMemory(options.memories, typeof agent.memory === "object" ? agent.memory.provider : undefined, typeof agent.memory === "object" ? agent.memory : {})
+        : undefined;
+    switch (agent.type) {
+        case "ai": {
             return ai_agent_js_1.AIAgent.from({
                 ...agent,
-                memory: !options?.memories?.length || !agent.memory
-                    ? undefined
-                    : await loadMemory(options.memories, typeof agent.memory === "object" ? agent.memory.provider : undefined, typeof agent.memory === "object" ? agent.memory : {}),
+                memory,
                 skills,
             });
         }
-        if (agent.type === "mcp") {
+        case "mcp": {
             if (agent.url) {
                 return mcp_agent_js_1.MCPAgent.from({
                     url: agent.url,
@@ -69,14 +79,21 @@ async function loadAgent(path, options) {
             }
             throw new Error(`Missing url or command in mcp agent: ${path}`);
         }
-        if (agent.type === "team") {
+        case "team": {
             return team_agent_js_1.TeamAgent.from({
                 ...agent,
+                memory,
+                skills,
+            });
+        }
+        case "transform": {
+            return transform_agent_js_1.TransformAgent.from({
+                ...agent,
+                memory,
                 skills,
             });
         }
     }
-    throw new Error(`Unsupported agent file type: ${path}`);
 }
 async function loadMemory(memories, provider, options) {
     const M = !provider

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

@@ -1,4 +1,4 @@
-import { z } from "zod";
+import { type ZodType, z } from "zod";
 export declare const inputOutputSchema: z.ZodObject<{
     type: z.ZodLiteral<"object">;
     properties: z.ZodRecord<z.ZodString, z.ZodAny>;
@@ -15,3 +15,4 @@ export declare const inputOutputSchema: z.ZodObject<{
     required?: string[] | undefined;
     additionalProperties?: boolean | undefined;
 }>;
+export declare function optionalize<T>(schema: ZodType<T>): ZodType<T | undefined>;

package/lib/cjs/loader/schema.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.inputOutputSchema = void 0;
+exports.optionalize = optionalize;
 const zod_1 = require("zod");
 exports.inputOutputSchema = zod_1.z.object({
     type: zod_1.z.literal("object"),
@@ -8,3 +9,6 @@ exports.inputOutputSchema = zod_1.z.object({
     required: zod_1.z.array(zod_1.z.string()).optional(),
     additionalProperties: zod_1.z.boolean().optional(),
 });
+function optionalize(schema) {
+    return schema.nullish().transform((v) => v ?? undefined);
+}

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

@@ -692,6 +692,7 @@ export type AgentProcessAsyncGenerator<O extends Message> = AsyncGenerator<Agent
  * @template O Agent output message type
  */
 export type AgentProcessResult<O extends Message> = AgentResponse<O> | AgentProcessAsyncGenerator<O> | Agent;
+export declare function agentProcessResultToObject<O extends Message>(response: AgentProcessResult<O>): Promise<O>;
 /**
  * Schema definition type for agent input/output
  *

package/lib/dts/agents/team-agent.d.ts

@@ -33,6 +33,42 @@ export interface TeamAgentOptions<I extends Message, O extends Message> extends
      * @default {ProcessMode.sequential}
      */
     mode?: ProcessMode;
+    /**
+     * Specifies which input field should be treated as an array for iterative processing.
+     *
+     * When this property is set, the TeamAgent will iterate over the array values in the
+     * specified input field, processing each element individually through the team's agents.
+     * The results from each iteration are accumulated and returned as a streaming response.
+     *
+     * This is particularly useful for batch processing scenarios where you need to apply
+     * the same agent workflow to multiple similar data items.
+     *
+     * @remarks
+     * - The specified field must contain an array or array-like value
+     * - Each array element should be an object that can be merged with the base input
+     * - Non-array values will be treated as single-element arrays
+     * - The processing results are streamed incrementally as each iteration completes
+     */
+    iterateOn?: keyof I;
+    /**
+     * Controls whether to merge the output from each iteration back into the array items
+     * for subsequent iterations when using `iterateOn`.
+     *
+     * When set to `true`, the output from processing each array element is merged back
+     * into that element, making it available for the next iteration. This creates a
+     * cumulative effect where each iteration builds upon the results of previous ones.
+     *
+     * When set to `false` or undefined, each array element is processed independently
+     * without any cross-iteration data sharing.
+     *
+     * This is particularly useful for scenarios where:
+     * - You need to progressively enrich data across iterations
+     * - Later iterations depend on the results of earlier ones
+     * - You want to build a chain of transformations on array data
+     *
+     * @default false
+     */
+    iterateWithPreviousOutput?: boolean;
 }
 /**
  * TeamAgent coordinates a group of agents working together to accomplish tasks.
@@ -80,6 +116,25 @@ export declare class TeamAgent<I extends Message, O extends Message> extends Age
      * This can be either sequential (one after another) or parallel (all at once).
      */
     mode: ProcessMode;
+    /**
+     * The input field key to iterate over when processing array inputs.
+     *
+     * When set, this property enables the TeamAgent to process array values iteratively,
+     * where each array element is processed individually through the team's agent workflow.
+     * The accumulated results are returned via streaming response chunks.
+     *
+     * @see TeamAgentOptions.iterateOn for detailed documentation
+     */
+    iterateOn?: keyof I;
+    /**
+     * Controls whether to merge the output from each iteration back into the array items
+     * for subsequent iterations when using `iterateOn`.
+     *
+     * @see TeamAgentOptions.iterateWithPreviousOutput for detailed documentation
+     *
+     * @default false
+     */
+    iterateWithPreviousOutput?: boolean;
     /**
      * Process an input message by routing it through the team's agents.
      *
@@ -93,6 +148,8 @@ export declare class TeamAgent<I extends Message, O extends Message> extends Age
      * @returns A stream of message chunks that collectively form the response
      */
     process(input: I, options: AgentInvokeOptions): PromiseOrValue<AgentProcessResult<O>>;
+    private _processIterator;
+    private _process;
     /**
      * Process input sequentially through each agent in the team.
      *
@@ -108,7 +165,7 @@ export declare class TeamAgent<I extends Message, O extends Message> extends Age
      *
      * @private
      */
-    _processSequential(input: I, options: AgentInvokeOptions): PromiseOrValue<AgentProcessResult<O>>;
+    _processSequential(input: Message, options: AgentInvokeOptions): PromiseOrValue<AgentProcessResult<O>>;
     /**
      * Process input in parallel through all agents in the team.
      *
@@ -123,5 +180,5 @@ export declare class TeamAgent<I extends Message, O extends Message> extends Age
      *
      * @private
      */
-    _processParallel(input: I, options: AgentInvokeOptions): PromiseOrValue<AgentProcessResult<O>>;
+    _processParallel(input: Message, options: AgentInvokeOptions): PromiseOrValue<AgentProcessResult<O>>;
 }

package/lib/dts/agents/transform-agent.d.ts

@@ -0,0 +1,82 @@
+import { Agent, type AgentOptions, type Message } from "./agent.js";
+/**
+ * Configuration options for TransformAgent
+ *
+ * TransformAgent is a specialized agent that transforms input data to output data
+ * using [JSONata](https://jsonata.org/) expressions. It's particularly useful for:
+ * - Data format conversion (e.g., snake_case to camelCase)
+ * - Field mapping and renaming
+ * - Data structure transformation
+ * - Simple data processing without complex logic
+ * - API response normalization
+ * - Configuration data transformation
+ */
+export interface TransformAgentOptions<I extends Message, O extends Message> extends AgentOptions<I, O> {
+    /**
+     * JSONata expression string for data transformation
+     *
+     * JSONata is a lightweight query and transformation language for JSON data.
+     * The expression defines how input data should be transformed into output data.
+     *
+     * Common JSONata patterns:
+     * - Field mapping: `{ "newField": oldField }`
+     * - Array transformation: `items.{ "name": product_name, "price": price }`
+     * - Calculations: `$sum(items.price)`, `$count(items)`
+     * - Conditional logic: `condition ? value1 : value2`
+     * - String operations: `$uppercase(name)`, `$substring(text, 0, 10)`
+     *
+     * @see https://jsonata.org/ for complete JSONata syntax documentation
+     * @see https://try.jsonata.org/ for interactive JSONata playground
+     */
+    jsonata: string;
+}
+/**
+ * TransformAgent - A specialized agent for data transformation using JSONata expressions
+ *
+ * This agent provides a declarative way to transform structured data without writing
+ * custom processing logic. It leverages the power of JSONata, a lightweight query and
+ * transformation language, to handle complex data manipulations through simple expressions.
+ *
+ * Common Use Cases:
+ * - API response normalization and field mapping
+ * - Database query result transformation
+ * - Configuration data restructuring
+ * - Data format conversion (snake_case ↔ camelCase)
+ * - Aggregation and calculation operations
+ * - Filtering and conditional data processing
+ */
+export declare class TransformAgent<I extends Message = Message, O extends Message = Message> extends Agent<I, O> {
+    static type: string;
+    /**
+     * Factory method to create a new TransformAgent instance
+     *
+     * Provides a convenient way to create TransformAgent instances with proper typing
+     *
+     * @param options Configuration options for the TransformAgent
+     * @returns A new TransformAgent instance
+     */
+    static from<I extends Message, O extends Message>(options: TransformAgentOptions<I, O>): TransformAgent<I, O>;
+    /**
+     * Create a new TransformAgent instance
+     *
+     * @param options Configuration options including the JSONata expression
+     */
+    constructor(options: TransformAgentOptions<I, O>);
+    /**
+     * The JSONata expression string used for data transformation
+     *
+     * This expression is compiled and executed against input data to produce
+     * the transformed output. The expression is stored as a string and compiled
+     * on each invocation for maximum flexibility.
+     */
+    private jsonata;
+    /**
+     * Process input data using the configured JSONata expression
+     *
+     * This method compiles the JSONata expression and evaluates it against the input data.
+     *
+     * @param input The input message to transform
+     * @returns Promise resolving to the transformed output message
+     */
+    process(input: I): Promise<O>;
+}

package/lib/dts/index.d.ts

@@ -4,6 +4,7 @@ export * from "./agents/chat-model.js";
 export * from "./agents/guide-rail-agent.js";
 export * from "./agents/mcp-agent.js";
 export * from "./agents/team-agent.js";
+export * from "./agents/transform-agent.js";
 export * from "./agents/types.js";
 export * from "./agents/user-agent.js";
 export * from "./aigne/index.js";

package/lib/dts/loader/agent-js.d.ts

@@ -1,7 +1,7 @@
 import { type ZodObject, type ZodType, z } from "zod";
-import { Agent, type Message } from "../agents/agent.js";
+import { Agent, type FunctionAgentFn } from "../agents/agent.js";
 export declare function loadAgentFromJsFile(path: string): Promise<Agent<any, any> | {
-    process: (args_0: Message) => Message;
+    process: FunctionAgentFn;
     name: string;
     description?: string | undefined;
     inputSchema?: ZodObject<Record<string, ZodType<any, z.ZodTypeDef, any>>, z.UnknownKeysParam, z.ZodTypeAny, {

package/lib/dts/loader/agent-yaml.d.ts

@@ -1,48 +1,39 @@
-import { type ZodObject, type ZodType, z } from "zod";
+import { type ZodType } from "zod";
 import { AIAgentToolChoice } from "../agents/ai-agent.js";
 import { ProcessMode } from "../agents/team-agent.js";
-export declare function loadAgentFromYamlFile(path: string): Promise<{
+interface BaseAgentSchema {
+    name?: string;
+    description?: string;
+    inputSchema?: ZodType<Record<string, ZodType>>;
+    outputSchema?: ZodType<Record<string, ZodType>>;
+    skills?: (string | AgentSchema)[];
+    memory?: boolean | {
+        provider: string;
+        subscribeTopic?: string[];
+    };
+}
+interface AIAgentSchema extends BaseAgentSchema {
+    type: "ai";
+    instructions?: string;
+    inputKey?: string;
+    outputKey?: string;
+    toolChoice?: AIAgentToolChoice;
+}
+interface MCPAgentSchema {
     type: "mcp";
-    url?: string | undefined;
-    command?: string | undefined;
-    args?: string[] | undefined;
-} | {
+    url?: string;
+    command?: string;
+    args?: string[];
+}
+interface TeamAgentSchema extends BaseAgentSchema {
     type: "team";
-    name: string;
-    description?: string | undefined;
-    skills?: string[] | undefined;
-    mode?: ProcessMode | undefined;
-    inputSchema?: ZodObject<Record<string, ZodType<any, z.ZodTypeDef, any>>, z.UnknownKeysParam, z.ZodTypeAny, {
-        [x: string]: any;
-    }, {
-        [x: string]: any;
-    }> | undefined;
-    outputSchema?: ZodObject<Record<string, ZodType<any, z.ZodTypeDef, any>>, z.UnknownKeysParam, z.ZodTypeAny, {
-        [x: string]: any;
-    }, {
-        [x: string]: any;
-    }> | undefined;
-} | {
-    instructions: string | undefined;
-    type: "ai";
-    name: string;
-    description?: string | undefined;
-    skills?: string[] | undefined;
-    memory?: true | {
-        provider: string;
-        subscribeTopic?: string[] | undefined;
-    } | undefined;
-    inputSchema?: ZodObject<Record<string, ZodType<any, z.ZodTypeDef, any>>, z.UnknownKeysParam, z.ZodTypeAny, {
-        [x: string]: any;
-    }, {
-        [x: string]: any;
-    }> | undefined;
-    outputSchema?: ZodObject<Record<string, ZodType<any, z.ZodTypeDef, any>>, z.UnknownKeysParam, z.ZodTypeAny, {
-        [x: string]: any;
-    }, {
-        [x: string]: any;
-    }> | undefined;
-    inputKey?: string | undefined;
-    outputKey?: string | undefined;
-    toolChoice?: AIAgentToolChoice | undefined;
-}>;
+    mode?: ProcessMode;
+    iterateOn?: string;
+}
+interface TransformAgentSchema extends BaseAgentSchema {
+    type: "transform";
+    jsonata: string;
+}
+type AgentSchema = AIAgentSchema | MCPAgentSchema | TeamAgentSchema | TransformAgentSchema;
+export declare function loadAgentFromYamlFile(path: string): Promise<AgentSchema>;
+export {};

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

@@ -1,4 +1,4 @@
-import { z } from "zod";
+import { type ZodType, z } from "zod";
 export declare const inputOutputSchema: z.ZodObject<{
     type: z.ZodLiteral<"object">;
     properties: z.ZodRecord<z.ZodString, z.ZodAny>;
@@ -15,3 +15,4 @@ export declare const inputOutputSchema: z.ZodObject<{
     required?: string[] | undefined;
     additionalProperties?: boolean | undefined;
 }>;
+export declare function optionalize<T>(schema: ZodType<T>): ZodType<T | undefined>;

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

@@ -692,6 +692,7 @@ export type AgentProcessAsyncGenerator<O extends Message> = AsyncGenerator<Agent
  * @template O Agent output message type
  */
 export type AgentProcessResult<O extends Message> = AgentResponse<O> | AgentProcessAsyncGenerator<O> | Agent;
+export declare function agentProcessResultToObject<O extends Message>(response: AgentProcessResult<O>): Promise<O>;
 /**
  * Schema definition type for agent input/output
  *

package/lib/esm/agents/agent.js

@@ -326,11 +326,7 @@ export class Agent {
                     },
                 }), opts);
             }
-            return await this.checkResponseByGuideRails(input, this.processAgentOutput(parsedInput, response instanceof ReadableStream
-                ? await agentResponseStreamToObject(response)
-                : isAsyncGenerator(response)
-                    ? await agentResponseStreamToObject(response)
-                    : response, opts), opts);
+            return await this.checkResponseByGuideRails(input, this.processAgentOutput(parsedInput, await agentProcessResultToObject(response), opts), opts);
         }
         catch (error) {
             throw await this.processAgentError(input, error, opts);
@@ -578,6 +574,13 @@ export function textDelta(textDelta) {
 export function jsonDelta(jsonDelta) {
     return { delta: { json: jsonDelta } };
 }
+export async function agentProcessResultToObject(response) {
+    return response instanceof ReadableStream
+        ? await agentResponseStreamToObject(response)
+        : isAsyncGenerator(response)
+            ? await agentResponseStreamToObject(response)
+            : response;
+}
 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, got: ${typeof schema}`);