@aigne/core 1.33.2 → 1.36.0

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

@@ -2,9 +2,17 @@ import { nodejs } from "@aigne/platform-helpers/nodejs/index.js";
 import { ZodObject, z } from "zod";
 import { logger } from "../utils/logger.js";
 import { agentResponseStreamToObject, asyncGeneratorToReadableStream, isAsyncGenerator, objectToAgentResponseStream, onAgentResponseStreamEnd, } from "../utils/stream-utils.js";
-import { checkArguments, createAccessorArray, flat, isEmpty, isRecord, } from "../utils/type-utils.js";
+import { checkArguments, createAccessorArray, flat, isEmpty, isNil, isRecord, } from "../utils/type-utils.js";
 import { replaceTransferAgentToName, transferToAgentOutput, } from "./types.js";
 export * from "./types.js";
+export const DEFAULT_INPUT_ACTION_GET = "$get";
+const hooksSchema = z.object({
+    onStart: z.custom().optional(),
+    onEnd: z.custom().optional(),
+    onSkillStart: z.custom().optional(),
+    onSkillEnd: z.custom().optional(),
+    onHandoff: z.custom().optional(),
+});
 export const agentOptionsSchema = z.object({
     subscribeTopic: z.union([z.string(), z.array(z.string())]).optional(),
     publishTopic: z
@@ -13,21 +21,14 @@ export const agentOptionsSchema = z.object({
     name: z.string().optional(),
     description: z.string().optional(),
     inputSchema: z.custom().optional(),
+    defaultInput: z.record(z.any()).optional(),
     outputSchema: z.custom().optional(),
     includeInputInOutput: z.boolean().optional(),
     skills: z.array(z.union([z.custom(), z.custom()])).optional(),
     disableEvents: z.boolean().optional(),
     memory: z.union([z.custom(), z.array(z.custom())]).optional(),
     maxRetrieveMemoryCount: z.number().optional(),
-    hooks: z
-        .object({
-        onStart: z.custom().optional(),
-        onEnd: z.custom().optional(),
-        onSkillStart: z.custom().optional(),
-        onSkillEnd: z.custom().optional(),
-        onHandoff: z.custom().optional(),
-    })
-        .optional(),
+    hooks: z.union([z.array(hooksSchema), hooksSchema]).optional(),
     guideRails: z.array(z.custom()).optional(),
 });
 /**
@@ -62,6 +63,7 @@ export class Agent {
         if (outputSchema)
             checkAgentInputOutputSchema(outputSchema);
         this._inputSchema = inputSchema;
+        this.defaultInput = options.defaultInput;
         this._outputSchema = outputSchema;
         this.includeInputInOutput = options.includeInputInOutput;
         this.subscribeTopic = options.subscribeTopic;
@@ -76,7 +78,7 @@ export class Agent {
             this.memories.push(options.memory);
         }
         this.maxRetrieveMemoryCount = options.maxRetrieveMemoryCount;
-        this.hooks = options.hooks ?? {};
+        this.hooks = flat(options.hooks);
         this.guideRails = options.guideRails;
     }
     /**
@@ -142,6 +144,7 @@ export class Agent {
      */
     description;
     _inputSchema;
+    defaultInput;
     _outputSchema;
     /**
      * Get the input data schema for this agent
@@ -291,17 +294,23 @@ export class Agent {
             ...options,
             context: options.context ?? (await this.newDefaultContext()),
         };
+        input = this.mergeDefaultInput(input);
         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 = 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 = 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 = transferToAgentOutput(response);
+            if (!response) {
+                response = await this.process(input, opts);
+                if (response instanceof Agent) {
+                    response = transferToAgentOutput(response);
+                }
             }
             if (opts.streaming) {
                 const stream = response instanceof ReadableStream
@@ -311,29 +320,62 @@ export class Agent {
                         : objectToAgentResponseStream(response);
                 return this.checkResponseByGuideRails(input, 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 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" && 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" &&
+                DEFAULT_INPUT_ACTION_GET in v &&
+                typeof v[DEFAULT_INPUT_ACTION_GET] === "string" &&
+                isNil(input[key])) {
+                const value = input[v[DEFAULT_INPUT_ACTION_GET]];
+                if (!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;
         }
     }
@@ -353,14 +395,17 @@ export class Agent {
             throw new Error(`expect to return a record type such as {result: ...}, but got (${typeof output}): ${output}`);
         }
         const parsedOutput = 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.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;
     }
     /**
@@ -375,8 +420,8 @@ export class Agent {
         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/esm/agents/ai-agent.js

@@ -240,7 +240,7 @@ export class AIAgent extends 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;
                 stream = stream.pipeThrough(new ExtractMetadataTransform({ start: metadataStart, end: metadataEnd, parse }));
@@ -315,14 +315,17 @@ export class AIAgent extends 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/esm/agents/team-agent.js

@@ -165,19 +165,13 @@ export class TeamAgent extends 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;
                 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.
@@ -194,8 +188,7 @@ export class TeamAgent extends 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 }));
@@ -230,8 +223,5 @@ export class TeamAgent extends Agent {
                     yield { delta: { ...delta, text } };
             }
         }
-        const agents = await Promise.all(result.map((i) => i[1]));
-        this.skills.splice(0);
-        this.skills.push(...agents);
     }
 }

package/lib/esm/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/esm/aigne/context.js

@@ -34,7 +34,7 @@ export 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 ?? v7();
@@ -265,9 +265,10 @@ class AIGNEContextShared {
     constructor(parent) {
         this.parent = parent;
         this.messageQueue = this.parent?.messageQueue ?? new MessageQueue();
+        this.events = this.parent?.events ?? new Emitter();
     }
     messageQueue;
-    events = new Emitter();
+    events;
     get model() {
         return this.parent?.model;
     }
@@ -302,21 +303,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 (isAgentResponseDelta(value)) {
                         if (value.delta.json) {

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

@@ -1,26 +1,25 @@
 import { jsonSchemaToZod } from "@aigne/json-schema-to-zod";
-import camelize from "camelize-ts";
 import { z } from "zod";
 import { Agent } from "../agents/agent.js";
 import { tryOrThrow } from "../utils/type-utils.js";
-import { inputOutputSchema, optionalize } from "./schema.js";
+import { camelizeSchema, inputOutputSchema, optionalize } from "./schema.js";
 export async function loadAgentFromJsFile(path) {
-    const agentJsFileSchema = z.object({
+    const agentJsFileSchema = camelizeSchema(z.object({
         name: z.string(),
         description: optionalize(z.string()),
         inputSchema: optionalize(inputOutputSchema({ path })).transform((v) => v ? jsonSchemaToZod(v) : undefined),
         outputSchema: optionalize(inputOutputSchema({ path })).transform((v) => v ? jsonSchemaToZod(v) : undefined),
         process: z.custom(),
-    });
+    }));
     const { default: agent } = await tryOrThrow(() => import(/* @vite-ignore */ path), (error) => new Error(`Failed to load agent definition from ${path}: ${error.message}`));
     if (agent instanceof Agent)
         return agent;
     if (typeof agent !== "function") {
         throw new Error(`Agent file ${path} must export a default function, but got ${typeof agent}`);
     }
-    return tryOrThrow(() => agentJsFileSchema.parseAsync(camelize({
+    return 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/esm/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;