@agent-vm/mcp-portal 0.0.69 → 0.0.71

package/dist/upstream-mcp-client-runtime-JlsfTm7_.js

@@ -0,0 +1,760 @@
+import { a as portalToolRecordSchema, r as encodeToolRef } from "./zod-schema-loader-yNekKNpm.js";
+import { a as redactUpstreamCatalogValue, c as createToolSummary, d as portalAgentScopeKey, f as resolvePortalAccessPolicy, i as redactThrownError, o as redactUpstreamResponse } from "./upstream-response-middleware-BjUWZ2G8.js";
+import { createHash } from "node:crypto";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { normalizeHeaders } from "@modelcontextprotocol/sdk/shared/transport.js";
+import { ToolSchema } from "@modelcontextprotocol/sdk/types.js";
+//#region src/search-index.ts
+function collectSchemaText(value, parts) {
+	if (Array.isArray(value)) {
+		for (const item of value) collectSchemaText(item, parts);
+		return;
+	}
+	if (typeof value !== "object" || value === null) {
+		if (typeof value === "string") parts.push(value);
+		return;
+	}
+	for (const [key, childValue] of Object.entries(value)) {
+		parts.push(key);
+		collectSchemaText(childValue, parts);
+	}
+}
+function normalizeSearchText(text) {
+	return text.toLowerCase().replace(/[_-]/g, " ");
+}
+function buildSearchText(tool) {
+	const parts = [
+		tool.namespace,
+		tool.toolName,
+		tool.title ?? "",
+		tool.description ?? ""
+	];
+	collectSchemaText(tool.inputSchema, parts);
+	if (tool.outputSchema) collectSchemaText(tool.outputSchema, parts);
+	return normalizeSearchText(parts.join(" "));
+}
+function propertiesFromSchema(schema) {
+	const properties = schema.properties;
+	if (typeof properties !== "object" || properties === null || Array.isArray(properties)) return [];
+	return Object.keys(properties).toSorted();
+}
+function createRelationshipHints(tool, relationships) {
+	const targetToolRef = createToolSummary(tool).toolRef;
+	return relationships.filter((relationship) => relationship.to.toolRef === targetToolRef).map((relationship) => relationship.field === void 0 ? {
+		reason: relationship.reason,
+		sourceToolRef: relationship.from.toolRef,
+		type: relationship.type
+	} : {
+		field: relationship.field,
+		reason: relationship.reason,
+		sourceToolRef: relationship.from.toolRef,
+		type: relationship.type
+	}).toSorted((left, right) => {
+		const typeOrder = left.type.localeCompare(right.type);
+		if (typeOrder !== 0) return typeOrder;
+		return left.sourceToolRef.localeCompare(right.sourceToolRef);
+	});
+}
+function scopedSkillText(toolRef, graph) {
+	if (!graph) return "";
+	return graph.skills.filter((skill) => skill.toolRefs.includes(toolRef)).map((skill) => [
+		skill.title,
+		skill.description ?? "",
+		...skill.tags
+	].join(" ")).join(" ");
+}
+function scoreEntry(entry, terms) {
+	let score = 0;
+	for (const term of terms) if (entry.searchText.includes(term)) score += 1;
+	return score;
+}
+function compareSummaries(left, right) {
+	const namespaceOrder = left.namespace.localeCompare(right.namespace);
+	if (namespaceOrder !== 0) return namespaceOrder;
+	return left.toolName.localeCompare(right.toolName);
+}
+function withRelationshipHints(summary, relationshipHints) {
+	if (relationshipHints.length === 0) return summary;
+	return {
+		...summary.description !== void 0 ? { description: summary.description } : {},
+		input: summary.input,
+		namespace: summary.namespace,
+		...summary.output !== void 0 ? { output: summary.output } : {},
+		relationshipHints,
+		safety: summary.safety,
+		...summary.title !== void 0 ? { title: summary.title } : {},
+		toolName: summary.toolName,
+		toolRef: summary.toolRef
+	};
+}
+function withSchemaFieldMatches(summary, schemaFieldMatches) {
+	if (schemaFieldMatches.length === 0) return summary;
+	return {
+		...summary.description !== void 0 ? { description: summary.description } : {},
+		input: summary.input,
+		namespace: summary.namespace,
+		...summary.output !== void 0 ? { output: summary.output } : {},
+		...summary.relationshipHints !== void 0 ? { relationshipHints: summary.relationshipHints } : {},
+		safety: summary.safety,
+		schemaFieldMatches,
+		...summary.title !== void 0 ? { title: summary.title } : {},
+		toolName: summary.toolName,
+		toolRef: summary.toolRef
+	};
+}
+function createSearchIndex(tools, graph) {
+	const entries = tools.map((tool) => portalToolRecordSchema.parse(tool)).map((tool) => {
+		const summary = createToolSummary(tool);
+		const relationshipHints = createRelationshipHints(tool, graph?.relationships ?? []);
+		const inputFields = propertiesFromSchema(tool.inputSchema);
+		const relationText = relationshipHints.map((hint) => [
+			hint.field ?? "",
+			hint.reason,
+			hint.sourceToolRef,
+			hint.type
+		].join(" ")).join(" ");
+		const skillText = scopedSkillText(summary.toolRef, graph);
+		return {
+			inputFields,
+			relationshipHints,
+			searchText: normalizeSearchText([
+				buildSearchText(tool),
+				relationText,
+				skillText
+			].join(" ")),
+			summary: withRelationshipHints(summary, relationshipHints)
+		};
+	}).toSorted((left, right) => compareSummaries(left.summary, right.summary));
+	return { search(query) {
+		const limit = Math.max(0, Math.floor(query.limit));
+		const namespaceFilter = new Set(query.namespaces ?? []);
+		const terms = normalizeSearchText(query.query ?? "").split(/\s+/).map((term) => term.trim()).filter(Boolean);
+		return { results: entries.filter((entry) => namespaceFilter.size === 0 || namespaceFilter.has(entry.summary.namespace)).map((entry) => ({
+			entry,
+			score: terms.length === 0 ? 1 : scoreEntry(entry, terms)
+		})).filter(({ score }) => score > 0).toSorted((left, right) => {
+			if (right.score !== left.score) return right.score - left.score;
+			return compareSummaries(left.entry.summary, right.entry.summary);
+		}).slice(0, limit).map(({ entry }) => {
+			const schemaFieldMatches = entry.inputFields.filter((fieldName) => terms.some((term) => normalizeSearchText(fieldName).includes(term))).toSorted();
+			return withSchemaFieldMatches(entry.summary, schemaFieldMatches);
+		}) };
+	} };
+}
+//#endregion
+//#region src/tool-graph.ts
+const genericLinkFields = new Set([
+	"id",
+	"name",
+	"title",
+	"url",
+	"uri"
+]);
+function compareCodePoint(left, right) {
+	if (left < right) return -1;
+	if (left > right) return 1;
+	return 0;
+}
+function objectPropertiesFromSchema(schema) {
+	if (!schema) return [];
+	const properties = schema.properties;
+	if (typeof properties !== "object" || properties === null || Array.isArray(properties)) return [];
+	return Object.keys(properties).toSorted();
+}
+function collectEntityNames(schema) {
+	if (!schema) return [];
+	const names = [];
+	const schemaId = schema.$id;
+	const title = schema.title;
+	const entityName = schema.entityName;
+	if (typeof schemaId === "string" && schemaId.length > 0) names.push(schemaId);
+	if (typeof title === "string" && title.length > 0) names.push(title);
+	if (typeof entityName === "string" && entityName.length > 0) names.push(entityName);
+	return names.map((name) => name.toLowerCase()).toSorted();
+}
+function createGraphTool(tool) {
+	const record = portalToolRecordSchema.parse(tool);
+	const toolRef = encodeToolRef({
+		namespace: record.namespace,
+		toolName: record.toolName
+	});
+	return {
+		entityNames: [...collectEntityNames(record.inputSchema), ...collectEntityNames(record.outputSchema)].toSorted(),
+		inputFields: objectPropertiesFromSchema(record.inputSchema),
+		outputFields: objectPropertiesFromSchema(record.outputSchema),
+		record,
+		ref: {
+			namespace: record.namespace,
+			toolName: record.toolName,
+			toolRef
+		}
+	};
+}
+function sharesEntity(left, right) {
+	const rightEntities = new Set(right.entityNames);
+	return left.entityNames.some((entityName) => rightEntities.has(entityName));
+}
+function shouldLinkField(field, fromTool, toTool) {
+	if (!genericLinkFields.has(field.toLowerCase())) return true;
+	return fromTool.record.namespace === toTool.record.namespace && sharesEntity(fromTool, toTool);
+}
+function createSchemaRelationships(tools) {
+	const relationships = [];
+	for (const fromTool of tools) for (const toTool of tools) {
+		if (fromTool.ref.toolRef === toTool.ref.toolRef) continue;
+		const inputFields = new Set(toTool.inputFields);
+		for (const field of fromTool.outputFields) {
+			if (!inputFields.has(field) || !shouldLinkField(field, fromTool, toTool)) continue;
+			relationships.push({
+				field,
+				from: fromTool.ref,
+				reason: `Output field "${field}" matches input field "${field}".`,
+				to: toTool.ref,
+				type: "schema-field"
+			});
+		}
+	}
+	return relationships;
+}
+function createEntityRelationships(tools) {
+	const relationships = [];
+	for (const fromTool of tools) for (const toTool of tools) {
+		if (fromTool.ref.toolRef === toTool.ref.toolRef || !sharesEntity(fromTool, toTool)) continue;
+		relationships.push({
+			from: fromTool.ref,
+			reason: "Tools declare a shared schema entity through title, $id, or entityName.",
+			to: toTool.ref,
+			type: "entity"
+		});
+	}
+	return relationships;
+}
+function createSkillEntries(skills, allowedToolRefs) {
+	const entries = [];
+	for (const skill of skills) {
+		const scopedToolRefs = skill.toolRefs.filter((toolRef) => allowedToolRefs.has(toolRef)).toSorted();
+		if (scopedToolRefs.length === 0) continue;
+		entries.push({
+			...skill.description !== void 0 ? { description: skill.description } : {},
+			tags: [...skill.tags ?? []].toSorted(),
+			title: skill.title,
+			toolRefs: scopedToolRefs
+		});
+	}
+	return entries.toSorted((left, right) => left.title.localeCompare(right.title));
+}
+function createSkillRelationships(skills, toolsByRef) {
+	const relationships = [];
+	for (const skill of skills) for (const fromToolRef of skill.toolRefs) for (const toToolRef of skill.toolRefs) {
+		if (fromToolRef === toToolRef) continue;
+		const fromTool = toolsByRef.get(fromToolRef);
+		const toTool = toolsByRef.get(toToolRef);
+		if (!fromTool || !toTool) continue;
+		relationships.push({
+			from: fromTool.ref,
+			reason: `Both tools are referenced by skill "${skill.title}".`,
+			to: toTool.ref,
+			type: "skill"
+		});
+	}
+	return relationships;
+}
+function compareRelationships(left, right) {
+	const typeOrder = compareCodePoint(left.type, right.type);
+	if (typeOrder !== 0) return typeOrder;
+	const targetOrder = compareCodePoint(left.to.toolRef, right.to.toolRef);
+	if (targetOrder !== 0) return targetOrder;
+	return compareCodePoint(left.from.toolRef, right.from.toolRef);
+}
+function buildToolGraph(input) {
+	const tools = input.tools.map((tool) => createGraphTool(tool)).toSorted((left, right) => compareCodePoint(left.ref.toolRef, right.ref.toolRef));
+	const allowedToolRefs = new Set(tools.map((tool) => tool.ref.toolRef));
+	const skills = createSkillEntries(input.skills ?? [], allowedToolRefs);
+	const toolsByRef = new Map(tools.map((tool) => [tool.ref.toolRef, tool]));
+	return {
+		relationships: [
+			...createEntityRelationships(tools),
+			...createSchemaRelationships(tools),
+			...createSkillRelationships(skills, toolsByRef)
+		].toSorted(compareRelationships),
+		skills
+	};
+}
+//#endregion
+//#region src/portal-session.ts
+function isHiddenTool(tool, hiddenTools) {
+	return hiddenTools.some((hiddenTool) => hiddenTool.namespace === tool.namespace && hiddenTool.toolName === tool.toolName);
+}
+function isEnabledTool(tool, enabledTools) {
+	if (enabledTools.length === 0) return true;
+	return enabledTools.some((enabledTool) => enabledTool.namespace === tool.namespace && enabledTool.toolName === tool.toolName);
+}
+function portalToolFromMcpTool(namespace, tool) {
+	return portalToolRecordSchema.parse({
+		...tool.annotations !== void 0 ? { annotations: tool.annotations } : {},
+		...tool.description !== void 0 ? { description: tool.description } : {},
+		inputSchema: tool.inputSchema,
+		namespace,
+		...tool.outputSchema !== void 0 ? { outputSchema: tool.outputSchema } : {},
+		...tool.title !== void 0 ? { title: tool.title } : {},
+		toolName: tool.name
+	});
+}
+function createSourceHash(tools) {
+	return createHash("sha256").update(JSON.stringify(tools)).digest("hex");
+}
+function messageFromError(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+function createPortalSessionManager(options) {
+	const sessions = /* @__PURE__ */ new Map();
+	const agentScopeGenerations = /* @__PURE__ */ new Map();
+	const getNow = options.now ?? (() => Date.now());
+	function generationForAgentScope(agentScopeId) {
+		return agentScopeGenerations.get(agentScopeId) ?? 0;
+	}
+	function incrementAgentScopeGeneration(agentScopeId) {
+		agentScopeGenerations.set(agentScopeId, generationForAgentScope(agentScopeId) + 1);
+	}
+	function generationForScope(scopeKey) {
+		const agentScopeId = scopeKey.split("\n", 1)[0] ?? scopeKey;
+		return (agentScopeGenerations.get(scopeKey) ?? 0) + generationForAgentScope(agentScopeId);
+	}
+	function incrementScopeGeneration(scopeKey) {
+		agentScopeGenerations.set(scopeKey, generationForScope(scopeKey) + 1);
+	}
+	async function buildSession(identity) {
+		const policy = resolvePortalAccessPolicy({
+			config: options.accessPolicy,
+			identity,
+			upstreamNamespaces: options.upstreamNamespaces
+		});
+		const tools = [];
+		const discoveryFailures = [...options.discoveryFailures ?? []];
+		const allowedNamespaces = policy.allowedNamespaces;
+		const namespaceToolGroups = await Promise.allSettled(allowedNamespaces.map(async (namespace) => ({
+			mcpTools: await options.runtime.listTools({
+				agentScopeId: portalAgentScopeKey(identity),
+				namespace
+			}),
+			namespace
+		})));
+		for (const [index, namespaceToolGroup] of namespaceToolGroups.entries()) {
+			if (namespaceToolGroup.status === "rejected") {
+				const namespace = allowedNamespaces[index] ?? "unknown";
+				discoveryFailures.push({
+					message: messageFromError(namespaceToolGroup.reason),
+					namespace
+				});
+				continue;
+			}
+			const { mcpTools, namespace } = namespaceToolGroup.value;
+			for (const mcpTool of mcpTools) {
+				const portalTool = portalToolFromMcpTool(namespace, mcpTool);
+				if (isEnabledTool(portalTool, policy.enabledTools) && !isHiddenTool(portalTool, policy.hiddenTools)) tools.push(portalTool);
+			}
+		}
+		const sortedTools = tools.toSorted((left, right) => {
+			const namespaceOrder = left.namespace.localeCompare(right.namespace);
+			return namespaceOrder === 0 ? left.toolName.localeCompare(right.toolName) : namespaceOrder;
+		});
+		const graph = buildToolGraph({
+			skills: options.skills ?? [],
+			tools: sortedTools
+		});
+		return {
+			catalog: {
+				agentScopeId: identity.agentScopeId,
+				discoveryFailures,
+				generatedAt: new Date(getNow()).toISOString(),
+				sourceHash: createSourceHash(sortedTools),
+				tools: sortedTools
+			},
+			graph,
+			identity,
+			searchIndex: createSearchIndex(sortedTools, graph)
+		};
+	}
+	return {
+		async getSession(identity) {
+			const key = portalAgentScopeKey(identity);
+			const now = getNow();
+			const cached = sessions.get(key);
+			if (cached && cached.expiresAt > now) return cached.session;
+			const generation = generationForScope(key);
+			const session = await buildSession(identity);
+			if (generationForScope(key) === generation && session.catalog.discoveryFailures.length === 0) sessions.set(key, {
+				expiresAt: now + options.catalogTtlMs,
+				session
+			});
+			return session;
+		},
+		async invalidateAgentScope(agentScopeId) {
+			incrementAgentScopeGeneration(agentScopeId);
+			for (const key of sessions.keys()) if (key === agentScopeId || key.startsWith(`${agentScopeId}\n`)) sessions.delete(key);
+			await options.runtime.closeAgentScope(agentScopeId);
+		},
+		async invalidateSession(identity) {
+			const scopeKey = portalAgentScopeKey(identity);
+			incrementScopeGeneration(scopeKey);
+			sessions.delete(scopeKey);
+			if (options.runtime.closeSession) {
+				await options.runtime.closeSession(scopeKey);
+				return;
+			}
+			await options.runtime.closeAgentScope(scopeKey);
+		}
+	};
+}
+//#endregion
+//#region src/upstream-mcp-client-runtime.ts
+const defaultConnectionTimeoutMs = 3e4;
+const defaultMaxResponseBytes = 4 * 1024 * 1024;
+function isObjectRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isTransport(value) {
+	return isObjectRecord(value) && typeof value.start === "function" && typeof value.send === "function" && typeof value.close === "function";
+}
+function createSdkClient() {
+	const client = new Client({
+		name: "mcp-portal",
+		version: "1.0.0"
+	});
+	return {
+		callTool: async (params, _resultSchema, options) => await client.callTool(params, void 0, options),
+		close: async () => {
+			await client.close();
+		},
+		connect: async (transport, options) => {
+			if (!isTransport(transport)) throw new Error("SDK MCP client requires a valid MCP transport.");
+			await client.connect(transport, options);
+		},
+		listTools: async (params, options) => {
+			const result = await client.listTools(params, options);
+			return {
+				...result.nextCursor !== void 0 ? { nextCursor: result.nextCursor } : {},
+				tools: result.tools
+			};
+		}
+	};
+}
+function withRemoteHeaders(server) {
+	if (!server.headers) return server;
+	return {
+		...server,
+		requestInit: {
+			...server.requestInit,
+			headers: {
+				...normalizeHeaders(server.requestInit?.headers),
+				...server.headers
+			}
+		}
+	};
+}
+function createSdkTransport(server, transport) {
+	if (transport === "stdio") {
+		if (server.transport !== "stdio") throw new Error("Stdio transport requires stdio server config.");
+		return new StdioClientTransport({
+			...server.args ? { args: [...server.args] } : {},
+			command: server.command,
+			...server.cwd !== void 0 ? { cwd: server.cwd } : {},
+			...server.env ? { env: { ...server.env } } : {}
+		});
+	}
+	if (server.transport === "stdio") throw new Error("Remote transport requires remote server config.");
+	const remoteServer = withRemoteHeaders(server);
+	if (transport === "sse") {
+		const options = {};
+		if (remoteServer.eventSourceInit !== void 0) options.eventSourceInit = remoteServer.eventSourceInit;
+		if (remoteServer.requestInit !== void 0) options.requestInit = remoteServer.requestInit;
+		return new SSEClientTransport(new URL(remoteServer.url), options);
+	}
+	const options = {};
+	if (remoteServer.requestInit !== void 0) options.requestInit = remoteServer.requestInit;
+	return new StreamableHTTPClientTransport(new URL(remoteServer.url), options);
+}
+function cacheKey(agentScopeId, namespace) {
+	return `${agentScopeId}\n${namespace}`;
+}
+function rootAgentScopeId(agentScopeId) {
+	return agentScopeId.split("\n", 1)[0] ?? agentScopeId;
+}
+function transportAttempts(server) {
+	if (server.transport === "auto-http") return ["streamable-http", "sse"];
+	return [server.transport];
+}
+function redactionValuesFromServer(server) {
+	if (server.transport === "stdio") return Object.values(server.env ?? {}).filter((value) => value.length > 0);
+	return Object.values(server.headers ?? {}).filter((value) => value.length > 0);
+}
+function timeoutMsForServer(server) {
+	return server.connectionTimeoutMs ?? defaultConnectionTimeoutMs;
+}
+function assertUpstreamResponseSize(value, maxResponseBytes) {
+	const serialized = JSON.stringify(value);
+	if (serialized === void 0) return;
+	const byteLength = Buffer.byteLength(serialized, "utf8");
+	if (byteLength > maxResponseBytes) throw new Error(`MCP upstream response exceeded ${String(maxResponseBytes)} bytes (${String(byteLength)} bytes).`);
+}
+function isAbortError(error) {
+	return error instanceof Error && error.name === "AbortError";
+}
+function isCallerAbortError(error, signal) {
+	return signal?.aborted === true && (error === signal.reason || isAbortError(error));
+}
+async function withTimeout(promise, props) {
+	let timeout;
+	try {
+		return await Promise.race([promise, new Promise((_resolve, reject) => {
+			timeout = setTimeout(() => {
+				const error = /* @__PURE__ */ new Error(`${props.operation} timed out after ${props.timeoutMs}ms.`);
+				props.onTimeout?.(error);
+				reject(error);
+			}, props.timeoutMs);
+		})]);
+	} finally {
+		if (timeout) clearTimeout(timeout);
+	}
+}
+function createRuntimeAbortSignal(parentSignal) {
+	const controller = new AbortController();
+	const abortFromParent = () => {
+		if (!controller.signal.aborted) controller.abort(parentSignal?.reason);
+	};
+	if (parentSignal?.aborted) abortFromParent();
+	else parentSignal?.addEventListener("abort", abortFromParent, { once: true });
+	return {
+		abortTimeout: (error) => {
+			if (!controller.signal.aborted) controller.abort(error);
+		},
+		dispose: () => {
+			parentSignal?.removeEventListener("abort", abortFromParent);
+		},
+		signal: controller.signal
+	};
+}
+async function listAllTools(client, cursor, collectedTools, timeoutAbort, timeoutMs) {
+	const result = await withTimeout(client.listTools(cursor ? { cursor } : void 0, { signal: timeoutAbort.signal }), {
+		onTimeout: timeoutAbort.abortTimeout,
+		operation: "MCP listTools",
+		timeoutMs
+	});
+	const nextTools = [...collectedTools, ...result.tools];
+	return result.nextCursor ? listAllTools(client, result.nextCursor, nextTools, timeoutAbort, timeoutMs) : nextTools;
+}
+async function closeClientAfterFailure(client) {
+	if (!client) return;
+	try {
+		await client.close();
+	} catch {}
+}
+async function closeClientForTeardown(client, props) {
+	if (!client) return;
+	try {
+		await client.close();
+	} catch (error) {
+		props.onCloseError?.(redactThrownError(error), props.context);
+	}
+}
+function closeErrorContextFromCacheKey(cacheKeyValue) {
+	const keyParts = cacheKeyValue.split("\n");
+	const namespace = keyParts.length > 1 ? keyParts[keyParts.length - 1] : void 0;
+	return {
+		agentScopeId: namespace !== void 0 ? keyParts.slice(0, keyParts.length - 1).join("\n") : cacheKeyValue,
+		...namespace !== void 0 ? { namespace } : {}
+	};
+}
+function redactToolCatalog(tools, options) {
+	return tools.map((tool) => ToolSchema.parse(redactUpstreamCatalogValue(tool, options)));
+}
+function createUpstreamMcpClientRuntime(options) {
+	const serversByNamespace = new Map(options.servers.map((server) => [server.namespace, server]));
+	const clients = /* @__PURE__ */ new Map();
+	const pendingClients = /* @__PURE__ */ new Map();
+	const agentScopeGenerations = /* @__PURE__ */ new Map();
+	const closedClients = /* @__PURE__ */ new WeakSet();
+	const createClient = options.createClient ?? createSdkClient;
+	const createTransport = options.createTransport ?? createSdkTransport;
+	const maxResponseBytes = options.maxResponseBytes ?? defaultMaxResponseBytes;
+	const redactionValues = [...options.additionalRedactionValues ?? [], ...options.servers.flatMap((server) => redactionValuesFromServer(server))];
+	function generationForAgentScope(agentScopeId) {
+		return agentScopeGenerations.get(agentScopeId) ?? agentScopeGenerations.get(rootAgentScopeId(agentScopeId)) ?? 0;
+	}
+	function incrementAgentScopeGeneration(agentScopeId) {
+		const rootAgentScope = rootAgentScopeId(agentScopeId);
+		agentScopeGenerations.set(rootAgentScope, (agentScopeGenerations.get(rootAgentScope) ?? 0) + 1);
+	}
+	function incrementScopeGeneration(scopeKey) {
+		agentScopeGenerations.set(scopeKey, (agentScopeGenerations.get(scopeKey) ?? 0) + 1);
+	}
+	async function closeClientAfterFailureOnce(client) {
+		if (!client || closedClients.has(client)) return;
+		closedClients.add(client);
+		await closeClientAfterFailure(client);
+	}
+	async function closeClientForTeardownOnce(client, context) {
+		if (!client || closedClients.has(client)) return;
+		closedClients.add(client);
+		await closeClientForTeardown(client, {
+			context,
+			onCloseError: options.onCloseError
+		});
+	}
+	async function createConnectedClient(server) {
+		const attempts = transportAttempts(server);
+		async function tryAttempt(attemptIndex, lastError) {
+			const transportKind = attempts[attemptIndex];
+			if (transportKind === void 0) throw lastError ?? /* @__PURE__ */ new Error(`Could not connect to upstream MCP namespace "${server.namespace}".`);
+			const client = createClient();
+			const transport = createTransport(transportKind === "sse" && server.transport !== "stdio" ? withRemoteHeaders(server) : server, transportKind);
+			const timeoutAbort = createRuntimeAbortSignal(void 0);
+			try {
+				await withTimeout(client.connect(transport, { signal: timeoutAbort.signal }), {
+					onTimeout: timeoutAbort.abortTimeout,
+					operation: `MCP ${transportKind} connect for namespace "${server.namespace}"`,
+					timeoutMs: timeoutMsForServer(server)
+				});
+				return client;
+			} catch (error) {
+				const redactedError = redactThrownError(error, { exactValues: redactionValues });
+				await closeClientAfterFailureOnce(client);
+				return tryAttempt(attemptIndex + 1, redactedError);
+			} finally {
+				timeoutAbort.dispose();
+			}
+		}
+		return tryAttempt(0, null);
+	}
+	async function getClient(agentScopeId, namespace) {
+		const key = cacheKey(agentScopeId, namespace);
+		const cachedClient = clients.get(key);
+		if (cachedClient) return cachedClient.client;
+		const pendingClient = pendingClients.get(key);
+		const generation = generationForAgentScope(agentScopeId);
+		if (pendingClient && pendingClient.generation === generation) return pendingClient.promise;
+		if (pendingClient) {
+			pendingClients.delete(key);
+			pendingClient.promise.then(closeClientAfterFailureOnce, () => void 0);
+		}
+		const server = serversByNamespace.get(namespace);
+		if (!server) throw new Error(`Unknown upstream MCP namespace "${namespace}".`);
+		const pending = createConnectedClient(server);
+		const pendingRecord = {
+			generation,
+			promise: pending
+		};
+		pendingClients.set(key, pendingRecord);
+		try {
+			const client = await pending;
+			if (generationForAgentScope(agentScopeId) !== generation) {
+				await closeClientAfterFailureOnce(client);
+				throw new Error(`MCP client for agent scope "${rootAgentScopeId(agentScopeId)}" was invalidated.`);
+			}
+			clients.set(key, { client });
+			if (generationForAgentScope(agentScopeId) !== generation) {
+				if (clients.get(key)?.client === client) clients.delete(key);
+				await closeClientAfterFailureOnce(client);
+				throw new Error(`MCP client for agent scope "${rootAgentScopeId(agentScopeId)}" was invalidated.`);
+			}
+			return client;
+		} finally {
+			if (pendingClients.get(key) === pendingRecord) pendingClients.delete(key);
+		}
+	}
+	return {
+		async callTool(call) {
+			const key = cacheKey(call.agentScopeId, call.namespace);
+			let client = null;
+			try {
+				client = await getClient(call.agentScopeId, call.namespace);
+				const server = serversByNamespace.get(call.namespace);
+				const timeoutAbort = createRuntimeAbortSignal(call.signal);
+				try {
+					const upstreamResult = await withTimeout(client.callTool({
+						arguments: call.arguments,
+						name: call.toolName
+					}, void 0, {
+						onprogress: (progress) => {
+							call.onEvent?.({
+								kind: "progress",
+								...progress.message !== void 0 ? { message: progress.message } : {},
+								progress: progress.progress,
+								...progress.total !== void 0 ? { total: progress.total } : {}
+							});
+						},
+						signal: timeoutAbort.signal
+					}), {
+						onTimeout: timeoutAbort.abortTimeout,
+						operation: `MCP callTool ${call.namespace}.${call.toolName}`,
+						timeoutMs: server ? timeoutMsForServer(server) : defaultConnectionTimeoutMs
+					});
+					assertUpstreamResponseSize(upstreamResult, maxResponseBytes);
+					return redactUpstreamResponse(upstreamResult, { exactValues: redactionValues });
+				} finally {
+					timeoutAbort.dispose();
+				}
+			} catch (error) {
+				if (isCallerAbortError(error, call.signal)) throw redactThrownError(error, { exactValues: redactionValues });
+				clients.delete(key);
+				await closeClientAfterFailureOnce(client);
+				throw redactThrownError(error, { exactValues: redactionValues });
+			}
+		},
+		async closeAgentScope(agentScopeId) {
+			incrementAgentScopeGeneration(agentScopeId);
+			const closePromises = [];
+			for (const [key, cachedClient] of clients.entries()) {
+				if (key !== agentScopeId && !key.startsWith(`${agentScopeId}\n`)) continue;
+				clients.delete(key);
+				closePromises.push(closeClientForTeardownOnce(cachedClient.client, closeErrorContextFromCacheKey(key)));
+			}
+			for (const [key, pendingClient] of pendingClients.entries()) {
+				if (key !== agentScopeId && !key.startsWith(`${agentScopeId}\n`)) continue;
+				pendingClients.delete(key);
+				closePromises.push(pendingClient.promise.then((client) => closeClientForTeardownOnce(client, closeErrorContextFromCacheKey(key)), () => void 0));
+			}
+			await Promise.all(closePromises);
+		},
+		async closeSession(scopeKey) {
+			incrementScopeGeneration(scopeKey);
+			const closePromises = [];
+			for (const [key, cachedClient] of clients.entries()) {
+				if (key !== scopeKey && !key.startsWith(`${scopeKey}\n`)) continue;
+				clients.delete(key);
+				closePromises.push(closeClientForTeardownOnce(cachedClient.client, closeErrorContextFromCacheKey(key)));
+			}
+			for (const [key, pendingClient] of pendingClients.entries()) {
+				if (key !== scopeKey && !key.startsWith(`${scopeKey}\n`)) continue;
+				pendingClients.delete(key);
+				closePromises.push(pendingClient.promise.then((client) => closeClientForTeardownOnce(client, closeErrorContextFromCacheKey(key)), () => void 0));
+			}
+			await Promise.all(closePromises);
+		},
+		async listTools(call) {
+			const key = cacheKey(call.agentScopeId, call.namespace);
+			let client = null;
+			try {
+				client = await getClient(call.agentScopeId, call.namespace);
+				const server = serversByNamespace.get(call.namespace);
+				const timeoutAbort = createRuntimeAbortSignal(void 0);
+				try {
+					return redactToolCatalog(await listAllTools(client, void 0, [], timeoutAbort, server ? timeoutMsForServer(server) : defaultConnectionTimeoutMs), { exactValues: redactionValues });
+				} finally {
+					timeoutAbort.dispose();
+				}
+			} catch (error) {
+				clients.delete(key);
+				await closeClientAfterFailureOnce(client);
+				throw redactThrownError(error, { exactValues: redactionValues });
+			}
+		}
+	};
+}
+//#endregion
+export { createSearchIndex as i, createPortalSessionManager as n, buildToolGraph as r, createUpstreamMcpClientRuntime as t };
+
+//# sourceMappingURL=upstream-mcp-client-runtime-JlsfTm7_.js.map