@nextclaw/mcp 0.1.64 → 0.1.66

package/dist/index.js

@@ -1,723 +1,607 @@
-// src/types.ts
+import { Agent, fetch } from "undici";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+//#region src/types.ts
 function normalizeMcpServerName(name) {
-  const normalized = name.trim();
-  if (!normalized) {
-    throw new Error("MCP server name is required.");
-  }
-  if (!/^[A-Za-z0-9._-]+$/.test(normalized)) {
-    throw new Error("MCP server name may only contain letters, numbers, dot, underscore, and dash.");
-  }
-  return normalized;
+	const normalized = name.trim();
+	if (!normalized) throw new Error("MCP server name is required.");
+	if (!/^[A-Za-z0-9._-]+$/.test(normalized)) throw new Error("MCP server name may only contain letters, numbers, dot, underscore, and dash.");
+	return normalized;
 }
 function readDefaultAgentId(config) {
-  return config.agents.list.find((entry) => entry.default)?.id?.trim() || config.agents.list[0]?.id?.trim() || "main";
+	return config.agents.list.find((entry) => entry.default)?.id?.trim() || config.agents.list[0]?.id?.trim() || "main";
 }
 function isServerAccessibleToAgent(params) {
-  if (params.scope.allAgents) {
-    return true;
-  }
-  const targetAgentId = params.agentId?.trim() || readDefaultAgentId(params.config);
-  const explicitAgents = params.scope.agents.map((agentId) => agentId.trim()).filter(Boolean);
-  if (explicitAgents.length > 0) {
-    return explicitAgents.includes(targetAgentId);
-  }
-  return targetAgentId === readDefaultAgentId(params.config);
+	if (params.scope.allAgents) return true;
+	const targetAgentId = params.agentId?.trim() || readDefaultAgentId(params.config);
+	const explicitAgents = params.scope.agents.map((agentId) => agentId.trim()).filter(Boolean);
+	if (explicitAgents.length > 0) return explicitAgents.includes(targetAgentId);
+	return targetAgentId === readDefaultAgentId(params.config);
 }
 function buildQualifiedMcpToolName(serverName, toolName) {
-  return `mcp_${sanitizeMcpSegment(serverName)}__${sanitizeMcpSegment(toolName)}`;
+	return `mcp_${sanitizeMcpSegment(serverName)}__${sanitizeMcpSegment(toolName)}`;
 }
 function sanitizeMcpSegment(value) {
-  const sanitized = value.trim().replace(/[^A-Za-z0-9_]+/g, "_").replace(/^_+|_+$/g, "");
-  return sanitized || "unnamed";
+	return value.trim().replace(/[^A-Za-z0-9_]+/g, "_").replace(/^_+|_+$/g, "") || "unnamed";
 }
-
-// src/config/mcp-config-normalizer.ts
+//#endregion
+//#region src/config/mcp-config-normalizer.ts
 function listMcpServers(config) {
-  return Object.entries(config.mcp.servers).map(([name, definition]) => ({
-    name: normalizeMcpServerName(name),
-    definition
-  })).sort((left, right) => left.name.localeCompare(right.name));
+	return Object.entries(config.mcp.servers).map(([name, definition]) => ({
+		name: normalizeMcpServerName(name),
+		definition
+	})).sort((left, right) => left.name.localeCompare(right.name));
 }
 function getMcpServer(config, name) {
-  const normalizedName = normalizeMcpServerName(name);
-  const definition = config.mcp.servers[normalizedName];
-  if (!definition) {
-    return void 0;
-  }
-  return {
-    name: normalizedName,
-    definition
-  };
+	const normalizedName = normalizeMcpServerName(name);
+	const definition = config.mcp.servers[normalizedName];
+	if (!definition) return;
+	return {
+		name: normalizedName,
+		definition
+	};
 }
-
-// src/client/mcp-client-factory.ts
-import { Agent, fetch as undiciFetch } from "undici";
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
-import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
-import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+//#endregion
+//#region src/client/mcp-client-factory.ts
 function createClient() {
-  return new Client({
-    name: "nextclaw-mcp-client",
-    version: "0.1.0"
-  });
+	return new Client({
+		name: "nextclaw-mcp-client",
+		version: "0.1.0"
+	});
 }
 function buildFetch(transport) {
-  const timeoutMs = transport.timeoutMs;
-  const insecureAgent = transport.verifyTls ? null : new Agent({
-    connect: {
-      rejectUnauthorized: false
-    }
-  });
-  return async (input, init) => {
-    const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), timeoutMs);
-    try {
-      return await undiciFetch(input, {
-        ...init,
-        dispatcher: insecureAgent ?? init?.dispatcher,
-        signal: controller.signal
-      });
-    } finally {
-      clearTimeout(timeout);
-    }
-  };
+	const timeoutMs = transport.timeoutMs;
+	const insecureAgent = transport.verifyTls ? null : new Agent({ connect: { rejectUnauthorized: false } });
+	return async (input, init) => {
+		const controller = new AbortController();
+		const timeout = setTimeout(() => controller.abort(), timeoutMs);
+		try {
+			return await fetch(input, {
+				...init,
+				dispatcher: insecureAgent ?? init?.dispatcher,
+				signal: controller.signal
+			});
+		} finally {
+			clearTimeout(timeout);
+		}
+	};
 }
 function createStdioTransport(transport) {
-  return new StdioClientTransport({
-    command: transport.command,
-    args: transport.args,
-    cwd: transport.cwd,
-    env: Object.keys(transport.env).length > 0 ? transport.env : void 0,
-    stderr: transport.stderr
-  });
+	return new StdioClientTransport({
+		command: transport.command,
+		args: transport.args,
+		cwd: transport.cwd,
+		env: Object.keys(transport.env).length > 0 ? transport.env : void 0,
+		stderr: transport.stderr
+	});
 }
 function createHttpTransport(transport) {
-  return new StreamableHTTPClientTransport(new URL(transport.url), {
-    requestInit: {
-      headers: transport.headers
-    },
-    fetch: buildFetch(transport)
-  });
+	return new StreamableHTTPClientTransport(new URL(transport.url), {
+		requestInit: { headers: transport.headers },
+		fetch: buildFetch(transport)
+	});
 }
 function createSseTransport(transport) {
-  return new SSEClientTransport(new URL(transport.url), {
-    requestInit: {
-      headers: transport.headers
-    },
-    eventSourceInit: {
-      fetch: buildFetch(transport),
-      headers: transport.headers
-    },
-    fetch: buildFetch(transport)
-  });
+	return new SSEClientTransport(new URL(transport.url), {
+		requestInit: { headers: transport.headers },
+		eventSourceInit: {
+			fetch: buildFetch(transport),
+			headers: transport.headers
+		},
+		fetch: buildFetch(transport)
+	});
 }
 var McpClientFactory = class {
-  constructor(_config) {
-    this._config = _config;
-    void this._config;
-  }
-  create(record) {
-    const transport = (() => {
-      switch (record.definition.transport.type) {
-        case "stdio":
-          return createStdioTransport(record.definition.transport);
-        case "http":
-          return createHttpTransport(record.definition.transport);
-        case "sse":
-          return createSseTransport(record.definition.transport);
-        default:
-          throw new Error(`Unsupported MCP transport: ${String(record.definition.transport.type)}`);
-      }
-    })();
-    return {
-      client: createClient(),
-      transport
-    };
-  }
+	constructor(_config) {
+		this._config = _config;
+		this._config;
+	}
+	create(record) {
+		const transport = (() => {
+			switch (record.definition.transport.type) {
+				case "stdio": return createStdioTransport(record.definition.transport);
+				case "http": return createHttpTransport(record.definition.transport);
+				case "sse": return createSseTransport(record.definition.transport);
+				default: throw new Error(`Unsupported MCP transport: ${String(record.definition.transport.type)}`);
+			}
+		})();
+		return {
+			client: createClient(),
+			transport
+		};
+	}
 };
-
-// src/lifecycle/mcp-server-lifecycle-manager.ts
+//#endregion
+//#region src/lifecycle/mcp-server-lifecycle-manager.ts
 var McpServerLifecycleManager = class {
-  constructor(options) {
-    this.options = options;
-  }
-  pendingConnections = /* @__PURE__ */ new Map();
-  readyConnections = /* @__PURE__ */ new Map();
-  async warmServer(record) {
-    const connection = await this.ensureConnection(record);
-    return this.stripConnection(connection);
-  }
-  getCachedCatalog(serverName) {
-    return this.readyConnections.get(serverName)?.tools ?? [];
-  }
-  getCachedState(serverName) {
-    const ready = this.readyConnections.get(serverName);
-    if (!ready) {
-      return void 0;
-    }
-    return this.stripConnection(ready);
-  }
-  async callTool(record, toolName, args) {
-    const connection = await this.ensureConnection(record);
-    const result = await connection.client.callTool({
-      name: toolName,
-      arguments: args
-    });
-    return this.normalizeToolResult(result);
-  }
-  async closeAll() {
-    const pending = await Promise.allSettled(this.pendingConnections.values());
-    for (const result of pending) {
-      if (result.status === "fulfilled") {
-        this.readyConnections.set(result.value.record.name, result.value);
-      }
-    }
-    for (const connection of this.readyConnections.values()) {
-      await connection.transport.close().catch(() => {
-      });
-    }
-    this.pendingConnections.clear();
-    this.readyConnections.clear();
-  }
-  async closeServer(serverName) {
-    const ready = this.readyConnections.get(serverName);
-    this.readyConnections.delete(serverName);
-    const pending = this.pendingConnections.get(serverName);
-    this.pendingConnections.delete(serverName);
-    if (ready) {
-      await ready.transport.close().catch(() => {
-      });
-    }
-    if (!pending) {
-      return;
-    }
-    const result = await Promise.allSettled([pending]);
-    const settled = result[0];
-    if (settled?.status === "fulfilled") {
-      await settled.value.transport.close().catch(() => {
-      });
-    }
-    this.readyConnections.delete(serverName);
-    this.pendingConnections.delete(serverName);
-  }
-  async ensureConnection(record) {
-    const ready = this.readyConnections.get(record.name);
-    if (ready) {
-      return ready;
-    }
-    const existing = this.pendingConnections.get(record.name);
-    if (existing) {
-      return existing;
-    }
-    const task = this.connect(record);
-    this.pendingConnections.set(record.name, task);
-    try {
-      const connection = await task;
-      this.readyConnections.set(record.name, connection);
-      this.pendingConnections.delete(record.name);
-      return connection;
-    } catch (error) {
-      this.pendingConnections.delete(record.name);
-      throw error;
-    }
-  }
-  async connect(record) {
-    const config = this.options.getConfig();
-    const clientFactory = this.options.clientFactory ?? new McpClientFactory(config);
-    const { client, transport } = clientFactory.create(record);
-    await client.connect(transport);
-    const listedTools = await client.listTools();
-    const tools = listedTools.tools.map((tool) => ({
-      qualifiedName: buildQualifiedMcpToolName(record.name, tool.name),
-      serverName: record.name,
-      toolName: tool.name,
-      description: tool.description,
-      parameters: tool.inputSchema
-    }));
-    const now = (this.options.now ?? (() => /* @__PURE__ */ new Date()))().toISOString();
-    return {
-      record,
-      tools,
-      clientReady: true,
-      lastReadyAt: now,
-      client,
-      transport
-    };
-  }
-  stripConnection(connection) {
-    return {
-      record: connection.record,
-      tools: connection.tools,
-      clientReady: connection.clientReady,
-      lastReadyAt: connection.lastReadyAt,
-      lastError: connection.lastError
-    };
-  }
-  normalizeToolResult(result) {
-    if ("toolResult" in result) {
-      return result.toolResult;
-    }
-    return {
-      content: result.content,
-      structuredContent: result.structuredContent,
-      isError: result.isError ?? false
-    };
-  }
+	pendingConnections = /* @__PURE__ */ new Map();
+	readyConnections = /* @__PURE__ */ new Map();
+	constructor(options) {
+		this.options = options;
+	}
+	async warmServer(record) {
+		const connection = await this.ensureConnection(record);
+		return this.stripConnection(connection);
+	}
+	getCachedCatalog(serverName) {
+		return this.readyConnections.get(serverName)?.tools ?? [];
+	}
+	getCachedState(serverName) {
+		const ready = this.readyConnections.get(serverName);
+		if (!ready) return;
+		return this.stripConnection(ready);
+	}
+	async callTool(record, toolName, args) {
+		const result = await (await this.ensureConnection(record)).client.callTool({
+			name: toolName,
+			arguments: args
+		});
+		return this.normalizeToolResult(result);
+	}
+	async closeAll() {
+		const pending = await Promise.allSettled(this.pendingConnections.values());
+		for (const result of pending) if (result.status === "fulfilled") this.readyConnections.set(result.value.record.name, result.value);
+		for (const connection of this.readyConnections.values()) await connection.transport.close().catch(() => {});
+		this.pendingConnections.clear();
+		this.readyConnections.clear();
+	}
+	async closeServer(serverName) {
+		const ready = this.readyConnections.get(serverName);
+		this.readyConnections.delete(serverName);
+		const pending = this.pendingConnections.get(serverName);
+		this.pendingConnections.delete(serverName);
+		if (ready) await ready.transport.close().catch(() => {});
+		if (!pending) return;
+		const settled = (await Promise.allSettled([pending]))[0];
+		if (settled?.status === "fulfilled") await settled.value.transport.close().catch(() => {});
+		this.readyConnections.delete(serverName);
+		this.pendingConnections.delete(serverName);
+	}
+	async ensureConnection(record) {
+		const ready = this.readyConnections.get(record.name);
+		if (ready) return ready;
+		const existing = this.pendingConnections.get(record.name);
+		if (existing) return existing;
+		const task = this.connect(record);
+		this.pendingConnections.set(record.name, task);
+		try {
+			const connection = await task;
+			this.readyConnections.set(record.name, connection);
+			this.pendingConnections.delete(record.name);
+			return connection;
+		} catch (error) {
+			this.pendingConnections.delete(record.name);
+			throw error;
+		}
+	}
+	async connect(record) {
+		const config = this.options.getConfig();
+		const { client, transport } = (this.options.clientFactory ?? new McpClientFactory(config)).create(record);
+		await client.connect(transport);
+		return {
+			record,
+			tools: (await client.listTools()).tools.map((tool) => ({
+				qualifiedName: buildQualifiedMcpToolName(record.name, tool.name),
+				serverName: record.name,
+				toolName: tool.name,
+				description: tool.description,
+				parameters: tool.inputSchema
+			})),
+			clientReady: true,
+			lastReadyAt: (this.options.now ?? (() => /* @__PURE__ */ new Date()))().toISOString(),
+			client,
+			transport
+		};
+	}
+	stripConnection(connection) {
+		return {
+			record: connection.record,
+			tools: connection.tools,
+			clientReady: connection.clientReady,
+			lastReadyAt: connection.lastReadyAt,
+			lastError: connection.lastError
+		};
+	}
+	normalizeToolResult(result) {
+		if ("toolResult" in result) return result.toolResult;
+		return {
+			content: result.content,
+			structuredContent: result.structuredContent,
+			isError: result.isError ?? false
+		};
+	}
 };
-
-// src/registry/mcp-registry-service.ts
+//#endregion
+//#region src/registry/mcp-registry-service.ts
 var McpRegistryService = class {
-  constructor(options) {
-    this.options = options;
-    this.lifecycleManager = this.options.lifecycleManager ?? new McpServerLifecycleManager({
-      getConfig: this.options.getConfig
-    });
-  }
-  lifecycleManager;
-  listServers() {
-    return listMcpServers(this.options.getConfig());
-  }
-  getServer(name) {
-    return getMcpServer(this.options.getConfig(), name);
-  }
-  async prewarmEnabledServers() {
-    const results = await Promise.all(
-      this.listServers().filter((record) => record.definition.enabled).map(async (record) => {
-        try {
-          const state = await this.lifecycleManager.warmServer(record);
-          return {
-            name: record.name,
-            ok: true,
-            toolCount: state.tools.length
-          };
-        } catch (error) {
-          return {
-            name: record.name,
-            ok: false,
-            toolCount: 0,
-            error: toErrorMessage(error)
-          };
-        }
-      })
-    );
-    return results.sort((left, right) => left.name.localeCompare(right.name));
-  }
-  async warmServer(name) {
-    const server = this.getServer(name);
-    if (!server) {
-      throw new Error(`Unknown MCP server: ${name}`);
-    }
-    try {
-      const state = await this.lifecycleManager.warmServer(server);
-      return {
-        name: server.name,
-        ok: true,
-        toolCount: state.tools.length
-      };
-    } catch (error) {
-      return {
-        name: server.name,
-        ok: false,
-        toolCount: 0,
-        error: toErrorMessage(error)
-      };
-    }
-  }
-  async reconcileConfig(params) {
-    const previousServers = new Map(listMcpServers(params.prevConfig).map((record) => [record.name, record]));
-    const nextServers = new Map(listMcpServers(params.nextConfig).map((record) => [record.name, record]));
-    const serverNames = Array.from(/* @__PURE__ */ new Set([...previousServers.keys(), ...nextServers.keys()])).sort(
-      (left, right) => left.localeCompare(right)
-    );
-    const result = {
-      added: [],
-      removed: [],
-      enabled: [],
-      disabled: [],
-      restarted: [],
-      warmed: []
-    };
-    for (const serverName of serverNames) {
-      const previous = previousServers.get(serverName);
-      const next = nextServers.get(serverName);
-      if (!next) {
-        await this.lifecycleManager.closeServer(serverName);
-        result.removed.push(serverName);
-        continue;
-      }
-      if (!previous) {
-        result.added.push(serverName);
-        if (next.definition.enabled) {
-          result.warmed.push(await this.warmRecord(next));
-        }
-        continue;
-      }
-      if (previous.definition.enabled && !next.definition.enabled) {
-        await this.lifecycleManager.closeServer(serverName);
-        result.disabled.push(serverName);
-        continue;
-      }
-      if (!previous.definition.enabled && next.definition.enabled) {
-        result.enabled.push(serverName);
-        result.warmed.push(await this.warmRecord(next));
-        continue;
-      }
-      if (hasReconnectRelevantChange(previous.definition, next.definition)) {
-        await this.lifecycleManager.closeServer(serverName);
-        result.restarted.push(serverName);
-        if (next.definition.enabled) {
-          result.warmed.push(await this.warmRecord(next));
-        }
-      }
-    }
-    return result;
-  }
-  listAccessibleTools(filter = {}) {
-    const config = this.options.getConfig();
-    return this.listServers().filter((record) => record.definition.enabled).filter(
-      (record) => isServerAccessibleToAgent({
-        config,
-        scope: record.definition.scope,
-        agentId: filter.agentId
-      })
-    ).flatMap((record) => this.lifecycleManager.getCachedCatalog(record.name)).sort((left, right) => left.qualifiedName.localeCompare(right.qualifiedName));
-  }
-  getCachedState(serverName) {
-    return this.lifecycleManager.getCachedState(serverName);
-  }
-  async callTool(params) {
-    const server = this.getServer(params.serverName);
-    if (!server) {
-      throw new Error(`Unknown MCP server: ${params.serverName}`);
-    }
-    return this.lifecycleManager.callTool(server, params.toolName, params.args);
-  }
-  async close() {
-    await this.lifecycleManager.closeAll();
-  }
-  async warmRecord(record) {
-    try {
-      const state = await this.lifecycleManager.warmServer(record);
-      return {
-        name: record.name,
-        ok: true,
-        toolCount: state.tools.length
-      };
-    } catch (error) {
-      return {
-        name: record.name,
-        ok: false,
-        toolCount: 0,
-        error: toErrorMessage(error)
-      };
-    }
-  }
+	lifecycleManager;
+	constructor(options) {
+		this.options = options;
+		this.lifecycleManager = this.options.lifecycleManager ?? new McpServerLifecycleManager({ getConfig: this.options.getConfig });
+	}
+	listServers() {
+		return listMcpServers(this.options.getConfig());
+	}
+	getServer(name) {
+		return getMcpServer(this.options.getConfig(), name);
+	}
+	async prewarmEnabledServers() {
+		return (await Promise.all(this.listServers().filter((record) => record.definition.enabled).map(async (record) => {
+			try {
+				const state = await this.lifecycleManager.warmServer(record);
+				return {
+					name: record.name,
+					ok: true,
+					toolCount: state.tools.length
+				};
+			} catch (error) {
+				return {
+					name: record.name,
+					ok: false,
+					toolCount: 0,
+					error: toErrorMessage(error)
+				};
+			}
+		}))).sort((left, right) => left.name.localeCompare(right.name));
+	}
+	async warmServer(name) {
+		const server = this.getServer(name);
+		if (!server) throw new Error(`Unknown MCP server: ${name}`);
+		try {
+			const state = await this.lifecycleManager.warmServer(server);
+			return {
+				name: server.name,
+				ok: true,
+				toolCount: state.tools.length
+			};
+		} catch (error) {
+			return {
+				name: server.name,
+				ok: false,
+				toolCount: 0,
+				error: toErrorMessage(error)
+			};
+		}
+	}
+	async reconcileConfig(params) {
+		const previousServers = new Map(listMcpServers(params.prevConfig).map((record) => [record.name, record]));
+		const nextServers = new Map(listMcpServers(params.nextConfig).map((record) => [record.name, record]));
+		const serverNames = Array.from(new Set([...previousServers.keys(), ...nextServers.keys()])).sort((left, right) => left.localeCompare(right));
+		const result = {
+			added: [],
+			removed: [],
+			enabled: [],
+			disabled: [],
+			restarted: [],
+			warmed: []
+		};
+		for (const serverName of serverNames) {
+			const previous = previousServers.get(serverName);
+			const next = nextServers.get(serverName);
+			if (!next) {
+				await this.lifecycleManager.closeServer(serverName);
+				result.removed.push(serverName);
+				continue;
+			}
+			if (!previous) {
+				result.added.push(serverName);
+				if (next.definition.enabled) result.warmed.push(await this.warmRecord(next));
+				continue;
+			}
+			if (previous.definition.enabled && !next.definition.enabled) {
+				await this.lifecycleManager.closeServer(serverName);
+				result.disabled.push(serverName);
+				continue;
+			}
+			if (!previous.definition.enabled && next.definition.enabled) {
+				result.enabled.push(serverName);
+				result.warmed.push(await this.warmRecord(next));
+				continue;
+			}
+			if (hasReconnectRelevantChange(previous.definition, next.definition)) {
+				await this.lifecycleManager.closeServer(serverName);
+				result.restarted.push(serverName);
+				if (next.definition.enabled) result.warmed.push(await this.warmRecord(next));
+			}
+		}
+		return result;
+	}
+	listAccessibleTools(filter = {}) {
+		const config = this.options.getConfig();
+		return this.listServers().filter((record) => record.definition.enabled).filter((record) => isServerAccessibleToAgent({
+			config,
+			scope: record.definition.scope,
+			agentId: filter.agentId
+		})).flatMap((record) => this.lifecycleManager.getCachedCatalog(record.name)).sort((left, right) => left.qualifiedName.localeCompare(right.qualifiedName));
+	}
+	getCachedState(serverName) {
+		return this.lifecycleManager.getCachedState(serverName);
+	}
+	async callTool(params) {
+		const server = this.getServer(params.serverName);
+		if (!server) throw new Error(`Unknown MCP server: ${params.serverName}`);
+		return this.lifecycleManager.callTool(server, params.toolName, params.args);
+	}
+	async close() {
+		await this.lifecycleManager.closeAll();
+	}
+	async warmRecord(record) {
+		try {
+			const state = await this.lifecycleManager.warmServer(record);
+			return {
+				name: record.name,
+				ok: true,
+				toolCount: state.tools.length
+			};
+		} catch (error) {
+			return {
+				name: record.name,
+				ok: false,
+				toolCount: 0,
+				error: toErrorMessage(error)
+			};
+		}
+	}
 };
 function toErrorMessage(error) {
-  return error instanceof Error ? error.message : String(error);
+	return error instanceof Error ? error.message : String(error);
 }
 function hasReconnectRelevantChange(left, right) {
-  return JSON.stringify(left.transport) !== JSON.stringify(right.transport);
+	return JSON.stringify(left.transport) !== JSON.stringify(right.transport);
 }
-
-// src/doctor/mcp-doctor-service.ts
+//#endregion
+//#region src/doctor/mcp-doctor-service.ts
 var McpDoctorService = class {
-  constructor(options) {
-    this.options = options;
-  }
-  async inspect(name) {
-    const registry = this.options.registryService ?? new McpRegistryService({
-      getConfig: this.options.getConfig
-    });
-    const specificServer = name ? registry.getServer(name) : void 0;
-    const servers = specificServer ? [specificServer] : name ? [] : registry.listServers();
-    return await Promise.all(
-      servers.map(async (server) => {
-        const warmResult = await registry.warmServer(server.name);
-        return {
-          name: server.name,
-          enabled: server.definition.enabled,
-          transport: server.definition.transport.type,
-          accessible: warmResult.ok,
-          toolCount: warmResult.toolCount,
-          ...warmResult.error ? { error: warmResult.error } : {}
-        };
-      })
-    );
-  }
+	constructor(options) {
+		this.options = options;
+	}
+	async inspect(name) {
+		const registry = this.options.registryService ?? new McpRegistryService({ getConfig: this.options.getConfig });
+		const specificServer = name ? registry.getServer(name) : void 0;
+		const servers = specificServer ? [specificServer] : name ? [] : registry.listServers();
+		return await Promise.all(servers.map(async (server) => {
+			const warmResult = await registry.warmServer(server.name);
+			return {
+				name: server.name,
+				enabled: server.definition.enabled,
+				transport: server.definition.transport.type,
+				accessible: warmResult.ok,
+				toolCount: warmResult.toolCount,
+				...warmResult.error ? { error: warmResult.error } : {}
+			};
+		}));
+	}
 };
-
-// src/doctor/mcp-doctor-facade.ts
+//#endregion
+//#region src/doctor/mcp-doctor-facade.ts
 var McpDoctorFacade = class {
-  constructor(options) {
-    this.options = options;
-    this.doctorService = new McpDoctorService({
-      getConfig: this.options.getConfig,
-      registryService: this.options.registryService
-    });
-  }
-  doctorService;
-  async inspect(name) {
-    return await this.doctorService.inspect(name);
-  }
-  async inspectOne(name) {
-    const reports = await this.inspect(name);
-    return reports[0] ?? null;
-  }
+	doctorService;
+	constructor(options) {
+		this.options = options;
+		this.doctorService = new McpDoctorService({
+			getConfig: this.options.getConfig,
+			registryService: this.options.registryService
+		});
+	}
+	async inspect(name) {
+		return await this.doctorService.inspect(name);
+	}
+	async inspectOne(name) {
+		return (await this.inspect(name))[0] ?? null;
+	}
 };
-
-// src/install/mcp-install-template-materializer.ts
+//#endregion
+//#region src/install/mcp-install-template-materializer.ts
 var McpInstallTemplateMaterializer = class {
-  materialize(params) {
-    const name = normalizeMcpServerName(params.name?.trim() || params.template.defaultName);
-    const inputs = params.inputs ?? {};
-    const definition = this.applyInputs(params.template.template, inputs);
-    definition.enabled = params.enabled ?? definition.enabled;
-    definition.scope = this.mergeScope(definition.scope, params.scope);
-    definition.metadata = this.mergeMetadata(definition.metadata, params.template, params.metadata);
-    return { name, definition };
-  }
-  applyInputs(definition, inputs) {
-    const replacer = (value) => value.replace(/\{\{\s*([A-Za-z0-9._-]+)\s*\}\}/g, (_, key) => inputs[key]?.trim() ?? "");
-    const transform = (value) => {
-      if (typeof value === "string") {
-        return replacer(value);
-      }
-      if (Array.isArray(value)) {
-        return value.map((entry) => transform(entry));
-      }
-      if (!value || typeof value !== "object") {
-        return value;
-      }
-      return Object.fromEntries(
-        Object.entries(value).map(([key, entry]) => [key, transform(entry)])
-      );
-    };
-    return transform(structuredClone(definition));
-  }
-  mergeScope(current, override) {
-    if (!override) {
-      return current;
-    }
-    const agents = Array.from(new Set((override.agents ?? current.agents ?? []).map((entry) => entry.trim()).filter(Boolean)));
-    const allAgents = override.allAgents ?? current.allAgents ?? agents.length === 0;
-    return {
-      allAgents,
-      agents: allAgents ? [] : agents
-    };
-  }
-  mergeMetadata(current, template, override) {
-    return {
-      ...current,
-      source: "marketplace",
-      catalogSlug: template.spec,
-      displayName: override?.displayName ?? current?.displayName,
-      vendor: override?.vendor ?? current?.vendor,
-      docsUrl: override?.docsUrl ?? current?.docsUrl,
-      homepage: override?.homepage ?? current?.homepage,
-      trustLevel: override?.trustLevel ?? current?.trustLevel ?? "official",
-      installedAt: override?.installedAt ?? current?.installedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
-      ...override ?? {}
-    };
-  }
+	materialize(params) {
+		const name = normalizeMcpServerName(params.name?.trim() || params.template.defaultName);
+		const inputs = params.inputs ?? {};
+		const definition = this.applyInputs(params.template.template, inputs);
+		definition.enabled = params.enabled ?? definition.enabled;
+		definition.scope = this.mergeScope(definition.scope, params.scope);
+		definition.metadata = this.mergeMetadata(definition.metadata, params.template, params.metadata);
+		return {
+			name,
+			definition
+		};
+	}
+	applyInputs(definition, inputs) {
+		const replacer = (value) => value.replace(/\{\{\s*([A-Za-z0-9._-]+)\s*\}\}/g, (_, key) => inputs[key]?.trim() ?? "");
+		const transform = (value) => {
+			if (typeof value === "string") return replacer(value);
+			if (Array.isArray(value)) return value.map((entry) => transform(entry));
+			if (!value || typeof value !== "object") return value;
+			return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, transform(entry)]));
+		};
+		return transform(structuredClone(definition));
+	}
+	mergeScope(current, override) {
+		if (!override) return current;
+		const agents = Array.from(new Set((override.agents ?? current.agents ?? []).map((entry) => entry.trim()).filter(Boolean)));
+		const allAgents = override.allAgents ?? current.allAgents ?? agents.length === 0;
+		return {
+			allAgents,
+			agents: allAgents ? [] : agents
+		};
+	}
+	mergeMetadata(current, template, override) {
+		return {
+			...current,
+			source: "marketplace",
+			catalogSlug: template.spec,
+			displayName: override?.displayName ?? current?.displayName,
+			vendor: override?.vendor ?? current?.vendor,
+			docsUrl: override?.docsUrl ?? current?.docsUrl,
+			homepage: override?.homepage ?? current?.homepage,
+			trustLevel: override?.trustLevel ?? current?.trustLevel ?? "official",
+			installedAt: override?.installedAt ?? current?.installedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+			...override ?? {}
+		};
+	}
 };
-
-// src/manage/mcp-mutation-service.ts
+//#endregion
+//#region src/manage/mcp-mutation-service.ts
 var McpMutationService = class {
-  constructor(options) {
-    this.options = options;
-    this.materializer = this.options.materializer ?? new McpInstallTemplateMaterializer();
-  }
-  materializer;
-  listServerNames() {
-    return listMcpServers(this.options.getConfig()).map((record) => record.name);
-  }
-  addServer(name, definition) {
-    const normalizedName = normalizeMcpServerName(name);
-    const config = this.options.getConfig();
-    if (config.mcp.servers[normalizedName]) {
-      return {
-        changed: false,
-        name: normalizedName,
-        message: `MCP server already exists: ${normalizedName}. Use 'mcp list' or remove it first.`,
-        definition: config.mcp.servers[normalizedName]
-      };
-    }
-    config.mcp.servers[normalizedName] = definition;
-    this.options.saveConfig(config);
-    return {
-      changed: true,
-      name: normalizedName,
-      message: `Added MCP server ${normalizedName}.`,
-      definition
-    };
-  }
-  updateServer(name, definition) {
-    const normalizedName = normalizeMcpServerName(name);
-    const config = this.options.getConfig();
-    if (!config.mcp.servers[normalizedName]) {
-      return {
-        changed: false,
-        name: normalizedName,
-        message: `Unknown MCP server: ${normalizedName}`
-      };
-    }
-    config.mcp.servers[normalizedName] = definition;
-    this.options.saveConfig(config);
-    return {
-      changed: true,
-      name: normalizedName,
-      message: `Updated MCP server ${normalizedName}.`,
-      definition
-    };
-  }
-  removeServer(name) {
-    const normalizedName = normalizeMcpServerName(name);
-    const config = this.options.getConfig();
-    if (!config.mcp.servers[normalizedName]) {
-      return {
-        changed: false,
-        name: normalizedName,
-        message: `Unknown MCP server: ${normalizedName}`
-      };
-    }
-    delete config.mcp.servers[normalizedName];
-    this.options.saveConfig(config);
-    return {
-      changed: true,
-      name: normalizedName,
-      message: `Removed MCP server ${normalizedName}.`
-    };
-  }
-  toggleEnabled(name, enabled) {
-    const normalizedName = normalizeMcpServerName(name);
-    const config = this.options.getConfig();
-    const current = config.mcp.servers[normalizedName];
-    if (!current) {
-      return {
-        changed: false,
-        name: normalizedName,
-        message: `Unknown MCP server: ${normalizedName}`
-      };
-    }
-    current.enabled = enabled;
-    this.options.saveConfig(config);
-    return {
-      changed: true,
-      name: normalizedName,
-      message: `${enabled ? "Enabled" : "Disabled"} MCP server ${normalizedName}.`,
-      definition: current
-    };
-  }
-  installFromTemplate(params) {
-    const materialized = this.materializer.materialize(params);
-    return this.addServer(materialized.name, materialized.definition);
-  }
-  duplicateServer(sourceName, targetName) {
-    const source = getMcpServer(this.options.getConfig(), sourceName);
-    if (!source) {
-      return {
-        changed: false,
-        name: normalizeMcpServerName(sourceName),
-        message: `Unknown MCP server: ${normalizeMcpServerName(sourceName)}`
-      };
-    }
-    const definition = structuredClone(source.definition);
-    if (definition.metadata) {
-      definition.metadata = {
-        ...definition.metadata,
-        installedAt: (/* @__PURE__ */ new Date()).toISOString()
-      };
-    }
-    return this.addServer(targetName, definition);
-  }
-  renameServer(sourceName, targetName) {
-    const source = getMcpServer(this.options.getConfig(), sourceName);
-    if (!source) {
-      return {
-        changed: false,
-        name: normalizeMcpServerName(sourceName),
-        message: `Unknown MCP server: ${normalizeMcpServerName(sourceName)}`
-      };
-    }
-    const nextName = normalizeMcpServerName(targetName);
-    const config = this.options.getConfig();
-    if (source.name === nextName) {
-      return {
-        changed: false,
-        name: nextName,
-        message: `MCP server already named ${nextName}.`,
-        definition: source.definition
-      };
-    }
-    if (config.mcp.servers[nextName]) {
-      return {
-        changed: false,
-        name: nextName,
-        message: `MCP server already exists: ${nextName}. Use another name.`
-      };
-    }
-    delete config.mcp.servers[source.name];
-    config.mcp.servers[nextName] = source.definition;
-    this.options.saveConfig(config);
-    return {
-      changed: true,
-      name: nextName,
-      message: `Renamed MCP server ${source.name} -> ${nextName}.`,
-      definition: source.definition
-    };
-  }
+	materializer;
+	constructor(options) {
+		this.options = options;
+		this.materializer = this.options.materializer ?? new McpInstallTemplateMaterializer();
+	}
+	listServerNames() {
+		return listMcpServers(this.options.getConfig()).map((record) => record.name);
+	}
+	addServer(name, definition) {
+		const normalizedName = normalizeMcpServerName(name);
+		const config = this.options.getConfig();
+		if (config.mcp.servers[normalizedName]) return {
+			changed: false,
+			name: normalizedName,
+			message: `MCP server already exists: ${normalizedName}. Use 'mcp list' or remove it first.`,
+			definition: config.mcp.servers[normalizedName]
+		};
+		config.mcp.servers[normalizedName] = definition;
+		this.options.saveConfig(config);
+		return {
+			changed: true,
+			name: normalizedName,
+			message: `Added MCP server ${normalizedName}.`,
+			definition
+		};
+	}
+	updateServer(name, definition) {
+		const normalizedName = normalizeMcpServerName(name);
+		const config = this.options.getConfig();
+		if (!config.mcp.servers[normalizedName]) return {
+			changed: false,
+			name: normalizedName,
+			message: `Unknown MCP server: ${normalizedName}`
+		};
+		config.mcp.servers[normalizedName] = definition;
+		this.options.saveConfig(config);
+		return {
+			changed: true,
+			name: normalizedName,
+			message: `Updated MCP server ${normalizedName}.`,
+			definition
+		};
+	}
+	removeServer(name) {
+		const normalizedName = normalizeMcpServerName(name);
+		const config = this.options.getConfig();
+		if (!config.mcp.servers[normalizedName]) return {
+			changed: false,
+			name: normalizedName,
+			message: `Unknown MCP server: ${normalizedName}`
+		};
+		delete config.mcp.servers[normalizedName];
+		this.options.saveConfig(config);
+		return {
+			changed: true,
+			name: normalizedName,
+			message: `Removed MCP server ${normalizedName}.`
+		};
+	}
+	toggleEnabled(name, enabled) {
+		const normalizedName = normalizeMcpServerName(name);
+		const config = this.options.getConfig();
+		const current = config.mcp.servers[normalizedName];
+		if (!current) return {
+			changed: false,
+			name: normalizedName,
+			message: `Unknown MCP server: ${normalizedName}`
+		};
+		current.enabled = enabled;
+		this.options.saveConfig(config);
+		return {
+			changed: true,
+			name: normalizedName,
+			message: `${enabled ? "Enabled" : "Disabled"} MCP server ${normalizedName}.`,
+			definition: current
+		};
+	}
+	installFromTemplate(params) {
+		const materialized = this.materializer.materialize(params);
+		return this.addServer(materialized.name, materialized.definition);
+	}
+	duplicateServer(sourceName, targetName) {
+		const source = getMcpServer(this.options.getConfig(), sourceName);
+		if (!source) return {
+			changed: false,
+			name: normalizeMcpServerName(sourceName),
+			message: `Unknown MCP server: ${normalizeMcpServerName(sourceName)}`
+		};
+		const definition = structuredClone(source.definition);
+		if (definition.metadata) definition.metadata = {
+			...definition.metadata,
+			installedAt: (/* @__PURE__ */ new Date()).toISOString()
+		};
+		return this.addServer(targetName, definition);
+	}
+	renameServer(sourceName, targetName) {
+		const source = getMcpServer(this.options.getConfig(), sourceName);
+		if (!source) return {
+			changed: false,
+			name: normalizeMcpServerName(sourceName),
+			message: `Unknown MCP server: ${normalizeMcpServerName(sourceName)}`
+		};
+		const nextName = normalizeMcpServerName(targetName);
+		const config = this.options.getConfig();
+		if (source.name === nextName) return {
+			changed: false,
+			name: nextName,
+			message: `MCP server already named ${nextName}.`,
+			definition: source.definition
+		};
+		if (config.mcp.servers[nextName]) return {
+			changed: false,
+			name: nextName,
+			message: `MCP server already exists: ${nextName}. Use another name.`
+		};
+		delete config.mcp.servers[source.name];
+		config.mcp.servers[nextName] = source.definition;
+		this.options.saveConfig(config);
+		return {
+			changed: true,
+			name: nextName,
+			message: `Renamed MCP server ${source.name} -> ${nextName}.`,
+			definition: source.definition
+		};
+	}
 };
-
-// src/view/mcp-installed-view-service.ts
+//#endregion
+//#region src/view/mcp-installed-view-service.ts
 var McpInstalledViewService = class {
-  constructor(options) {
-    this.options = options;
-    this.registryService = this.options.registryService ?? new McpRegistryService({
-      getConfig: this.options.getConfig
-    });
-  }
-  registryService;
-  listInstalled() {
-    return this.registryService.listServers().map((server) => {
-      const metadata = server.definition.metadata;
-      const cached = this.registryService.getCachedState(server.name);
-      return {
-        name: server.name,
-        enabled: server.definition.enabled,
-        transport: server.definition.transport.type,
-        scope: server.definition.scope,
-        source: metadata?.source === "marketplace" ? "marketplace" : "manual",
-        catalogSlug: metadata?.catalogSlug,
-        displayName: metadata?.displayName,
-        vendor: metadata?.vendor,
-        docsUrl: metadata?.docsUrl,
-        homepage: metadata?.homepage,
-        trustLevel: metadata?.trustLevel,
-        installedAt: metadata?.installedAt,
-        accessible: cached?.clientReady,
-        toolCount: cached?.tools.length,
-        lastReadyAt: cached?.lastReadyAt,
-        lastError: cached?.lastError
-      };
-    });
-  }
-};
-export {
-  McpClientFactory,
-  McpDoctorFacade,
-  McpDoctorService,
-  McpInstallTemplateMaterializer,
-  McpInstalledViewService,
-  McpMutationService,
-  McpRegistryService,
-  McpServerLifecycleManager,
-  buildQualifiedMcpToolName,
-  getMcpServer,
-  isServerAccessibleToAgent,
-  listMcpServers,
-  normalizeMcpServerName,
-  readDefaultAgentId,
-  sanitizeMcpSegment
+	registryService;
+	constructor(options) {
+		this.options = options;
+		this.registryService = this.options.registryService ?? new McpRegistryService({ getConfig: this.options.getConfig });
+	}
+	listInstalled() {
+		return this.registryService.listServers().map((server) => {
+			const metadata = server.definition.metadata;
+			const cached = this.registryService.getCachedState(server.name);
+			return {
+				name: server.name,
+				enabled: server.definition.enabled,
+				transport: server.definition.transport.type,
+				scope: server.definition.scope,
+				source: metadata?.source === "marketplace" ? "marketplace" : "manual",
+				catalogSlug: metadata?.catalogSlug,
+				displayName: metadata?.displayName,
+				vendor: metadata?.vendor,
+				docsUrl: metadata?.docsUrl,
+				homepage: metadata?.homepage,
+				trustLevel: metadata?.trustLevel,
+				installedAt: metadata?.installedAt,
+				accessible: cached?.clientReady,
+				toolCount: cached?.tools.length,
+				lastReadyAt: cached?.lastReadyAt,
+				lastError: cached?.lastError
+			};
+		});
+	}
 };
+//#endregion
+export { McpClientFactory, McpDoctorFacade, McpDoctorService, McpInstallTemplateMaterializer, McpInstalledViewService, McpMutationService, McpRegistryService, McpServerLifecycleManager, buildQualifiedMcpToolName, getMcpServer, isServerAccessibleToAgent, listMcpServers, normalizeMcpServerName, readDefaultAgentId, sanitizeMcpSegment };