openclaw/dist/agent-bundle-mcp-runtime-config-MN40lQtN.js

Multi-channel AI gateway with extensible messaging integrations

import { t as assignSafeServerNames } from "./agent-bundle-mcp-names-CP3ugHLh.js";
import { i as logWarn } from "./logger-DwECwNVZ.js";
import { t as loadMergedBundleMcpConfig } from "./bundle-mcp-config-D7dA4odX.js";
import { a as redactMcpServersForFingerprint, i as partitionMcpServersByConnectionScope } from "./mcp-connection-resolver-FyG5JEPz.js";
import crypto from "node:crypto";
//#region src/agents/embedded-agent-mcp.ts
/** Loads merged MCP server config for an embedded agent workspace. */
function loadEmbeddedAgentMcpConfig(params) {
	const bundleMcp = loadMergedBundleMcpConfig({
		workspaceDir: params.workspaceDir,
		cfg: params.cfg,
		manifestRegistry: params.manifestRegistry,
		toolOverrides: params.toolOverrides
	});
	return {
		mcpServers: bundleMcp.config.mcpServers,
		diagnostics: bundleMcp.diagnostics,
		prepareDataDirsByServer: bundleMcp.prepareDataDirsByServer
	};
}
//#endregion
//#region src/agents/agent-bundle-mcp-runtime-config.ts
/** Session MCP config loading, filtering, and catalog fingerprints. */
function digestSafeServerNameAssignments(safeServerNamesByServer) {
	if (!safeServerNamesByServer || safeServerNamesByServer.size === 0) return;
	return Object.fromEntries([...safeServerNamesByServer.entries()].toSorted(([a], [b]) => a.localeCompare(b)));
}
function digestMcpToolDenials(value) {
	const entries = Object.entries(value ?? {}).map(([serverName, toolNames]) => [serverName, [...new Set(toolNames)].toSorted((left, right) => left.localeCompare(right))]).filter(([, toolNames]) => toolNames.length > 0).toSorted(([left], [right]) => left.localeCompare(right));
	return entries.length > 0 ? Object.fromEntries(entries) : void 0;
}
function createCatalogFingerprint(params) {
	return crypto.createHash("sha256").update(JSON.stringify(params)).digest("hex");
}
function filterMcpServers(mcpServers, options) {
	if (!options?.includeServerNames && !options?.excludeServerNames) return mcpServers;
	const filtered = {};
	for (const [serverName, rawServer] of Object.entries(mcpServers)) {
		if (options.includeServerNames && !options.includeServerNames.has(serverName)) continue;
		if (options.excludeServerNames?.has(serverName)) continue;
		filtered[serverName] = rawServer;
	}
	return filtered;
}
function loadSessionMcpConfig(params) {
	const loaded = params.loaded ?? loadEmbeddedAgentMcpConfig({
		workspaceDir: params.workspaceDir,
		cfg: params.cfg,
		manifestRegistry: params.manifestRegistry,
		toolOverrides: params.toolOverrides
	});
	if (params.logDiagnostics !== false) for (const diagnostic of loaded.diagnostics) logWarn(`bundle-mcp: ${diagnostic.pluginId}: ${diagnostic.message}`);
	const safeServerNames = digestSafeServerNameAssignments(params.safeServerNamesByServer);
	const mcpAppsEnabled = params.cfg?.mcp?.apps?.enabled === true;
	const mcpToolsDeny = digestMcpToolDenials(params.toolOverrides?.mcpToolsDeny);
	const mcpServers = filterMcpServers(loaded.mcpServers, {
		includeServerNames: params.includeServerNames,
		excludeServerNames: params.excludeServerNames
	});
	const prepareDataDirsByServer = Object.fromEntries(Object.entries(loaded.prepareDataDirsByServer ?? {}).filter(([serverName]) => Object.hasOwn(mcpServers, serverName)));
	const fingerprintServers = params.redactConnectionServerNames?.size ? redactMcpServersForFingerprint(mcpServers, params.redactConnectionServerNames) : mcpServers;
	const result = {
		loaded: {
			...loaded,
			mcpServers,
			prepareDataDirsByServer
		},
		fingerprint: createCatalogFingerprint({
			servers: fingerprintServers,
			mcpAppsEnabled,
			...safeServerNames ? { safeServerNames } : {},
			mcpToolsDeny
		})
	};
	return structuredClone(result);
}
/**
* Loads enabled MCP config metadata for a session without creating runtimes,
* connecting transports, or issuing MCP tools/list requests.
*/
function resolveSessionMcpConfigSummary(params) {
	const loaded = loadEmbeddedAgentMcpConfig(params);
	const declaredServerNames = Object.keys(loaded.mcpServers);
	const serverNames = declaredServerNames.toSorted((a, b) => a.localeCompare(b));
	const safeServerNamesByServer = assignSafeServerNames(declaredServerNames);
	const { requesterScopedServerNames } = partitionMcpServersByConnectionScope(loaded.mcpServers);
	const { fingerprint } = loadSessionMcpConfig({
		...params,
		loaded,
		logDiagnostics: false,
		...requesterScopedServerNames.length > 0 ? { excludeServerNames: new Set(requesterScopedServerNames) } : {},
		safeServerNamesByServer
	});
	return {
		fingerprint,
		serverNames
	};
}
/** Reads the enabled static MCP server set without opening transports or listing tools. */
function resolveStaticSessionMcpServerNames(params) {
	const { loaded } = loadSessionMcpConfig({
		...params,
		logDiagnostics: false
	});
	const { staticServers } = partitionMcpServersByConnectionScope(loaded.mcpServers);
	return Object.keys(staticServers).toSorted((left, right) => left.localeCompare(right));
}
//#endregion
export { loadEmbeddedAgentMcpConfig as i, resolveSessionMcpConfigSummary as n, resolveStaticSessionMcpServerNames as r, loadSessionMcpConfig as t };