@aigne/afs-mcp 1.11.0-beta.6 → 1.11.0-beta.8

package/dist/index.cjs

@@ -1,6 +1,6 @@
+Object.defineProperty(exports, '__esModule', { value: true });
 const require_kinds = require('./kinds.cjs');
 const require_decorate = require('./_virtual/_@oxc-project_runtime@0.108.0/helpers/decorate.cjs');
-let node_path = require("node:path");
 let _aigne_afs = require("@aigne/afs");
 let _aigne_afs_provider = require("@aigne/afs/provider");
 let _aigne_afs_utils_zod = require("@aigne/afs/utils/zod");
@@ -12,14 +12,6 @@ let zod = require("zod");
 
 //#region src/index.ts
 /**
-* AFS MCP Provider
-*
-* 将 MCP Server 挂载为 AFS 可访问的世界。
-* - Tools → 可执行的 AFS entries（通过 `exec()`）
-* - Prompts → 可读取的世界描述
-* - Resources → 可读取的世界状态（展开为 AFS 目录结构）
-*/
-/**
 * Zod schema for options validation
 */
 const afsMCPOptionsSchema = (0, _aigne_afs_utils_zod.camelize)(zod.z.object({
@@ -32,9 +24,9 @@ const afsMCPOptionsSchema = (0, _aigne_afs_utils_zod.camelize)(zod.z.object({
 	]),
 	command: (0, _aigne_afs_utils_zod.optionalize)(zod.z.string()),
 	args: (0, _aigne_afs_utils_zod.optionalize)(zod.z.array(zod.z.string())),
-	env: (0, _aigne_afs_utils_zod.optionalize)(zod.z.record(zod.z.string())),
+	env: (0, _aigne_afs_utils_zod.optionalize)(zod.z.record(zod.z.string(), zod.z.string())),
 	url: (0, _aigne_afs_utils_zod.optionalize)(zod.z.string()),
-	headers: (0, _aigne_afs_utils_zod.optionalize)(zod.z.record(zod.z.string())),
+	headers: (0, _aigne_afs_utils_zod.optionalize)(zod.z.record(zod.z.string(), zod.z.string())),
 	timeout: (0, _aigne_afs_utils_zod.optionalize)(zod.z.number()),
 	maxReconnects: (0, _aigne_afs_utils_zod.optionalize)(zod.z.number())
 }).refine((data) => {
@@ -55,13 +47,57 @@ var AFSMCP = class AFSMCP extends _aigne_afs_provider.AFSBaseProvider {
 	static schema() {
 		return afsMCPOptionsSchema;
 	}
+	static manifest() {
+		return [
+			{
+				name: "mcp-stdio",
+				description: "MCP server via stdio transport",
+				uriTemplate: "mcp+stdio://{command+}",
+				category: "integration",
+				schema: zod.z.object({
+					command: zod.z.string(),
+					args: zod.z.array(zod.z.string()).optional(),
+					env: zod.z.record(zod.z.string(), zod.z.string()).optional()
+				}),
+				tags: [
+					"mcp",
+					"stdio",
+					"integration"
+				]
+			},
+			{
+				name: "mcp-http",
+				description: "MCP server via HTTP transport",
+				uriTemplate: "mcp+http://{url+}",
+				category: "integration",
+				schema: zod.z.object({ url: zod.z.string() }),
+				tags: [
+					"mcp",
+					"http",
+					"integration"
+				]
+			},
+			{
+				name: "mcp-sse",
+				description: "MCP server via SSE transport",
+				uriTemplate: "mcp+sse://{url+}",
+				category: "integration",
+				schema: zod.z.object({ url: zod.z.string() }),
+				tags: [
+					"mcp",
+					"sse",
+					"integration"
+				]
+			}
+		];
+	}
 	/**
 	* Load module from configuration file
 	*/
-	static async load({ filepath, parsed }) {
+	static async load({ basePath, config } = {}) {
 		return new AFSMCP({
-			...await AFSMCP.schema().parseAsync(parsed),
-			cwd: (0, node_path.dirname)(filepath)
+			...await AFSMCP.schema().parseAsync(config),
+			cwd: basePath
 		});
 	}
 	/**
@@ -73,7 +109,7 @@ var AFSMCP = class AFSMCP extends _aigne_afs_provider.AFSBaseProvider {
 	* - "github://repos/owner/repo" -> { scheme: "github", path: "/repos/owner/repo" }
 	*/
 	static parseResourceUri(uri) {
-		const match = uri.match(/^(\w+):\/\/\/?(.*)$/);
+		const match = uri.match(/^([\w+.-]+):\/\/\/?(.*)$/);
 		if (match) {
 			const scheme = match[1];
 			const rest = match[2];
@@ -151,59 +187,130 @@ var AFSMCP = class AFSMCP extends _aigne_afs_provider.AFSBaseProvider {
 	constructor(options) {
 		super();
 		this.options = options;
+		if (!options.transport && options.uri) {
+			const uri = options.uri;
+			if (uri.startsWith("mcp+stdio://")) {
+				options.transport = "stdio";
+				if (!options.command) options.command = uri.slice(12).split("?")[0];
+			} else if (uri.startsWith("mcp+http://")) {
+				options.transport = "http";
+				if (!options.url) options.url = uri.replace("mcp+", "");
+			} else if (uri.startsWith("mcp+sse://")) {
+				options.transport = "sse";
+				if (!options.url) options.url = uri.replace("mcp+sse://", "http://");
+			}
+		}
+		if (typeof options.args === "string") {
+			const argsStr = options.args;
+			options.args = argsStr.includes(",") ? argsStr.split(",") : [argsStr];
+		} else if (Array.isArray(options.args)) options.args = options.args.flatMap((a) => a.includes(",") ? a.split(",") : [a]);
+		if (options.env && !Array.isArray(options.env) && typeof options.env === "string") {
+			const [key, ...rest] = options.env.split("=");
+			options.env = key ? { [key]: rest.join("=") } : {};
+		} else if (Array.isArray(options.env)) {
+			const envRecord = {};
+			for (const entry of options.env) {
+				const [key, ...rest] = entry.split("=");
+				if (key) envRecord[key] = rest.join("=");
+			}
+			options.env = envRecord;
+		}
 		(0, _aigne_afs_utils_zod.zodParse)(afsMCPOptionsSchema, options);
 		this.name = options.name || "mcp";
 		this.description = options.description;
 	}
 	/**
-	* Define static entry tree for MCP provider structure.
-	*
-	* This async method calls ensureConnected() to initialize provider state,
-	* then returns the tree with dynamic values based on connected data.
-	*
-	* Static entries:
-	* - /WORLD.md: Always present
-	* - /tools: With dynamic childrenCount
-	* - /prompts: Only if prompts exist, with dynamic childrenCount
-	* - /resources: Only if resources exist, with dynamic childrenCount
-	*/
-	async defineEntries() {
-		await this.ensureConnected();
-		const children = {
-			"WORLD.md": {
-				content: this.generateWorldMd(),
-				metadata: {
-					kind: "afs:document",
-					kinds: require_kinds.getKindsArray("afs:document"),
-					description: "MCP Server World Documentation",
-					mimeType: "text/markdown",
-					mcp: { type: "world" }
-				}
-			},
-			tools: { metadata: {
+	* List root directory children.
+	* Note: list() returns only children, never the path itself (per new semantics)
+	*/
+	async listRootHandler(_ctx) {
+		await this.ensureConnected();
+		const entries = [];
+		entries.push({
+			id: "/WORLD.md",
+			path: "/WORLD.md",
+			summary: "MCP Server World Documentation",
+			meta: {
+				kind: "afs:document",
+				kinds: require_kinds.getKindsArray("afs:document"),
+				description: "MCP Server World Documentation",
+				mimeType: "text/markdown",
+				mcp: { type: "world" }
+			}
+		});
+		entries.push({
+			id: "/tools",
+			path: "/tools",
+			summary: `${this._tools.length} tools available`,
+			meta: {
 				kind: "afs:node",
 				kinds: require_kinds.getKindsArray("afs:node"),
 				description: `${this._tools.length} tools available`,
 				childrenCount: this._tools.length
-			} }
+			}
+		});
+		if (this._prompts.length > 0) entries.push({
+			id: "/prompts",
+			path: "/prompts",
+			summary: `${this._prompts.length} prompts available`,
+			meta: {
+				kind: "afs:node",
+				kinds: require_kinds.getKindsArray("afs:node"),
+				description: `${this._prompts.length} prompts available`,
+				childrenCount: this._prompts.length
+			}
+		});
+		if (this._resources.length > 0 || this._resourceTemplates.length > 0) entries.push({
+			id: "/resources",
+			path: "/resources",
+			summary: `${this._resources.length} resources available`,
+			meta: {
+				kind: "afs:node",
+				kinds: require_kinds.getKindsArray("afs:node"),
+				description: `${this._resources.length} resources available`,
+				childrenCount: this._resources.length
+			}
+		});
+		return { data: entries };
+	}
+	/**
+	* Read root directory entry
+	*/
+	async readRootHandler(_ctx) {
+		await this.ensureConnected();
+		return {
+			id: "/",
+			path: "/",
+			summary: this.description || "MCP Server",
+			meta: {
+				kind: "mcp:module",
+				kinds: require_kinds.getKindsArray("mcp:module"),
+				description: this.description || "MCP Server",
+				childrenCount: 2 + (this._prompts.length > 0 ? 1 : 0) + (this._resources.length > 0 ? 1 : 0),
+				mcp: {
+					server: { name: this.name },
+					capabilities: {
+						tools: this._tools.length > 0,
+						prompts: this._prompts.length > 0,
+						resources: this._resources.length > 0
+					}
+				}
+			}
 		};
-		if (this._prompts.length > 0) children.prompts = { metadata: {
-			kind: "afs:node",
-			kinds: require_kinds.getKindsArray("afs:node"),
-			description: `${this._prompts.length} prompts available`,
-			childrenCount: this._prompts.length
-		} };
-		if (this._resources.length > 0 || this._resourceTemplates.length > 0) children.resources = { metadata: {
-			kind: "afs:node",
-			kinds: require_kinds.getKindsArray("afs:node"),
-			description: `${this._resources.length} resources available`,
-			childrenCount: this._resources.length
-		} };
+	}
+	/**
+	* Read root metadata
+	*/
+	async readRootMeta(_ctx) {
+		await this.ensureConnected();
 		return {
-			metadata: {
+			id: "/.meta",
+			path: "/.meta",
+			meta: {
 				kind: "mcp:module",
 				kinds: require_kinds.getKindsArray("mcp:module"),
 				description: this.description || "MCP Server",
+				childrenCount: 2 + (this._prompts.length > 0 ? 1 : 0) + (this._resources.length > 0 ? 1 : 0),
 				mcp: {
 					server: { name: this.name },
 					capabilities: {
@@ -212,10 +319,361 @@ var AFSMCP = class AFSMCP extends _aigne_afs_provider.AFSBaseProvider {
 						resources: this._resources.length > 0
 					}
 				}
+			}
+		};
+	}
+	/**
+	* Read capabilities manifest
+	*
+	* Returns all MCP tools as ToolDefinition objects.
+	* MCP has no node-level actions, so actions is always empty.
+	*/
+	async readCapabilities(_ctx) {
+		await this.ensureConnected();
+		const tools = this._tools.filter((tool) => tool.name).map((tool) => ({
+			name: tool.name,
+			description: tool.description,
+			path: `/tools/${tool.name}`,
+			inputSchema: tool.inputSchema
+		}));
+		return {
+			id: "/.meta/.capabilities",
+			path: "/.meta/.capabilities",
+			content: {
+				schemaVersion: 1,
+				provider: this.name,
+				version: "1.0.0",
+				description: this.description,
+				tools,
+				actions: [],
+				operations: this.getOperationsDeclaration()
 			},
-			children
+			meta: {
+				kind: "afs:capabilities",
+				description: "MCP Provider capabilities manifest"
+			}
+		};
+	}
+	/**
+	* Stat root directory
+	*/
+	async statRootHandler(_ctx) {
+		await this.ensureConnected();
+		const childrenCount = 2 + (this._prompts.length > 0 ? 1 : 0) + (this._resources.length > 0 ? 1 : 0);
+		return { data: {
+			id: "/",
+			path: "/",
+			meta: {
+				kind: "mcp:module",
+				kinds: require_kinds.getKindsArray("mcp:module"),
+				description: this.description || "MCP Server",
+				childrenCount
+			}
+		} };
+	}
+	/**
+	* Read WORLD.md file
+	*/
+	async readWorldMdHandler(_ctx) {
+		await this.ensureConnected();
+		return {
+			id: "/WORLD.md",
+			path: "/WORLD.md",
+			content: this.generateWorldMd(),
+			meta: {
+				kind: "afs:document",
+				kinds: require_kinds.getKindsArray("afs:document"),
+				description: "MCP Server World Documentation",
+				mimeType: "text/markdown",
+				mcp: { type: "world" }
+			}
+		};
+	}
+	/**
+	* List WORLD.md - files have no children
+	* Note: list() returns only children, never the path itself (per new semantics)
+	*/
+	async listWorldMdHandler(_ctx) {
+		await this.ensureConnected();
+		return { data: [] };
+	}
+	/**
+	* Read WORLD.md metadata
+	*/
+	async readWorldMdMeta(_ctx) {
+		await this.ensureConnected();
+		return {
+			id: "/WORLD.md/.meta",
+			path: "/WORLD.md/.meta",
+			meta: {
+				kind: "afs:document",
+				kinds: require_kinds.getKindsArray("afs:document"),
+				description: "MCP Server World Documentation",
+				mimeType: "text/markdown",
+				mcp: { type: "world" }
+			}
+		};
+	}
+	/**
+	* Read /tools directory entry
+	*/
+	async readToolsDir(_ctx) {
+		await this.ensureConnected();
+		return {
+			id: "/tools",
+			path: "/tools",
+			summary: `${this._tools.length} tools available`,
+			meta: {
+				kind: "afs:node",
+				kinds: require_kinds.getKindsArray("afs:node"),
+				description: `${this._tools.length} tools available`,
+				childrenCount: this._tools.length
+			}
+		};
+	}
+	/**
+	* Read /tools metadata
+	*/
+	async readToolsMeta(_ctx) {
+		await this.ensureConnected();
+		return {
+			id: "/tools/.meta",
+			path: "/tools/.meta",
+			meta: {
+				kind: "afs:node",
+				kinds: require_kinds.getKindsArray("afs:node"),
+				description: `${this._tools.length} tools available`,
+				childrenCount: this._tools.length
+			}
+		};
+	}
+	/**
+	* Read /prompts directory entry
+	*/
+	async readPromptsDir(_ctx) {
+		await this.ensureConnected();
+		if (this._prompts.length === 0) throw new _aigne_afs.AFSNotFoundError("/prompts");
+		return {
+			id: "/prompts",
+			path: "/prompts",
+			summary: `${this._prompts.length} prompts available`,
+			meta: {
+				kind: "afs:node",
+				kinds: require_kinds.getKindsArray("afs:node"),
+				description: `${this._prompts.length} prompts available`,
+				childrenCount: this._prompts.length
+			}
 		};
 	}
+	/**
+	* Read /prompts metadata
+	*/
+	async readPromptsMeta(_ctx) {
+		await this.ensureConnected();
+		if (this._prompts.length === 0) throw new _aigne_afs.AFSNotFoundError("/prompts/.meta");
+		return {
+			id: "/prompts/.meta",
+			path: "/prompts/.meta",
+			meta: {
+				kind: "afs:node",
+				kinds: require_kinds.getKindsArray("afs:node"),
+				description: `${this._prompts.length} prompts available`,
+				childrenCount: this._prompts.length
+			}
+		};
+	}
+	/**
+	* Read /resources directory entry
+	*/
+	async readResourcesDir(_ctx) {
+		await this.ensureConnected();
+		if (this._resources.length === 0 && this._resourceTemplates.length === 0) throw new _aigne_afs.AFSNotFoundError("/resources");
+		const immediateChildrenCount = this.getResourcesImmediateChildrenCount();
+		return {
+			id: "/resources",
+			path: "/resources",
+			summary: `${this._resources.length} resources available`,
+			meta: {
+				kind: "afs:node",
+				kinds: require_kinds.getKindsArray("afs:node"),
+				description: `${this._resources.length} resources available`,
+				childrenCount: immediateChildrenCount
+			}
+		};
+	}
+	/**
+	* Read /resources metadata
+	*/
+	async readResourcesMeta(_ctx) {
+		await this.ensureConnected();
+		if (this._resources.length === 0 && this._resourceTemplates.length === 0) throw new _aigne_afs.AFSNotFoundError("/resources/.meta");
+		const immediateChildrenCount = this.getResourcesImmediateChildrenCount();
+		return {
+			id: "/resources/.meta",
+			path: "/resources/.meta",
+			meta: {
+				kind: "afs:node",
+				kinds: require_kinds.getKindsArray("afs:node"),
+				description: `${this._resources.length} resources available`,
+				childrenCount: immediateChildrenCount
+			}
+		};
+	}
+	/**
+	* Calculate immediate children count for /resources directory
+	*/
+	getResourcesImmediateChildrenCount() {
+		const immediateChildren = /* @__PURE__ */ new Set();
+		for (const resource of this._resources) {
+			const resourcePath = this.resourceUriToPath(resource.uri);
+			if (!resourcePath) continue;
+			const segments = resourcePath.split("/").filter(Boolean);
+			if (segments.length > 0) immediateChildren.add(segments[0]);
+		}
+		return immediateChildren.size;
+	}
+	/**
+	* Stat WORLD.md file
+	*/
+	async statWorldMdHandler(_ctx) {
+		await this.ensureConnected();
+		return { data: {
+			id: "WORLD.md",
+			path: "/WORLD.md",
+			meta: {
+				kind: "afs:document",
+				kinds: require_kinds.getKindsArray("afs:document"),
+				description: "MCP Server World Documentation",
+				mimeType: "text/markdown",
+				childrenCount: 0
+			}
+		} };
+	}
+	/**
+	* Stat /tools directory
+	*/
+	async statToolsHandler(_ctx) {
+		await this.ensureConnected();
+		return { data: {
+			id: "tools",
+			path: "/tools",
+			meta: {
+				kind: "afs:node",
+				kinds: require_kinds.getKindsArray("afs:node"),
+				description: `${this._tools.length} tools available`,
+				childrenCount: this._tools.length
+			}
+		} };
+	}
+	/**
+	* Stat /prompts directory
+	*/
+	async statPromptsHandler(_ctx) {
+		await this.ensureConnected();
+		if (this._prompts.length === 0) throw new _aigne_afs.AFSNotFoundError("/prompts");
+		return { data: {
+			id: "prompts",
+			path: "/prompts",
+			meta: {
+				kind: "afs:node",
+				kinds: require_kinds.getKindsArray("afs:node"),
+				description: `${this._prompts.length} prompts available`,
+				childrenCount: this._prompts.length
+			}
+		} };
+	}
+	/**
+	* Stat /resources directory
+	*/
+	async statResourcesHandler(_ctx) {
+		await this.ensureConnected();
+		if (this._resources.length === 0 && this._resourceTemplates.length === 0) throw new _aigne_afs.AFSNotFoundError("/resources");
+		const immediateChildrenCount = this.getResourcesImmediateChildrenCount();
+		return { data: {
+			id: "resources",
+			path: "/resources",
+			meta: {
+				kind: "afs:node",
+				kinds: require_kinds.getKindsArray("afs:node"),
+				description: `${this._resources.length} resources available`,
+				childrenCount: immediateChildrenCount
+			}
+		} };
+	}
+	/**
+	* Stat specific tool
+	*/
+	async statToolHandler(ctx) {
+		await this.ensureConnected();
+		const tool = this._tools.find((t) => t.name === ctx.params.name);
+		if (!tool) throw new _aigne_afs.AFSNotFoundError(ctx.path);
+		const { content: _content, ...statData } = this.toolToEntry(tool);
+		return { data: statData };
+	}
+	/**
+	* Stat specific prompt
+	*/
+	async statPromptHandler(ctx) {
+		await this.ensureConnected();
+		const prompt = this._prompts.find((p) => p.name === ctx.params.name);
+		if (!prompt) throw new _aigne_afs.AFSNotFoundError(ctx.path);
+		const { content: _content, ...statData } = this.promptToEntry(prompt);
+		return { data: statData };
+	}
+	/**
+	* Stat resource paths (wildcard handler under /resources)
+	*/
+	async statResourceHandler(ctx) {
+		await this.ensureConnected();
+		const resourcePath = `/${ctx.params.path}`;
+		const afsPath = `/resources${resourcePath}`;
+		const resourceId = ctx.params.path.split("/").pop() || ctx.params.path;
+		const resourceMatch = this.findResourceForPath(resourcePath);
+		if (resourceMatch) {
+			if (resourceMatch.resource) return { data: {
+				id: resourceId,
+				path: afsPath,
+				meta: {
+					kind: "mcp:resource",
+					kinds: require_kinds.getKindsArray("mcp:resource"),
+					description: resourceMatch.resource.description,
+					mimeType: resourceMatch.resource.mimeType,
+					childrenCount: 0
+				}
+			} };
+			else if (resourceMatch.template) return { data: {
+				id: resourceId,
+				path: afsPath,
+				meta: {
+					kind: "mcp:resource-template",
+					kinds: require_kinds.getKindsArray("mcp:resource"),
+					description: resourceMatch.template.description,
+					mimeType: resourceMatch.template.mimeType,
+					childrenCount: 0
+				}
+			} };
+		}
+		const immediateChildren = this.getImmediateResourceChildren(resourcePath);
+		if (immediateChildren.size > 0) return { data: {
+			id: resourceId,
+			path: afsPath,
+			meta: {
+				kind: "afs:node",
+				kinds: require_kinds.getKindsArray("afs:node"),
+				childrenCount: immediateChildren.size
+			}
+		} };
+		if (this.isTemplateBasePath(resourcePath)) return { data: {
+			id: resourceId,
+			path: afsPath,
+			meta: {
+				kind: "afs:node",
+				kinds: require_kinds.getKindsArray("afs:node"),
+				childrenCount: 0
+			}
+		} };
+		throw new _aigne_afs.AFSNotFoundError(ctx.path);
+	}
 	get isConnected() {
 		return this._isConnected;
 	}
@@ -377,6 +835,35 @@ var AFSMCP = class AFSMCP extends _aigne_afs_provider.AFSBaseProvider {
 		return basePath.endsWith("/") ? basePath.slice(0, -1) : basePath;
 	}
 	/**
+	* Check if a resource path is a template base path (has dynamic children).
+	*/
+	isTemplateBasePath(resourcePath) {
+		return this._resourceTemplates.some((template) => {
+			return this.getTemplateBasePath(template.uriTemplate) === resourcePath;
+		});
+	}
+	/**
+	* Get immediate child segments under a resource parent path,
+	* scanning both static resources and template base paths.
+	*/
+	getImmediateResourceChildren(parentPath) {
+		const depth = parentPath.split("/").filter(Boolean).length;
+		const childSegments = /* @__PURE__ */ new Set();
+		for (const resource of this._resources) {
+			const rPath = this.resourceUriToPath(resource.uri);
+			if (!rPath || !rPath.startsWith(`${parentPath}/`)) continue;
+			const segments = rPath.split("/").filter(Boolean);
+			if (segments.length > depth) childSegments.add(segments[depth]);
+		}
+		for (const template of this._resourceTemplates) {
+			const basePath = this.getTemplateBasePath(template.uriTemplate);
+			if (!basePath || !basePath.startsWith(`${parentPath}/`)) continue;
+			const segments = basePath.split("/").filter(Boolean);
+			if (segments.length > depth) childSegments.add(segments[depth]);
+		}
+		return childSegments;
+	}
+	/**
 	* Find a resource or template that matches a given path
 	*/
 	findResourceForPath(path) {
@@ -398,7 +885,7 @@ var AFSMCP = class AFSMCP extends _aigne_afs_provider.AFSBaseProvider {
 			id: `/tools/${tool.name}`,
 			path: `/tools/${tool.name}`,
 			summary: tool.description,
-			metadata: {
+			meta: {
 				kind: "mcp:tool",
 				kinds: require_kinds.getKindsArray("mcp:tool"),
 				description: tool.description,
@@ -409,13 +896,15 @@ var AFSMCP = class AFSMCP extends _aigne_afs_provider.AFSBaseProvider {
 	}
 	/**
 	* Convert a Prompt to an AFSEntry (Meta Spec compliant)
+	* Note: inputSchema is NOT included in prompt entry meta.
+	* For prompts with arguments, use the action system (/.actions/get) to execute.
 	*/
 	promptToEntry(prompt) {
 		return {
 			id: `/prompts/${prompt.name}`,
 			path: `/prompts/${prompt.name}`,
 			summary: prompt.description,
-			metadata: {
+			meta: {
 				kind: "mcp:prompt",
 				kinds: require_kinds.getKindsArray("mcp:prompt"),
 				description: prompt.description,
@@ -427,6 +916,41 @@ var AFSMCP = class AFSMCP extends _aigne_afs_provider.AFSBaseProvider {
 		};
 	}
 	/**
+	* Convert prompt arguments to JSON Schema (for action inputSchema)
+	*/
+	promptArgsToSchema(args) {
+		if (!args || args.length === 0) return {
+			type: "object",
+			properties: {}
+		};
+		const properties = {};
+		const required = [];
+		for (const arg of args) {
+			properties[arg.name] = {
+				type: "string",
+				...arg.description ? { description: arg.description } : {}
+			};
+			if (arg.required) required.push(arg.name);
+		}
+		return {
+			type: "object",
+			properties,
+			...required.length > 0 ? { required } : {}
+		};
+	}
+	/**
+	* Extract text content from MCP prompt messages
+	*/
+	extractTextFromMessages(messages) {
+		const textParts = [];
+		for (const msg of messages) {
+			const c = msg.content;
+			if (typeof c === "string") textParts.push(c);
+			else if (c && typeof c === "object" && "text" in c) textParts.push(c.text);
+		}
+		return textParts.join("\n");
+	}
+	/**
 	* Convert a Resource to an AFSEntry (Meta Spec compliant)
 	*/
 	resourceToEntry(resource, path) {
@@ -434,7 +958,7 @@ var AFSMCP = class AFSMCP extends _aigne_afs_provider.AFSBaseProvider {
 			id: path,
 			path,
 			summary: resource.description || resource.name,
-			metadata: {
+			meta: {
 				kind: "mcp:resource",
 				kinds: require_kinds.getKindsArray("mcp:resource"),
 				description: resource.description,
@@ -454,7 +978,7 @@ var AFSMCP = class AFSMCP extends _aigne_afs_provider.AFSBaseProvider {
 			id: path,
 			path,
 			summary: template.description || template.name,
-			metadata: {
+			meta: {
 				kind: "mcp:resource-template",
 				kinds: require_kinds.getKindsArray("mcp:resource"),
 				description: template.description,
@@ -468,9 +992,7 @@ var AFSMCP = class AFSMCP extends _aigne_afs_provider.AFSBaseProvider {
 	}
 	/**
 	* List tools.
-	*
-	* Returns tool children only. The /tools directory entry comes from @StaticEntries
-	* and will be merged with dynamic childrenCount.
+	* Note: list() returns only children, never the path itself (per new semantics)
 	*/
 	async listToolsHandler(_ctx) {
 		await this.ensureConnected();
@@ -478,39 +1000,38 @@ var AFSMCP = class AFSMCP extends _aigne_afs_provider.AFSBaseProvider {
 	}
 	/**
 	* List prompts.
-	*
-	* Returns prompt children only. The /prompts directory entry comes from @StaticEntries
-	* and will be merged with dynamic childrenCount.
+	* Note: list() returns only children, never the path itself (per new semantics)
 	*/
 	async listPromptsHandler(_ctx) {
 		await this.ensureConnected();
+		if (this._prompts.length === 0) throw new _aigne_afs.AFSNotFoundError("/prompts");
 		return { data: this._prompts.map((prompt) => this.promptToEntry(prompt)) };
 	}
 	/**
-	* List specific tool
+	* List specific tool - tools are leaf nodes with no children
+	* Note: list() returns only children, never the path itself (per new semantics)
 	*/
 	async listToolHandler(ctx) {
 		await this.ensureConnected();
-		const tool = this._tools.find((t) => t.name === ctx.params.name);
-		if (!tool) throw new _aigne_afs.AFSNotFoundError(ctx.path);
-		return { data: [this.toolToEntry(tool)] };
+		if (!this._tools.find((t) => t.name === ctx.params.name)) throw new _aigne_afs.AFSNotFoundError(ctx.path);
+		return { data: [] };
 	}
 	/**
-	* List specific prompt
+	* List specific prompt - prompts are leaf nodes with no children
+	* Note: list() returns only children, never the path itself (per new semantics)
 	*/
 	async listPromptHandler(ctx) {
 		await this.ensureConnected();
-		const prompt = this._prompts.find((p) => p.name === ctx.params.name);
-		if (!prompt) throw new _aigne_afs.AFSNotFoundError(ctx.path);
-		return { data: [this.promptToEntry(prompt)] };
+		if (!this._prompts.find((p) => p.name === ctx.params.name)) throw new _aigne_afs.AFSNotFoundError(ctx.path);
+		return { data: [] };
 	}
 	/**
 	* List resources directory.
-	*
-	* Returns all resources as children of /resources.
+	* Note: list() returns only children, never the path itself (per new semantics)
 	*/
 	async listResourcesHandler(_ctx) {
 		await this.ensureConnected();
+		if (this._resources.length === 0 && this._resourceTemplates.length === 0) throw new _aigne_afs.AFSNotFoundError("/resources");
 		const immediateChildren = /* @__PURE__ */ new Map();
 		for (const resource of this._resources) {
 			const resourcePath = this.resourceUriToPath(resource.uri);
@@ -524,27 +1045,39 @@ var AFSMCP = class AFSMCP extends _aigne_afs_provider.AFSBaseProvider {
 			});
 			else if (!immediateChildren.has(childPath)) immediateChildren.set(childPath, { isDir: true });
 		}
+		for (const template of this._resourceTemplates) {
+			const basePath = this.getTemplateBasePath(template.uriTemplate);
+			if (!basePath) continue;
+			const segments = basePath.split("/").filter(Boolean);
+			if (segments.length === 0) continue;
+			const childPath = `/resources/${segments[0]}`;
+			if (!immediateChildren.has(childPath)) immediateChildren.set(childPath, { isDir: true });
+		}
 		const entries = [];
-		for (const [path, info] of immediateChildren) if (info.isDir) entries.push({
-			id: path,
-			path,
-			summary: `Resource directory: ${path.replace("/resources", "")}`,
-			metadata: {
-				kind: "afs:node",
-				kinds: require_kinds.getKindsArray("afs:node"),
-				mcp: { isResource: true }
-			}
-		});
-		else if (info.resource) entries.push(this.resourceToEntry(info.resource, path));
+		for (const [path, info] of immediateChildren) if (info.isDir) {
+			const resourceSubPath = path.replace("/resources", "");
+			const childrenCount = this.getImmediateResourceChildren(resourceSubPath).size;
+			entries.push({
+				id: path,
+				path,
+				summary: `Resource directory: ${resourceSubPath}`,
+				meta: {
+					kind: "afs:node",
+					kinds: require_kinds.getKindsArray("afs:node"),
+					childrenCount,
+					mcp: { isResource: true }
+				}
+			});
+		} else if (info.resource) entries.push(this.resourceToEntry(info.resource, path));
 		return { data: entries };
 	}
 	/**
 	* List resource paths (wildcard handler under /resources)
+	* Note: list() returns only children, never the path itself (per new semantics)
 	*/
 	async listResourceHandler(ctx) {
 		await this.ensureConnected();
 		const resourcePath = `/${ctx.params.path}`;
-		const afsPath = `/resources${resourcePath}`;
 		const entries = [];
 		let exactMatch = null;
 		const immediateChildren = /* @__PURE__ */ new Map();
@@ -564,32 +1097,37 @@ var AFSMCP = class AFSMCP extends _aigne_afs_provider.AFSBaseProvider {
 				else if (!immediateChildren.has(childPath)) immediateChildren.set(childPath, { isDir: true });
 			}
 		}
-		if (exactMatch) entries.push(this.resourceToEntry(exactMatch, afsPath));
-		else if (immediateChildren.size > 0) {
-			entries.push({
-				id: afsPath,
-				path: afsPath,
-				summary: `Resource directory: ${resourcePath}`,
-				metadata: {
-					kind: "afs:node",
-					kinds: require_kinds.getKindsArray("afs:node"),
-					childrenCount: immediateChildren.size,
-					mcp: { isResource: true }
-				}
-			});
-			for (const [path, info] of immediateChildren) if (info.isDir) entries.push({
-				id: path,
-				path,
-				summary: `Resource directory: ${path.replace("/resources", "")}`,
-				metadata: {
-					kind: "afs:node",
-					kinds: require_kinds.getKindsArray("afs:node"),
-					mcp: { isResource: true }
-				}
-			});
-			else if (info.resource) entries.push(this.resourceToEntry(info.resource, path));
-		} else throw new _aigne_afs.AFSNotFoundError(ctx.path);
-		return { data: entries };
+		for (const template of this._resourceTemplates) {
+			const basePath = this.getTemplateBasePath(template.uriTemplate);
+			if (!basePath) continue;
+			if (basePath === resourcePath) return { data: [] };
+			else if (basePath.startsWith(`${resourcePath}/`)) {
+				const segments = basePath.split("/").filter(Boolean);
+				if (segments.length <= depth) continue;
+				const childPath = `/resources${resourcePath}/${segments[depth]}`;
+				if (!immediateChildren.has(childPath)) immediateChildren.set(childPath, { isDir: true });
+			}
+		}
+		if (exactMatch) return { data: [] };
+		if (immediateChildren.size > 0) {
+			for (const [path, info] of immediateChildren) if (info.isDir) {
+				const resourceSubPath = path.replace("/resources", "");
+				const childrenCount = this.getImmediateResourceChildren(resourceSubPath).size;
+				entries.push({
+					id: path,
+					path,
+					summary: `Resource directory: ${resourceSubPath}`,
+					meta: {
+						kind: "afs:node",
+						kinds: require_kinds.getKindsArray("afs:node"),
+						childrenCount,
+						mcp: { isResource: true }
+					}
+				});
+			} else if (info.resource) entries.push(this.resourceToEntry(info.resource, path));
+			return { data: entries };
+		}
+		throw new _aigne_afs.AFSNotFoundError(ctx.path);
 	}
 	/**
 	* Read metadata for tools (dynamic entries not in static tree).
@@ -603,7 +1141,7 @@ var AFSMCP = class AFSMCP extends _aigne_afs_provider.AFSBaseProvider {
 		return {
 			id: `/tools/${ctx.params.name}/.meta`,
 			path: `/tools/${ctx.params.name}/.meta`,
-			metadata: entry.metadata
+			meta: entry.meta
 		};
 	}
 	/**
@@ -617,7 +1155,7 @@ var AFSMCP = class AFSMCP extends _aigne_afs_provider.AFSBaseProvider {
 		return {
 			id: `/prompts/${ctx.params.name}/.meta`,
 			path: `/prompts/${ctx.params.name}/.meta`,
-			metadata: entry.metadata
+			meta: entry.meta
 		};
 	}
 	/**
@@ -633,25 +1171,31 @@ var AFSMCP = class AFSMCP extends _aigne_afs_provider.AFSBaseProvider {
 			if (resourceMatch.resource) return {
 				id: metaPath,
 				path: metaPath,
-				metadata: this.resourceToEntry(resourceMatch.resource, `/resources${resourcePath}`).metadata
+				meta: this.resourceToEntry(resourceMatch.resource, `/resources${resourcePath}`).meta
 			};
 			else if (resourceMatch.template) return {
 				id: metaPath,
 				path: metaPath,
-				metadata: this.resourceTemplateToEntry(resourceMatch.template, `/resources${resourcePath}`).metadata
+				meta: this.resourceTemplateToEntry(resourceMatch.template, `/resources${resourcePath}`).meta
 			};
 		}
-		if (this._resources.some((resource) => {
-			return this.resourceUriToPath(resource.uri)?.startsWith(`${resourcePath}/`);
-		})) return {
+		if (this.getImmediateResourceChildren(resourcePath).size > 0) return {
 			id: metaPath,
 			path: metaPath,
-			metadata: {
+			meta: {
 				kind: "afs:node",
 				kinds: require_kinds.getKindsArray("afs:node"),
 				mcp: { isResource: true }
 			}
 		};
+		if (this.isTemplateBasePath(resourcePath)) {
+			const template = this._resourceTemplates.find((t) => this.getTemplateBasePath(t.uriTemplate) === resourcePath);
+			if (template) return {
+				id: metaPath,
+				path: metaPath,
+				meta: this.resourceTemplateToEntry(template, `/resources${resourcePath}`).meta
+			};
+		}
 		throw new _aigne_afs.AFSNotFoundError(ctx.path);
 	}
 	/**
@@ -665,12 +1209,195 @@ var AFSMCP = class AFSMCP extends _aigne_afs_provider.AFSBaseProvider {
 	}
 	/**
 	* Read prompt
+	*
+	* Behavior:
+	* - Prompts with NO arguments: returns content directly
+	* - Prompts with ONLY optional arguments: returns content (empty params)
+	* - Prompts with REQUIRED arguments: returns metadata only (use /.actions/get to execute)
 	*/
 	async readPromptHandler(ctx) {
 		await this.ensureConnected();
 		const prompt = this._prompts.find((p) => p.name === ctx.params.name);
 		if (!prompt) throw new _aigne_afs.AFSNotFoundError(ctx.path);
-		return this.promptToEntry(prompt);
+		const entry = this.promptToEntry(prompt);
+		const hasRequiredArgs = prompt.arguments?.some((arg) => arg.required) ?? false;
+		if (this.client && !hasRequiredArgs) try {
+			const result = await this.client.getPrompt({
+				name: prompt.name,
+				arguments: {}
+			});
+			const content = this.extractTextFromMessages(result.messages);
+			if (content) entry.content = content;
+		} catch {}
+		return entry;
+	}
+	/**
+	* List actions for a prompt
+	*
+	* Only prompts with arguments expose a "get" action.
+	*/
+	async listPromptActions(ctx) {
+		await this.ensureConnected();
+		const prompt = this._prompts.find((p) => p.name === ctx.params.name);
+		if (!prompt) throw new _aigne_afs.AFSNotFoundError(ctx.path);
+		if (!prompt.arguments || prompt.arguments.length === 0) return { data: [] };
+		return { data: [{
+			id: "get",
+			path: `/prompts/${prompt.name}/.actions/get`,
+			summary: `Get ${prompt.name} prompt content with arguments`,
+			meta: {
+				kind: "afs:executable",
+				kinds: require_kinds.getKindsArray("afs:executable"),
+				name: "get",
+				description: prompt.description,
+				inputSchema: this.promptArgsToSchema(prompt.arguments)
+			}
+		}] };
+	}
+	/**
+	* Execute prompt "get" action
+	*
+	* Fetches prompt content with provided arguments.
+	*/
+	async execPromptGetHandler(ctx, params) {
+		await this.ensureConnected();
+		const prompt = this._prompts.find((p) => p.name === ctx.params.name);
+		if (!prompt) return {
+			success: false,
+			error: {
+				code: "NOT_FOUND",
+				message: `Prompt not found: ${ctx.params.name}`
+			}
+		};
+		if (!this.client) return {
+			success: false,
+			error: {
+				code: "NOT_CONNECTED",
+				message: "MCP client not connected"
+			}
+		};
+		try {
+			const result = await this.client.getPrompt({
+				name: prompt.name,
+				arguments: params
+			});
+			return {
+				success: true,
+				data: {
+					content: this.extractTextFromMessages(result.messages),
+					meta: { mcp: {
+						name: prompt.name,
+						arguments: prompt.arguments
+					} }
+				}
+			};
+		} catch (error) {
+			return {
+				success: false,
+				error: {
+					code: "EXECUTION_ERROR",
+					message: error.message
+				}
+			};
+		}
+	}
+	/**
+	* List actions for a resource template
+	*
+	* Only resource templates expose a "get" action.
+	* Static resources do not have actions.
+	*/
+	async listResourceActions(ctx) {
+		await this.ensureConnected();
+		const resourcePath = `/${ctx.params.path}`;
+		if (!this.isTemplateBasePath(resourcePath)) return { data: [] };
+		const template = this._resourceTemplates.find((t) => this.getTemplateBasePath(t.uriTemplate) === resourcePath);
+		if (!template) return { data: [] };
+		const vars = AFSMCP.parseUriTemplate(template.uriTemplate);
+		if (vars.length === 0) return { data: [] };
+		const properties = {};
+		for (const v of vars) properties[v] = {
+			type: "string",
+			description: `Template variable: ${v}`
+		};
+		const inputSchema = {
+			type: "object",
+			properties,
+			required: vars
+		};
+		return { data: [{
+			id: "get",
+			path: `${`/resources${resourcePath}`}/.actions/get`,
+			summary: `Get resource with template parameters`,
+			meta: {
+				kind: "afs:executable",
+				kinds: require_kinds.getKindsArray("afs:executable"),
+				name: "get",
+				description: template.description,
+				inputSchema
+			}
+		}] };
+	}
+	/**
+	* Execute resource template "get" action
+	*
+	* Fetches resource content with provided template parameters.
+	*/
+	async execResourceGetHandler(ctx, params) {
+		await this.ensureConnected();
+		const resourcePath = `/${ctx.params.path}`;
+		if (!this.isTemplateBasePath(resourcePath)) return {
+			success: false,
+			error: {
+				code: "NOT_TEMPLATE",
+				message: `Not a resource template: ${resourcePath}`
+			}
+		};
+		const template = this._resourceTemplates.find((t) => this.getTemplateBasePath(t.uriTemplate) === resourcePath);
+		if (!template) return {
+			success: false,
+			error: {
+				code: "NOT_FOUND",
+				message: `Resource template not found: ${resourcePath}`
+			}
+		};
+		if (!this.client) return {
+			success: false,
+			error: {
+				code: "NOT_CONNECTED",
+				message: "MCP client not connected"
+			}
+		};
+		try {
+			const uri = AFSMCP.buildUriFromTemplate(template.uriTemplate, params);
+			const result = await this.readResourceByUri(uri);
+			if (!result.data) return {
+				success: false,
+				error: {
+					code: "NOT_FOUND",
+					message: result.message || "Resource not found"
+				}
+			};
+			return {
+				success: true,
+				data: {
+					content: result.data.content,
+					meta: { mcp: {
+						uri,
+						name: template.name,
+						uriTemplate: template.uriTemplate
+					} }
+				}
+			};
+		} catch (error) {
+			return {
+				success: false,
+				error: {
+					code: "EXECUTION_ERROR",
+					message: error.message
+				}
+			};
+		}
 	}
 	/**
 	* Read resource (wildcard handler under /resources)
@@ -696,18 +1423,38 @@ var AFSMCP = class AFSMCP extends _aigne_afs_provider.AFSBaseProvider {
 				return result.data;
 			}
 		}
-		if (this._resources.some((resource) => {
-			return this.resourceUriToPath(resource.uri)?.startsWith(`${resourcePath}/`);
-		})) return {
+		const immediateChildrenSet = this.getImmediateResourceChildren(resourcePath);
+		if (immediateChildrenSet.size > 0) return {
 			id: afsPath,
 			path: afsPath,
 			summary: `Resource directory: ${resourcePath}`,
-			metadata: {
+			meta: {
 				kind: "afs:node",
 				kinds: require_kinds.getKindsArray("afs:node"),
+				childrenCount: immediateChildrenSet.size,
 				mcp: { isResource: true }
 			}
 		};
+		if (this.isTemplateBasePath(resourcePath)) {
+			const template = this._resourceTemplates.find((t) => this.getTemplateBasePath(t.uriTemplate) === resourcePath);
+			return {
+				id: afsPath,
+				path: afsPath,
+				summary: template?.description || `Resource template: ${resourcePath}`,
+				meta: {
+					kind: "mcp:resource-template",
+					kinds: require_kinds.getKindsArray("mcp:resource"),
+					description: template?.description,
+					mimeType: template?.mimeType,
+					childrenCount: 0,
+					mcp: {
+						uriTemplate: template?.uriTemplate,
+						name: template?.name,
+						parameters: template ? AFSMCP.parseUriTemplate(template.uriTemplate) : []
+					}
+				}
+			};
+		}
 		throw new _aigne_afs.AFSNotFoundError(ctx.path);
 	}
 	/**
@@ -733,7 +1480,7 @@ var AFSMCP = class AFSMCP extends _aigne_afs_provider.AFSBaseProvider {
 				id: path,
 				path,
 				content,
-				metadata: { mcp: {
+				meta: { mcp: {
 					uri,
 					mimeType
 				} }
@@ -777,7 +1524,7 @@ var AFSMCP = class AFSMCP extends _aigne_afs_provider.AFSBaseProvider {
 				path: `/prompts/${promptName}`,
 				summary: prompt.description,
 				content: result.messages,
-				metadata: {
+				meta: {
 					arguments: prompt.arguments,
 					mcp: {
 						name: prompt.name,
@@ -898,6 +1645,191 @@ var AFSMCP = class AFSMCP extends _aigne_afs_provider.AFSBaseProvider {
 		return lines.join("\n");
 	}
 	/**
+	* Explain root → server name, tools/prompts/resources counts
+	*/
+	async explainRoot(_ctx) {
+		await this.ensureConnected();
+		const lines = [];
+		lines.push(`# ${this.name}`);
+		lines.push("");
+		if (this.description) {
+			lines.push(this.description);
+			lines.push("");
+		}
+		lines.push("## Overview");
+		lines.push("");
+		lines.push(`- **Tool count**: ${this._tools.length}`);
+		lines.push(`- **Prompt count**: ${this._prompts.length}`);
+		lines.push(`- **Resource count**: ${this._resources.length}`);
+		lines.push(`- **Resource template count**: ${this._resourceTemplates.length}`);
+		lines.push("");
+		if (this._tools.length > 0) {
+			lines.push("## Tools");
+			lines.push("");
+			for (const tool of this._tools) lines.push(`- **${tool.name}**: ${tool.description ?? "(no description)"}`);
+			lines.push("");
+		}
+		if (this._prompts.length > 0) {
+			lines.push("## Prompts");
+			lines.push("");
+			for (const prompt of this._prompts) {
+				const argNames = prompt.arguments?.map((a) => a.name).join(", ") ?? "";
+				lines.push(`- **${prompt.name}**: ${prompt.description ?? "(no description)"}${argNames ? ` (args: ${argNames})` : ""}`);
+			}
+			lines.push("");
+		}
+		if (this._resources.length > 0) {
+			lines.push("## Resources");
+			lines.push("");
+			for (const resource of this._resources) lines.push(`- **${resource.name}**: ${resource.description ?? resource.uri}`);
+			lines.push("");
+		}
+		return {
+			format: "markdown",
+			content: lines.join("\n")
+		};
+	}
+	/**
+	* Explain a specific tool → name, description, inputSchema
+	*/
+	async explainTool(ctx) {
+		await this.ensureConnected();
+		const tool = this._tools.find((t) => t.name === ctx.params.name);
+		if (!tool) throw new _aigne_afs.AFSNotFoundError(ctx.path, `Tool not found: ${ctx.params.name}`);
+		const lines = [];
+		lines.push(`# Tool: ${tool.name}`);
+		lines.push("");
+		if (tool.description) {
+			lines.push(tool.description);
+			lines.push("");
+		}
+		if (tool.inputSchema) {
+			lines.push("## Input Schema");
+			lines.push("");
+			lines.push("```json");
+			lines.push(JSON.stringify(tool.inputSchema, null, 2));
+			lines.push("```");
+			lines.push("");
+			const props = tool.inputSchema.properties;
+			if (props) {
+				lines.push("## Parameters");
+				lines.push("");
+				for (const [key, val] of Object.entries(props)) {
+					const prop = val;
+					lines.push(`- **${key}** (${prop.type ?? "unknown"}): ${prop.description ?? "(no description)"}`);
+				}
+				lines.push("");
+			}
+		}
+		return {
+			format: "markdown",
+			content: lines.join("\n")
+		};
+	}
+	/**
+	* Explain a specific prompt → name, description, arguments
+	*/
+	async explainPrompt(ctx) {
+		await this.ensureConnected();
+		const prompt = this._prompts.find((p) => p.name === ctx.params.name);
+		if (!prompt) throw new _aigne_afs.AFSNotFoundError(ctx.path, `Prompt not found: ${ctx.params.name}`);
+		const lines = [];
+		lines.push(`# Prompt: ${prompt.name}`);
+		lines.push("");
+		if (prompt.description) {
+			lines.push(prompt.description);
+			lines.push("");
+		}
+		if (prompt.arguments && prompt.arguments.length > 0) {
+			lines.push("## Arguments");
+			lines.push("");
+			for (const arg of prompt.arguments) {
+				const required = arg.required ? " (required)" : " (optional)";
+				lines.push(`- **${arg.name}**${required}: ${arg.description ?? "(no description)"}`);
+			}
+			lines.push("");
+		} else {
+			lines.push("*No arguments required.*");
+			lines.push("");
+		}
+		return {
+			format: "markdown",
+			content: lines.join("\n")
+		};
+	}
+	/**
+	* Explain a specific resource → name, URI, description
+	*/
+	async explainResource(ctx) {
+		await this.ensureConnected();
+		const resourcePath = `/${ctx.params.path}`;
+		const resourceMatch = this.findResourceForPath(resourcePath);
+		if (resourceMatch?.resource) {
+			const resource = resourceMatch.resource;
+			const lines = [];
+			lines.push(`# Resource: ${resource.name}`);
+			lines.push("");
+			if (resource.description) {
+				lines.push(resource.description);
+				lines.push("");
+			}
+			lines.push(`- **URI**: ${resource.uri}`);
+			if (resource.mimeType) lines.push(`- **MIME Type**: ${resource.mimeType}`);
+			lines.push("");
+			return {
+				format: "markdown",
+				content: lines.join("\n")
+			};
+		}
+		if (resourceMatch?.template) {
+			const template = resourceMatch.template;
+			const lines = [];
+			lines.push(`# Resource Template: ${template.name}`);
+			lines.push("");
+			if (template.description) {
+				lines.push(template.description);
+				lines.push("");
+			}
+			lines.push(`- **URI Template**: ${template.uriTemplate}`);
+			const vars = AFSMCP.parseUriTemplate(template.uriTemplate);
+			if (vars.length > 0) lines.push(`- **Variables**: ${vars.join(", ")}`);
+			lines.push("");
+			return {
+				format: "markdown",
+				content: lines.join("\n")
+			};
+		}
+		throw new _aigne_afs.AFSNotFoundError(ctx.path, `Resource not found: ${ctx.path}`);
+	}
+	/**
+	* Search tools, prompts, and resources by name or description
+	*/
+	async searchHandler(_ctx, query, options) {
+		await this.ensureConnected();
+		const results = [];
+		const limit = options?.limit;
+		const escapedQuery = query.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+		const flags = options?.caseSensitive ? "" : "i";
+		const pattern = new RegExp(escapedQuery, flags);
+		const matchAll = query === "";
+		for (const tool of this._tools) {
+			if (limit && results.length >= limit) break;
+			if (matchAll || pattern.test(tool.name) || tool.description && pattern.test(tool.description)) results.push(this.toolToEntry(tool));
+		}
+		for (const prompt of this._prompts) {
+			if (limit && results.length >= limit) break;
+			if (matchAll || pattern.test(prompt.name) || prompt.description && pattern.test(prompt.description)) results.push(this.promptToEntry(prompt));
+		}
+		for (const resource of this._resources) {
+			if (limit && results.length >= limit) break;
+			if (matchAll || pattern.test(resource.name) || resource.description && pattern.test(resource.description)) {
+				const path = this.resourceUriToPath(resource.uri);
+				results.push(this.resourceToEntry(resource, `/resources${path}`));
+			}
+		}
+		return { data: results };
+	}
+	/**
 	* Execute a tool
 	*/
 	async execToolHandler(ctx, args) {
@@ -913,7 +1845,27 @@ var AFSMCP = class AFSMCP extends _aigne_afs_provider.AFSBaseProvider {
 		};
 	}
 };
-require_decorate.__decorate([(0, _aigne_afs_provider.StaticEntries)()], AFSMCP.prototype, "defineEntries", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.List)("/")], AFSMCP.prototype, "listRootHandler", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Read)("/")], AFSMCP.prototype, "readRootHandler", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Meta)("/")], AFSMCP.prototype, "readRootMeta", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Read)("/.meta/.capabilities")], AFSMCP.prototype, "readCapabilities", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Stat)("/")], AFSMCP.prototype, "statRootHandler", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Read)("/WORLD.md")], AFSMCP.prototype, "readWorldMdHandler", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.List)("/WORLD.md")], AFSMCP.prototype, "listWorldMdHandler", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Meta)("/WORLD.md")], AFSMCP.prototype, "readWorldMdMeta", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Read)("/tools")], AFSMCP.prototype, "readToolsDir", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Meta)("/tools")], AFSMCP.prototype, "readToolsMeta", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Read)("/prompts")], AFSMCP.prototype, "readPromptsDir", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Meta)("/prompts")], AFSMCP.prototype, "readPromptsMeta", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Read)("/resources")], AFSMCP.prototype, "readResourcesDir", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Meta)("/resources")], AFSMCP.prototype, "readResourcesMeta", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Stat)("/WORLD.md")], AFSMCP.prototype, "statWorldMdHandler", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Stat)("/tools")], AFSMCP.prototype, "statToolsHandler", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Stat)("/prompts")], AFSMCP.prototype, "statPromptsHandler", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Stat)("/resources")], AFSMCP.prototype, "statResourcesHandler", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Stat)("/tools/:name")], AFSMCP.prototype, "statToolHandler", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Stat)("/prompts/:name")], AFSMCP.prototype, "statPromptHandler", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Stat)("/resources/:path+")], AFSMCP.prototype, "statResourceHandler", null);
 require_decorate.__decorate([(0, _aigne_afs_provider.List)("/tools")], AFSMCP.prototype, "listToolsHandler", null);
 require_decorate.__decorate([(0, _aigne_afs_provider.List)("/prompts")], AFSMCP.prototype, "listPromptsHandler", null);
 require_decorate.__decorate([(0, _aigne_afs_provider.List)("/tools/:name")], AFSMCP.prototype, "listToolHandler", null);
@@ -925,8 +1877,19 @@ require_decorate.__decorate([(0, _aigne_afs_provider.Meta)("/prompts/:name")], A
 require_decorate.__decorate([(0, _aigne_afs_provider.Meta)("/resources/:path+")], AFSMCP.prototype, "readResourceMeta", null);
 require_decorate.__decorate([(0, _aigne_afs_provider.Read)("/tools/:name")], AFSMCP.prototype, "readToolHandler", null);
 require_decorate.__decorate([(0, _aigne_afs_provider.Read)("/prompts/:name")], AFSMCP.prototype, "readPromptHandler", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Actions)("/prompts/:name")], AFSMCP.prototype, "listPromptActions", null);
+require_decorate.__decorate([_aigne_afs_provider.Actions.Exec("/prompts/:name", "get")], AFSMCP.prototype, "execPromptGetHandler", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Actions)("/resources/:path+")], AFSMCP.prototype, "listResourceActions", null);
+require_decorate.__decorate([_aigne_afs_provider.Actions.Exec("/resources/:path+", "get")], AFSMCP.prototype, "execResourceGetHandler", null);
 require_decorate.__decorate([(0, _aigne_afs_provider.Read)("/resources/:path+")], AFSMCP.prototype, "readResourceHandler", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Explain)("/")], AFSMCP.prototype, "explainRoot", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Explain)("/tools/:name")], AFSMCP.prototype, "explainTool", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Explain)("/prompts/:name")], AFSMCP.prototype, "explainPrompt", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Explain)("/resources/:path+")], AFSMCP.prototype, "explainResource", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Search)("/:path*")], AFSMCP.prototype, "searchHandler", null);
 require_decorate.__decorate([(0, _aigne_afs_provider.Exec)("/tools/:name")], AFSMCP.prototype, "execToolHandler", null);
+var src_default = AFSMCP;
 
 //#endregion
-exports.AFSMCP = AFSMCP;
+exports.AFSMCP = AFSMCP;
+exports.default = src_default;