@aigne/core 1.70.1-beta → 1.71.0-beta

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

@@ -9,6 +9,68 @@ import { tryOrThrow } from "../utils/type-utils.js";
 import { codeToFunctionAgentFn } from "./function-agent.js";
 import { camelizeSchema, chatModelSchema, defaultInputSchema, imageModelSchema, inputOutputSchema, optionalize, } from "./schema.js";
 export async function parseAgentFile(path, data) {
+    const agentSchema = getAgentSchema({ filepath: path });
+    return agentSchema.parseAsync({
+        ...data,
+        model: data.model || data.chatModel || data.chat_model,
+    });
+}
+export async function loadAgentFromYamlFile(path, options) {
+    const raw = await tryOrThrow(() => nodejs.fs.readFile(path, "utf8"), (error) => new Error(`Failed to load agent definition from ${path}: ${error.message}`));
+    const json = tryOrThrow(() => parse(raw), (error) => new Error(`Failed to parse agent definition from ${path}: ${error.message}`));
+    if (!["ai", "image", "mcp", "team", "transform", "function"].includes(json?.type)) {
+        if (typeof json?.type === "string") {
+            if (!options?.require)
+                throw new Error(`Module loader is not provided to load agent type module ${json.type} from ${path}`);
+            const Mod = await options.require(json.type, { parent: path });
+            if (typeof Mod?.default?.prototype?.constructor !== "function") {
+                throw new Error(`The agent type module ${json.type} does not export a default Agent class`);
+            }
+            json.agentClass = Mod.default;
+        }
+    }
+    const agent = await tryOrThrow(async () => await parseAgentFile(path, {
+        ...json,
+        type: json.type ?? "ai",
+        skills: json.skills ?? json.tools,
+    }), (error) => new Error(`Failed to validate agent definition from ${path}: ${error.message}`));
+    return agent;
+}
+const instructionItemSchema = z.union([
+    z.object({
+        role: roleSchema.default("system"),
+        url: z.string(),
+    }),
+    z.object({
+        role: roleSchema.default("system"),
+        content: z.string(),
+    }),
+]);
+const parseInstructionItem = ({ filepath }) => async ({ role, ...v }) => {
+    if (role === "tool")
+        throw new Error(`'tool' role is not allowed in instruction item in agent file ${filepath}`);
+    if ("content" in v && typeof v.content === "string") {
+        return { role, content: v.content, path: filepath };
+    }
+    if ("url" in v && typeof v.url === "string") {
+        const url = nodejs.path.isAbsolute(v.url)
+            ? v.url
+            : nodejs.path.join(nodejs.path.dirname(filepath), v.url);
+        return nodejs.fs.readFile(url, "utf8").then((content) => ({ role, content, path: url }));
+    }
+    throw new Error(`Invalid instruction item in agent file ${filepath}. Expected 'content' or 'url' property`);
+};
+export const getInstructionsSchema = ({ filepath }) => z
+    .union([z.string(), instructionItemSchema, z.array(instructionItemSchema)])
+    .transform(async (v) => {
+    if (typeof v === "string")
+        return [{ role: "system", content: v, path: filepath }];
+    if (Array.isArray(v)) {
+        return Promise.all(v.map((item) => parseInstructionItem({ filepath })(item)));
+    }
+    return [await parseInstructionItem({ filepath })(v)];
+});
+export const getAgentSchema = ({ filepath }) => {
     const agentSchema = z.lazy(() => {
         const nestAgentSchema = z.lazy(() => z.union([
             agentSchema,
@@ -37,9 +99,9 @@ export async function parseAgentFile(path, data) {
             imageModel: optionalize(imageModelSchema),
             taskTitle: optionalize(z.string()),
             taskRenderMode: optionalize(z.union([z.literal("hide"), z.literal("collapse")])),
-            inputSchema: optionalize(inputOutputSchema({ path })).transform((v) => v ? jsonSchemaToZod(v) : undefined),
+            inputSchema: optionalize(inputOutputSchema({ path: filepath })).transform((v) => v ? jsonSchemaToZod(v) : undefined),
             defaultInput: optionalize(defaultInputSchema),
-            outputSchema: optionalize(inputOutputSchema({ path })).transform((v) => v ? jsonSchemaToZod(v) : undefined),
+            outputSchema: optionalize(inputOutputSchema({ path: filepath })).transform((v) => v ? jsonSchemaToZod(v) : undefined),
             includeInputInOutput: optionalize(z.boolean()),
             hooks: optionalize(z.union([hooksSchema, z.array(hooksSchema)])),
             skills: optionalize(z.array(nestAgentSchema)),
@@ -62,117 +124,92 @@ export async function parseAgentFile(path, data) {
                     ]))),
                 })),
             ])),
+            shareAFS: optionalize(z.boolean()),
         });
-        const instructionItemSchema = z.union([
-            z.object({
-                role: roleSchema.default("system"),
-                url: z.string(),
-            }),
-            z.object({
-                role: roleSchema.default("system"),
-                content: z.string(),
-            }),
-        ]);
-        const parseInstructionItem = async ({ role, ...v }) => {
-            if (role === "tool")
-                throw new Error(`'tool' role is not allowed in instruction item in agent file ${path}`);
-            if ("content" in v && typeof v.content === "string") {
-                return { role, content: v.content, path };
-            }
-            if ("url" in v && typeof v.url === "string") {
-                const url = nodejs.path.isAbsolute(v.url)
-                    ? v.url
-                    : nodejs.path.join(nodejs.path.dirname(path), v.url);
-                return nodejs.fs.readFile(url, "utf8").then((content) => ({ role, content, path: url }));
-            }
-            throw new Error(`Invalid instruction item in agent file ${path}. Expected 'content' or 'url' property`);
-        };
-        const instructionsSchema = z
-            .union([z.string(), instructionItemSchema, z.array(instructionItemSchema)])
-            .transform(async (v) => {
-            if (typeof v === "string")
-                return [{ role: "system", content: v, path }];
-            if (Array.isArray(v)) {
-                return Promise.all(v.map((item) => parseInstructionItem(item)));
-            }
-            return [await parseInstructionItem(v)];
-        });
-        return camelizeSchema(z.discriminatedUnion("type", [
-            z
-                .object({
-                type: z.literal("ai"),
-                instructions: optionalize(instructionsSchema),
-                autoReorderSystemMessages: optionalize(z.boolean()),
-                autoMergeSystemMessages: optionalize(z.boolean()),
-                inputKey: optionalize(z.string()),
-                outputKey: optionalize(z.string()),
-                inputFileKey: optionalize(z.string()),
-                outputFileKey: optionalize(z.string()),
-                toolChoice: optionalize(z.nativeEnum(AIAgentToolChoice)),
-                toolCallsConcurrency: optionalize(z.number().int().min(0)),
-                keepTextInToolUses: optionalize(z.boolean()),
-                catchToolsError: optionalize(z.boolean()),
-                structuredStreamMode: optionalize(z.boolean()),
-            })
-                .extend(baseAgentSchema.shape),
-            z
-                .object({
-                type: z.literal("image"),
-                instructions: instructionsSchema,
-                inputFileKey: optionalize(z.string()),
-            })
-                .extend(baseAgentSchema.shape),
-            z
-                .object({
-                type: z.literal("mcp"),
-                url: optionalize(z.string()),
-                command: optionalize(z.string()),
-                args: optionalize(z.array(z.string())),
-            })
-                .extend(baseAgentSchema.shape),
-            z
-                .object({
-                type: z.literal("team"),
-                mode: optionalize(z.nativeEnum(ProcessMode)),
-                iterateOn: optionalize(z.string()),
-                concurrency: optionalize(z.number().int().min(1)),
-                iterateWithPreviousOutput: optionalize(z.boolean()),
-                includeAllStepsOutput: optionalize(z.boolean()),
-                reflection: camelizeSchema(optionalize(z.object({
-                    reviewer: nestAgentSchema,
-                    isApproved: z.string(),
-                    maxIterations: optionalize(z.number().int().min(1)),
-                    returnLastOnMaxIterations: optionalize(z.boolean()),
-                    customErrorMessage: optionalize(z.string()),
-                }))),
-            })
-                .extend(baseAgentSchema.shape),
+        const instructionsSchema = getInstructionsSchema({ filepath: filepath });
+        return camelizeSchema(z.union([
             z
                 .object({
-                type: z.literal("transform"),
-                jsonata: z.string(),
+                type: z.string(),
+                agentClass: z.custom((v) => typeof v?.prototype?.constructor === "function"),
             })
-                .extend(baseAgentSchema.shape),
-            z
-                .object({
-                type: z.literal("function"),
-                process: z.preprocess((v) => (typeof v === "string" ? codeToFunctionAgentFn(v) : v), z.custom()),
-            })
-                .extend(baseAgentSchema.shape),
+                .extend(baseAgentSchema.shape)
+                .passthrough(),
+            z.discriminatedUnion("type", [
+                z
+                    .object({
+                    type: z.literal("ai"),
+                    instructions: optionalize(instructionsSchema),
+                    autoReorderSystemMessages: optionalize(z.boolean()),
+                    autoMergeSystemMessages: optionalize(z.boolean()),
+                    inputKey: optionalize(z.string()),
+                    outputKey: optionalize(z.string()),
+                    inputFileKey: optionalize(z.string()),
+                    outputFileKey: optionalize(z.string()),
+                    toolChoice: optionalize(z.nativeEnum(AIAgentToolChoice)),
+                    toolCallsConcurrency: optionalize(z.number().int().min(0)),
+                    keepTextInToolUses: optionalize(z.boolean()),
+                    catchToolsError: optionalize(z.boolean()),
+                    structuredStreamMode: optionalize(z.boolean()),
+                })
+                    .extend(baseAgentSchema.shape),
+                z
+                    .object({
+                    type: z.literal("image"),
+                    instructions: instructionsSchema,
+                    inputFileKey: optionalize(z.string()),
+                })
+                    .extend(baseAgentSchema.shape),
+                z
+                    .object({
+                    type: z.literal("mcp"),
+                    url: optionalize(z.string()),
+                    command: optionalize(z.string()),
+                    args: optionalize(z.array(z.string())),
+                })
+                    .extend(baseAgentSchema.shape),
+                z
+                    .object({
+                    type: z.literal("team"),
+                    mode: optionalize(z.nativeEnum(ProcessMode)),
+                    iterateOn: optionalize(z.string()),
+                    concurrency: optionalize(z.number().int().min(1)),
+                    iterateWithPreviousOutput: optionalize(z.boolean()),
+                    includeAllStepsOutput: optionalize(z.boolean()),
+                    reflection: camelizeSchema(optionalize(z.object({
+                        reviewer: nestAgentSchema,
+                        isApproved: z.string(),
+                        maxIterations: optionalize(z.number().int().min(1)),
+                        returnLastOnMaxIterations: optionalize(z.boolean()),
+                        customErrorMessage: optionalize(z.string()),
+                    }))),
+                })
+                    .extend(baseAgentSchema.shape),
+                z
+                    .object({
+                    type: z.literal("transform"),
+                    jsonata: z.string(),
+                })
+                    .extend(baseAgentSchema.shape),
+                z
+                    .object({
+                    type: z.literal("function"),
+                    process: z.preprocess((v) => (typeof v === "string" ? codeToFunctionAgentFn(v) : v), z.custom()),
+                })
+                    .extend(baseAgentSchema.shape),
+            ]),
         ]));
     });
-    return agentSchema.parseAsync({
-        ...data,
-        model: data.model || data.chatModel || data.chat_model,
-    });
-}
-export async function loadAgentFromYamlFile(path) {
-    const raw = await tryOrThrow(() => nodejs.fs.readFile(path, "utf8"), (error) => new Error(`Failed to load agent definition from ${path}: ${error.message}`));
-    const json = tryOrThrow(() => parse(raw), (error) => new Error(`Failed to parse agent definition from ${path}: ${error.message}`));
-    const agent = await tryOrThrow(async () => await parseAgentFile(path, {
-        ...json,
-        type: json.type ?? "ai",
-        skills: json.skills ?? json.tools,
-    }), (error) => new Error(`Failed to validate agent definition from ${path}: ${error.message}`));
-    return agent;
-}
+    return agentSchema;
+};
+export const getNestAgentSchema = ({ filepath, }) => {
+    const agentSchema = getAgentSchema({ filepath });
+    return z.lazy(() => z.union([
+        agentSchema,
+        z.string(),
+        camelizeSchema(z.object({
+            url: z.string(),
+            defaultInput: optionalize(defaultInputSchema),
+        })),
+    ]));
+};

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

@@ -1,11 +1,13 @@
-import { type AFSModule } from "@aigne/afs";
+import { AFS, type AFSModule } from "@aigne/afs";
 import { type ZodType, z } from "zod";
 import { Agent, type AgentOptions } from "../agents/agent.js";
 import type { ChatModel } from "../agents/chat-model.js";
 import type { ImageModel } from "../agents/image-model.js";
 import type { AIGNEOptions } from "../aigne/aigne.js";
 import type { MemoryAgent, MemoryAgentOptions } from "../memory/memory.js";
+import { PromptBuilder } from "../prompt/prompt-builder.js";
 import { type PromiseOrValue } from "../utils/type-utils.js";
+import { type Instructions, loadAgentFromYamlFile, type NestAgentSchema } from "./agent-yaml.js";
 export interface LoadOptions {
     memories?: {
         new (parameters?: MemoryAgentOptions): MemoryAgent;
@@ -13,6 +15,7 @@ export interface LoadOptions {
     model?: ChatModel | ((model?: z.infer<typeof aigneFileSchema>["model"]) => PromiseOrValue<ChatModel | undefined>);
     imageModel?: ImageModel | ((model?: z.infer<typeof aigneFileSchema>["imageModel"]) => PromiseOrValue<ImageModel | undefined>);
     afs?: {
+        sharedAFS?: AFS;
         availableModules?: {
             module: string;
             alias?: string[];
@@ -20,9 +23,14 @@ export interface LoadOptions {
         }[];
     };
     aigne?: z.infer<typeof aigneFileSchema>;
+    require?: (modulePath: string, options: {
+        parent?: string;
+    }) => Promise<any>;
 }
 export declare function load(path: string, options?: LoadOptions): Promise<AIGNEOptions>;
 export declare function loadAgent(path: string, options?: LoadOptions, agentOptions?: AgentOptions): Promise<Agent>;
+export declare function loadNestAgent(path: string, agent: NestAgentSchema, options?: LoadOptions, agentOptions?: AgentOptions & Record<string, unknown>): Promise<Agent>;
+export declare function parseAgent(path: string, agent: Awaited<ReturnType<typeof loadAgentFromYamlFile>>, options?: LoadOptions, agentOptions?: AgentOptions): Promise<Agent>;
 type CliAgent = string | {
     url?: string;
     name?: string;
@@ -230,4 +238,5 @@ export declare function loadAIGNEFile(path: string): Promise<{
     aigne: z.infer<typeof aigneFileSchema>;
     rootDir: string;
 }>;
+export declare function instructionsToPromptBuilder(instructions: Instructions): PromptBuilder;
 export {};

package/lib/esm/loader/index.js

@@ -10,9 +10,10 @@ import { TeamAgent } from "../agents/team-agent.js";
 import { TransformAgent } from "../agents/transform-agent.js";
 import { PromptBuilder } from "../prompt/prompt-builder.js";
 import { ChatMessagesTemplate, parseChatMessages } from "../prompt/template.js";
+import { isAgent } from "../utils/agent-utils.js";
 import { flat, isNil, isNonNullable, omitBy, tryOrThrow, } from "../utils/type-utils.js";
 import { loadAgentFromJsFile } from "./agent-js.js";
-import { loadAgentFromYamlFile } from "./agent-yaml.js";
+import { loadAgentFromYamlFile, } from "./agent-yaml.js";
 import { camelizeSchema, chatModelSchema, imageModelSchema, optionalize } from "./schema.js";
 const AIGNE_FILE_NAME = ["aigne.yaml", "aigne.yml"];
 export async function load(path, options = {}) {
@@ -66,17 +67,18 @@ export async function loadAgent(path, options, agentOptions) {
         return parseAgent(path, agent, options, agentOptions);
     }
     if ([".yml", ".yaml"].includes(nodejs.path.extname(path))) {
-        const agent = await loadAgentFromYamlFile(path);
+        const agent = await loadAgentFromYamlFile(path, options);
         return parseAgent(path, agent, options, agentOptions);
     }
     throw new Error(`Unsupported agent file type: ${path}`);
 }
-async function loadNestAgent(path, agent, options) {
+export async function loadNestAgent(path, agent, options, agentOptions) {
     return typeof agent === "object" && "type" in agent
-        ? parseAgent(path, agent, options)
+        ? parseAgent(path, agent, options, agentOptions)
         : typeof agent === "string"
-            ? loadAgent(nodejs.path.join(nodejs.path.dirname(path), agent), options)
+            ? loadAgent(nodejs.path.join(nodejs.path.dirname(path), agent), options, agentOptions)
             : loadAgent(nodejs.path.join(nodejs.path.dirname(path), agent.url), options, {
+                ...agentOptions,
                 defaultInput: agent.defaultInput,
                 hooks: await parseHooks(path, agent.hooks, options),
             });
@@ -107,15 +109,18 @@ async function loadSkills(path, skills, options) {
     }
     return loadedSkills;
 }
-async function parseAgent(path, agent, options, agentOptions) {
-    const skills = "skills" in agent && agent.skills ? await loadSkills(path, agent.skills, options) : undefined;
+export async function parseAgent(path, agent, options, agentOptions) {
+    if (isAgent(agent))
+        return agent;
     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;
     let afs;
-    if (typeof agent.afs === "boolean") {
-        if (agent.afs)
-            afs = new AFS();
+    if (agent.afs !== false && (!agent.afs || agent.afs === true) && options?.afs?.sharedAFS) {
+        afs = options.afs.sharedAFS;
+    }
+    else if (agent.afs === true) {
+        afs = new AFS();
     }
     else if (agent.afs) {
         afs = new AFS();
@@ -128,6 +133,12 @@ async function parseAgent(path, agent, options, agentOptions) {
             afs.mount(module);
         }
     }
+    const skills = "skills" in agent && agent.skills
+        ? await loadSkills(path, agent.skills, {
+            ...options,
+            afs: { ...options?.afs, sharedAFS: (agent.shareAFS && afs) || options?.afs?.sharedAFS },
+        })
+        : [];
     const model = agent.model && typeof options?.model === "function"
         ? await options.model({ ...options.aigne?.model, ...omitBy(agent.model, (v) => isNil(v)) })
         : undefined;
@@ -142,22 +153,17 @@ async function parseAgent(path, agent, options, agentOptions) {
         ...agent,
         model,
         imageModel,
-        skills,
         memory,
         hooks: [
             ...((await parseHooks(path, agent.hooks, options)) ?? []),
             ...[agentOptions?.hooks].flat().filter(isNonNullable),
         ],
-        afs,
+        skills: [...(agentOptions?.skills || []), ...skills],
+        afs: afs || agentOptions?.afs,
     };
     let instructions;
-    if ("instructions" in agent && agent.instructions) {
-        instructions = new PromptBuilder({
-            instructions: ChatMessagesTemplate.from(parseChatMessages(agent.instructions.map((i) => ({
-                ...i,
-                options: { workingDir: nodejs.path.dirname(i.path) },
-            })))),
-        });
+    if ("instructions" in agent && agent.instructions && ["ai", "image"].includes(agent.type)) {
+        instructions = instructionsToPromptBuilder(agent.instructions);
     }
     switch (agent.type) {
         case "ai": {
@@ -214,6 +220,14 @@ async function parseAgent(path, agent, options, agentOptions) {
             });
         }
     }
+    if ("agentClass" in agent && agent.agentClass) {
+        return await agent.agentClass.load({
+            filepath: path,
+            parsed: baseOptions,
+            options,
+        });
+    }
+    throw new Error(`Unsupported agent type: ${"type" in agent ? agent.type : "unknown"} at path: ${path}`);
 }
 async function loadMemory(memories, provider, options) {
     const M = !provider
@@ -269,3 +283,11 @@ async function findAIGNEFile(path) {
     }
     throw new Error(`aigne.yaml not found in ${path}. Please ensure you are in the correct directory or provide a valid path.`);
 }
+export function instructionsToPromptBuilder(instructions) {
+    return new PromptBuilder({
+        instructions: ChatMessagesTemplate.from(parseChatMessages(instructions.map((i) => ({
+            ...i,
+            options: { workingDir: nodejs.path.dirname(i.path) },
+        })))),
+    });
+}

package/lib/esm/prompt/prompt-builder.d.ts

@@ -2,7 +2,6 @@ import type { GetPromptResult } from "@modelcontextprotocol/sdk/types.js";
 import { Agent, type AgentInvokeOptions, type Message } from "../agents/agent.js";
 import { type AIAgent } from "../agents/ai-agent.js";
 import type { ChatModel, ChatModelInput } from "../agents/chat-model.js";
-import type { ImageAgent } from "../agents/image-agent.js";
 import { type FileUnionContent } from "../agents/model.js";
 import { ChatMessagesTemplate } from "./template.js";
 export interface PromptBuilderOptions {
@@ -26,11 +25,12 @@ export declare class PromptBuilder {
     constructor(options?: PromptBuilderOptions);
     instructions?: string | ChatMessagesTemplate;
     workingDir?: string;
+    copy(): PromptBuilder;
     build(options: PromptBuildOptions): Promise<ChatModelInput & {
         toolAgents?: Agent[];
     }>;
-    buildImagePrompt(options: Pick<PromptBuildOptions, "input" | "context"> & {
-        agent: ImageAgent;
+    buildPrompt(options: Pick<PromptBuildOptions, "input" | "context"> & {
+        inputFileKey?: string;
     }): Promise<{
         prompt: string;
         image?: FileUnionContent[];

package/lib/esm/prompt/prompt-builder.js

@@ -62,6 +62,12 @@ export class PromptBuilder {
     }
     instructions;
     workingDir;
+    copy() {
+        return new PromptBuilder({
+            instructions: typeof this.instructions === "string" ? this.instructions : this.instructions?.copy(),
+            workingDir: this.workingDir,
+        });
+    }
     async build(options) {
         return {
             messages: await this.buildMessages(options),
@@ -72,11 +78,11 @@ export class PromptBuilder {
             ...(await this.buildTools(options)),
         };
     }
-    async buildImagePrompt(options) {
+    async buildPrompt(options) {
         const messages = (await (typeof this.instructions === "string"
             ? ChatMessagesTemplate.from([SystemMessageTemplate.from(this.instructions)])
             : this.instructions)?.format(this.getTemplateVariables(options), { workingDir: this.workingDir })) ?? [];
-        const inputFileKey = options.agent?.inputFileKey;
+        const inputFileKey = options.inputFileKey;
         const files = flat(inputFileKey
             ? checkArguments("Check input files", optionalize(fileUnionContentsSchema), options.input?.[inputFileKey])
             : null);

package/lib/esm/prompt/skills/afs.js

@@ -52,19 +52,39 @@ export async function getAFSSkills(afs) {
         }),
         FunctionAgent.from({
             name: "afs_read",
-            description: "Read file contents from the AFS - path must be an exact file path from list or search results",
+            description: `\
+Read file contents from the AFS - path must be an exact file path from list or search results
+
+Usage:
+- Use withLineNumbers=true to get line numbers for code reviews or edits
+`,
             inputSchema: z.object({
                 path: z
                     .string()
                     .describe("Exact file path from list or search results (e.g., '/docs/api.md', '/src/utils/helper.js')"),
+                withLineNumbers: z
+                    .boolean()
+                    .optional()
+                    .describe(`Whether to include line numbers in the returned content, default is false`),
             }),
             process: async (input) => {
                 const result = await afs.read(input.path);
+                let content = result.result?.content;
+                if (input.withLineNumbers && typeof content === "string") {
+                    content = content
+                        .split("\n")
+                        .map((line, idx) => `${idx + 1}| ${line}`)
+                        .join("\n");
+                }
                 return {
                     status: "success",
                     tool: "afs_read",
                     path: input.path,
                     ...result,
+                    result: {
+                        ...result.result,
+                        content,
+                    },
                 };
             },
         }),
@@ -106,7 +126,9 @@ export async function getAFSSkills(afs) {
 }
 function buildTreeView(entries) {
     const tree = {};
+    const entryMap = new Map();
     for (const entry of entries) {
+        entryMap.set(entry.path, entry);
         const parts = entry.path.split("/").filter(Boolean);
         let current = tree;
         for (const part of parts) {
@@ -116,13 +138,28 @@ function buildTreeView(entries) {
             current = current[part];
         }
     }
-    function renderTree(node, prefix = "") {
+    function renderTree(node, prefix = "", currentPath = "") {
         let result = "";
         const keys = Object.keys(node);
         keys.forEach((key, index) => {
             const isLast = index === keys.length - 1;
-            result += `${prefix}${isLast ? "└── " : "├── "}${key}\n`;
-            result += renderTree(node[key], `${prefix}${isLast ? "    " : "│   "}`);
+            const fullPath = currentPath ? `${currentPath}/${key}` : `/${key}`;
+            const entry = entryMap.get(fullPath);
+            // Build metadata suffix
+            const metadataParts = [];
+            // Children count
+            const childrenCount = entry?.metadata?.childrenCount;
+            if (childrenCount !== undefined && childrenCount > 0) {
+                metadataParts.push(`${childrenCount} items`);
+            }
+            // Executable
+            if (entry?.metadata?.execute) {
+                metadataParts.push("executable");
+            }
+            const metadataSuffix = metadataParts.length > 0 ? ` [${metadataParts.join(", ")}]` : "";
+            result += `${prefix}${isLast ? "└── " : "├── "}${key}${metadataSuffix}`;
+            result += `\n`;
+            result += renderTree(node[key], `${prefix}${isLast ? "    " : "│   "}`, fullPath);
         });
         return result;
     }

package/lib/esm/prompt/template.d.ts

@@ -62,6 +62,7 @@ export declare class ChatMessagesTemplate {
     messages: ChatMessageTemplate[];
     static from(messages: ChatMessageTemplate[] | string): ChatMessagesTemplate;
     constructor(messages: ChatMessageTemplate[]);
+    copy(): ChatMessagesTemplate;
     format(variables?: Record<string, unknown>, options?: FormatOptions): Promise<ChatModelInputMessage[]>;
 }
 declare const chatMessageSchema: z.ZodUnion<[z.ZodObject<{

package/lib/esm/prompt/template.js

@@ -1,5 +1,6 @@
 import { nodejs } from "@aigne/platform-helpers/nodejs/index.js";
 import nunjucks from "nunjucks";
+import { stringify } from "yaml";
 import { z } from "zod";
 import { isNil, omitBy } from "../utils/type-utils.js";
 import { setupFilters } from "./filters/index.js";
@@ -130,9 +131,7 @@ export class ToolMessageTemplate extends ChatMessageTemplate {
         return new ToolMessageTemplate(content, toolCallId, name, options);
     }
     constructor(content, toolCallId, name, options) {
-        super("tool", typeof content === "string"
-            ? content
-            : JSON.stringify(content, (_, value) => typeof value === "bigint" ? value.toString() : value), name, options);
+        super("tool", typeof content === "string" ? content : stringify(content), name, options);
         this.toolCallId = toolCallId;
     }
     async format(_variables, _options) {
@@ -153,6 +152,9 @@ export class ChatMessagesTemplate {
     constructor(messages) {
         this.messages = messages;
     }
+    copy() {
+        return new ChatMessagesTemplate(this.messages.map((m) => m));
+    }
     async format(variables, options) {
         return Promise.all(this.messages.map((message) => message.format(variables, options)));
     }

package/lib/esm/utils/agent-utils.d.ts

@@ -1,4 +1,4 @@
-import type { AgentHooks } from "../agents/agent.js";
+import type { Agent, AgentHooks } from "../agents/agent.js";
 import type { AIGNECLIAgents } from "../aigne/type.js";
 export declare function sortHooks(hooks: AgentHooks[]): AgentHooks[];
 export interface CLIAgent<T> {
@@ -9,4 +9,5 @@ export interface CLIAgent<T> {
     agents?: CLIAgent<T>[];
 }
 export declare function mapCliAgent<A, O>({ agent, agents, ...input }: CLIAgent<A>, transform: (input: A) => O): CLIAgent<O>;
-export declare function findCliAgent(cli: AIGNECLIAgents, parent: string[] | "*", name: string): import("../agents/agent.js").Agent<any, any> | undefined;
+export declare function findCliAgent(cli: AIGNECLIAgents, parent: string[] | "*", name: string): Agent<any, any> | undefined;
+export declare function isAgent<A extends Agent>(obj: any): obj is A;

package/lib/esm/utils/agent-utils.js

@@ -46,3 +46,9 @@ function findCliAgentRecursive(agents, name) {
     }
     return undefined;
 }
+export function isAgent(obj) {
+    return (obj &&
+        typeof obj.name === "string" &&
+        typeof obj.invoke === "function" &&
+        typeof obj.process === "function");
+}

package/lib/esm/utils/token-estimator.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Estimate tokens in text by analyzing character types
+ * This function handles mixed-language text (Chinese and English) by counting
+ * different character types and applying appropriate token ratios for each type
+ *
+ * @param text - The text to estimate
+ * @returns Estimated token count
+ */
+export declare function estimateTokens(text: string): number;