@aigne/core 1.70.1 → 1.71.0-beta

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

@@ -65,6 +65,12 @@ 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),
@@ -75,11 +81,11 @@ class PromptBuilder {
             ...(await this.buildTools(options)),
         };
     }
-    async buildImagePrompt(options) {
+    async buildPrompt(options) {
         const messages = (await (typeof this.instructions === "string"
             ? template_js_1.ChatMessagesTemplate.from([template_js_1.SystemMessageTemplate.from(this.instructions)])
             : this.instructions)?.format(this.getTemplateVariables(options), { workingDir: this.workingDir })) ?? [];
-        const inputFileKey = options.agent?.inputFileKey;
+        const inputFileKey = options.inputFileKey;
         const files = (0, type_utils_js_1.flat)(inputFileKey
             ? (0, type_utils_js_1.checkArguments)("Check input files", (0, schema_js_1.optionalize)(model_js_1.fileUnionContentsSchema), options.input?.[inputFileKey])
             : null);

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

@@ -55,19 +55,39 @@ async function getAFSSkills(afs) {
         }),
         agent_js_1.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: zod_1.z.object({
                 path: zod_1.z
                     .string()
                     .describe("Exact file path from list or search results (e.g., '/docs/api.md', '/src/utils/helper.js')"),
+                withLineNumbers: zod_1.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,
+                    },
                 };
             },
         }),
@@ -109,7 +129,9 @@ 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) {
@@ -119,13 +141,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/cjs/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/cjs/prompt/template.js

@@ -8,6 +8,7 @@ exports.safeParseChatMessages = safeParseChatMessages;
 exports.parseChatMessages = parseChatMessages;
 const index_js_1 = require("@aigne/platform-helpers/nodejs/index.js");
 const nunjucks_1 = __importDefault(require("nunjucks"));
+const yaml_1 = require("yaml");
 const zod_1 = require("zod");
 const type_utils_js_1 = require("../utils/type-utils.js");
 const index_js_2 = require("./filters/index.js");
@@ -144,9 +145,7 @@ 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 : (0, yaml_1.stringify)(content), name, options);
         this.toolCallId = toolCallId;
     }
     async format(_variables, _options) {
@@ -168,6 +167,9 @@ 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/cjs/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/cjs/utils/agent-utils.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.sortHooks = sortHooks;
 exports.mapCliAgent = mapCliAgent;
 exports.findCliAgent = findCliAgent;
+exports.isAgent = isAgent;
 const priorities = ["high", "medium", "low"];
 function sortHooks(hooks) {
     return hooks
@@ -51,3 +52,9 @@ function findCliAgentRecursive(agents, name) {
     }
     return undefined;
 }
+function isAgent(obj) {
+    return (obj &&
+        typeof obj.name === "string" &&
+        typeof obj.invoke === "function" &&
+        typeof obj.process === "function");
+}

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

package/lib/cjs/utils/token-estimator.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.estimateTokens = estimateTokens;
+/**
+ * Token estimation ratios for different character types
+ * Based on empirical data from various tokenizers
+ */
+const CHAR_TYPE_RATIOS = {
+    chinese: 1.5, // Chinese characters: ~1.5 characters per token
+    word: 0.75, // English words: ~0.75 tokens per word (accounting for subword tokenization)
+    other: 4, // Other characters (punctuation, numbers, etc.): ~4 characters per token
+};
+/**
+ * Regular expressions for character type detection
+ */
+const CHAR_PATTERNS = {
+    // CJK characters (Chinese, Japanese Kanji, etc.)
+    chinese: /[\u4e00-\u9fff\u3400-\u4dbf\u3040-\u309f\u30a0-\u30ff]/g,
+    // English words (sequences of letters)
+    word: /[a-zA-Z]+/g,
+};
+/**
+ * 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
+ */
+function estimateTokens(text) {
+    if (!text)
+        return 0;
+    let tokens = 0;
+    const processedIndices = new Set();
+    // Count Chinese characters (including CJK)
+    const chineseMatches = text.match(CHAR_PATTERNS.chinese);
+    if (chineseMatches) {
+        tokens += chineseMatches.length / CHAR_TYPE_RATIOS.chinese;
+        // Mark processed positions
+        const chineseRegex = new RegExp(CHAR_PATTERNS.chinese.source, "g");
+        let match = chineseRegex.exec(text);
+        while (match !== null) {
+            processedIndices.add(match.index);
+            match = chineseRegex.exec(text);
+        }
+    }
+    // Count English words
+    const wordMatches = text.match(CHAR_PATTERNS.word);
+    if (wordMatches) {
+        tokens += wordMatches.length * CHAR_TYPE_RATIOS.word;
+        const wordRegex = new RegExp(CHAR_PATTERNS.word.source, "g");
+        let match = wordRegex.exec(text);
+        while (match !== null) {
+            for (let i = 0; i < match[0].length; i++) {
+                processedIndices.add(match.index + i);
+            }
+            match = wordRegex.exec(text);
+        }
+    }
+    // Count remaining characters (punctuation, numbers, whitespace, etc.)
+    const remainingChars = text.length - processedIndices.size;
+    if (remainingChars > 0) {
+        tokens += remainingChars / CHAR_TYPE_RATIOS.other;
+    }
+    return Math.ceil(tokens);
+}

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

@@ -205,6 +205,10 @@ export declare abstract class Agent<I extends Message = any, O extends Message =
      * @returns Agent name
      */
     [nodejs.customInspect]: () => string;
+    static load<I extends Message = any, O extends Message = any>(_options: {
+        filepath: string;
+        parsed: object;
+    }): Promise<Agent<I, O>>;
     constructor(options?: AgentOptions<I, O>);
     /**
      * List of memories this agent can use

package/lib/dts/agents/types.d.ts

@@ -1,5 +1,5 @@
 import z, { type ZodType } from "zod";
-import { type Agent, DEFAULT_INPUT_ACTION_GET, type Message } from "./agent.js";
+import { type Agent, type AgentOptions, DEFAULT_INPUT_ACTION_GET, type Message } from "./agent.js";
 export declare const transferAgentOutputKey = "$transferAgentTo";
 export interface TransferAgentOutput extends Message {
     [transferAgentOutputKey]: {
@@ -21,3 +21,11 @@ export declare function getterSchema<T extends ZodType>(schema: T): z.ZodUnion<[
 }, {
     $get: string;
 }>]>;
+export interface AgentClass {
+    new (...args: any[]): Agent<any, any>;
+    load<I extends Message = any, O extends Message = any>(options: {
+        filepath: string;
+        parsed: AgentOptions;
+        [key: string]: any;
+    }): Promise<Agent<I, O>>;
+}

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

@@ -1,2 +1 @@
-import { Agent } from "../agents/agent.js";
-export declare function loadAgentFromJsFile(path: string): Promise<Agent<any, any> | import("./agent-yaml.js").AgentSchema>;
+export declare function loadAgentFromJsFile(path: string): Promise<import("../index.js").Agent<any, any> | import("./agent-yaml.js").AgentSchema>;

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

@@ -1,9 +1,10 @@
 import type { AFSOptions } from "@aigne/afs";
 import { type ZodType, z } from "zod";
-import type { AgentHooks, FunctionAgentFn, TaskRenderMode } from "../agents/agent.js";
+import type { AgentClass, AgentHooks, FunctionAgentFn, TaskRenderMode } from "../agents/agent.js";
 import { AIAgentToolChoice } from "../agents/ai-agent.js";
 import { type Role } from "../agents/chat-model.js";
 import { ProcessMode, type ReflectionMode } from "../agents/team-agent.js";
+import type { LoadOptions } from "./index.js";
 import { chatModelSchema, imageModelSchema } from "./schema.js";
 export interface HooksSchema {
     priority?: AgentHooks["priority"];
@@ -44,6 +45,7 @@ export interface BaseAgentSchema {
     afs?: boolean | (Omit<AFSOptions, "modules"> & {
         modules?: AFSModuleSchema[];
     });
+    shareAFS?: boolean;
 }
 export type Instructions = {
     role: Exclude<Role, "tool">;
@@ -93,6 +95,20 @@ export interface FunctionAgentSchema extends BaseAgentSchema {
     type: "function";
     process: FunctionAgentFn;
 }
-export type AgentSchema = AIAgentSchema | ImageAgentSchema | MCPAgentSchema | TeamAgentSchema | TransformAgentSchema | FunctionAgentSchema;
+export interface ThirdAgentSchema extends BaseAgentSchema {
+    agentClass?: AgentClass;
+    type: "";
+    [key: string]: any;
+}
+export type AgentSchema = AIAgentSchema | ImageAgentSchema | MCPAgentSchema | TeamAgentSchema | TransformAgentSchema | FunctionAgentSchema | ThirdAgentSchema;
 export declare function parseAgentFile(path: string, data: any): Promise<AgentSchema>;
-export declare function loadAgentFromYamlFile(path: string): Promise<AgentSchema>;
+export declare function loadAgentFromYamlFile(path: string, options?: LoadOptions): Promise<AgentSchema>;
+export declare const getInstructionsSchema: ({ filepath }: {
+    filepath: string;
+}) => ZodType<Instructions>;
+export declare const getAgentSchema: ({ filepath }: {
+    filepath: string;
+}) => ZodType<AgentSchema, z.ZodTypeDef, AgentSchema>;
+export declare const getNestAgentSchema: ({ filepath, }: {
+    filepath: string;
+}) => ZodType<NestAgentSchema>;

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

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

@@ -205,6 +205,10 @@ export declare abstract class Agent<I extends Message = any, O extends Message =
      * @returns Agent name
      */
     [nodejs.customInspect]: () => string;
+    static load<I extends Message = any, O extends Message = any>(_options: {
+        filepath: string;
+        parsed: object;
+    }): Promise<Agent<I, O>>;
     constructor(options?: AgentOptions<I, O>);
     /**
      * List of memories this agent can use

package/lib/esm/agents/agent.js

@@ -77,6 +77,9 @@ export const agentOptionsSchema = z.object({
  * {@includeCode ../../test/agents/agent.test.ts#example-custom-agent}
  */
 export class Agent {
+    static async load(_options) {
+        throw new Error("Not implemented");
+    }
     constructor(options = {}) {
         checkArguments("Agent options", agentOptionsSchema, options);
         const { inputSchema, outputSchema } = options;

package/lib/esm/agents/image-agent.js

@@ -31,10 +31,10 @@ export class ImageAgent extends Agent {
         if (!imageModel)
             throw new Error("image model is required to run ImageAgent");
         const modelOptions = await imageModel.getModelOptions(input, options);
-        const { prompt, image } = await this.instructions.buildImagePrompt({
+        const { prompt, image } = await this.instructions.buildPrompt({
             ...options,
             input,
-            agent: this,
+            inputFileKey: this.inputFileKey,
         });
         const n = input.n || modelOptions?.n;
         return (await this.invokeChildAgent(imageModel, {

package/lib/esm/agents/types.d.ts

@@ -1,5 +1,5 @@
 import z, { type ZodType } from "zod";
-import { type Agent, DEFAULT_INPUT_ACTION_GET, type Message } from "./agent.js";
+import { type Agent, type AgentOptions, DEFAULT_INPUT_ACTION_GET, type Message } from "./agent.js";
 export declare const transferAgentOutputKey = "$transferAgentTo";
 export interface TransferAgentOutput extends Message {
     [transferAgentOutputKey]: {
@@ -21,3 +21,11 @@ export declare function getterSchema<T extends ZodType>(schema: T): z.ZodUnion<[
 }, {
     $get: string;
 }>]>;
+export interface AgentClass {
+    new (...args: any[]): Agent<any, any>;
+    load<I extends Message = any, O extends Message = any>(options: {
+        filepath: string;
+        parsed: AgentOptions;
+        [key: string]: any;
+    }): Promise<Agent<I, O>>;
+}

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

@@ -1,2 +1 @@
-import { Agent } from "../agents/agent.js";
-export declare function loadAgentFromJsFile(path: string): Promise<Agent<any, any> | import("./agent-yaml.js").AgentSchema>;
+export declare function loadAgentFromJsFile(path: string): Promise<import("../index.js").Agent<any, any> | import("./agent-yaml.js").AgentSchema>;

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

@@ -1,5 +1,5 @@
 import { nodejs } from "@aigne/platform-helpers/nodejs/index.js";
-import { Agent } from "../agents/agent.js";
+import { isAgent } from "../utils/agent-utils.js";
 import { tryOrThrow } from "../utils/type-utils.js";
 import { parseAgentFile } from "./agent-yaml.js";
 import { LoadJsAgentError } from "./error.js";
@@ -7,7 +7,7 @@ const importFn = new Function("path", "return import(path)");
 export async function loadAgentFromJsFile(path) {
     const url = nodejs.path.isAbsolute(path) ? nodejs.url.pathToFileURL(path).toString() : path;
     const { default: agent } = await tryOrThrow(() => importFn(url), (error) => new LoadJsAgentError(`Failed to load agent definition from ${url}: ${error.message}`));
-    if (agent instanceof Agent)
+    if (isAgent(agent))
         return agent;
     return tryOrThrow(() => parseAgentFile(path, {
         type: "function",

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

@@ -1,9 +1,10 @@
 import type { AFSOptions } from "@aigne/afs";
 import { type ZodType, z } from "zod";
-import type { AgentHooks, FunctionAgentFn, TaskRenderMode } from "../agents/agent.js";
+import type { AgentClass, AgentHooks, FunctionAgentFn, TaskRenderMode } from "../agents/agent.js";
 import { AIAgentToolChoice } from "../agents/ai-agent.js";
 import { type Role } from "../agents/chat-model.js";
 import { ProcessMode, type ReflectionMode } from "../agents/team-agent.js";
+import type { LoadOptions } from "./index.js";
 import { chatModelSchema, imageModelSchema } from "./schema.js";
 export interface HooksSchema {
     priority?: AgentHooks["priority"];
@@ -44,6 +45,7 @@ export interface BaseAgentSchema {
     afs?: boolean | (Omit<AFSOptions, "modules"> & {
         modules?: AFSModuleSchema[];
     });
+    shareAFS?: boolean;
 }
 export type Instructions = {
     role: Exclude<Role, "tool">;
@@ -93,6 +95,20 @@ export interface FunctionAgentSchema extends BaseAgentSchema {
     type: "function";
     process: FunctionAgentFn;
 }
-export type AgentSchema = AIAgentSchema | ImageAgentSchema | MCPAgentSchema | TeamAgentSchema | TransformAgentSchema | FunctionAgentSchema;
+export interface ThirdAgentSchema extends BaseAgentSchema {
+    agentClass?: AgentClass;
+    type: "";
+    [key: string]: any;
+}
+export type AgentSchema = AIAgentSchema | ImageAgentSchema | MCPAgentSchema | TeamAgentSchema | TransformAgentSchema | FunctionAgentSchema | ThirdAgentSchema;
 export declare function parseAgentFile(path: string, data: any): Promise<AgentSchema>;
-export declare function loadAgentFromYamlFile(path: string): Promise<AgentSchema>;
+export declare function loadAgentFromYamlFile(path: string, options?: LoadOptions): Promise<AgentSchema>;
+export declare const getInstructionsSchema: ({ filepath }: {
+    filepath: string;
+}) => ZodType<Instructions>;
+export declare const getAgentSchema: ({ filepath }: {
+    filepath: string;
+}) => ZodType<AgentSchema, z.ZodTypeDef, AgentSchema>;
+export declare const getNestAgentSchema: ({ filepath, }: {
+    filepath: string;
+}) => ZodType<NestAgentSchema>;