@aigne/afs-mcp 1.11.0-beta.6

package/dist/index.cjs

@@ -0,0 +1,932 @@
+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");
+let _modelcontextprotocol_sdk_client_index_js = require("@modelcontextprotocol/sdk/client/index.js");
+let _modelcontextprotocol_sdk_client_sse_js = require("@modelcontextprotocol/sdk/client/sse.js");
+let _modelcontextprotocol_sdk_client_stdio_js = require("@modelcontextprotocol/sdk/client/stdio.js");
+let _modelcontextprotocol_sdk_client_streamableHttp_js = require("@modelcontextprotocol/sdk/client/streamableHttp.js");
+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({
+	name: (0, _aigne_afs_utils_zod.optionalize)(zod.z.string()),
+	description: (0, _aigne_afs_utils_zod.optionalize)(zod.z.string()),
+	transport: zod.z.enum([
+		"stdio",
+		"http",
+		"sse"
+	]),
+	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())),
+	url: (0, _aigne_afs_utils_zod.optionalize)(zod.z.string()),
+	headers: (0, _aigne_afs_utils_zod.optionalize)(zod.z.record(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) => {
+	if (data.transport === "stdio" && !data.command) return false;
+	if ((data.transport === "http" || data.transport === "sse") && !data.url) return false;
+	return true;
+}, { message: "stdio transport requires 'command', http/sse transport requires 'url'" }));
+/**
+* AFS Module for MCP Server integration
+*/
+var AFSMCP = class AFSMCP extends _aigne_afs_provider.AFSBaseProvider {
+	name;
+	description;
+	accessMode = "readwrite";
+	/**
+	* Get the Zod schema for options validation
+	*/
+	static schema() {
+		return afsMCPOptionsSchema;
+	}
+	/**
+	* Load module from configuration file
+	*/
+	static async load({ filepath, parsed }) {
+		return new AFSMCP({
+			...await AFSMCP.schema().parseAsync(parsed),
+			cwd: (0, node_path.dirname)(filepath)
+		});
+	}
+	/**
+	* Parse a resource URI into its components
+	*
+	* Examples:
+	* - "file:///path/to/file.txt" -> { scheme: "file", path: "/path/to/file.txt" }
+	* - "sqlite://posts" -> { scheme: "sqlite", path: "/posts" }
+	* - "github://repos/owner/repo" -> { scheme: "github", path: "/repos/owner/repo" }
+	*/
+	static parseResourceUri(uri) {
+		const match = uri.match(/^(\w+):\/\/\/?(.*)$/);
+		if (match) {
+			const scheme = match[1];
+			const rest = match[2];
+			return {
+				scheme,
+				path: rest.startsWith("/") ? rest : `/${rest}`
+			};
+		}
+		return {
+			scheme: "unknown",
+			path: uri
+		};
+	}
+	/**
+	* Parse a URI template and extract variable names
+	*
+	* Examples:
+	* - "sqlite://posts/{id}" -> ["id"]
+	* - "github://repos/{owner}/{repo}/issues/{number}" -> ["owner", "repo", "number"]
+	*/
+	static parseUriTemplate(template) {
+		const vars = [];
+		const regex = /\{(\w+)\}/g;
+		let match = regex.exec(template);
+		while (match !== null) {
+			vars.push(match[1]);
+			match = regex.exec(template);
+		}
+		return vars;
+	}
+	/**
+	* Match a path against a URI template and extract parameters
+	*
+	* Examples:
+	* - matchPathToTemplate("/posts/123", "sqlite://posts/{id}") -> { id: "123" }
+	* - matchPathToTemplate("/repos/arcblock/afs/issues/42", "github://repos/{owner}/{repo}/issues/{number}")
+	*   -> { owner: "arcblock", repo: "afs", number: "42" }
+	*
+	* Returns null if path doesn't match the template
+	*/
+	static matchPathToTemplate(path, uriTemplate) {
+		const templatePath = AFSMCP.parseResourceUri(uriTemplate).path;
+		const vars = [];
+		const regexStr = templatePath.replace(/\{(\w+)\}/g, (_, varName) => {
+			vars.push(varName);
+			return "([^/]+)";
+		});
+		const regex = /* @__PURE__ */ new RegExp(`^${regexStr}$`);
+		const match = path.match(regex);
+		if (!match) return null;
+		const params = {};
+		for (let i = 0; i < vars.length; i++) {
+			const varName = vars[i];
+			const value = match[i + 1];
+			if (varName && value) params[varName] = value;
+		}
+		return params;
+	}
+	/**
+	* Build a complete URI from a template and parameters
+	*/
+	static buildUriFromTemplate(template, params) {
+		let uri = template;
+		for (const [key, value] of Object.entries(params)) uri = uri.replace(`{${key}}`, value);
+		return uri;
+	}
+	client = null;
+	transport = null;
+	_tools = [];
+	_prompts = [];
+	_resources = [];
+	_resourceTemplates = [];
+	_resourcePathMap = /* @__PURE__ */ new Map();
+	_isConnected = false;
+	constructor(options) {
+		super();
+		this.options = options;
+		(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: {
+				kind: "afs:node",
+				kinds: require_kinds.getKindsArray("afs:node"),
+				description: `${this._tools.length} tools available`,
+				childrenCount: this._tools.length
+			} }
+		};
+		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
+		} };
+		return {
+			metadata: {
+				kind: "mcp:module",
+				kinds: require_kinds.getKindsArray("mcp:module"),
+				description: this.description || "MCP Server",
+				mcp: {
+					server: { name: this.name },
+					capabilities: {
+						tools: this._tools.length > 0,
+						prompts: this._prompts.length > 0,
+						resources: this._resources.length > 0
+					}
+				}
+			},
+			children
+		};
+	}
+	get isConnected() {
+		return this._isConnected;
+	}
+	/**
+	* Get cached tools
+	*/
+	get tools() {
+		return this._tools;
+	}
+	/**
+	* Get cached prompts
+	*/
+	get prompts() {
+		return this._prompts;
+	}
+	/**
+	* Get cached resources
+	*/
+	get resources() {
+		return this._resources;
+	}
+	/**
+	* Get cached resource templates
+	*/
+	get resourceTemplates() {
+		return this._resourceTemplates;
+	}
+	/** Promise for in-progress connection */
+	_connectPromise = null;
+	/**
+	* Ensure connection is established (lazy connect)
+	*/
+	async ensureConnected() {
+		if (this._isConnected) return;
+		if (this._connectPromise) return this._connectPromise;
+		this._connectPromise = this.connect();
+		try {
+			await this._connectPromise;
+		} finally {
+			this._connectPromise = null;
+		}
+	}
+	/**
+	* Connect to the MCP server
+	*/
+	async connect() {
+		if (this._isConnected) return;
+		this.transport = this.createTransport();
+		this.client = new _modelcontextprotocol_sdk_client_index_js.Client({
+			name: "afs-mcp-client",
+			version: "1.0.0"
+		}, { capabilities: {} });
+		await this.client.connect(this.transport);
+		this._isConnected = true;
+		await this.refreshCapabilities();
+		this.buildResourcePathMap();
+	}
+	/**
+	* Disconnect from the MCP server
+	*/
+	async disconnect() {
+		if (!this._isConnected) return;
+		try {
+			await this.client?.close();
+		} catch (error) {
+			if (!(error instanceof Error && (error.message.includes("EPIPE") || error.code === "EPIPE"))) throw error;
+		}
+		this.client = null;
+		this.transport = null;
+		this._isConnected = false;
+		this._tools = [];
+		this._prompts = [];
+		this._resources = [];
+		this._resourceTemplates = [];
+		this._resourcePathMap.clear();
+	}
+	/**
+	* Create transport based on configuration
+	*/
+	createTransport() {
+		switch (this.options.transport) {
+			case "stdio": return new _modelcontextprotocol_sdk_client_stdio_js.StdioClientTransport({
+				command: this.options.command,
+				args: this.options.args,
+				env: {
+					...process.env,
+					...this.options.env
+				},
+				stderr: "pipe"
+			});
+			case "http": return new _modelcontextprotocol_sdk_client_streamableHttp_js.StreamableHTTPClientTransport(new URL(this.options.url), { requestInit: { headers: this.options.headers } });
+			case "sse": return new _modelcontextprotocol_sdk_client_sse_js.SSEClientTransport(new URL(this.options.url), { requestInit: { headers: this.options.headers } });
+			default: throw new Error(`Unknown transport: ${this.options.transport}`);
+		}
+	}
+	/**
+	* Refresh cached capabilities from the server
+	*/
+	async refreshCapabilities() {
+		if (!this.client) return;
+		try {
+			this._tools = (await this.client.listTools()).tools || [];
+		} catch {
+			this._tools = [];
+		}
+		try {
+			this._prompts = (await this.client.listPrompts()).prompts || [];
+		} catch {
+			this._prompts = [];
+		}
+		try {
+			this._resources = (await this.client.listResources()).resources || [];
+		} catch {
+			this._resources = [];
+		}
+		try {
+			this._resourceTemplates = (await this.client.listResourceTemplates()).resourceTemplates || [];
+		} catch {
+			this._resourceTemplates = [];
+		}
+	}
+	/**
+	* Build the resource path mapping from cached resources
+	*/
+	buildResourcePathMap() {
+		this._resourcePathMap.clear();
+		for (const resource of this._resources) {
+			const path = this.resourceUriToPath(resource.uri);
+			if (path) this._resourcePathMap.set(path, { resource });
+		}
+		for (const template of this._resourceTemplates) {
+			const basePath = this.getTemplateBasePath(template.uriTemplate);
+			if (basePath) this._resourcePathMap.set(basePath, { template });
+		}
+	}
+	/**
+	* Convert a resource URI to an AFS path
+	*
+	* Examples:
+	* - "file:///path/to/file.txt" -> "/path/to/file.txt"
+	* - "sqlite://posts" -> "/posts"
+	* - "github://repos" -> "/repos"
+	*/
+	resourceUriToPath(uri) {
+		return AFSMCP.parseResourceUri(uri).path;
+	}
+	/**
+	* Get the base path from a URI template (path before first variable)
+	*
+	* Examples:
+	* - "sqlite://posts/{id}" -> "/posts"
+	* - "github://repos/{owner}/{repo}" -> "/repos"
+	*/
+	getTemplateBasePath(uriTemplate) {
+		const parsed = AFSMCP.parseResourceUri(uriTemplate);
+		const varIndex = parsed.path.indexOf("{");
+		if (varIndex === -1) return parsed.path;
+		const basePath = parsed.path.substring(0, varIndex);
+		return basePath.endsWith("/") ? basePath.slice(0, -1) : basePath;
+	}
+	/**
+	* Find a resource or template that matches a given path
+	*/
+	findResourceForPath(path) {
+		for (const resource of this._resources) if (this.resourceUriToPath(resource.uri) === path) return { resource };
+		for (const template of this._resourceTemplates) {
+			const params = AFSMCP.matchPathToTemplate(path, template.uriTemplate);
+			if (params) return {
+				template,
+				params
+			};
+		}
+		return null;
+	}
+	/**
+	* Convert a Tool to an AFSEntry (Meta Spec compliant)
+	*/
+	toolToEntry(tool) {
+		return {
+			id: `/tools/${tool.name}`,
+			path: `/tools/${tool.name}`,
+			summary: tool.description,
+			metadata: {
+				kind: "mcp:tool",
+				kinds: require_kinds.getKindsArray("mcp:tool"),
+				description: tool.description,
+				inputSchema: tool.inputSchema,
+				mcp: { name: tool.name }
+			}
+		};
+	}
+	/**
+	* Convert a Prompt to an AFSEntry (Meta Spec compliant)
+	*/
+	promptToEntry(prompt) {
+		return {
+			id: `/prompts/${prompt.name}`,
+			path: `/prompts/${prompt.name}`,
+			summary: prompt.description,
+			metadata: {
+				kind: "mcp:prompt",
+				kinds: require_kinds.getKindsArray("mcp:prompt"),
+				description: prompt.description,
+				mcp: {
+					name: prompt.name,
+					arguments: prompt.arguments
+				}
+			}
+		};
+	}
+	/**
+	* Convert a Resource to an AFSEntry (Meta Spec compliant)
+	*/
+	resourceToEntry(resource, path) {
+		return {
+			id: path,
+			path,
+			summary: resource.description || resource.name,
+			metadata: {
+				kind: "mcp:resource",
+				kinds: require_kinds.getKindsArray("mcp:resource"),
+				description: resource.description,
+				mimeType: resource.mimeType,
+				mcp: {
+					uri: resource.uri,
+					name: resource.name
+				}
+			}
+		};
+	}
+	/**
+	* Convert a ResourceTemplate to an AFSEntry (Meta Spec compliant)
+	*/
+	resourceTemplateToEntry(template, path) {
+		return {
+			id: path,
+			path,
+			summary: template.description || template.name,
+			metadata: {
+				kind: "mcp:resource-template",
+				kinds: require_kinds.getKindsArray("mcp:resource"),
+				description: template.description,
+				mimeType: template.mimeType,
+				mcp: {
+					uriTemplate: template.uriTemplate,
+					name: template.name
+				}
+			}
+		};
+	}
+	/**
+	* List tools.
+	*
+	* Returns tool children only. The /tools directory entry comes from @StaticEntries
+	* and will be merged with dynamic childrenCount.
+	*/
+	async listToolsHandler(_ctx) {
+		await this.ensureConnected();
+		return { data: this._tools.map((tool) => this.toolToEntry(tool)) };
+	}
+	/**
+	* List prompts.
+	*
+	* Returns prompt children only. The /prompts directory entry comes from @StaticEntries
+	* and will be merged with dynamic childrenCount.
+	*/
+	async listPromptsHandler(_ctx) {
+		await this.ensureConnected();
+		return { data: this._prompts.map((prompt) => this.promptToEntry(prompt)) };
+	}
+	/**
+	* List specific tool
+	*/
+	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)] };
+	}
+	/**
+	* List specific prompt
+	*/
+	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)] };
+	}
+	/**
+	* List resources directory.
+	*
+	* Returns all resources as children of /resources.
+	*/
+	async listResourcesHandler(_ctx) {
+		await this.ensureConnected();
+		const immediateChildren = /* @__PURE__ */ new Map();
+		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) continue;
+			const childPath = `/resources/${segments[0]}`;
+			if (segments.length === 1) immediateChildren.set(childPath, {
+				isDir: false,
+				resource
+			});
+			else 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));
+		return { data: entries };
+	}
+	/**
+	* List resource paths (wildcard handler under /resources)
+	*/
+	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();
+		const depth = resourcePath.split("/").filter(Boolean).length;
+		for (const resource of this._resources) {
+			const rPath = this.resourceUriToPath(resource.uri);
+			if (!rPath) continue;
+			if (rPath === resourcePath) exactMatch = resource;
+			else if (rPath.startsWith(`${resourcePath}/`)) {
+				const segments = rPath.split("/").filter(Boolean);
+				if (segments.length <= depth) continue;
+				const childPath = `/resources${resourcePath}/${segments[depth]}`;
+				if (segments.length === depth + 1) immediateChildren.set(childPath, {
+					isDir: false,
+					resource
+				});
+				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 };
+	}
+	/**
+	* Read metadata for tools (dynamic entries not in static tree).
+	* Static entries metadata is handled by AFSBaseProvider.
+	*/
+	async readToolMeta(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 entry = this.toolToEntry(tool);
+		return {
+			id: `/tools/${ctx.params.name}/.meta`,
+			path: `/tools/${ctx.params.name}/.meta`,
+			metadata: entry.metadata
+		};
+	}
+	/**
+	* Read metadata for prompts (dynamic entries not in static tree).
+	*/
+	async readPromptMeta(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 entry = this.promptToEntry(prompt);
+		return {
+			id: `/prompts/${ctx.params.name}/.meta`,
+			path: `/prompts/${ctx.params.name}/.meta`,
+			metadata: entry.metadata
+		};
+	}
+	/**
+	* Read metadata for resources (dynamic entries not in static tree).
+	* Handles both actual resources and synthesized intermediate directories.
+	*/
+	async readResourceMeta(ctx) {
+		await this.ensureConnected();
+		const resourcePath = `/${ctx.params.path}`;
+		const metaPath = `/resources${resourcePath}/.meta`;
+		const resourceMatch = this.findResourceForPath(resourcePath);
+		if (resourceMatch) {
+			if (resourceMatch.resource) return {
+				id: metaPath,
+				path: metaPath,
+				metadata: this.resourceToEntry(resourceMatch.resource, `/resources${resourcePath}`).metadata
+			};
+			else if (resourceMatch.template) return {
+				id: metaPath,
+				path: metaPath,
+				metadata: this.resourceTemplateToEntry(resourceMatch.template, `/resources${resourcePath}`).metadata
+			};
+		}
+		if (this._resources.some((resource) => {
+			return this.resourceUriToPath(resource.uri)?.startsWith(`${resourcePath}/`);
+		})) return {
+			id: metaPath,
+			path: metaPath,
+			metadata: {
+				kind: "afs:node",
+				kinds: require_kinds.getKindsArray("afs:node"),
+				mcp: { isResource: true }
+			}
+		};
+		throw new _aigne_afs.AFSNotFoundError(ctx.path);
+	}
+	/**
+	* Read tool
+	*/
+	async readToolHandler(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 this.toolToEntry(tool);
+	}
+	/**
+	* Read prompt
+	*/
+	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);
+	}
+	/**
+	* Read resource (wildcard handler under /resources)
+	*/
+	async readResourceHandler(ctx) {
+		await this.ensureConnected();
+		const resourcePath = `/${ctx.params.path}`;
+		const afsPath = `/resources${resourcePath}`;
+		const resourceMatch = this.findResourceForPath(resourcePath);
+		if (resourceMatch) {
+			if (resourceMatch.resource) {
+				const result = await this.readResourceByUri(resourceMatch.resource.uri);
+				if (!result.data) throw new _aigne_afs.AFSNotFoundError(ctx.path, result.message || `Resource not found: ${ctx.path}`);
+				result.data.path = `/resources${result.data.path}`;
+				result.data.id = result.data.path;
+				return result.data;
+			} else if (resourceMatch.template && resourceMatch.params) {
+				const uri = AFSMCP.buildUriFromTemplate(resourceMatch.template.uriTemplate, resourceMatch.params);
+				const result = await this.readResourceByUri(uri);
+				if (!result.data) throw new _aigne_afs.AFSNotFoundError(ctx.path, result.message || `Resource not found: ${ctx.path}`);
+				result.data.path = `/resources${result.data.path}`;
+				result.data.id = result.data.path;
+				return result.data;
+			}
+		}
+		if (this._resources.some((resource) => {
+			return this.resourceUriToPath(resource.uri)?.startsWith(`${resourcePath}/`);
+		})) return {
+			id: afsPath,
+			path: afsPath,
+			summary: `Resource directory: ${resourcePath}`,
+			metadata: {
+				kind: "afs:node",
+				kinds: require_kinds.getKindsArray("afs:node"),
+				mcp: { isResource: true }
+			}
+		};
+		throw new _aigne_afs.AFSNotFoundError(ctx.path);
+	}
+	/**
+	* Read a resource by its URI (internal helper)
+	*/
+	async readResourceByUri(uri) {
+		if (!this.client) return {
+			data: void 0,
+			message: "MCP client not connected"
+		};
+		try {
+			const result = await this.client.readResource({ uri });
+			const path = this.resourceUriToPath(uri) || uri;
+			let content;
+			let mimeType;
+			if (result.contents && result.contents.length > 0) {
+				const firstContent = result.contents[0];
+				mimeType = firstContent.mimeType;
+				if ("text" in firstContent) content = firstContent.text;
+				else if ("blob" in firstContent) content = firstContent.blob;
+			}
+			return { data: {
+				id: path,
+				path,
+				content,
+				metadata: { mcp: {
+					uri,
+					mimeType
+				} }
+			} };
+		} catch (error) {
+			return {
+				data: void 0,
+				message: `Failed to read resource: ${error.message}`
+			};
+		}
+	}
+	/**
+	* Read a prompt with arguments, returning the prompt content
+	*
+	* This is a specialized method that calls the MCP getPrompt API
+	* to get the actual prompt content with substituted arguments.
+	*/
+	async readPrompt(path, args) {
+		const normalizedPath = path.startsWith("/") ? path : `/${path}`;
+		if (!normalizedPath.startsWith("/prompts/")) return {
+			data: void 0,
+			message: `readPrompt only supported on /prompts/* paths, got: ${normalizedPath}`
+		};
+		if (!this.client) return {
+			data: void 0,
+			message: "MCP client not connected"
+		};
+		const promptName = normalizedPath.slice(9);
+		const prompt = this._prompts.find((p) => p.name === promptName);
+		if (!prompt) return {
+			data: void 0,
+			message: `Prompt not found: ${promptName}`
+		};
+		try {
+			const result = await this.client.getPrompt({
+				name: promptName,
+				arguments: args
+			});
+			return { data: {
+				id: `/prompts/${promptName}`,
+				path: `/prompts/${promptName}`,
+				summary: prompt.description,
+				content: result.messages,
+				metadata: {
+					arguments: prompt.arguments,
+					mcp: {
+						name: prompt.name,
+						description: prompt.description,
+						arguments: prompt.arguments
+					}
+				}
+			} };
+		} catch (error) {
+			return {
+				data: void 0,
+				message: `Failed to get prompt: ${error.message}`
+			};
+		}
+	}
+	/**
+	* Generate WORLD.md content describing this MCP server's capabilities
+	*/
+	generateWorldMd() {
+		const lines = [];
+		lines.push(`# ${this.name}`);
+		lines.push("");
+		if (this.description) {
+			lines.push(this.description);
+			lines.push("");
+		}
+		lines.push("## Server Information");
+		lines.push("");
+		lines.push(`- **Name**: ${this.name}`);
+		lines.push(`- **Transport**: ${this.options.transport}`);
+		if (this.options.transport === "stdio") lines.push(`- **Command**: ${this.options.command}`);
+		else lines.push(`- **URL**: ${this.options.url}`);
+		lines.push("");
+		lines.push("## Capabilities");
+		lines.push("");
+		lines.push(`- Tools: ${this._tools.length}`);
+		lines.push(`- Prompts: ${this._prompts.length}`);
+		lines.push(`- Resources: ${this._resources.length}`);
+		lines.push(`- Resource Templates: ${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}`);
+				lines.push("");
+				if (tool.description) {
+					lines.push(tool.description);
+					lines.push("");
+				}
+				lines.push(`**Path**: \`/tools/${tool.name}\``);
+				lines.push("");
+				if (tool.inputSchema) {
+					lines.push("**Input Schema**:");
+					lines.push("```json");
+					lines.push(JSON.stringify(tool.inputSchema, null, 2));
+					lines.push("```");
+					lines.push("");
+				}
+			}
+		}
+		if (this._prompts.length > 0) {
+			lines.push("## Prompts");
+			lines.push("");
+			for (const prompt of this._prompts) {
+				lines.push(`### ${prompt.name}`);
+				lines.push("");
+				if (prompt.description) {
+					lines.push(prompt.description);
+					lines.push("");
+				}
+				lines.push(`**Path**: \`/prompts/${prompt.name}\``);
+				lines.push("");
+				if (prompt.arguments && prompt.arguments.length > 0) {
+					lines.push("**Arguments**:");
+					for (const arg of prompt.arguments) {
+						const required = arg.required ? " (required)" : " (optional)";
+						lines.push(`- \`${arg.name}\`${required}: ${arg.description || ""}`);
+					}
+					lines.push("");
+				}
+			}
+		}
+		if (this._resources.length > 0) {
+			lines.push("## Resources");
+			lines.push("");
+			for (const resource of this._resources) {
+				lines.push(`### ${resource.name}`);
+				lines.push("");
+				if (resource.description) {
+					lines.push(resource.description);
+					lines.push("");
+				}
+				lines.push(`**URI**: \`${resource.uri}\``);
+				const afsPath = this.resourceUriToPath(resource.uri);
+				if (afsPath) lines.push(`**AFS Path**: \`${afsPath}\``);
+				if (resource.mimeType) lines.push(`**MIME Type**: ${resource.mimeType}`);
+				lines.push("");
+			}
+		}
+		if (this._resourceTemplates.length > 0) {
+			lines.push("## Resource Templates");
+			lines.push("");
+			for (const template of this._resourceTemplates) {
+				lines.push(`### ${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.map((v) => `\`{${v}}\``).join(", ")}`);
+				if (template.mimeType) lines.push(`**MIME Type**: ${template.mimeType}`);
+				lines.push("");
+			}
+		}
+		return lines.join("\n");
+	}
+	/**
+	* Execute a tool
+	*/
+	async execToolHandler(ctx, args) {
+		await this.ensureConnected();
+		if (!this.client) throw new Error("MCP client not connected");
+		if (!this._tools.find((t) => t.name === ctx.params.name)) throw new Error(`Tool not found: ${ctx.params.name}`);
+		return {
+			success: true,
+			data: await this.client.callTool({
+				name: ctx.params.name,
+				arguments: args
+			})
+		};
+	}
+};
+require_decorate.__decorate([(0, _aigne_afs_provider.StaticEntries)()], AFSMCP.prototype, "defineEntries", 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);
+require_decorate.__decorate([(0, _aigne_afs_provider.List)("/prompts/:name")], AFSMCP.prototype, "listPromptHandler", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.List)("/resources")], AFSMCP.prototype, "listResourcesHandler", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.List)("/resources/:path+")], AFSMCP.prototype, "listResourceHandler", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Meta)("/tools/:name")], AFSMCP.prototype, "readToolMeta", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Meta)("/prompts/:name")], AFSMCP.prototype, "readPromptMeta", null);
+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.Read)("/resources/:path+")], AFSMCP.prototype, "readResourceHandler", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Exec)("/tools/:name")], AFSMCP.prototype, "execToolHandler", null);
+
+//#endregion
+exports.AFSMCP = AFSMCP;