@xopcai/xopc 0.0.368 → 0.0.370

package/dist/src/agent/mcp/bundle-mcp-runtime.js

@@ -1,571 +0,0 @@
-import { createLogger } from "../../utils/logger/index.js";
-import { init_logger } from "../../utils/logger.js";
-import { init_global_singleton, resolveGlobalSingleton } from "../../utils/global-singleton.js";
-import { init_string_coerce, normalizeOptionalString } from "../../utils/string-coerce.js";
-import { resolveConnectorSecretReferences } from "../../connectors/secret-store.js";
-import { recordPluginMcpHealth } from "../../extensions/agent-plugins/health.js";
-import { redactSensitiveUrlLikeString } from "../../utils/redact-sensitive-url.js";
-import { loadEmbeddedMcpConfig } from "./embedded-mcp.js";
-import { isMcpConfigRecord } from "./mcp-config-shared.js";
-import { isMcpAuthorizationError } from "./oauth/mcp-oauth-errors.js";
-import { resolveMcpTransport } from "./mcp-transport.js";
-import { sanitizeServerName } from "./bundle-mcp-names.js";
-import crypto from "node:crypto";
-import Ajv2020 from "ajv/dist/2020.js";
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import { AjvJsonSchemaValidator } from "@modelcontextprotocol/sdk/validation/ajv-provider.js";
-//#region src/agent/mcp/bundle-mcp-runtime.ts
-init_logger();
-init_global_singleton();
-init_string_coerce();
-const log = createLogger("Mcp:Bundle");
-const SESSION_MCP_RUNTIME_MANAGER_KEY = Symbol.for("xopc.sessionMcpRuntimeManager");
-const DRAFT_2020_12_SCHEMA = "https://json-schema.org/draft/2020-12/schema";
-const DEFAULT_SESSION_MCP_RUNTIME_IDLE_TTL_MS = 600 * 1e3;
-const SESSION_MCP_RUNTIME_SWEEP_INTERVAL_MS = 60 * 1e3;
-function isDraft202012Schema(schema) {
-	return schema.$schema === DRAFT_2020_12_SCHEMA;
-}
-function createBundleMcpJsonSchemaValidator() {
-	const defaultValidator = new AjvJsonSchemaValidator();
-	const ajv2020 = new Ajv2020({
-		strict: false,
-		validateFormats: false,
-		validateSchema: false,
-		allErrors: true
-	});
-	return { getValidator(schema) {
-		if (!isDraft202012Schema(schema)) return defaultValidator.getValidator(schema);
-		const ajvValidator = ajv2020.compile(schema);
-		return (input) => {
-			if (ajvValidator(input)) return {
-				valid: true,
-				data: input,
-				errorMessage: void 0
-			};
-			return {
-				valid: false,
-				data: void 0,
-				errorMessage: ajv2020.errorsText(ajvValidator.errors)
-			};
-		};
-	} };
-}
-function connectWithTimeout(client, transport, timeoutMs) {
-	return new Promise((resolve, reject) => {
-		const timer = setTimeout(() => reject(/* @__PURE__ */ new Error(`MCP server connection timed out after ${timeoutMs}ms`)), timeoutMs);
-		client.connect(transport).then((value) => {
-			clearTimeout(timer);
-			resolve(value);
-		}, (error) => {
-			clearTimeout(timer);
-			reject(error);
-		});
-	});
-}
-function redactErrorUrls(error) {
-	return redactSensitiveUrlLikeString(String(error));
-}
-async function listAllTools(client) {
-	const tools = [];
-	let cursor;
-	do {
-		const page = await client.listTools(cursor ? { cursor } : void 0);
-		tools.push(...page.tools);
-		cursor = page.nextCursor;
-	} while (cursor);
-	return tools;
-}
-async function listAllResources(client) {
-	const resources = [];
-	let cursor;
-	do {
-		const page = await client.listResources(cursor ? { cursor } : void 0);
-		resources.push(...page.resources);
-		cursor = page.nextCursor;
-	} while (cursor);
-	return resources;
-}
-async function listAllPrompts(client) {
-	const prompts = [];
-	let cursor;
-	do {
-		const page = await client.listPrompts(cursor ? { cursor } : void 0);
-		prompts.push(...page.prompts);
-		cursor = page.nextCursor;
-	} while (cursor);
-	return prompts;
-}
-async function listOptionalMcpCapability(params) {
-	try {
-		return await params.list();
-	} catch (error) {
-		log.debug({
-			phase: "agent.mcp_connect",
-			serverName: params.serverName,
-			capability: params.capability,
-			errorMessage: redactErrorUrls(error)
-		}, `bundle-mcp: server "${params.serverName}" did not list ${params.capability}`);
-		return [];
-	}
-}
-async function disposeSession(session) {
-	session.detachStderr?.();
-	if (session.transportType === "streamable-http") await session.transport.terminateSession().catch(() => {});
-	await session.transport.close().catch(() => {});
-	await session.client.close().catch(() => {});
-}
-function createCatalogFingerprint(servers) {
-	return crypto.createHash("sha1").update(JSON.stringify(servers)).digest("hex");
-}
-function loadSessionMcpConfig(params) {
-	const loaded = loadEmbeddedMcpConfig({
-		workspaceDir: params.workspaceDir,
-		cfg: params.cfg
-	});
-	if (params.logDiagnostics !== false) for (const diagnostic of loaded.diagnostics) log.warn({
-		phase: "agent.mcp_connect",
-		extensionId: diagnostic.extensionId,
-		message: diagnostic.message
-	}, `bundle-mcp diagnostic: ${diagnostic.extensionId}: ${diagnostic.message}`);
-	return {
-		loaded,
-		fingerprint: createCatalogFingerprint(loaded.mcpServers)
-	};
-}
-function createDisposedError(sessionId) {
-	return /* @__PURE__ */ new Error(`bundle-mcp runtime disposed for session ${sessionId}`);
-}
-function resolveSessionMcpRuntimeIdleTtlMs(cfg) {
-	const raw = cfg?.mcp?.sessionIdleTtlMs;
-	if (typeof raw === "number" && Number.isFinite(raw) && raw >= 0) return Math.floor(raw);
-	return DEFAULT_SESSION_MCP_RUNTIME_IDLE_TTL_MS;
-}
-function createSessionMcpRuntime(params) {
-	const { loaded, fingerprint: configFingerprint } = loadSessionMcpConfig({
-		workspaceDir: params.workspaceDir,
-		cfg: params.cfg,
-		logDiagnostics: true
-	});
-	const createdAt = Date.now();
-	let lastUsedAt = createdAt;
-	let activeLeases = 0;
-	let disposed = false;
-	let catalog = null;
-	let catalogInFlight;
-	const sessions = /* @__PURE__ */ new Map();
-	const failIfDisposed = () => {
-		if (disposed) throw createDisposedError(params.sessionId);
-	};
-	const getCatalog = async () => {
-		failIfDisposed();
-		if (catalog) return catalog;
-		if (catalogInFlight) return catalogInFlight;
-		catalogInFlight = (async () => {
-			if (Object.keys(loaded.mcpServers).length === 0) return {
-				version: 1,
-				generatedAt: Date.now(),
-				servers: {},
-				tools: [],
-				resources: [],
-				prompts: []
-			};
-			const servers = {};
-			const tools = [];
-			const resources = [];
-			const prompts = [];
-			const usedServerNames = /* @__PURE__ */ new Set();
-			try {
-				for (const [serverName, rawServer] of Object.entries(loaded.mcpServers)) {
-					failIfDisposed();
-					let resolved;
-					try {
-						resolved = await resolveMcpTransport(serverName, await resolveConnectorSecretReferences(rawServer), params.cfg);
-					} catch (error) {
-						recordPluginMcpHealth(rawServer, "error");
-						servers[serverName] = {
-							serverName,
-							launchSummary: "",
-							toolCount: 0,
-							resourceCount: 0,
-							promptCount: 0,
-							error: {
-								code: "MCP_CONNECTION_FAILED",
-								message: redactErrorUrls(error)
-							}
-						};
-						continue;
-					}
-					if (!resolved) continue;
-					const safeServerName = sanitizeServerName(serverName, usedServerNames);
-					if (safeServerName !== serverName) log.warn({
-						phase: "agent.mcp_connect",
-						serverName,
-						safeServerName
-					}, `bundle-mcp: server key "${serverName}" uses policy namespace "${safeServerName}"`);
-					const client = new Client({
-						name: "xopc-bundle-mcp",
-						version: "0.0.0"
-					}, { jsonSchemaValidator: createBundleMcpJsonSchemaValidator() });
-					const session = {
-						serverName,
-						client,
-						transport: resolved.transport,
-						transportType: resolved.transportType,
-						requestTimeoutMs: resolved.requestTimeoutMs,
-						detachStderr: resolved.detachStderr
-					};
-					sessions.set(serverName, session);
-					try {
-						failIfDisposed();
-						await connectWithTimeout(client, resolved.transport, resolved.connectionTimeoutMs);
-						failIfDisposed();
-						const listedTools = await listAllTools(client);
-						recordPluginMcpHealth(rawServer, "ready");
-						const listedResources = await listOptionalMcpCapability({
-							serverName,
-							capability: "resources",
-							list: () => listAllResources(client)
-						});
-						const listedPrompts = await listOptionalMcpCapability({
-							serverName,
-							capability: "prompts",
-							list: () => listAllPrompts(client)
-						});
-						failIfDisposed();
-						servers[serverName] = {
-							serverName,
-							launchSummary: resolved.description,
-							toolCount: listedTools.length,
-							resourceCount: listedResources.length,
-							promptCount: listedPrompts.length
-						};
-						for (const tool of listedTools) {
-							const toolName = tool.name.trim();
-							if (!toolName) continue;
-							tools.push({
-								serverName,
-								safeServerName,
-								toolName,
-								title: tool.title,
-								description: normalizeOptionalString(tool.description) ?? normalizeOptionalString(tool.title),
-								inputSchema: tool.inputSchema,
-								annotations: tool.annotations,
-								fallbackDescription: `Provided by bundle MCP server "${serverName}" (${resolved.description}).`
-							});
-						}
-						for (const resource of listedResources) {
-							const uri = resource.uri.trim();
-							const name = resource.name.trim();
-							if (!uri || !name) continue;
-							resources.push({
-								serverName,
-								uri,
-								name,
-								title: resource.title,
-								description: normalizeOptionalString(resource.description),
-								mimeType: normalizeOptionalString(resource.mimeType)
-							});
-						}
-						for (const prompt of listedPrompts) {
-							const name = prompt.name.trim();
-							if (!name) continue;
-							prompts.push({
-								serverName,
-								name,
-								title: prompt.title,
-								description: normalizeOptionalString(prompt.description),
-								argumentCount: Array.isArray(prompt.arguments) ? prompt.arguments.length : 0
-							});
-						}
-					} catch (error) {
-						servers[serverName] = {
-							serverName,
-							launchSummary: resolved.description,
-							toolCount: 0,
-							resourceCount: 0,
-							promptCount: 0,
-							error: {
-								code: isMcpAuthorizationError(error) || error?.code === 401 ? "MCP_AUTHORIZATION_REQUIRED" : "MCP_CONNECTION_FAILED",
-								message: redactErrorUrls(error)
-							}
-						};
-						recordPluginMcpHealth(rawServer, servers[serverName].error?.code === "MCP_AUTHORIZATION_REQUIRED" ? "authorization_required" : "error");
-						if (!disposed) log.warn(`bundle-mcp: failed to start server "${serverName}" (${resolved.description}): ${redactErrorUrls(error)}`);
-						await disposeSession(session);
-						sessions.delete(serverName);
-						failIfDisposed();
-					}
-				}
-				failIfDisposed();
-				return {
-					version: 1,
-					generatedAt: Date.now(),
-					servers,
-					tools,
-					resources,
-					prompts
-				};
-			} catch (error) {
-				await Promise.allSettled(Array.from(sessions.values(), (session) => disposeSession(session)));
-				sessions.clear();
-				throw error;
-			}
-		})();
-		try {
-			const nextCatalog = await catalogInFlight;
-			failIfDisposed();
-			catalog = nextCatalog;
-			return nextCatalog;
-		} finally {
-			catalogInFlight = void 0;
-		}
-	};
-	return {
-		sessionId: params.sessionId,
-		conversationId: params.conversationId,
-		workspaceDir: params.workspaceDir,
-		configFingerprint,
-		createdAt,
-		get lastUsedAt() {
-			return lastUsedAt;
-		},
-		get activeLeases() {
-			return activeLeases;
-		},
-		acquireLease() {
-			activeLeases += 1;
-			let released = false;
-			return () => {
-				if (released) return;
-				released = true;
-				activeLeases = Math.max(0, activeLeases - 1);
-				lastUsedAt = Date.now();
-			};
-		},
-		getCatalog,
-		markUsed() {
-			lastUsedAt = Date.now();
-		},
-		async callTool(serverName, toolName, input, signal) {
-			failIfDisposed();
-			await getCatalog();
-			const session = sessions.get(serverName);
-			if (!session) throw new Error(`bundle-mcp server "${serverName}" is not connected`);
-			return await session.client.callTool({
-				name: toolName,
-				arguments: isMcpConfigRecord(input) ? input : {}
-			}, void 0, {
-				signal,
-				timeout: session.requestTimeoutMs,
-				maxTotalTimeout: session.requestTimeoutMs
-			});
-		},
-		async readResource(serverName, uri, signal) {
-			failIfDisposed();
-			if (!(await getCatalog()).resources.some((resource) => resource.serverName === serverName && resource.uri === uri)) throw new Error(`bundle-mcp resource "${uri}" is not available from server "${serverName}"`);
-			const session = sessions.get(serverName);
-			if (!session) throw new Error(`bundle-mcp server "${serverName}" is not connected`);
-			return session.client.readResource({ uri }, {
-				signal,
-				timeout: session.requestTimeoutMs,
-				maxTotalTimeout: session.requestTimeoutMs
-			});
-		},
-		async dispose() {
-			if (disposed) return;
-			disposed = true;
-			catalog = null;
-			catalogInFlight = void 0;
-			const sessionsToClose = Array.from(sessions.values());
-			sessions.clear();
-			await Promise.allSettled(sessionsToClose.map((session) => disposeSession(session)));
-		}
-	};
-}
-function createSessionMcpRuntimeManager(opts = {}) {
-	const runtimesBySessionId = /* @__PURE__ */ new Map();
-	const sessionIdByConversationId = /* @__PURE__ */ new Map();
-	const idleTtlMsBySessionId = /* @__PURE__ */ new Map();
-	const createRuntime = opts.createRuntime ?? createSessionMcpRuntime;
-	const now = opts.now ?? Date.now;
-	const createInFlight = /* @__PURE__ */ new Map();
-	const idleSweepIntervalMs = opts.idleSweepIntervalMs ?? SESSION_MCP_RUNTIME_SWEEP_INTERVAL_MS;
-	let idleSweepTimer;
-	let idleSweepInFlight;
-	const forgetConversationIdsForSessionId = (sessionId) => {
-		for (const [conversationId, mappedSessionId] of sessionIdByConversationId.entries()) if (mappedSessionId === sessionId) sessionIdByConversationId.delete(conversationId);
-	};
-	const sweepIdleRuntimes = async () => {
-		const nowMs = now();
-		const expired = [];
-		for (const [sessionId, runtime] of runtimesBySessionId.entries()) {
-			const idleTtlMs = idleTtlMsBySessionId.get(sessionId) ?? DEFAULT_SESSION_MCP_RUNTIME_IDLE_TTL_MS;
-			if (idleTtlMs <= 0 || (runtime.activeLeases ?? 0) > 0) continue;
-			if (nowMs - runtime.lastUsedAt < idleTtlMs) continue;
-			runtimesBySessionId.delete(sessionId);
-			idleTtlMsBySessionId.delete(sessionId);
-			forgetConversationIdsForSessionId(sessionId);
-			expired.push(runtime);
-		}
-		await Promise.allSettled(expired.map((runtime) => runtime.dispose()));
-		return expired.length;
-	};
-	const queueIdleSweep = () => {
-		if (idleSweepInFlight) return;
-		idleSweepInFlight = sweepIdleRuntimes().then(() => void 0).catch((error) => {
-			const em = error instanceof Error ? error.message : String(error);
-			log.warn({
-				err: error,
-				errorMessage: em,
-				phase: "agent.mcp_connect"
-			}, `bundle-mcp: idle runtime sweep failed: ${em}`);
-		}).finally(() => {
-			idleSweepInFlight = void 0;
-		});
-	};
-	const ensureIdleSweepTimer = () => {
-		if (opts.enableIdleSweepTimer === false || idleSweepIntervalMs <= 0 || idleSweepTimer) return;
-		idleSweepTimer = setInterval(queueIdleSweep, idleSweepIntervalMs);
-		idleSweepTimer.unref?.();
-	};
-	const clearIdleSweepTimer = () => {
-		if (!idleSweepTimer) return;
-		clearInterval(idleSweepTimer);
-		idleSweepTimer = void 0;
-	};
-	return {
-		async getOrCreate(params) {
-			const idleTtlMs = resolveSessionMcpRuntimeIdleTtlMs(params.cfg);
-			if (runtimesBySessionId.has(params.sessionId)) idleTtlMsBySessionId.set(params.sessionId, idleTtlMs);
-			await sweepIdleRuntimes();
-			if (idleTtlMs > 0) ensureIdleSweepTimer();
-			if (params.conversationId) sessionIdByConversationId.set(params.conversationId, params.sessionId);
-			const { fingerprint: nextFingerprint } = loadSessionMcpConfig({
-				workspaceDir: params.workspaceDir,
-				cfg: params.cfg,
-				logDiagnostics: false
-			});
-			const existing = runtimesBySessionId.get(params.sessionId);
-			if (existing) if (existing.workspaceDir !== params.workspaceDir || existing.configFingerprint !== nextFingerprint) {
-				runtimesBySessionId.delete(params.sessionId);
-				await existing.dispose();
-			} else {
-				existing.markUsed();
-				idleTtlMsBySessionId.set(params.sessionId, idleTtlMs);
-				return existing;
-			}
-			const inFlight = createInFlight.get(params.sessionId);
-			if (inFlight) {
-				if (inFlight.workspaceDir === params.workspaceDir && inFlight.configFingerprint === nextFingerprint) return inFlight.promise;
-				createInFlight.delete(params.sessionId);
-				const staleRuntime = await inFlight.promise.catch(() => void 0);
-				runtimesBySessionId.delete(params.sessionId);
-				idleTtlMsBySessionId.delete(params.sessionId);
-				await staleRuntime?.dispose();
-			}
-			const created = Promise.resolve(createRuntime({
-				sessionId: params.sessionId,
-				conversationId: params.conversationId,
-				workspaceDir: params.workspaceDir,
-				cfg: params.cfg
-			})).then((runtime) => {
-				runtime.markUsed();
-				runtimesBySessionId.set(params.sessionId, runtime);
-				idleTtlMsBySessionId.set(params.sessionId, idleTtlMs);
-				return runtime;
-			});
-			createInFlight.set(params.sessionId, {
-				promise: created,
-				workspaceDir: params.workspaceDir,
-				configFingerprint: nextFingerprint
-			});
-			try {
-				return await created;
-			} finally {
-				createInFlight.delete(params.sessionId);
-			}
-		},
-		bindConversationId(conversationId, sessionId) {
-			sessionIdByConversationId.set(conversationId, sessionId);
-		},
-		resolveSessionId(conversationId) {
-			return sessionIdByConversationId.get(conversationId);
-		},
-		async disposeSession(sessionId) {
-			const inFlight = createInFlight.get(sessionId);
-			createInFlight.delete(sessionId);
-			let runtime = runtimesBySessionId.get(sessionId);
-			if (!runtime && inFlight) runtime = await inFlight.promise.catch(() => void 0);
-			runtimesBySessionId.delete(sessionId);
-			idleTtlMsBySessionId.delete(sessionId);
-			if (!runtime) {
-				forgetConversationIdsForSessionId(sessionId);
-				return;
-			}
-			forgetConversationIdsForSessionId(sessionId);
-			await runtime.dispose();
-		},
-		async disposeAll() {
-			clearIdleSweepTimer();
-			const inFlightRuntimes = Array.from(createInFlight.values());
-			createInFlight.clear();
-			const runtimes = Array.from(runtimesBySessionId.values());
-			runtimesBySessionId.clear();
-			sessionIdByConversationId.clear();
-			idleTtlMsBySessionId.clear();
-			const lateRuntimes = await Promise.all(inFlightRuntimes.map(async ({ promise }) => await promise.catch(() => void 0)));
-			const allRuntimes = new Set(runtimes);
-			for (const runtime of lateRuntimes) if (runtime) allRuntimes.add(runtime);
-			await Promise.allSettled(Array.from(allRuntimes, (runtime) => runtime.dispose()));
-		},
-		sweepIdleRuntimes,
-		listSessionIds() {
-			return Array.from(runtimesBySessionId.keys());
-		}
-	};
-}
-function getSessionMcpRuntimeManager() {
-	return resolveGlobalSingleton(SESSION_MCP_RUNTIME_MANAGER_KEY, createSessionMcpRuntimeManager);
-}
-async function getOrCreateSessionMcpRuntime(params) {
-	return await getSessionMcpRuntimeManager().getOrCreate(params);
-}
-async function disposeSessionMcpRuntime(sessionId) {
-	await getSessionMcpRuntimeManager().disposeSession(sessionId);
-}
-async function retireSessionMcpRuntime(params) {
-	const sessionId = normalizeOptionalString(params.sessionId);
-	if (!sessionId) return false;
-	try {
-		await disposeSessionMcpRuntime(sessionId);
-		return true;
-	} catch (error) {
-		params.onError?.(error, sessionId, params.reason);
-		return false;
-	}
-}
-async function retireSessionMcpRuntimeForConversationId(params) {
-	const conversationId = normalizeOptionalString(params.conversationId);
-	if (!conversationId) return false;
-	return await retireSessionMcpRuntime({
-		sessionId: getSessionMcpRuntimeManager().resolveSessionId(conversationId),
-		reason: params.reason,
-		onError: params.onError
-	});
-}
-async function disposeAllSessionMcpRuntimes() {
-	await getSessionMcpRuntimeManager().disposeAll();
-}
-const __testing = {
-	createSessionMcpRuntimeManager,
-	async resetSessionMcpRuntimeManager() {
-		await disposeAllSessionMcpRuntimes();
-	},
-	getCachedSessionIds() {
-		return getSessionMcpRuntimeManager().listSessionIds();
-	},
-	resolveSessionMcpRuntimeIdleTtlMs
-};
-//#endregion
-export { __testing, createBundleMcpJsonSchemaValidator, createSessionMcpRuntime, disposeAllSessionMcpRuntimes, disposeSessionMcpRuntime, getOrCreateSessionMcpRuntime, getSessionMcpRuntimeManager, retireSessionMcpRuntime, retireSessionMcpRuntimeForConversationId };

package/dist/src/agent/mcp/bundle-mcp-tools.d.ts

@@ -1,2 +0,0 @@
-export type { McpCatalogTool, McpServerCatalog, McpToolCatalog, SessionMcpRuntime, SessionMcpRuntimeManager, } from "./bundle-mcp-types.js";
-export { __testing, createSessionMcpRuntime, disposeAllSessionMcpRuntimes, disposeSessionMcpRuntime, getOrCreateSessionMcpRuntime, getSessionMcpRuntimeManager, retireSessionMcpRuntime, retireSessionMcpRuntimeForConversationId, } from "./bundle-mcp-runtime.js";

package/dist/src/agent/mcp/bundle-mcp-tools.js

@@ -1,2 +0,0 @@
-import { __testing, createSessionMcpRuntime, disposeAllSessionMcpRuntimes, disposeSessionMcpRuntime, getOrCreateSessionMcpRuntime, getSessionMcpRuntimeManager, retireSessionMcpRuntime, retireSessionMcpRuntimeForConversationId } from "./bundle-mcp-runtime.js";
-export { __testing, createSessionMcpRuntime, disposeAllSessionMcpRuntimes, disposeSessionMcpRuntime, getOrCreateSessionMcpRuntime, getSessionMcpRuntimeManager, retireSessionMcpRuntime, retireSessionMcpRuntimeForConversationId };

package/dist/src/agent/mcp/bundle-mcp-types.d.ts

@@ -1,76 +0,0 @@
-import type { CallToolResult, ReadResourceResult, ToolAnnotations } from "@modelcontextprotocol/sdk/types.js";
-import type { JsonSchemaType } from "@modelcontextprotocol/sdk/validation/types.js";
-import type { Config } from "../../config/schema.js";
-export type McpServerCatalog = {
-    serverName: string;
-    launchSummary: string;
-    toolCount: number;
-    resourceCount: number;
-    promptCount: number;
-    error?: {
-        code: 'MCP_AUTHORIZATION_REQUIRED' | 'MCP_CONNECTION_FAILED';
-        message: string;
-    };
-};
-export type McpCatalogTool = {
-    serverName: string;
-    safeServerName: string;
-    toolName: string;
-    title?: string;
-    description?: string;
-    inputSchema: JsonSchemaType;
-    annotations?: ToolAnnotations;
-    fallbackDescription: string;
-};
-export type McpCatalogResource = {
-    serverName: string;
-    uri: string;
-    name: string;
-    title?: string;
-    description?: string;
-    mimeType?: string;
-};
-export type McpCatalogPrompt = {
-    serverName: string;
-    name: string;
-    title?: string;
-    description?: string;
-    argumentCount: number;
-};
-export type McpToolCatalog = {
-    version: number;
-    generatedAt: number;
-    servers: Record<string, McpServerCatalog>;
-    tools: McpCatalogTool[];
-    resources: McpCatalogResource[];
-    prompts: McpCatalogPrompt[];
-};
-export type SessionMcpRuntime = {
-    sessionId: string;
-    conversationId?: string;
-    workspaceDir: string;
-    configFingerprint: string;
-    createdAt: number;
-    lastUsedAt: number;
-    activeLeases?: number;
-    acquireLease?: () => () => void;
-    getCatalog: () => Promise<McpToolCatalog>;
-    markUsed: () => void;
-    callTool: (serverName: string, toolName: string, input: unknown, signal?: AbortSignal) => Promise<CallToolResult>;
-    readResource: (serverName: string, uri: string, signal?: AbortSignal) => Promise<ReadResourceResult>;
-    dispose: () => Promise<void>;
-};
-export type SessionMcpRuntimeManager = {
-    getOrCreate: (params: {
-        sessionId: string;
-        conversationId?: string;
-        workspaceDir: string;
-        cfg?: Config;
-    }) => Promise<SessionMcpRuntime>;
-    bindConversationId: (conversationId: string, sessionId: string) => void;
-    resolveSessionId: (conversationId: string) => string | undefined;
-    disposeSession: (sessionId: string) => Promise<void>;
-    disposeAll: () => Promise<void>;
-    sweepIdleRuntimes: () => Promise<number>;
-    listSessionIds: () => string[];
-};

package/dist/src/agent/mcp/bundle-mcp-types.js

@@ -1 +0,0 @@
-export {};

package/dist/src/agent/mcp/embedded-mcp.d.ts

@@ -1,10 +0,0 @@
-import type { Config } from "../../config/schema.js";
-import { type BundleMcpDiagnostic, type BundleMcpServerConfig } from "./bundle-mcp-config.js";
-export type EmbeddedMcpConfig = {
-    mcpServers: Record<string, BundleMcpServerConfig>;
-    diagnostics: BundleMcpDiagnostic[];
-};
-export declare function loadEmbeddedMcpConfig(params: {
-    workspaceDir: string;
-    cfg?: Config;
-}): EmbeddedMcpConfig;

package/dist/src/agent/mcp/embedded-mcp.js

@@ -1,14 +0,0 @@
-import { loadMergedBundleMcpConfig } from "./bundle-mcp-config.js";
-//#region src/agent/mcp/embedded-mcp.ts
-function loadEmbeddedMcpConfig(params) {
-	const bundleMcp = loadMergedBundleMcpConfig({
-		workspaceDir: params.workspaceDir,
-		cfg: params.cfg
-	});
-	return {
-		mcpServers: bundleMcp.config.mcpServers,
-		diagnostics: bundleMcp.diagnostics
-	};
-}
-//#endregion
-export { loadEmbeddedMcpConfig };

package/dist/src/agent/mcp/index.d.ts

@@ -1,5 +0,0 @@
-export * from './bundle-mcp-tools.js';
-export * from './bundle-mcp-policy.js';
-export * from './bundle-mcp-config.js';
-export * from './embedded-mcp.js';
-export * from './oauth/index.js';