@xopcai/xopc 0.0.180 → 0.0.188

package/dist/src/agent/external-tools/mcp-provider.js

@@ -0,0 +1,118 @@
+import { resolveEffectiveAgentProfileForSession } from "../../config/agent-profile.js";
+import { externalToolRef, parseExternalToolRef } from "./refs.js";
+import { isMcpCatalogToolDenied, mcpToolPolicyId } from "../mcp/bundle-mcp-policy.js";
+import { getOrCreateSessionMcpRuntime } from "../mcp/bundle-mcp-runtime.js";
+//#region src/agent/external-tools/mcp-provider.ts
+function policyToolId(tool) {
+	return mcpToolPolicyId(tool.safeServerName, tool.toolName);
+}
+function toAgentToolResult(params) {
+	const content = Array.isArray(params.result.content) ? params.result.content : [];
+	return {
+		content: content.length > 0 ? content : [{
+			type: "text",
+			text: JSON.stringify(params.result.structuredContent ?? {
+				status: params.result.isError === true ? "error" : "ok",
+				server: params.serverName,
+				tool: params.toolName
+			}, null, 2)
+		}],
+		details: {
+			mcpServer: params.serverName,
+			mcpTool: params.toolName,
+			...params.result.structuredContent !== void 0 ? { structuredContent: params.result.structuredContent } : {},
+			...params.result.isError === true ? { status: "error" } : {}
+		}
+	};
+}
+var McpToolProvider = class {
+	source = "mcp";
+	constructor(deps) {
+		this.deps = deps;
+	}
+	async search(_query) {
+		return this.withRuntime(async (runtime) => {
+			return (await runtime.getCatalog()).tools.filter((tool) => this.isAllowed(tool)).map((tool) => ({
+				toolRef: externalToolRef(this.source, tool.serverName, tool.toolName),
+				source: this.source,
+				namespace: tool.serverName,
+				title: tool.title || tool.toolName,
+				summary: tool.description || tool.fallbackDescription
+			}));
+		});
+	}
+	async describe(toolRef) {
+		return this.withRuntime(async (runtime) => {
+			const tool = await this.resolve(runtime, toolRef);
+			if (!tool) return void 0;
+			const summary = tool.description || tool.fallbackDescription;
+			return {
+				toolRef,
+				source: this.source,
+				namespace: tool.serverName,
+				title: tool.title || tool.toolName,
+				summary,
+				description: summary,
+				inputSchema: tool.inputSchema
+			};
+		});
+	}
+	async execute(toolRef, args, _approvalId, context) {
+		return this.withRuntime(async (runtime) => {
+			const tool = await this.resolve(runtime, toolRef);
+			if (!tool) throw new Error(`MCP tool is unavailable or denied: ${toolRef}`);
+			let executionArgs = args;
+			if (this.deps.hookRunner) {
+				const hook = await this.deps.hookRunner.runBeforeToolCall(policyToolId(tool), args, {
+					sessionKey: this.deps.getSessionKey(),
+					isMcpTool: true,
+					mcpServerId: tool.serverName
+				});
+				if (!hook.allowed) throw new Error(hook.reason ?? "MCP tool call blocked by policy hook.");
+				executionArgs = hook.params ?? args;
+			}
+			const result = await runtime.callTool(tool.serverName, tool.toolName, executionArgs, context.signal);
+			return toAgentToolResult({
+				serverName: tool.serverName,
+				toolName: tool.toolName,
+				result
+			});
+		});
+	}
+	async resolve(runtime, toolRef) {
+		const parsed = parseExternalToolRef(toolRef, this.source);
+		if (!parsed) return void 0;
+		const tool = (await runtime.getCatalog()).tools.find((candidate) => candidate.serverName === parsed.namespace && candidate.toolName === parsed.toolName);
+		return tool && this.isAllowed(tool) ? tool : void 0;
+	}
+	isAllowed(tool) {
+		const cfg = this.deps.getConfig();
+		const sessionKey = this.deps.getSessionKey();
+		const profile = cfg && sessionKey ? resolveEffectiveAgentProfileForSession(cfg, sessionKey) : void 0;
+		const policyName = policyToolId(tool);
+		return !profile?.tools.denied.has(policyName) && !isMcpCatalogToolDenied({
+			serverId: tool.safeServerName,
+			policyToolId: policyName
+		}, profile?.manifest.tools.mcp);
+	}
+	async withRuntime(run) {
+		const cfg = this.deps.getConfig();
+		const sessionKey = this.deps.getSessionKey();
+		const sessionId = sessionKey ?? `agent:${this.deps.agentId ?? "main"}`;
+		const runtime = await (this.deps.getRuntime ?? getOrCreateSessionMcpRuntime)({
+			sessionId,
+			sessionKey,
+			workspaceDir: this.deps.workspace,
+			cfg
+		});
+		const releaseLease = runtime.acquireLease?.();
+		runtime.markUsed();
+		try {
+			return await run(runtime);
+		} finally {
+			releaseLease?.();
+		}
+	}
+};
+//#endregion
+export { McpToolProvider };

package/dist/src/agent/external-tools/memory-provider.d.ts

@@ -0,0 +1,21 @@
+import type { ExtensionHookRunner } from '../../extensions/index.js';
+import type { MemoryManager } from '../memory/manager.js';
+import { type ToolExecutorConfig } from '../tools/executor.js';
+import type { ExternalToolDescriptor, ExternalToolExecutionContext, ExternalToolProvider, ExternalToolSearchHit } from './types.js';
+export interface MemoryToolProviderDeps {
+    getMemoryManager?: () => MemoryManager;
+    disabledTools?: Set<string>;
+    getSessionKey: () => string | undefined;
+    hookRunner?: ExtensionHookRunner;
+    toolExecutorConfig?: Partial<ToolExecutorConfig>;
+}
+export declare class MemoryToolProvider implements ExternalToolProvider {
+    private readonly deps;
+    readonly source: "memory";
+    constructor(deps: MemoryToolProviderDeps);
+    search(_query: string): Promise<ExternalToolSearchHit[]>;
+    describe(toolRef: string): Promise<ExternalToolDescriptor | undefined>;
+    execute(toolRef: string, args: Record<string, unknown>, _approvalId: string | undefined, context: ExternalToolExecutionContext): Promise<import("@earendil-works/pi-agent-core").AgentToolResult<any>>;
+    private entries;
+    private resolve;
+}

package/dist/src/agent/external-tools/memory-provider.js

@@ -0,0 +1,56 @@
+import { externalToolRef, parseExternalToolRef } from "./refs.js";
+import { executeToolWithProtection } from "../tools/executor.js";
+//#region src/agent/external-tools/memory-provider.ts
+function toolSummary(tool) {
+	return tool.description || tool.label || tool.name;
+}
+var MemoryToolProvider = class {
+	source = "memory";
+	constructor(deps) {
+		this.deps = deps;
+	}
+	async search(_query) {
+		return this.entries().map(({ providerId, tool }) => ({
+			toolRef: externalToolRef(this.source, providerId, tool.name),
+			source: this.source,
+			namespace: providerId,
+			title: tool.label || tool.name,
+			summary: toolSummary(tool)
+		}));
+	}
+	async describe(toolRef) {
+		const resolved = this.resolve(toolRef);
+		if (!resolved) return void 0;
+		const summary = toolSummary(resolved.tool);
+		return {
+			toolRef,
+			source: this.source,
+			namespace: resolved.providerId,
+			title: resolved.tool.label || resolved.tool.name,
+			summary,
+			description: summary,
+			inputSchema: resolved.tool.parameters
+		};
+	}
+	async execute(toolRef, args, _approvalId, context) {
+		const resolved = this.resolve(toolRef);
+		if (!resolved) throw new Error(`Memory provider tool is unavailable: ${toolRef}`);
+		let executionArgs = args;
+		if (this.deps.hookRunner) {
+			const hook = await this.deps.hookRunner.runBeforeToolCall(resolved.tool.name, args, { sessionKey: this.deps.getSessionKey() });
+			if (!hook.allowed) throw new Error(hook.reason ?? "Memory provider tool call blocked by policy hook.");
+			executionArgs = hook.params ?? args;
+		}
+		return executeToolWithProtection(resolved.tool, context.toolCallId, executionArgs, context.signal, context.onUpdate, this.deps.toolExecutorConfig);
+	}
+	entries() {
+		return (this.deps.getMemoryManager?.().getExternalToolEntries() ?? []).filter(({ tool }) => !this.deps.disabledTools?.has(tool.name));
+	}
+	resolve(toolRef) {
+		const parsed = parseExternalToolRef(toolRef, this.source);
+		if (!parsed) return void 0;
+		return this.entries().find(({ providerId, tool }) => providerId === parsed.namespace && tool.name === parsed.toolName);
+	}
+};
+//#endregion
+export { MemoryToolProvider };

package/dist/src/agent/external-tools/refs.d.ts

@@ -0,0 +1,5 @@
+export declare function externalToolRef(source: string, namespace: string, toolName: string): string;
+export declare function parseExternalToolRef(toolRef: string, expectedSource: string): {
+    namespace: string;
+    toolName: string;
+} | undefined;

package/dist/src/agent/external-tools/refs.js

@@ -0,0 +1,18 @@
+//#region src/agent/external-tools/refs.ts
+function externalToolRef(source, namespace, toolName) {
+	return `${source}:${encodeURIComponent(namespace)}:${encodeURIComponent(toolName)}`;
+}
+function parseExternalToolRef(toolRef, expectedSource) {
+	const parts = toolRef.split(":");
+	if (parts.length !== 3 || parts[0] !== expectedSource) return void 0;
+	try {
+		return {
+			namespace: decodeURIComponent(parts[1]),
+			toolName: decodeURIComponent(parts[2])
+		};
+	} catch {
+		return;
+	}
+}
+//#endregion
+export { externalToolRef, parseExternalToolRef };

package/dist/src/agent/external-tools/service.d.ts

@@ -0,0 +1,26 @@
+import type { ExternalToolExecutionContext, ExternalToolProvider, ExternalToolSearchHit, ExternalToolSource, VersionedExternalToolDescriptor } from './types.js';
+export declare class ExternalToolService {
+    private readonly providerBySource;
+    private readonly ajv;
+    constructor(providers: ExternalToolProvider[]);
+    search(params: {
+        query: string;
+        sources?: ExternalToolSource[];
+        limit?: number;
+    }): Promise<{
+        tools: ExternalToolSearchHit[];
+        unavailableSources: ExternalToolSource[];
+    }>;
+    describe(toolRefs: string[]): Promise<{
+        tools: VersionedExternalToolDescriptor[];
+        notFound: string[];
+    }>;
+    execute(params: {
+        toolRef: string;
+        revision: string;
+        arguments?: Record<string, unknown>;
+        approvalId?: string;
+        context: ExternalToolExecutionContext;
+    }): Promise<import("@earendil-works/pi-agent-core").AgentToolResult<Record<string, unknown>>>;
+    private providerForRef;
+}

package/dist/src/agent/external-tools/service.js

@@ -0,0 +1,117 @@
+import crypto from "node:crypto";
+import Ajv2020 from "ajv/dist/2020.js";
+//#region src/agent/external-tools/service.ts
+const DEFAULT_SEARCH_LIMIT = 8;
+const MAX_SEARCH_LIMIT = 20;
+const MAX_DESCRIBE_COUNT = 3;
+const MAX_DESCRIPTOR_BYTES = 64 * 1024;
+function normalizedTokens(value) {
+	return value.toLowerCase().split(/[^\p{L}\p{N}_-]+/u).filter(Boolean);
+}
+function relevanceScore(hit, query) {
+	const haystack = `${hit.title} ${hit.summary} ${hit.namespace}`.toLowerCase();
+	const tokens = normalizedTokens(query);
+	if (tokens.length === 0) return 0;
+	return tokens.reduce((score, token) => {
+		if (hit.title.toLowerCase() === token) return score + 8;
+		if (hit.title.toLowerCase().includes(token)) return score + 4;
+		return haystack.includes(token) ? score + 1 : score;
+	}, 0);
+}
+function descriptorRevision(descriptor) {
+	return crypto.createHash("sha256").update(JSON.stringify({
+		toolRef: descriptor.toolRef,
+		description: descriptor.description,
+		inputSchema: descriptor.inputSchema
+	})).digest("hex").slice(0, 16);
+}
+function versionDescriptor(descriptor) {
+	return {
+		...descriptor,
+		revision: descriptorRevision(descriptor)
+	};
+}
+var ExternalToolService = class {
+	providerBySource;
+	ajv = new Ajv2020({
+		allErrors: true,
+		strict: false,
+		validateFormats: false,
+		validateSchema: false
+	});
+	constructor(providers) {
+		this.providerBySource = new Map(providers.map((provider) => [provider.source, provider]));
+	}
+	async search(params) {
+		const selected = params.sources?.length ? params.sources.map((source) => this.providerBySource.get(source)).filter((provider) => provider !== void 0) : [...this.providerBySource.values()];
+		const settled = await Promise.allSettled(selected.map(async (provider) => ({
+			provider,
+			hits: await provider.search(params.query)
+		})));
+		const unavailableSources = [];
+		const hits = [];
+		for (const [index, result] of settled.entries()) if (result.status === "fulfilled") hits.push(...result.value.hits);
+		else {
+			const provider = selected[index];
+			if (provider) unavailableSources.push(provider.source);
+		}
+		const limit = Math.min(MAX_SEARCH_LIMIT, Math.max(1, params.limit ?? DEFAULT_SEARCH_LIMIT));
+		return {
+			tools: hits.map((hit) => ({
+				hit,
+				score: relevanceScore(hit, params.query)
+			})).filter((entry) => entry.score > 0 || normalizedTokens(params.query).length === 0).toSorted((left, right) => right.score - left.score || left.hit.toolRef.localeCompare(right.hit.toolRef)).slice(0, limit).map(({ hit }) => ({
+				toolRef: hit.toolRef,
+				source: hit.source,
+				namespace: hit.namespace,
+				title: hit.title,
+				summary: hit.summary.slice(0, 300)
+			})),
+			unavailableSources
+		};
+	}
+	async describe(toolRefs) {
+		if (toolRefs.length === 0 || toolRefs.length > MAX_DESCRIBE_COUNT) throw new Error(`Describe between 1 and ${MAX_DESCRIBE_COUNT} tools per call.`);
+		const tools = [];
+		const notFound = [];
+		for (const toolRef of toolRefs) {
+			const provider = this.providerForRef(toolRef);
+			const descriptor = provider ? await provider.describe(toolRef) : void 0;
+			if (!descriptor) {
+				notFound.push(toolRef);
+				continue;
+			}
+			const versioned = versionDescriptor(descriptor);
+			if (Buffer.byteLength(JSON.stringify(versioned), "utf8") > MAX_DESCRIPTOR_BYTES) throw new Error(`Tool contract is too large to expose safely: ${toolRef}`);
+			tools.push(versioned);
+		}
+		return {
+			tools,
+			notFound
+		};
+	}
+	async execute(params) {
+		const provider = this.providerForRef(params.toolRef);
+		if (!provider) throw new Error(`Unknown external tool source: ${params.toolRef}`);
+		const descriptor = await provider.describe(params.toolRef);
+		if (!descriptor) throw new Error(`External tool is unavailable: ${params.toolRef}`);
+		const current = versionDescriptor(descriptor);
+		if (current.revision !== params.revision) throw new Error(`Tool contract changed. Describe ${params.toolRef} again before executing it.`);
+		const args = params.arguments ?? {};
+		let validate;
+		try {
+			validate = this.ajv.compile(current.inputSchema);
+		} catch (error) {
+			throw new Error(`Tool contract is invalid: ${params.toolRef}`, { cause: error });
+		}
+		if (!validate(args)) throw new Error(`Arguments do not match ${params.toolRef}: ${this.ajv.errorsText(validate.errors)}`);
+		return provider.execute(params.toolRef, args, params.approvalId, params.context);
+	}
+	providerForRef(toolRef) {
+		const separator = toolRef.indexOf(":");
+		if (separator <= 0) return void 0;
+		return this.providerBySource.get(toolRef.slice(0, separator));
+	}
+};
+//#endregion
+export { ExternalToolService };

package/dist/src/agent/external-tools/types.d.ts

@@ -0,0 +1,28 @@
+import type { AgentToolResult, AgentToolUpdateCallback } from '@earendil-works/pi-agent-core';
+export declare const EXTERNAL_TOOL_SOURCES: readonly ["mcp", "composio", "extension", "memory"];
+export type ExternalToolSource = (typeof EXTERNAL_TOOL_SOURCES)[number];
+export interface ExternalToolSearchHit {
+    toolRef: string;
+    source: ExternalToolSource;
+    namespace: string;
+    title: string;
+    summary: string;
+}
+export interface ExternalToolDescriptor extends ExternalToolSearchHit {
+    description: string;
+    inputSchema: Record<string, unknown>;
+}
+export interface VersionedExternalToolDescriptor extends ExternalToolDescriptor {
+    revision: string;
+}
+export interface ExternalToolExecutionContext {
+    toolCallId: string;
+    signal?: AbortSignal;
+    onUpdate?: AgentToolUpdateCallback<Record<string, unknown>>;
+}
+export interface ExternalToolProvider {
+    readonly source: ExternalToolSource;
+    search(query: string): Promise<ExternalToolSearchHit[]>;
+    describe(toolRef: string): Promise<ExternalToolDescriptor | undefined>;
+    execute(toolRef: string, args: Record<string, unknown>, approvalId: string | undefined, context: ExternalToolExecutionContext): Promise<AgentToolResult<Record<string, unknown>>>;
+}

package/dist/src/agent/external-tools/types.js

@@ -0,0 +1,9 @@
+//#region src/agent/external-tools/types.ts
+const EXTERNAL_TOOL_SOURCES = [
+	"mcp",
+	"composio",
+	"extension",
+	"memory"
+];
+//#endregion
+export { EXTERNAL_TOOL_SOURCES };

package/dist/src/agent/image/tool-model-config.js

@@ -1,7 +1,7 @@
 import { getAgentDefaultImageModelConfig, getAgentDefaultModelRef, init_schema, parseModelRef } from "../../config/schema.js";
 import { init_agent_scope, resolveDefaultAgentId } from "../agent-scope.js";
-import { getDefaultModelSync, getModelsByProvider, init_providers, isProviderConfiguredSync, resolveModel } from "../../providers/index.js";
 import { resolveEffectiveAgentManifestForAgent } from "../../config/agent-profile.js";
+import { getDefaultModelSync, getModelsByProvider, init_providers, isProviderConfiguredSync, resolveModel } from "../../providers/index.js";
 import { resolveAgentModelFallbackValues, resolveAgentModelPrimaryValue } from "../../config/model-input.js";
 //#region src/agent/image/tool-model-config.ts
 init_schema();

package/dist/src/agent/inbound/inbound-loop.d.ts

@@ -23,7 +23,6 @@ import type { CommandHandler, OutboundCoordinator, StreamManager } from '../mess
 import type { MessageRouter } from '../messaging/message-router.js';
 import type { ModelManager } from '../models/index.js';
 import type { SessionContextManager, SessionHydrator, SessionLifecycleManager, SessionStateBag } from '../session/index.js';
-import type { FeedbackCoordinator } from '../feedback/index.js';
 import type { HookHandler } from '../lifecycle/hook-handler.js';
 import type { SessionStore } from '../../session/store.js';
 import type { StreamHandle } from '../service.types.js';
@@ -35,7 +34,6 @@ export interface InboundLoopConfig {
     messageRouter: MessageRouter;
     commandHandler: CommandHandler;
     sessionContextManager: SessionContextManager;
-    feedbackCoordinator: FeedbackCoordinator;
     agentManager: AgentManager;
     sessionLifecycleManager: SessionLifecycleManager;
     agentOrchestrator: AgentOrchestrator;

package/dist/src/agent/inbound/inbound-loop.js

@@ -91,7 +91,6 @@ var InboundLoop = class {
 				...sessionMetadata?.sessionId ? { sessionId: sessionMetadata.sessionId } : {}
 			});
 			await this.cfg.sessionContextManager.runWith(sessionContext, async () => {
-				this.cfg.feedbackCoordinator.setContext(sessionContext);
 				this.cfg.agentManager.getOrCreateAgent(sessionContext.sessionKey);
 				this.cfg.setupSessionEventHandling(sessionContext.sessionKey);
 				await this.cfg.sessionLifecycleManager.startSession(sessionContext);
@@ -181,7 +180,7 @@ var InboundLoop = class {
 								assistantPlainText,
 								aborted: false,
 								...busProcessFailed !== void 0 ? { streamError: busProcessFailed } : {},
-								skipPersistentGoalPostTurn: false,
+								skipTaskReview: false,
 								outboundMetadata: {
 									accountId: meta?.accountId,
 									threadId: meta?.threadId
@@ -196,8 +195,6 @@ var InboundLoop = class {
 						}
 						this.cfg.sessionState.endInboundTurn(sessionContext.sessionKey);
 					}
-					this.cfg.feedbackCoordinator.endTask();
-					this.cfg.feedbackCoordinator.clearContext();
 				}
 			});
 		});

package/dist/src/agent/inbound/turn-dispatcher.js

@@ -110,7 +110,7 @@ var TurnDispatcher = class {
 				agentManager: c.agentManager,
 				modelManager: c.modelManager
 			}),
-			recordPersistentGoalStreamOutcome: (sk, o) => c.sessionState.recordPersistentGoalStreamOutcome(sk, o),
+			recordTaskReviewStreamHint: (sk, o) => c.sessionState.recordTaskReviewStreamHint(sk, o),
 			enqueueProvisionalSessionTitle: (sk, userText) => {
 				c.enqueueProvisionalSessionTitle?.(sk, userText);
 			},

package/dist/src/agent/ipc/inbox.js

@@ -1,7 +1,7 @@
 import { createLogger } from "../../utils/logger/index.js";
 import { init_logger } from "../../utils/logger.js";
-import { init_write_file_atomic, writeTextAtomic } from "../../infra/write-file-atomic.js";
 import { init_paths, resolveAgentDir } from "../../config/paths.js";
+import { init_write_file_atomic, writeTextAtomic } from "../../infra/write-file-atomic.js";
 import { join } from "path";
 import { existsSync, watch } from "fs";
 import { mkdir, readFile, readdir, rename } from "fs/promises";

package/dist/src/agent/mcp/{bundle-mcp-materialize.d.ts → bundle-mcp-gateway.d.ts}

@@ -1,6 +1,4 @@
-import type { AgentTool as AnyAgentTool } from "@earendil-works/pi-agent-core";
-import type { Config } from "../../config/schema.js";
-import type { BundleMcpToolRuntime, SessionMcpRuntime } from "./bundle-mcp-types.js";
+import type { Config } from '../../config/schema.js';
 export type McpGatewayToolEntry = {
     name: string;
     shortName: string;
@@ -28,7 +26,6 @@ export type McpGatewayCapabilitySummary = {
     resources: McpGatewayResourceEntry[];
     prompts: McpGatewayPromptEntry[];
 };
-export declare function mapBundleMcpToolsForGateway(tools: AnyAgentTool[], serverId: string): McpGatewayToolEntry[];
 export declare function listBundleMcpServerToolsForGateway(params: {
     workspaceDir: string;
     cfg?: Config;
@@ -39,18 +36,3 @@ export declare function listBundleMcpServerCapabilitiesForGateway(params: {
     cfg?: Config;
     serverId: string;
 }): Promise<McpGatewayCapabilitySummary>;
-export declare function materializeBundleMcpToolsForRun(params: {
-    runtime: SessionMcpRuntime;
-    reservedToolNames?: Iterable<string>;
-    disposeRuntime?: () => Promise<void>;
-}): Promise<BundleMcpToolRuntime>;
-export declare function createBundleMcpToolRuntime(params: {
-    workspaceDir: string;
-    cfg?: Config;
-    reservedToolNames?: Iterable<string>;
-    createRuntime?: (params: {
-        sessionId: string;
-        workspaceDir: string;
-        cfg?: Config;
-    }) => SessionMcpRuntime;
-}): Promise<BundleMcpToolRuntime>;

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

@@ -0,0 +1,60 @@
+import { mcpToolPolicyId } from "./bundle-mcp-policy.js";
+import { createSessionMcpRuntime } from "./bundle-mcp-runtime.js";
+import crypto from "node:crypto";
+//#region src/agent/mcp/bundle-mcp-gateway.ts
+function mapTools(tools, serverId) {
+	return tools.filter((tool) => tool.serverName === serverId).map((tool) => ({
+		name: mcpToolPolicyId(tool.safeServerName, tool.toolName),
+		shortName: tool.toolName,
+		description: tool.description || tool.title || tool.fallbackDescription
+	}));
+}
+function mapResources(resources, serverId) {
+	return resources.filter((resource) => resource.serverName === serverId).map((resource) => ({
+		uri: resource.uri,
+		name: resource.name,
+		title: resource.title,
+		description: resource.description,
+		mimeType: resource.mimeType
+	}));
+}
+function mapPrompts(prompts, serverId) {
+	return prompts.filter((prompt) => prompt.serverName === serverId).map((prompt) => ({
+		name: prompt.name,
+		title: prompt.title,
+		description: prompt.description,
+		argumentCount: prompt.argumentCount
+	}));
+}
+async function loadCatalog(params) {
+	const runtime = createSessionMcpRuntime({
+		sessionId: `mcp-gateway:${crypto.randomUUID()}`,
+		workspaceDir: params.workspaceDir,
+		cfg: params.cfg
+	});
+	try {
+		return await runtime.getCatalog();
+	} finally {
+		await runtime.dispose();
+	}
+}
+async function listBundleMcpServerToolsForGateway(params) {
+	return mapTools((await loadCatalog(params)).tools, params.serverId);
+}
+async function listBundleMcpServerCapabilitiesForGateway(params) {
+	const catalog = await loadCatalog(params);
+	const tools = mapTools(catalog.tools, params.serverId);
+	const resources = mapResources(catalog.resources, params.serverId);
+	const prompts = mapPrompts(catalog.prompts, params.serverId);
+	return {
+		serverId: params.serverId,
+		toolCount: tools.length,
+		resourceCount: resources.length,
+		promptCount: prompts.length,
+		tools,
+		resources,
+		prompts
+	};
+}
+//#endregion
+export { listBundleMcpServerCapabilitiesForGateway, listBundleMcpServerToolsForGateway };

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

@@ -1,9 +1 @@
-export declare const TOOL_NAME_SEPARATOR = "__";
 export declare function sanitizeServerName(raw: string, usedNames: Set<string>): string;
-export declare function sanitizeToolName(raw: string): string;
-export declare function normalizeReservedToolNames(names?: Iterable<string>): Set<string>;
-export declare function buildSafeToolName(params: {
-    serverName: string;
-    toolName: string;
-    reservedNames: Set<string>;
-}): string;

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

@@ -1,14 +1,8 @@
-import { init_string_coerce, normalizeLowercaseStringOrEmpty, normalizeOptionalString } from "../../utils/string-coerce.js";
+import { init_string_coerce, normalizeLowercaseStringOrEmpty } from "../../utils/string-coerce.js";
 //#region src/agent/mcp/bundle-mcp-names.ts
 init_string_coerce();
-function normalizeOptionalLowercaseString(value) {
-	const s = normalizeOptionalString(value);
-	return s ? s.toLowerCase() : void 0;
-}
 const TOOL_NAME_SAFE_RE = /[^A-Za-z0-9_-]/g;
-const TOOL_NAME_SEPARATOR = "__";
 const TOOL_NAME_MAX_PREFIX = 30;
-const TOOL_NAME_MAX_TOTAL = 64;
 function sanitizeToolFragment(raw, fallback, maxChars) {
 	const normalized = raw.trim().replace(TOOL_NAME_SAFE_RE, "-") || fallback;
 	if (!maxChars) return normalized;
@@ -26,26 +20,5 @@ function sanitizeServerName(raw, usedNames) {
 	usedNames.add(normalizeLowercaseStringOrEmpty(candidate));
 	return candidate;
 }
-function sanitizeToolName(raw) {
-	return sanitizeToolFragment(raw, "tool");
-}
-function normalizeReservedToolNames(names) {
-	return new Set(Array.from(names ?? [], (name) => normalizeOptionalLowercaseString(name)).filter((name) => Boolean(name)));
-}
-function buildSafeToolName(params) {
-	const cleanedToolName = sanitizeToolName(params.toolName);
-	const maxToolChars = Math.max(1, TOOL_NAME_MAX_TOTAL - params.serverName.length - 2);
-	const truncatedToolName = cleanedToolName.slice(0, maxToolChars);
-	let candidateToolName = truncatedToolName || "tool";
-	let candidate = `${params.serverName}__${candidateToolName}`;
-	let n = 2;
-	while (params.reservedNames.has(normalizeLowercaseStringOrEmpty(candidate))) {
-		const suffix = `-${n}`;
-		candidateToolName = `${(truncatedToolName || "tool").slice(0, Math.max(1, maxToolChars - suffix.length))}${suffix}`;
-		candidate = `${params.serverName}__${candidateToolName}`;
-		n += 1;
-	}
-	return candidate;
-}
 //#endregion
-export { TOOL_NAME_SEPARATOR, buildSafeToolName, normalizeReservedToolNames, sanitizeServerName, sanitizeToolName };
+export { sanitizeServerName };

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

@@ -1,11 +1,6 @@
-import type { Config } from '../../config/schema.js';
-export declare function shouldCreateBundleMcpRuntimeForAttempt(params: {
-    cfg?: Config;
-    toolsEnabled?: boolean;
-    disabledTools?: Set<string>;
-}): boolean;
-export declare function isMcpToolName(toolName: string): boolean;
-export declare function parseMcpToolName(toolName: string): {
+import type { AgentManifest } from '../../agent-manifest/schema.js';
+export declare function mcpToolPolicyId(serverId: string, toolName: string): string;
+export declare function isMcpCatalogToolDenied(identity: {
     serverId: string;
-    toolId: string;
-} | null;
+    policyToolId: string;
+}, policy: AgentManifest['tools']['mcp']): boolean;