@aigne/core 1.71.0 → 1.72.0-beta.1

package/CHANGELOG.md

@@ -1,5 +1,37 @@
 # Changelog
 
+## [1.72.0-beta.1](https://github.com/AIGNE-io/aigne-framework/compare/core-v1.72.0-beta...core-v1.72.0-beta.1) (2025-12-17)
+
+
+### Bug Fixes
+
+* bump version ([70d217c](https://github.com/AIGNE-io/aigne-framework/commit/70d217c8360dd0dda7f5f17011c4e92ec836e801))
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * dependencies
+    * @aigne/afs bumped to 1.4.0-beta.1
+    * @aigne/afs-history bumped to 1.2.0-beta.1
+    * @aigne/observability-api bumped to 0.11.14-beta
+    * @aigne/platform-helpers bumped to 0.6.7-beta
+
+## [1.72.0-beta](https://github.com/AIGNE-io/aigne-framework/compare/core-v1.71.0...core-v1.72.0-beta) (2025-12-17)
+
+
+### Features
+
+* **afs:** support expand context into prompt template by call `$afs.xxx` ([#830](https://github.com/AIGNE-io/aigne-framework/issues/830)) ([5616acd](https://github.com/AIGNE-io/aigne-framework/commit/5616acd6ea257c91aa0b766608f45c5ce17f0345))
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * dependencies
+    * @aigne/afs bumped to 1.4.0-beta
+    * @aigne/afs-history bumped to 1.2.0-beta
+
 ## [1.71.0](https://github.com/AIGNE-io/aigne-framework/compare/core-v1.71.0-beta.6...core-v1.71.0) (2025-12-12)
 
 

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

@@ -1,4 +1,4 @@
-import { AFS, type AFSEntry, type AFSListOptions, type AFSModule, type AFSOptions, type AFSSearchOptions } from "@aigne/afs";
+import { AFS, type AFSExecOptions, type AFSExecResult, type AFSListOptions, type AFSListResult, type AFSModule, type AFSOptions, type AFSReadResult, type AFSSearchOptions } from "@aigne/afs";
 import { nodejs } from "@aigne/platform-helpers/nodejs/index.js";
 import type * as prompts from "@inquirer/prompts";
 import { type ZodObject, type ZodType } from "zod";
@@ -573,23 +573,10 @@ export declare abstract class Agent<I extends Message = any, O extends Message =
     /** For AFSModule interface **/
     private agentToAFSEntry;
     private findAgentByAFSPath;
-    list(_path: string, _options?: AFSListOptions): Promise<{
-        list: AFSEntry[];
-        message?: string;
-    }>;
-    read(path: string): Promise<{
-        result?: AFSEntry;
-        message?: string;
-    }>;
-    search(path: string, _query: string, options?: AFSSearchOptions): Promise<{
-        list: AFSEntry[];
-        message?: string;
-    }>;
-    exec(path: string, args: Record<string, any>, options: {
-        context: Context;
-    }): Promise<{
-        result: Record<string, any>;
-    }>;
+    list(_path: string, _options?: AFSListOptions): Promise<AFSListResult>;
+    read(path: string): Promise<AFSReadResult>;
+    search(path: string, _query: string, options?: AFSSearchOptions): Promise<AFSListResult>;
+    exec(path: string, args: Record<string, any>, options: AFSExecOptions): Promise<AFSExecResult>;
 }
 export type AgentInput<T extends Agent> = T extends Agent<infer I, any> ? I : never;
 export type AgentOutput<T extends Agent> = T extends Agent<any, infer O> ? O : never;

package/lib/cjs/agents/agent.js

@@ -781,7 +781,7 @@ class Agent {
     // TODO: support list skills inside agent path, and use options to filter skills
     async list(_path, _options) {
         const agents = [this, ...this.skills];
-        return { list: agents.map((agent) => this.agentToAFSEntry(agent)) };
+        return { data: agents.map((agent) => this.agentToAFSEntry(agent)) };
     }
     async read(path) {
         const agent = this.findAgentByAFSPath(path);
@@ -789,7 +789,7 @@ class Agent {
             return { message: `Agent not found at path: ${path}` };
         }
         return {
-            result: this.agentToAFSEntry(agent),
+            data: this.agentToAFSEntry(agent),
         };
     }
     // TODO: implement search inside agent skills
@@ -800,7 +800,7 @@ class Agent {
         const agent = this.findAgentByAFSPath(path);
         if (!agent)
             throw new Error(`Agent not found at path: ${path}`);
-        return { result: await options.context.invoke(agent, args) };
+        return { data: await options.context.invoke(agent, args) };
     }
 }
 exports.Agent = Agent;

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

@@ -25,6 +25,26 @@ export type AFSModuleSchema = string | {
     module: string;
     options?: Record<string, any>;
 };
+export interface AFSContextPresetSchema {
+    view?: string;
+    select?: {
+        agent: NestAgentSchema;
+    };
+    per?: {
+        agent: NestAgentSchema;
+    };
+    dedupe?: {
+        agent: NestAgentSchema;
+    };
+}
+export interface AFSContextSchema {
+    search?: {
+        presets?: Record<string, AFSContextPresetSchema>;
+    };
+    list?: {
+        presets?: Record<string, AFSContextPresetSchema>;
+    };
+}
 export interface BaseAgentSchema {
     name?: string;
     description?: string;
@@ -42,8 +62,9 @@ export interface BaseAgentSchema {
         provider: string;
         subscribeTopic?: string[];
     };
-    afs?: boolean | (Omit<AFSOptions, "modules"> & {
+    afs?: boolean | (Omit<AFSOptions, "modules" | "context"> & {
         modules?: AFSModuleSchema[];
+        context?: AFSContextSchema;
     });
     shareAFS?: boolean;
 }

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

@@ -86,6 +86,20 @@ const getAgentSchema = ({ filepath, options, }) => {
             onSkillEnd: (0, schema_js_1.optionalize)(nestAgentSchema),
             onHandoff: (0, schema_js_1.optionalize)(nestAgentSchema),
         }));
+        const afsContextPresetsSchema = zod_1.z.object({
+            presets: (0, schema_js_1.optionalize)(zod_1.z.record(zod_1.z.string(), zod_1.z.object({
+                view: (0, schema_js_1.optionalize)(zod_1.z.string()),
+                select: (0, schema_js_1.optionalize)(zod_1.z.object({
+                    agent: nestAgentSchema,
+                })),
+                per: (0, schema_js_1.optionalize)(zod_1.z.object({
+                    agent: nestAgentSchema,
+                })),
+                dedupe: (0, schema_js_1.optionalize)(zod_1.z.object({
+                    agent: nestAgentSchema,
+                })),
+            }))),
+        });
         const baseAgentSchema = zod_1.z.object({
             name: (0, schema_js_1.optionalize)(zod_1.z.string()),
             alias: (0, schema_js_1.optionalize)(zod_1.z.array(zod_1.z.string())),
@@ -117,6 +131,10 @@ const getAgentSchema = ({ filepath, options, }) => {
                             options: (0, schema_js_1.optionalize)(zod_1.z.record(zod_1.z.any())),
                         })),
                     ]))),
+                    context: (0, schema_js_1.optionalize)(zod_1.z.object({
+                        search: (0, schema_js_1.optionalize)(afsContextPresetsSchema),
+                        list: (0, schema_js_1.optionalize)(afsContextPresetsSchema),
+                    })),
                 })),
             ])),
             shareAFS: (0, schema_js_1.optionalize)(zod_1.z.boolean()),

package/lib/cjs/loader/index.js

@@ -132,7 +132,32 @@ async function parseAgent(path, agent, options, agentOptions) {
         afs = new afs_1.AFS();
     }
     else if (agent.afs) {
-        afs = new afs_1.AFS();
+        afs = new afs_1.AFS({});
+        const loadAFSContextPresets = async (presets) => {
+            return Object.fromEntries(await Promise.all(Object.entries(presets).map(async ([key, value]) => {
+                const [select, per, dedupe] = await Promise.all([value.select, value.per, value.dedupe].map(async (item) => {
+                    if (!item?.agent)
+                        return undefined;
+                    const agent = await loadNestAgent(path, item.agent, options, { afs });
+                    return {
+                        invoke: (input, options) => options.context.invoke(agent, input, {
+                            ...options,
+                            streaming: false,
+                        }),
+                    };
+                }));
+                return [key, { ...value, select, per, dedupe }];
+            })));
+        };
+        const context = {
+            search: {
+                presets: await loadAFSContextPresets(agent.afs.context?.search?.presets || {}),
+            },
+            list: {
+                presets: await loadAFSContextPresets(agent.afs.context?.list?.presets || {}),
+            },
+        };
+        afs.options.context = context;
         for (const m of agent.afs.modules || []) {
             const moduleName = typeof m === "string" ? m : m.module;
             const mod = options?.afs?.availableModules?.find((mod) => mod.module === moduleName || mod.alias?.includes(moduleName));

package/lib/cjs/prompt/context/afs/history.d.ts

@@ -0,0 +1,5 @@
+import type { Agent } from "../../../agents/agent.js";
+export declare function getHistories(agent: Agent): Promise<{
+    role: "user" | "agent";
+    content: unknown;
+}[]>;

package/lib/cjs/prompt/context/afs/history.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getHistories = getHistories;
+const afs_history_1 = require("@aigne/afs-history");
+const type_utils_js_1 = require("../../../utils/type-utils.js");
+async function getHistories(agent) {
+    const afs = agent?.afs;
+    if (!afs)
+        return [];
+    const historyModule = (await afs.listModules()).find((m) => m.module instanceof afs_history_1.AFSHistory);
+    if (!historyModule)
+        return [];
+    const history = (await afs.list(historyModule.path, {
+        limit: agent.historyConfig?.maxItems || 10,
+        orderBy: [["createdAt", "desc"]],
+    })).data;
+    return history
+        .reverse()
+        .map((i) => {
+        if (!i.content)
+            return;
+        const { input, output } = i.content;
+        if (!input || !output)
+            return;
+        return [
+            { role: "user", content: input },
+            { role: "agent", content: output },
+        ];
+    })
+        .filter(type_utils_js_1.isNonNullable)
+        .flat();
+}

package/lib/cjs/prompt/context/afs/index.d.ts

@@ -0,0 +1,20 @@
+import type { AFSRootListOptions, AFSRootSearchOptions } from "@aigne/afs";
+import type { Agent, AgentInvokeOptions } from "../../../agents/agent.js";
+export declare function createAFSContext(agent?: Agent<any, any>, context?: AgentInvokeOptions["context"]): {
+    readonly enabled: boolean;
+    description: string;
+    readonly modules: Promise<Pick<{
+        name: string;
+        path: string;
+        description?: string;
+        module: import("@aigne/afs").AFSModule;
+    }, "path" | "name" | "description">[]> | undefined;
+    readonly histories: Promise<{
+        role: "user" | "agent";
+        content: unknown;
+    }[]>;
+    readonly skills: never[] | Promise<Pick<Agent<any, any>, "name" | "description">[]>;
+    list(path: string, options?: AFSRootListOptions): Promise<any>;
+    read(path: string): Promise<import("@aigne/afs").AFSEntry<any> | undefined>;
+    search(path: string, query: string, options?: AFSRootSearchOptions): Promise<any>;
+};

package/lib/cjs/prompt/context/afs/index.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAFSContext = createAFSContext;
+const type_utils_js_1 = require("../../../utils/type-utils.js");
+const afs_builtin_prompt_js_1 = require("../../prompts/afs-builtin-prompt.js");
+const index_js_1 = require("../../skills/afs/index.js");
+const history_js_1 = require("./history.js");
+function createAFSContext(agent, context) {
+    const afs = agent?.afs;
+    return {
+        get enabled() {
+            return !!afs;
+        },
+        description: afs_builtin_prompt_js_1.AFS_DESCRIPTION_PROMPT_TEMPLATE,
+        get modules() {
+            return afs
+                ?.listModules()
+                .then((list) => list.map((i) => (0, type_utils_js_1.pick)(i, ["name", "path", "description"])));
+        },
+        get histories() {
+            if (!agent)
+                return Promise.resolve([]);
+            return (0, history_js_1.getHistories)(agent);
+        },
+        get skills() {
+            const afs = agent?.afs;
+            if (!afs)
+                return [];
+            return (0, index_js_1.getAFSSkills)(afs).then((skills) => skills.map((s) => (0, type_utils_js_1.pick)(s, ["name", "description"])));
+        },
+        async list(path, options) {
+            if (!afs)
+                throw new Error("AFS is not configured for this agent.");
+            return (await afs.list(path, { ...options, context, format: options?.format || "tree" }))
+                .data;
+        },
+        async read(path) {
+            if (!afs)
+                throw new Error("AFS is not configured for this agent.");
+            return (await afs.read(path)).data;
+        },
+        async search(path, query, options = {}) {
+            if (!afs)
+                throw new Error("AFS is not configured for this agent.");
+            return (await afs.search(path, query, { ...options, context })).data;
+        },
+    };
+}

package/lib/cjs/prompt/context/index.d.ts

@@ -0,0 +1,31 @@
+import type { PromptBuildOptions } from "../prompt-builder.js";
+export declare function createPromptBuilderContext(options: PromptBuildOptions): {
+    $afs: {
+        readonly enabled: boolean;
+        description: string;
+        readonly modules: Promise<Pick<{
+            name: string;
+            path: string;
+            description?: string;
+            module: import("@aigne/afs/.").AFSModule;
+        }, "path" | "name" | "description">[]> | undefined;
+        readonly histories: Promise<{
+            role: "user" | "agent";
+            content: unknown;
+        }[]>;
+        readonly skills: never[] | Promise<Pick<import("../../index.js").Agent<any, any>, "name" | "description">[]>;
+        list(path: string, options?: import("@aigne/afs/.").AFSRootListOptions): Promise<any>;
+        read(path: string): Promise<import("@aigne/afs/.").AFSEntry<any> | undefined>;
+        search(path: string, query: string, options?: import("@aigne/afs/.").AFSRootSearchOptions): Promise<any>;
+    };
+    $agent: {
+        readonly skills: Pick<import("../../index.js").Agent<any, any>, "name" | "description">[] | undefined;
+    };
+    $meta?: {
+        usage?: import("../../index.js").ContextUsage;
+        [key: string]: unknown;
+    };
+    userId?: string;
+    sessionId?: string;
+    userContext: import("../../index.js").UserContext | undefined;
+};

package/lib/cjs/prompt/context/index.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPromptBuilderContext = createPromptBuilderContext;
+const type_utils_js_1 = require("../../utils/type-utils.js");
+const index_js_1 = require("./afs/index.js");
+function createPromptBuilderContext(options) {
+    return {
+        userContext: options.context?.userContext,
+        ...options.context?.userContext,
+        ...options.input,
+        $afs: (0, index_js_1.createAFSContext)(options.agent, options.context),
+        $agent: {
+            get skills() {
+                return options.agent?.skills.map((s) => (0, type_utils_js_1.pick)(s, ["name", "description"]));
+            },
+        },
+    };
+}

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

@@ -12,10 +12,11 @@ const model_js_1 = require("../agents/model.js");
 const schema_js_1 = require("../loader/schema.js");
 const json_schema_js_1 = require("../utils/json-schema.js");
 const type_utils_js_1 = require("../utils/type-utils.js");
+const index_js_2 = require("./context/index.js");
 const afs_builtin_prompt_js_1 = require("./prompts/afs-builtin-prompt.js");
 const memory_message_template_js_1 = require("./prompts/memory-message-template.js");
 const structured_stream_instructions_js_1 = require("./prompts/structured-stream-instructions.js");
-const index_js_2 = require("./skills/afs/index.js");
+const index_js_3 = require("./skills/afs/index.js");
 const template_js_1 = require("./template.js");
 class PromptBuilder {
     static from(instructions, { workingDir } = {}) {
@@ -95,37 +96,7 @@ class PromptBuilder {
         };
     }
     getTemplateVariables(options) {
-        const self = this;
-        return {
-            userContext: options.context?.userContext,
-            ...options.context?.userContext,
-            ...options.input,
-            $afs: {
-                get enabled() {
-                    return !!options.agent?.afs;
-                },
-                description: afs_builtin_prompt_js_1.AFS_DESCRIPTION_PROMPT_TEMPLATE,
-                get modules() {
-                    return options.agent?.afs
-                        ?.listModules()
-                        .then((list) => list.map((i) => (0, type_utils_js_1.pick)(i, ["name", "path", "description"])));
-                },
-                get histories() {
-                    return self.getHistories(options);
-                },
-                get skills() {
-                    const afs = options.agent?.afs;
-                    if (!afs)
-                        return [];
-                    return (0, index_js_2.getAFSSkills)(afs).then((skills) => skills.map((s) => (0, type_utils_js_1.pick)(s, ["name", "description"])));
-                },
-            },
-            $agent: {
-                get skills() {
-                    return options.agent?.skills.map((s) => (0, type_utils_js_1.pick)(s, ["name", "description"]));
-                },
-            },
-        };
+        return (0, index_js_2.createPromptBuilderContext)(options);
     }
     async buildMessages(options) {
         const { input } = options;
@@ -154,12 +125,12 @@ class PromptBuilder {
                     limit: options.agent?.maxRetrieveMemoryCount || 10,
                     orderBy: [["createdAt", "desc"]],
                 });
-                memories.push(...history.list
+                memories.push(...history.data
                     .reverse()
                     .filter((i) => (0, type_utils_js_1.isNonNullable)(i.content)));
                 if (message) {
-                    const result = await afs.search("/", message);
-                    const ms = result.list
+                    const result = (await afs.search("/", message)).data;
+                    const ms = result
                         .map((entry) => {
                         if (entry.metadata?.execute)
                             return null;
@@ -173,7 +144,7 @@ class PromptBuilder {
                     })
                         .filter(type_utils_js_1.isNonNullable);
                     memories.push(...ms);
-                    const executable = result.list.filter((i) => !!i.metadata?.execute);
+                    const executable = result.filter((i) => !!i.metadata?.execute);
                     if (executable.length) {
                         messages.push({
                             role: "system",
@@ -232,10 +203,10 @@ class PromptBuilder {
         const historyModule = (await afs.listModules()).find((m) => m.module instanceof afs_history_1.AFSHistory);
         if (!historyModule)
             return [];
-        const { list: history } = await afs.list(historyModule.path, {
+        const history = (await afs.list(historyModule.path, {
             limit: agent.historyConfig?.maxItems || 10,
             orderBy: [["createdAt", "desc"]],
-        });
+        })).data;
         return history
             .reverse()
             .map((i) => {
@@ -364,7 +335,7 @@ class PromptBuilder {
             .concat(options.agent?.memoryAgentsAsTools ? options.agent.memories : [])
             .flatMap((i) => (i.isInvokable ? i : i.skills)), (i) => i.name);
         if (options.agent?.afs) {
-            toolAgents.push(...(await (0, index_js_2.getAFSSkills)(options.agent.afs)));
+            toolAgents.push(...(await (0, index_js_3.getAFSSkills)(options.agent.afs)));
         }
         const tools = toolAgents.map((i) => ({
             type: "function",

package/lib/cjs/prompt/skills/afs/edit.d.ts

@@ -14,7 +14,7 @@ export interface AFSEditOutput extends Message {
     tool: string;
     path: string;
     message: string;
-    content: string;
+    data: string;
 }
 export interface AFSEditAgentOptions extends AgentOptions<AFSEditInput, AFSEditOutput> {
     afs: NonNullable<AgentOptions<AFSEditInput, AFSEditOutput>["afs"]>;

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

@@ -26,7 +26,7 @@ class AFSEditAgent extends agent_js_1.Agent {
                 tool: zod_1.z.string(),
                 path: zod_1.z.string(),
                 message: zod_1.z.string(),
-                content: zod_1.z.string(),
+                data: zod_1.z.string(),
             }),
         });
     }
@@ -37,10 +37,10 @@ class AFSEditAgent extends agent_js_1.Agent {
             throw new Error("No patches provided for afs_edit.");
         }
         const readResult = await this.afs.read(input.path);
-        if (!readResult.result?.content || typeof readResult.result.content !== "string") {
+        if (!readResult.data?.content || typeof readResult.data.content !== "string") {
             throw new Error(`Cannot read file content from: ${input.path}`);
         }
-        const originalContent = readResult.result.content;
+        const originalContent = readResult.data.content;
         const updatedContent = this.applyCustomPatches(originalContent, input.patches);
         await this.afs.write(input.path, {
             content: updatedContent,
@@ -50,7 +50,7 @@ class AFSEditAgent extends agent_js_1.Agent {
             tool: "afs_edit",
             path: input.path,
             message: `Applied ${input.patches.length} patches to ${input.path}`,
-            content: updatedContent,
+            data: updatedContent,
         };
     }
     applyCustomPatches(text, patches) {

package/lib/cjs/prompt/skills/afs/exec.d.ts

@@ -4,7 +4,7 @@ export interface AFSExecInput extends Message {
     args: string;
 }
 export interface AFSExecOutput extends Message {
-    result: Record<string, any>;
+    data: Record<string, any>;
 }
 export interface AFSExecAgentOptions extends AgentOptions<AFSExecInput, AFSExecOutput> {
     afs: NonNullable<AgentOptions<AFSExecInput, AFSExecOutput>["afs"]>;

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

@@ -14,14 +14,16 @@ class AFSExecAgent extends agent_js_1.Agent {
                 args: zod_1.z.string().describe("JSON string of arguments matching the function's input schema"),
             }),
             outputSchema: zod_1.z.object({
-                result: zod_1.z.record(zod_1.z.any()),
+                data: zod_1.z.record(zod_1.z.any()),
             }),
         });
     }
     async process(input, options) {
         if (!this.afs)
             throw new Error("AFS is not configured for this agent.");
-        return await this.afs.exec(input.path, JSON.parse(input.args), options);
+        return {
+            ...(await this.afs.exec(input.path, JSON.parse(input.args), options)),
+        };
     }
 }
 exports.AFSExecAgent = AFSExecAgent;

package/lib/cjs/prompt/skills/afs/list.d.ts

@@ -10,7 +10,7 @@ export interface AFSListOutput extends Message {
     path: string;
     options?: AFSListOptions;
     message?: string;
-    result: string;
+    data?: unknown;
 }
 export interface AFSListAgentOptions extends AgentOptions<AFSListInput, AFSListOutput> {
     afs: NonNullable<AgentOptions<AFSListInput, AFSListOutput>["afs"]>;
@@ -18,5 +18,4 @@ export interface AFSListAgentOptions extends AgentOptions<AFSListInput, AFSListO
 export declare class AFSListAgent extends Agent<AFSListInput, AFSListOutput> {
     constructor(options: AFSListAgentOptions);
     process(input: AFSListInput, _options: AgentInvokeOptions): Promise<AFSListOutput>;
-    private buildTreeView;
 }

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

@@ -14,6 +14,19 @@ class AFSListAgent extends agent_js_1.Agent {
                 options: zod_1.z
                     .object({
                     maxDepth: zod_1.z.number().optional().describe("Tree depth limit (default: 1)"),
+                    disableGitignore: zod_1.z
+                        .boolean()
+                        .optional()
+                        .describe("Disable .gitignore filtering, default is enabled"),
+                    maxChildren: zod_1.z
+                        .number()
+                        .optional()
+                        .describe("Maximum number of children to list per directory"),
+                    format: zod_1.z
+                        .union([zod_1.z.literal("tree"), zod_1.z.literal("list")])
+                        .optional()
+                        .default("tree")
+                        .describe("Output format, either 'tree' or 'list' (default: 'tree')"),
                 })
                     .optional(),
             }),
@@ -24,67 +37,28 @@ class AFSListAgent extends agent_js_1.Agent {
                 options: zod_1.z
                     .object({
                     maxDepth: zod_1.z.number().optional(),
+                    disableGitignore: zod_1.z.boolean().optional(),
+                    maxChildren: zod_1.z.number().optional(),
+                    format: zod_1.z.union([zod_1.z.literal("tree"), zod_1.z.literal("list")]).optional(),
                 })
                     .optional(),
                 message: zod_1.z.string().optional(),
-                result: zod_1.z.string(),
+                data: zod_1.z.unknown(),
             }),
         });
     }
     async process(input, _options) {
         if (!this.afs)
             throw new Error("AFS is not configured for this agent.");
-        const { list, message } = await this.afs.list(input.path, input.options);
-        const result = this.buildTreeView(list);
+        const { data, message } = await this.afs.list(input.path, input.options);
         return {
             status: "success",
             tool: "afs_list",
             path: input.path,
             options: input.options,
             message,
-            result,
+            data,
         };
     }
-    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) {
-                if (!current[part]) {
-                    current[part] = {};
-                }
-                current = current[part];
-            }
-        }
-        const renderTree = (node, prefix = "", currentPath = "") => {
-            let result = "";
-            const keys = Object.keys(node);
-            keys.forEach((key, index) => {
-                const isLast = index === keys.length - 1;
-                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;
-        };
-        return renderTree(tree);
-    }
 }
 exports.AFSListAgent = AFSListAgent;

package/lib/cjs/prompt/skills/afs/read.d.ts

@@ -9,7 +9,7 @@ export interface AFSReadOutput extends Message {
     tool: string;
     path: string;
     withLineNumbers?: boolean;
-    result?: AFSEntry;
+    data?: AFSEntry;
     message?: string;
 }
 export interface AFSReadAgentOptions extends AgentOptions<AFSReadInput, AFSReadOutput> {