@aigne/core 1.33.2 → 1.36.0

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

@@ -1,12 +1,8 @@
 "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");
@@ -15,21 +11,41 @@ const type_utils_js_1 = require("../utils/type-utils.js");
 const schema_js_1 = require("./schema.js");
 async function loadAgentFromYamlFile(path) {
     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 +56,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,10 +84,10 @@ async function loadAgentFromYamlFile(path) {
                 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 = (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 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 agentSchema.parseAsync({
         ...json,
         type: json.type ?? "ai",

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,7 +39,7 @@ 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)
@@ -48,38 +48,74 @@ 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);
-        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,13 @@ 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,
             });
         }
     }

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/package.json

@@ -1 +1,3 @@
-{"type": "commonjs"}
+{
+  "type": "commonjs"
+}

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;
 };

package/lib/cjs/utils/type-utils.js

@@ -102,10 +102,8 @@ function omitBy(obj, predicate) {
         return !predicate(value, k);
     }));
 }
-function flat(value) {
-    if (isNil(value))
-        return [];
-    return Array.isArray(value) ? value : [value];
+function flat(...value) {
+    return value.flat().filter(isNonNullable);
 }
 function createAccessorArray(array, accessor) {
     return new Proxy(array, {

package/lib/dts/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/dts/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/dts/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/dts/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;

package/lib/dts/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/dts/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/dts/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;
 };