@aigne/core 1.34.0 → 1.37.0

package/lib/cjs/agents/team-agent.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TeamAgent = exports.ProcessMode = void 0;
+exports.TeamAgent = exports.DEFAULT_REFLECTION_MAX_ITERATIONS = exports.ProcessMode = void 0;
 const node_assert_1 = __importDefault(require("node:assert"));
 const immer_1 = require("immer");
 const stream_utils_js_1 = require("../utils/stream-utils.js");
@@ -32,6 +32,7 @@ var ProcessMode;
      */
     ProcessMode["parallel"] = "parallel";
 })(ProcessMode || (exports.ProcessMode = ProcessMode = {}));
+exports.DEFAULT_REFLECTION_MAX_ITERATIONS = 3;
 /**
  * TeamAgent coordinates a group of agents working together to accomplish tasks.
  *
@@ -76,6 +77,10 @@ class TeamAgent extends agent_js_1.Agent {
     constructor(options) {
         super(options);
         this.mode = options.mode ?? ProcessMode.sequential;
+        this.reflection = options.reflection && {
+            ...options.reflection,
+            maxIterations: options.reflection.maxIterations ?? exports.DEFAULT_REFLECTION_MAX_ITERATIONS,
+        };
         this.iterateOn = options.iterateOn;
         this.iterateWithPreviousOutput = options.iterateWithPreviousOutput;
     }
@@ -85,6 +90,14 @@ class TeamAgent extends agent_js_1.Agent {
      * This can be either sequential (one after another) or parallel (all at once).
      */
     mode;
+    /**
+     * The reflection mode configuration with guaranteed maxIterations value.
+     *
+     * This is the internal representation after processing the user-provided
+     * reflection configuration, ensuring that maxIterations always has a value
+     * (defaulting to DEFAULT_REFLECTION_MAX_ITERATIONS if not specified).
+     */
+    reflection;
     /**
      * The input field key to iterate over when processing array inputs.
      *
@@ -119,10 +132,35 @@ class TeamAgent extends agent_js_1.Agent {
     process(input, options) {
         if (!this.skills.length)
             throw new Error("TeamAgent must have at least one skill defined.");
+        if (this.reflection)
+            return this._processReflection(input, options);
+        return this._processNonReflection(input, options);
+    }
+    _processNonReflection(input, options) {
         if (this.iterateOn) {
             return this._processIterator(this.iterateOn, input, options);
         }
-        return this._process(input, options);
+        return this._processNonIterator(input, options);
+    }
+    async _processReflection(input, options) {
+        (0, node_assert_1.default)(this.reflection, "Reflection mode must be defined for reflection processing");
+        let iterations = 0;
+        const previousOutput = { ...input };
+        for (;;) {
+            const output = await (0, agent_js_1.agentProcessResultToObject)(await this._processNonReflection(previousOutput, options));
+            Object.assign(previousOutput, output);
+            const reviewOutput = await options.context.invoke(this.reflection.reviewer, previousOutput);
+            Object.assign(previousOutput, reviewOutput);
+            const approved = await this.reflection.isApproved(reviewOutput);
+            if (approved)
+                return output;
+            if (++iterations >= this.reflection.maxIterations) {
+                if (this.reflection.returnLastOnMaxIterations)
+                    return output;
+                break;
+            }
+        }
+        throw new Error(`Reflection mode exceeded max iterations ${this.reflection.maxIterations}. Please review the feedback and try again.`);
     }
     async *_processIterator(key, input, options) {
         (0, node_assert_1.default)(this.iterateOn, "iterateInputKey must be defined for iterator processing");
@@ -133,7 +171,7 @@ class TeamAgent extends agent_js_1.Agent {
             const item = arr[i];
             if (!(0, type_utils_js_1.isRecord)(item))
                 throw new TypeError(`Expected ${String(key)} to be an object, got ${typeof item}`);
-            const res = await (0, agent_js_1.agentProcessResultToObject)(await this._process({ ...input, [key]: arr, ...item }, { ...options, streaming: false }));
+            const res = await (0, agent_js_1.agentProcessResultToObject)(await this._processNonIterator({ ...input, [key]: arr, ...item }, { ...options, streaming: false }));
             // Merge the item result with the original item used for next iteration
             if (this.iterateWithPreviousOutput) {
                 arr = (0, immer_1.produce)(arr, (draft) => {
@@ -146,7 +184,7 @@ class TeamAgent extends agent_js_1.Agent {
             yield { delta: { json: { [key]: result } } };
         }
     }
-    _process(input, options) {
+    _processNonIterator(input, options) {
         switch (this.mode) {
             case ProcessMode.sequential:
                 return this._processSequential(input, options);
@@ -171,19 +209,13 @@ class TeamAgent extends agent_js_1.Agent {
      */
     async *_processSequential(input, options) {
         const output = {};
-        // Clone the agents to run, so that we can update the agents list during the loop
-        const agents = [...this.skills];
-        const newAgents = [];
-        for (const agent of agents) {
-            const [o, transferToAgent] = await options.context.invoke(agent, { ...input, ...output }, { returnActiveAgent: true, streaming: true });
+        for (const agent of this.skills) {
+            const o = await options.context.invoke(agent, { ...input, ...output }, { ...options, streaming: true });
             for await (const chunk of o) {
                 yield chunk;
                 (0, stream_utils_js_1.mergeAgentResponseChunk)(output, chunk);
             }
-            newAgents.push(await transferToAgent);
         }
-        this.skills.splice(0);
-        this.skills.push(...newAgents);
     }
     /**
      * Process input in parallel through all agents in the team.
@@ -200,8 +232,7 @@ class TeamAgent extends agent_js_1.Agent {
      * @private
      */
     async *_processParallel(input, options) {
-        const result = await Promise.all(this.skills.map((agent) => options.context.invoke(agent, input, { returnActiveAgent: true, streaming: true })));
-        const streams = result.map((i) => i[0]);
+        const streams = await Promise.all(this.skills.map((agent) => options.context.invoke(agent, input, { ...options, streaming: true })));
         const read = async (index, reader) => {
             const promise = reader.read();
             return promise.then((result) => ({ ...result, reader, index }));
@@ -236,9 +267,6 @@ class TeamAgent extends agent_js_1.Agent {
                     yield { delta: { ...delta, text } };
             }
         }
-        const agents = await Promise.all(result.map((i) => i[1]));
-        this.skills.splice(0);
-        this.skills.push(...agents);
     }
 }
 exports.TeamAgent = TeamAgent;

package/lib/cjs/aigne/context.d.ts

@@ -180,6 +180,7 @@ declare class AIGNEContextShared {
     span?: Span;
     constructor(parent?: (Pick<Context, "model" | "skills" | "limits" | "observer"> & {
         messageQueue?: MessageQueue;
+        events?: Emitter<any>;
     }) | undefined);
     readonly messageQueue: MessageQueue;
     readonly events: Emitter<any>;

package/lib/cjs/aigne/context.js

@@ -40,7 +40,7 @@ class AIGNEContext {
             }
         }
         else {
-            this.internal = new AIGNEContextShared(parent);
+            this.internal = new AIGNEContextShared(parent instanceof AIGNEContext ? parent.internal : parent);
             this.span = tracer?.startSpan("AIGNEContext");
             // 修改了 rootId 是否会之前的有影响？，之前为 this.id
             this.rootId = this.span?.spanContext?.().traceId ?? (0, uuid_1.v7)();
@@ -272,9 +272,10 @@ class AIGNEContextShared {
     constructor(parent) {
         this.parent = parent;
         this.messageQueue = this.parent?.messageQueue ?? new message_queue_js_1.MessageQueue();
+        this.events = this.parent?.events ?? new strict_event_emitter_1.Emitter();
     }
     messageQueue;
-    events = new strict_event_emitter_1.Emitter();
+    events;
     get model() {
         return this.parent?.model;
     }
@@ -309,21 +310,35 @@ class AIGNEContextShared {
         this.initTimeout();
         return withAbortSignal(this.abortController.signal, new Error("AIGNEContext is timeout"), () => this.invokeAgent(agent, input, context, options));
     }
-    async *invokeAgent(agent, input, context, options) {
+    async *invokeAgent(agent, input, context, options = {}) {
         const startedAt = Date.now();
         try {
             let activeAgent = agent;
             for (;;) {
                 const result = {};
                 if (options?.sourceAgent && activeAgent !== options.sourceAgent) {
-                    options.sourceAgent.hooks.onHandoff?.({
-                        context,
-                        source: options.sourceAgent,
-                        target: activeAgent,
-                        input,
-                    });
+                    for (const { onHandoff } of [options.hooks ?? {}, ...options.sourceAgent.hooks]) {
+                        if (!onHandoff)
+                            continue;
+                        await (typeof onHandoff === "function"
+                            ? onHandoff({
+                                context,
+                                source: options.sourceAgent,
+                                target: activeAgent,
+                                input,
+                            })
+                            : context.invoke(onHandoff, {
+                                source: options.sourceAgent,
+                                target: activeAgent,
+                                input,
+                            }));
+                    }
                 }
-                const stream = await activeAgent.invoke(input, { ...options, context, streaming: true });
+                const stream = await activeAgent.invoke(input, {
+                    hooks: options.hooks,
+                    context,
+                    streaming: true,
+                });
                 for await (const value of stream) {
                     if ((0, agent_js_1.isAgentResponseDelta)(value)) {
                         if (value.delta.json) {

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

@@ -1,17 +1,2 @@
-import { type ZodObject, type ZodType, z } from "zod";
-import { Agent, type FunctionAgentFn } from "../agents/agent.js";
-export declare function loadAgentFromJsFile(path: string): Promise<Agent<any, any> | {
-    process: FunctionAgentFn;
-    name: string;
-    description?: string | 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;
-}>;
+import { Agent } from "../agents/agent.js";
+export declare function loadAgentFromJsFile(path: string): Promise<Agent<any, any> | import("./agent-yaml.js").AgentSchema>;

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

@@ -32,34 +32,22 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.loadAgentFromJsFile = loadAgentFromJsFile;
-const json_schema_to_zod_1 = require("@aigne/json-schema-to-zod");
-const camelize_ts_1 = __importDefault(require("camelize-ts"));
-const zod_1 = require("zod");
 const agent_js_1 = require("../agents/agent.js");
 const type_utils_js_1 = require("../utils/type-utils.js");
-const schema_js_1 = require("./schema.js");
+const agent_yaml_js_1 = require("./agent-yaml.js");
 async function loadAgentFromJsFile(path) {
-    const agentJsFileSchema = zod_1.z.object({
-        name: zod_1.z.string(),
-        description: (0, schema_js_1.optionalize)(zod_1.z.string()),
-        inputSchema: (0, schema_js_1.optionalize)((0, schema_js_1.inputOutputSchema)({ path })).transform((v) => v ? (0, json_schema_to_zod_1.jsonSchemaToZod)(v) : undefined),
-        outputSchema: (0, schema_js_1.optionalize)((0, schema_js_1.inputOutputSchema)({ path })).transform((v) => v ? (0, json_schema_to_zod_1.jsonSchemaToZod)(v) : undefined),
-        process: zod_1.z.custom(),
-    });
     const { default: agent } = await (0, type_utils_js_1.tryOrThrow)(() => Promise.resolve(`${path}`).then(s => __importStar(require(s))), (error) => new Error(`Failed to load agent definition from ${path}: ${error.message}`));
     if (agent instanceof agent_js_1.Agent)
         return agent;
     if (typeof agent !== "function") {
         throw new Error(`Agent file ${path} must export a default function, but got ${typeof agent}`);
     }
-    return (0, type_utils_js_1.tryOrThrow)(() => agentJsFileSchema.parseAsync((0, camelize_ts_1.default)({
+    return (0, type_utils_js_1.tryOrThrow)(() => (0, agent_yaml_js_1.parseAgentFile)(path, {
         ...agent,
+        type: "function",
         name: agent.agent_name || agent.agentName || agent.name,
         process: agent,
-    })), (error) => new Error(`Failed to parse agent from ${path}: ${error.message}`));
+    }), (error) => new Error(`Failed to parse agent from ${path}: ${error.message}`));
 }

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

@@ -1,39 +1,60 @@
 import { type ZodType } from "zod";
+import type { FunctionAgentFn } from "../agents/agent.js";
 import { AIAgentToolChoice } from "../agents/ai-agent.js";
 import { ProcessMode } from "../agents/team-agent.js";
-interface BaseAgentSchema {
+export interface HooksSchema {
+    onStart?: NestAgentSchema;
+    onSuccess?: NestAgentSchema;
+    onError?: NestAgentSchema;
+    onEnd?: NestAgentSchema;
+    onSkillStart?: NestAgentSchema;
+    onSkillEnd?: NestAgentSchema;
+    onHandoff?: NestAgentSchema;
+}
+export type NestAgentSchema = string | {
+    url: string;
+    defaultInput?: Record<string, any>;
+    hooks?: HooksSchema | HooksSchema[];
+} | AgentSchema;
+export interface BaseAgentSchema {
     name?: string;
     description?: string;
     inputSchema?: ZodType<Record<string, any>>;
+    defaultInput?: Record<string, any>;
     outputSchema?: ZodType<Record<string, any>>;
-    skills?: (string | AgentSchema)[];
+    skills?: NestAgentSchema[];
+    hooks?: HooksSchema | HooksSchema[];
     memory?: boolean | {
         provider: string;
         subscribeTopic?: string[];
     };
 }
-interface AIAgentSchema extends BaseAgentSchema {
+export interface AIAgentSchema extends BaseAgentSchema {
     type: "ai";
     instructions?: string;
     inputKey?: string;
     outputKey?: string;
     toolChoice?: AIAgentToolChoice;
 }
-interface MCPAgentSchema {
+export interface MCPAgentSchema extends BaseAgentSchema {
     type: "mcp";
     url?: string;
     command?: string;
     args?: string[];
 }
-interface TeamAgentSchema extends BaseAgentSchema {
+export interface TeamAgentSchema extends BaseAgentSchema {
     type: "team";
     mode?: ProcessMode;
     iterateOn?: string;
 }
-interface TransformAgentSchema extends BaseAgentSchema {
+export interface TransformAgentSchema extends BaseAgentSchema {
     type: "transform";
     jsonata: string;
 }
-type AgentSchema = AIAgentSchema | MCPAgentSchema | TeamAgentSchema | TransformAgentSchema;
+export interface FunctionAgentSchema extends BaseAgentSchema {
+    type: "function";
+    process: FunctionAgentFn;
+}
+export type AgentSchema = AIAgentSchema | MCPAgentSchema | TeamAgentSchema | TransformAgentSchema | FunctionAgentSchema;
+export declare function parseAgentFile(path: string, data: object): Promise<AgentSchema>;
 export declare function loadAgentFromYamlFile(path: string): Promise<AgentSchema>;
-export {};

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

@@ -1,35 +1,52 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseAgentFile = parseAgentFile;
 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 type_utils_js_1 = require("../utils/type-utils.js");
 const schema_js_1 = require("./schema.js");
-async function loadAgentFromYamlFile(path) {
+async function parseAgentFile(path, data) {
     const agentSchema = zod_1.z.lazy(() => {
+        const nestAgentSchema = zod_1.z.lazy(() => zod_1.z.union([
+            agentSchema,
+            zod_1.z.string(),
+            (0, schema_js_1.camelizeSchema)(zod_1.z.object({
+                url: zod_1.z.string(),
+                defaultInput: (0, schema_js_1.optionalize)(schema_js_1.defaultInputSchema),
+                hooks: (0, schema_js_1.optionalize)(zod_1.z.union([hooksSchema, zod_1.z.array(hooksSchema)])),
+            })),
+        ]));
+        const hooksSchema = (0, schema_js_1.camelizeSchema)(zod_1.z.object({
+            onStart: (0, schema_js_1.optionalize)(nestAgentSchema),
+            onSuccess: (0, schema_js_1.optionalize)(nestAgentSchema),
+            onError: (0, schema_js_1.optionalize)(nestAgentSchema),
+            onEnd: (0, schema_js_1.optionalize)(nestAgentSchema),
+            onSkillStart: (0, schema_js_1.optionalize)(nestAgentSchema),
+            onSkillEnd: (0, schema_js_1.optionalize)(nestAgentSchema),
+            onHandoff: (0, schema_js_1.optionalize)(nestAgentSchema),
+        }));
         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)((0, schema_js_1.inputOutputSchema)({ path })).transform((v) => v ? (0, json_schema_to_zod_1.jsonSchemaToZod)(v) : undefined),
+            defaultInput: (0, schema_js_1.optionalize)(schema_js_1.defaultInputSchema),
             outputSchema: (0, schema_js_1.optionalize)((0, schema_js_1.inputOutputSchema)({ path })).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]))),
+            hooks: (0, schema_js_1.optionalize)(zod_1.z.union([hooksSchema, zod_1.z.array(hooksSchema)])),
+            skills: (0, schema_js_1.optionalize)(zod_1.z.array(nestAgentSchema)),
             memory: (0, schema_js_1.optionalize)(zod_1.z.union([
                 zod_1.z.boolean(),
-                zod_1.z.object({
+                (0, schema_js_1.camelizeSchema)(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", [
+        return (0, schema_js_1.camelizeSchema)(zod_1.z.discriminatedUnion("type", [
             zod_1.z
                 .object({
                 type: zod_1.z.literal("ai"),
@@ -40,18 +57,21 @@ async function loadAgentFromYamlFile(path) {
                     }),
                 ])).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")),
+                    : 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({
+            zod_1.z
+                .object({
                 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())),
-            }),
+            })
+                .extend(baseAgentSchema.shape),
             zod_1.z
                 .object({
                 type: zod_1.z.literal("team"),
@@ -65,11 +85,20 @@ async function loadAgentFromYamlFile(path) {
                 jsonata: zod_1.z.string(),
             })
                 .extend(baseAgentSchema.shape),
-        ]);
+            zod_1.z
+                .object({
+                type: zod_1.z.literal("function"),
+                process: zod_1.z.custom(),
+            })
+                .extend(baseAgentSchema.shape),
+        ]));
     });
+    return agentSchema.parseAsync(data);
+}
+async function loadAgentFromYamlFile(path) {
     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 = (0, type_utils_js_1.tryOrThrow)(() => (0, camelize_ts_1.default)((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 () => await agentSchema.parseAsync({
+    const json = (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 () => await parseAgentFile(path, {
         ...json,
         type: json.type ?? "ai",
         skills: json.skills ?? json.tools,

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

@@ -1,6 +1,6 @@
 import type { Camelize } from "camelize-ts";
 import { z } from "zod";
-import { Agent } from "../agents/agent.js";
+import { Agent, type AgentOptions } from "../agents/agent.js";
 import type { ChatModel, ChatModelOptions } from "../agents/chat-model.js";
 import type { AIGNEOptions } from "../aigne/aigne.js";
 import type { MemoryAgent, MemoryAgentOptions } from "../memory/memory.js";
@@ -25,7 +25,7 @@ export interface LoadOptions {
     path: string;
 }
 export declare function load(options: LoadOptions): Promise<AIGNEOptions>;
-export declare function loadAgent(path: string, options?: LoadOptions): Promise<Agent>;
+export declare function loadAgent(path: string, options?: LoadOptions, agentOptions?: AgentOptions): Promise<Agent>;
 export declare function loadModel(models: LoadableModel[], model?: Camelize<z.infer<typeof aigneFileSchema>["model"]>, modelOptions?: ChatModelOptions): Promise<ChatModel | undefined>;
 declare const aigneFileSchema: z.ZodObject<{
     name: z.ZodType<string | undefined, z.ZodTypeDef, string | undefined>;

package/lib/cjs/loader/index.js

@@ -39,47 +39,83 @@ async function load(options) {
         skills,
     };
 }
-async function loadAgent(path, options) {
+async function loadAgent(path, options, agentOptions) {
     if ([".js", ".mjs", ".ts", ".mts"].includes(index_js_1.nodejs.path.extname(path))) {
         const agent = await (0, agent_js_js_1.loadAgentFromJsFile)(path);
         if (agent instanceof agent_js_1.Agent)
             return agent;
-        return agent_js_1.FunctionAgent.from(agent);
+        return parseAgent(path, agent, options, agentOptions);
     }
     if ([".yml", ".yaml"].includes(index_js_1.nodejs.path.extname(path))) {
         const agent = await (0, agent_yaml_js_1.loadAgentFromYamlFile)(path);
-        return parseAgent(path, agent, options);
+        return parseAgent(path, agent, options, agentOptions);
     }
     throw new Error(`Unsupported agent file type: ${path}`);
 }
-async function parseAgent(path, agent, options) {
+async function loadNestAgent(path, agent, options) {
+    return typeof agent === "object" && "type" in agent
+        ? parseAgent(path, agent, options)
+        : typeof agent === "string"
+            ? loadAgent(index_js_1.nodejs.path.join(index_js_1.nodejs.path.dirname(path), agent), options)
+            : loadAgent(index_js_1.nodejs.path.join(index_js_1.nodejs.path.dirname(path), agent.url), options, {
+                defaultInput: agent.defaultInput,
+                hooks: await parseHooks(path, agent.hooks, options),
+            });
+}
+async function parseHooks(path, hooks, options) {
+    hooks = [hooks].flat().filter(type_utils_js_1.isNonNullable);
+    if (!hooks.length)
+        return undefined;
+    return await Promise.all(hooks.map(async (hook) => ({
+        onStart: hook.onStart ? await loadNestAgent(path, hook.onStart, options) : undefined,
+        onSuccess: hook.onSuccess ? await loadNestAgent(path, hook.onSuccess, options) : undefined,
+        onError: hook.onError ? await loadNestAgent(path, hook.onError, options) : undefined,
+        onEnd: hook.onEnd ? await loadNestAgent(path, hook.onEnd, options) : undefined,
+        onSkillStart: hook.onSkillStart
+            ? await loadNestAgent(path, hook.onSkillStart, options)
+            : undefined,
+        onSkillEnd: hook.onSkillEnd
+            ? await loadNestAgent(path, hook.onSkillEnd, options)
+            : undefined,
+        onHandoff: hook.onHandoff ? await loadNestAgent(path, hook.onHandoff, options) : undefined,
+    })));
+}
+async function parseAgent(path, agent, options, agentOptions) {
     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))))
+            (await Promise.all(agent.skills.map((skill) => loadNestAgent(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;
+    const baseOptions = {
+        ...agentOptions,
+        ...agent,
+        skills,
+        memory,
+        hooks: [
+            ...((await parseHooks(path, agent.hooks, options)) ?? []),
+            ...[agentOptions?.hooks].flat().filter(type_utils_js_1.isNonNullable),
+        ],
+    };
     switch (agent.type) {
         case "ai": {
             return ai_agent_js_1.AIAgent.from({
-                ...agent,
+                ...baseOptions,
                 instructions: agent.instructions &&
                     prompt_builder_js_1.PromptBuilder.from(agent.instructions, { workingDir: index_js_1.nodejs.path.dirname(path) }),
-                memory,
-                skills,
             });
         }
         case "mcp": {
             if (agent.url) {
                 return mcp_agent_js_1.MCPAgent.from({
+                    ...baseOptions,
                     url: agent.url,
                 });
             }
             if (agent.command) {
                 return mcp_agent_js_1.MCPAgent.from({
+                    ...baseOptions,
                     command: agent.command,
                     args: agent.args,
                 });
@@ -88,16 +124,19 @@ async function parseAgent(path, agent, options) {
         }
         case "team": {
             return team_agent_js_1.TeamAgent.from({
-                ...agent,
-                memory,
-                skills,
+                ...baseOptions,
             });
         }
         case "transform": {
             return transform_agent_js_1.TransformAgent.from({
-                ...agent,
-                memory,
-                skills,
+                ...baseOptions,
+                jsonata: agent.jsonata,
+            });
+        }
+        case "function": {
+            return agent_js_1.FunctionAgent.from({
+                ...baseOptions,
+                process: agent.process,
             });
         }
     }

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

@@ -22,4 +22,14 @@ export declare const inputOutputSchema: ({ path }: {
     required?: string[] | undefined;
     additionalProperties?: boolean | undefined;
 }>]>;
+export declare const defaultInputSchema: z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodObject<{
+    $get: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    $get: string;
+}, {
+    $get: string;
+}>, z.ZodUnknown]>>;
 export declare function optionalize<T>(schema: ZodType<T>): ZodType<T | undefined>;
+export declare function camelizeSchema<T>(schema: ZodType<T>, { shallow }?: {
+    shallow?: boolean;
+}): ZodType<T>;

package/lib/cjs/loader/schema.js

@@ -1,10 +1,17 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.inputOutputSchema = void 0;
+exports.defaultInputSchema = exports.inputOutputSchema = void 0;
 exports.optionalize = optionalize;
+exports.camelizeSchema = camelizeSchema;
 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 agent_js_1 = require("../agents/agent.js");
+const type_utils_js_1 = require("../utils/type-utils.js");
 const inputOutputSchema = ({ path }) => {
     const includeExternalSchema = async (schema) => {
         if (schema?.type === "object" && schema.properties) {
@@ -50,6 +57,15 @@ const inputOutputSchema = ({ path }) => {
     ]);
 };
 exports.inputOutputSchema = inputOutputSchema;
+exports.defaultInputSchema = zod_1.z.record(zod_1.z.string(), zod_1.z.union([
+    zod_1.z.object({
+        [agent_js_1.DEFAULT_INPUT_ACTION_GET]: zod_1.z.string(),
+    }),
+    zod_1.z.unknown(),
+]));
 function optionalize(schema) {
     return schema.nullish().transform((v) => v ?? undefined);
 }
+function camelizeSchema(schema, { shallow = true } = {}) {
+    return zod_1.z.preprocess((v) => ((0, type_utils_js_1.isRecord)(v) ? (0, camelize_ts_1.default)(v, shallow) : v), schema);
+}

package/lib/cjs/utils/type-utils.d.ts

@@ -19,7 +19,7 @@ export declare function pick<T extends object, K extends keyof T>(obj: T, ...key
 export declare function omit<T extends object, K extends keyof T>(obj: T, ...keys: (K | K[])[]): Omit<T, K>;
 export declare function omitDeep<T, K>(obj: T, ...keys: (K | K[])[]): unknown;
 export declare function omitBy<T extends Record<string, unknown>, K extends keyof T>(obj: T, predicate: (value: T[K], key: K) => boolean): Partial<T>;
-export declare function flat<T>(value?: T | T[]): T[];
+export declare function flat<T>(...value: (T | T[])[]): NonNullable<T>[];
 export declare function createAccessorArray<T>(array: T[], accessor: (array: T[], name: string) => T | undefined): T[] & {
     [key: string]: T;
 };