@aigne/core 1.34.0 → 1.36.0

package/CHANGELOG.md

@@ -12,6 +12,20 @@
   * dependencies
     * @aigne/observability bumped to 0.1.0
 
+## [1.36.0](https://github.com/AIGNE-io/aigne-framework/compare/core-v1.35.0...core-v1.36.0) (2025-07-17)
+
+
+### Features
+
+* **core:** support define hooks for agent in yaml ([#260](https://github.com/AIGNE-io/aigne-framework/issues/260)) ([c388e82](https://github.com/AIGNE-io/aigne-framework/commit/c388e8216134271af4d9c7def70862ea3c354c7f))
+
+## [1.35.0](https://github.com/AIGNE-io/aigne-framework/compare/core-v1.34.0...core-v1.35.0) (2025-07-17)
+
+
+### Features
+
+* **core:** support custom default input value for agent ([#258](https://github.com/AIGNE-io/aigne-framework/issues/258)) ([352ac70](https://github.com/AIGNE-io/aigne-framework/commit/352ac70400fb7e28cc36c4f6dc9c591b0d64e546))
+
 ## [1.34.0](https://github.com/AIGNE-io/aigne-framework/compare/core-v1.33.2...core-v1.34.0) (2025-07-15)
 
 

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

@@ -10,6 +10,7 @@ import { type Nullish, type PromiseOrValue, type XOr } from "../utils/type-utils
 import type { GuideRailAgent, GuideRailAgentOutput } from "./guide-rail-agent.js";
 import { type TransferAgentOutput } from "./types.js";
 export * from "./types.js";
+export declare const DEFAULT_INPUT_ACTION_GET = "$get";
 /**
  * Basic message type that can contain any key-value pairs
  */
@@ -72,6 +73,11 @@ export interface AgentOptions<I extends Message = Message, O extends Message = M
      * Used to validate that input messages conform to the expected format
      */
     inputSchema?: AgentInputOutputSchema<I>;
+    /**
+     * Default input message for the agent, it can be used to provide partial input
+     * or default values for the agent's input schema.
+     */
+    defaultInput?: Agent<I, O>["defaultInput"];
     /**
      * Zod schema defining the output message structure
      *
@@ -106,7 +112,7 @@ export interface AgentOptions<I extends Message = Message, O extends Message = M
      * Maximum number of memory items to retrieve
      */
     maxRetrieveMemoryCount?: number;
-    hooks?: AgentHooks<I, O>;
+    hooks?: AgentHooks<I, O> | AgentHooks<I, O>[];
 }
 export declare const agentOptionsSchema: ZodObject<{
     [key in keyof AgentOptions]: ZodType<AgentOptions[key]>;
@@ -137,6 +143,10 @@ export interface AgentInvokeOptions<U extends UserContext = UserContext> {
      * and returns the final JSON result
      */
     streaming?: boolean;
+    /**
+     * Optional hooks for agent invocation
+     */
+    hooks?: AgentHooks<any, any>;
 }
 /**
  * Agent is the base class for all agents.
@@ -190,7 +200,7 @@ export declare abstract class Agent<I extends Message = any, O extends Message =
      * Here's an example of using hooks:
      * {@includeCode ../../test/agents/agent.test.ts#example-agent-hooks}
      */
-    readonly hooks: AgentHooks<I, O>;
+    readonly hooks: AgentHooks<I, O>[];
     /**
      * List of GuideRail agents applied to this agent
      *
@@ -232,6 +242,11 @@ export declare abstract class Agent<I extends Message = any, O extends Message =
      */
     readonly description?: string;
     private readonly _inputSchema?;
+    defaultInput?: Partial<{
+        [key in keyof I]: {
+            [DEFAULT_INPUT_ACTION_GET]: string;
+        } | I[key];
+    }>;
     private readonly _outputSchema?;
     /**
      * Get the input data schema for this agent
@@ -372,6 +387,8 @@ export declare abstract class Agent<I extends Message = any, O extends Message =
      * @returns Agent response (streaming or regular)
      */
     invoke(input: I & Message, options?: Partial<AgentInvokeOptions>): Promise<AgentResponse<O>>;
+    private callHooks;
+    private mergeDefaultInput;
     protected invokeSkill<I extends Message, O extends Message>(skill: Agent<I, O>, input: I & Message, options: AgentInvokeOptions): Promise<O>;
     /**
      * Process agent output
@@ -517,11 +534,15 @@ export interface AgentHooks<I extends Message = Message, O extends Message = Mes
      *
      * @param event Object containing the input message
      */
-    onStart?: (event: {
+    onStart?: ((event: {
         context: Context;
         input: I;
     }) => PromiseOrValue<void | {
         input?: I;
+    }>) | Agent<{
+        input: I;
+    }, {
+        input?: I;
     }>;
     /**
      * Called when agent processing completes or fails
@@ -532,13 +553,39 @@ export interface AgentHooks<I extends Message = Message, O extends Message = Mes
      *
      * @param event Object containing the input message and either output or error
      */
-    onEnd?: (event: XOr<{
+    onEnd?: ((event: XOr<{
         context: Context;
         input: I;
         output: O;
         error: Error;
     }, "output", "error">) => PromiseOrValue<void | {
         output?: O;
+    }>) | Agent<XOr<{
+        input: I;
+        output: O;
+        error: Error;
+    }, "output", "error">, {
+        output?: O;
+    }>;
+    onSuccess?: ((event: {
+        context: Context;
+        input: I;
+        output: O;
+    }) => PromiseOrValue<void | {
+        output?: O;
+    }>) | Agent<{
+        input: I;
+        output: O;
+    }, {
+        output?: O;
+    }>;
+    onError?: ((event: {
+        context: Context;
+        input: I;
+        error: Error;
+    }) => void) | Agent<{
+        input: I;
+        error: Error;
     }>;
     /**
      * Called before a skill (sub-agent) is invoked
@@ -548,11 +595,14 @@ export interface AgentHooks<I extends Message = Message, O extends Message = Mes
      *
      * @param event Object containing the skill being used and input message
      */
-    onSkillStart?: (event: {
+    onSkillStart?: ((event: {
         context: Context;
         skill: Agent;
         input: Message;
-    }) => PromiseOrValue<void>;
+    }) => PromiseOrValue<void>) | Agent<{
+        skill: Agent;
+        input: Message;
+    }>;
     /**
      * Called after a skill (sub-agent) completes or fails
      *
@@ -562,13 +612,18 @@ export interface AgentHooks<I extends Message = Message, O extends Message = Mes
      *
      * @param event Object containing the skill used, input message, and either output or error
      */
-    onSkillEnd?: (event: XOr<{
+    onSkillEnd?: ((event: XOr<{
         context: Context;
         skill: Agent;
         input: Message;
         output: Message;
         error: Error;
-    }, "output", "error">) => PromiseOrValue<void>;
+    }, "output", "error">) => PromiseOrValue<void>) | Agent<XOr<{
+        skill: Agent;
+        input: Message;
+        output: Message;
+        error: Error;
+    }, "output", "error">>;
     /**
      * Called when an agent hands off processing to another agent
      *
@@ -578,13 +633,19 @@ export interface AgentHooks<I extends Message = Message, O extends Message = Mes
      *
      * @param event Object containing the source agent, target agent, and input message
      */
-    onHandoff?: (event: {
+    onHandoff?: ((event: {
         context: Context;
         source: Agent;
         target: Agent;
         input: I;
-    }) => PromiseOrValue<void>;
+    }) => PromiseOrValue<void>) | Agent<{
+        source: Agent;
+        target: Agent;
+        input: I;
+    }>;
 }
+export type AgentHookInput<H extends keyof AgentHooks, Hook extends AgentHooks[H] = AgentHooks[H]> = Hook extends (input: infer I) => any ? Omit<I, "context"> : never;
+export type AgentHookOutput<H extends keyof AgentHooks, Hook extends AgentHooks[H] = AgentHooks[H]> = Hook extends (...args: any[]) => any ? Exclude<Awaited<ReturnType<Hook>>, void> | undefined : never;
 /**
  * Response type for an agent, can be:
  * - Direct response object

package/lib/cjs/agents/agent.js

@@ -36,7 +36,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FunctionAgent = exports.Agent = exports.agentOptionsSchema = void 0;
+exports.FunctionAgent = exports.Agent = exports.agentOptionsSchema = exports.DEFAULT_INPUT_ACTION_GET = void 0;
 exports.isEmptyChunk = isEmptyChunk;
 exports.isAgentResponseDelta = isAgentResponseDelta;
 exports.isAgentResponseProgress = isAgentResponseProgress;
@@ -50,6 +50,14 @@ const stream_utils_js_1 = require("../utils/stream-utils.js");
 const type_utils_js_1 = require("../utils/type-utils.js");
 const types_js_1 = require("./types.js");
 __exportStar(require("./types.js"), exports);
+exports.DEFAULT_INPUT_ACTION_GET = "$get";
+const hooksSchema = zod_1.z.object({
+    onStart: zod_1.z.custom().optional(),
+    onEnd: zod_1.z.custom().optional(),
+    onSkillStart: zod_1.z.custom().optional(),
+    onSkillEnd: zod_1.z.custom().optional(),
+    onHandoff: zod_1.z.custom().optional(),
+});
 exports.agentOptionsSchema = zod_1.z.object({
     subscribeTopic: zod_1.z.union([zod_1.z.string(), zod_1.z.array(zod_1.z.string())]).optional(),
     publishTopic: zod_1.z
@@ -58,21 +66,14 @@ exports.agentOptionsSchema = zod_1.z.object({
     name: zod_1.z.string().optional(),
     description: zod_1.z.string().optional(),
     inputSchema: zod_1.z.custom().optional(),
+    defaultInput: zod_1.z.record(zod_1.z.any()).optional(),
     outputSchema: zod_1.z.custom().optional(),
     includeInputInOutput: zod_1.z.boolean().optional(),
     skills: zod_1.z.array(zod_1.z.union([zod_1.z.custom(), zod_1.z.custom()])).optional(),
     disableEvents: zod_1.z.boolean().optional(),
     memory: zod_1.z.union([zod_1.z.custom(), zod_1.z.array(zod_1.z.custom())]).optional(),
     maxRetrieveMemoryCount: zod_1.z.number().optional(),
-    hooks: zod_1.z
-        .object({
-        onStart: zod_1.z.custom().optional(),
-        onEnd: zod_1.z.custom().optional(),
-        onSkillStart: zod_1.z.custom().optional(),
-        onSkillEnd: zod_1.z.custom().optional(),
-        onHandoff: zod_1.z.custom().optional(),
-    })
-        .optional(),
+    hooks: zod_1.z.union([zod_1.z.array(hooksSchema), hooksSchema]).optional(),
     guideRails: zod_1.z.array(zod_1.z.custom()).optional(),
 });
 /**
@@ -107,6 +108,7 @@ class Agent {
         if (outputSchema)
             checkAgentInputOutputSchema(outputSchema);
         this._inputSchema = inputSchema;
+        this.defaultInput = options.defaultInput;
         this._outputSchema = outputSchema;
         this.includeInputInOutput = options.includeInputInOutput;
         this.subscribeTopic = options.subscribeTopic;
@@ -121,7 +123,7 @@ class Agent {
             this.memories.push(options.memory);
         }
         this.maxRetrieveMemoryCount = options.maxRetrieveMemoryCount;
-        this.hooks = options.hooks ?? {};
+        this.hooks = (0, type_utils_js_1.flat)(options.hooks);
         this.guideRails = options.guideRails;
     }
     /**
@@ -187,6 +189,7 @@ class Agent {
      */
     description;
     _inputSchema;
+    defaultInput;
     _outputSchema;
     /**
      * Get the input data schema for this agent
@@ -336,17 +339,23 @@ class Agent {
             ...options,
             context: options.context ?? (await this.newDefaultContext()),
         };
+        input = this.mergeDefaultInput(input);
         logger_js_1.logger.debug("Invoke agent %s started with input: %O", this.name, input);
         if (!this.disableEvents)
             opts.context.emit("agentStarted", { agent: this, input });
         try {
-            let parsedInput = (await this.hooks.onStart?.({ context: opts.context, input }))?.input ?? input;
-            parsedInput = (0, type_utils_js_1.checkArguments)(`Agent ${this.name} input`, this.inputSchema, input);
-            await this.preprocess(parsedInput, opts);
+            let response;
+            const s = await this.callHooks("onStart", { input }, opts);
+            if (s?.input)
+                input = s.input;
+            input = (0, type_utils_js_1.checkArguments)(`Agent ${this.name} input`, this.inputSchema, input);
+            await this.preprocess(input, opts);
             this.checkContextStatus(opts);
-            let response = await this.process(parsedInput, opts);
-            if (response instanceof Agent) {
-                response = (0, types_js_1.transferToAgentOutput)(response);
+            if (!response) {
+                response = await this.process(input, opts);
+                if (response instanceof Agent) {
+                    response = (0, types_js_1.transferToAgentOutput)(response);
+                }
             }
             if (opts.streaming) {
                 const stream = response instanceof ReadableStream
@@ -356,29 +365,62 @@ class Agent {
                         : (0, stream_utils_js_1.objectToAgentResponseStream)(response);
                 return this.checkResponseByGuideRails(input, (0, stream_utils_js_1.onAgentResponseStreamEnd)(stream, {
                     onResult: async (result) => {
-                        return await this.processAgentOutput(parsedInput, result, opts);
+                        return await this.processAgentOutput(input, result, opts);
                     },
                     onError: async (error) => {
                         return await this.processAgentError(input, error, opts);
                     },
                 }), opts);
             }
-            return await this.checkResponseByGuideRails(input, this.processAgentOutput(parsedInput, await agentProcessResultToObject(response), opts), opts);
+            return await this.checkResponseByGuideRails(input, this.processAgentOutput(input, await agentProcessResultToObject(response), opts), opts);
         }
         catch (error) {
             throw await this.processAgentError(input, error, opts);
         }
     }
+    async callHooks(hook, input, options) {
+        const { context } = options;
+        const result = {};
+        for (const hooks of (0, type_utils_js_1.flat)(options.hooks, this.hooks)) {
+            const h = hooks[hook];
+            if (!h)
+                continue;
+            if (typeof h === "function") {
+                Object.assign(result, await h({ ...input, context }));
+            }
+            else {
+                Object.assign(result, await context.invoke(h, input));
+            }
+        }
+        return result;
+    }
+    mergeDefaultInput(input) {
+        const defaultInput = Object.fromEntries(Object.entries(this.defaultInput ?? {}).filter(([, v]) => !(typeof v === "object" && exports.DEFAULT_INPUT_ACTION_GET in v)));
+        input = { ...defaultInput, ...input };
+        for (const key of Object.keys(this.defaultInput ?? {})) {
+            const v = this.defaultInput?.[key];
+            if (v &&
+                typeof v === "object" &&
+                exports.DEFAULT_INPUT_ACTION_GET in v &&
+                typeof v[exports.DEFAULT_INPUT_ACTION_GET] === "string" &&
+                (0, type_utils_js_1.isNil)(input[key])) {
+                const value = input[v[exports.DEFAULT_INPUT_ACTION_GET]];
+                if (!(0, type_utils_js_1.isNil)(value))
+                    Object.assign(input, { [key]: value });
+            }
+        }
+        return input;
+    }
     async invokeSkill(skill, input, options) {
         const { context } = options;
-        await this.hooks.onSkillStart?.({ context, skill, input });
+        await this.callHooks("onSkillStart", { skill, input }, options);
         try {
             const output = await context.invoke(skill, input);
-            await this.hooks.onSkillEnd?.({ context, skill, input, output });
+            await this.callHooks("onSkillEnd", { skill, input, output }, options);
             return output;
         }
         catch (error) {
-            await this.hooks.onSkillEnd?.({ context, skill, input, error });
+            await this.callHooks("onSkillEnd", { skill, input, error }, options);
             throw error;
         }
     }
@@ -398,14 +440,17 @@ class Agent {
             throw new Error(`expect to return a record type such as {result: ...}, but got (${typeof output}): ${output}`);
         }
         const parsedOutput = (0, type_utils_js_1.checkArguments)(`Agent ${this.name} output`, this.outputSchema, output);
-        const finalOutput = this.includeInputInOutput ? { ...input, ...parsedOutput } : parsedOutput;
+        let finalOutput = this.includeInputInOutput ? { ...input, ...parsedOutput } : parsedOutput;
         await this.postprocess(input, finalOutput, options);
         logger_js_1.logger.debug("Invoke agent %s succeed with output: %O", this.name, finalOutput);
         if (!this.disableEvents)
             context.emit("agentSucceed", { agent: this, output: finalOutput });
-        const o = (await this.hooks.onEnd?.({ context, input, output: finalOutput }))?.output;
-        if (o)
-            return o;
+        let o = await this.callHooks("onSuccess", { input, output: finalOutput }, options);
+        if (o?.output)
+            finalOutput = o.output;
+        o = await this.callHooks("onEnd", { input, output: finalOutput }, options);
+        if (o?.output)
+            finalOutput = o.output;
         return finalOutput;
     }
     /**
@@ -420,8 +465,8 @@ class Agent {
         logger_js_1.logger.error("Invoke agent %s failed with error: %O", this.name, error);
         if (!this.disableEvents)
             options.context.emit("agentFailed", { agent: this, error });
-        const { context } = options;
-        await this.hooks.onEnd?.({ context, input, error });
+        await this.callHooks("onError", { input, error }, options);
+        await this.callHooks("onEnd", { input, error }, options);
         return error;
     }
     /**

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

@@ -243,7 +243,7 @@ class AIAgent extends agent_js_1.Agent {
         const outputKey = this.outputKey;
         for (;;) {
             const modelOutput = {};
-            let stream = await options.context.invoke(model, { ...modelInput, messages: modelInput.messages.concat(toolCallMessages) }, { streaming: true });
+            let stream = await options.context.invoke(model, { ...modelInput, messages: modelInput.messages.concat(toolCallMessages) }, { ...options, streaming: true });
             if (this.structuredStreamMode) {
                 const { metadataStart, metadataEnd, parse } = this.customStructuredStreamInstructions || structured_stream_instructions_js_1.STRUCTURED_STREAM_INSTRUCTIONS;
                 stream = stream.pipeThrough(new structured_stream_extractor_js_1.ExtractMetadataTransform({ start: metadataStart, end: metadataEnd, parse }));
@@ -318,14 +318,17 @@ class AIAgent extends agent_js_1.Agent {
      * @protected
      */
     async *_processRouter(input, model, modelInput, options, toolsMap) {
-        const { toolCalls: [call] = [] } = await options.context.invoke(model, modelInput);
+        const { toolCalls: [call] = [] } = await options.context.invoke(model, modelInput, {
+            ...options,
+            streaming: false,
+        });
         if (!call) {
             throw new Error("Router toolChoice requires exactly one tool to be executed");
         }
         const tool = toolsMap.get(call.function.name);
         if (!tool)
             throw new Error(`Tool not found: ${call.function.name}`);
-        const stream = await options.context.invoke(tool, { ...call.function.arguments, ...input }, { streaming: true, sourceAgent: this });
+        const stream = await options.context.invoke(tool, { ...call.function.arguments, ...input }, { ...options, streaming: true, sourceAgent: this });
         return yield* stream;
     }
 }

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

@@ -171,19 +171,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 +194,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 +229,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,8 @@
-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;
+    inputSchema?: any;
+    outputSchema?: any;
 }>;

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

@@ -32,34 +32,30 @@ 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");
 async function loadAgentFromJsFile(path) {
-    const agentJsFileSchema = zod_1.z.object({
+    const agentJsFileSchema = (0, schema_js_1.camelizeSchema)(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)(() => agentJsFileSchema.parseAsync({
         ...agent,
         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,12 +1,28 @@
 import { type ZodType } from "zod";
 import { AIAgentToolChoice } from "../agents/ai-agent.js";
 import { ProcessMode } from "../agents/team-agent.js";
+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;
 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[];
@@ -19,7 +35,7 @@ interface AIAgentSchema extends BaseAgentSchema {
     outputKey?: string;
     toolChoice?: AIAgentToolChoice;
 }
-interface MCPAgentSchema {
+interface MCPAgentSchema extends BaseAgentSchema {
     type: "mcp";
     url?: string;
     command?: string;