@xopcai/xopc 0.0.368 → 0.0.370

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

@@ -1,208 +0,0 @@
-import { init_connection_wait_repository, publishConnectionWait, requireSessionConnection } from "../../storage/sqlite/connection-wait-repository.js";
-import { resolveEffectiveAgentProfileForSession } from "../../config/agent-profile.js";
-import { connectorPrincipalForSession } from "../../connectors/principal.js";
-import { externalToolRef, parseExternalToolRef } from "./refs.js";
-import { pluginMcpCandidateRef } from "../../extensions/agent-plugins/connection.js";
-import { mcpToolPolicyId } from "../mcp/bundle-mcp-policy.js";
-import { isMcpAuthorizationError } from "../mcp/oauth/mcp-oauth-errors.js";
-import { getOrCreateSessionMcpRuntime } from "../mcp/bundle-mcp-runtime.js";
-//#region src/agent/external-tools/mcp-provider.ts
-init_connection_wait_repository();
-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" } : {}
-		}
-	};
-}
-function hasAuthorizationChallenge(result) {
-	const challenge = result._meta?.["mcp/www_authenticate"];
-	return typeof challenge === "string" || Array.isArray(challenge) && challenge.some((value) => typeof value === "string");
-}
-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.safeServerName, tool.toolName),
-				source: this.source,
-				namespace: tool.safeServerName,
-				title: tool.title || tool.toolName,
-				summary: tool.description || tool.fallbackDescription
-			}));
-		});
-	}
-	async connectionCandidates(query) {
-		return this.withRuntime(async (runtime) => {
-			const catalog = await runtime.getCatalog();
-			const normalizedQuery = query.toLocaleLowerCase();
-			return Object.values(catalog.servers).flatMap((server) => {
-				if (!server.serverName.startsWith("plugin/") || server.error?.code !== "MCP_AUTHORIZATION_REQUIRED") return [];
-				const [, encodedPluginId, encodedServerName] = server.serverName.split("/");
-				if (!encodedPluginId || !encodedServerName) return [];
-				const pluginId = decodeURIComponent(encodedPluginId);
-				const serverName = decodeURIComponent(encodedServerName);
-				const searchable = `${pluginId} ${serverName}`.toLocaleLowerCase();
-				const tokens = normalizedQuery.split(/[^\p{L}\p{N}_-]+/u).filter((token) => token.length > 1);
-				if (tokens.length && !tokens.some((token) => searchable.includes(token))) return [];
-				return [{
-					candidateRef: pluginMcpCandidateRef(pluginId, serverName),
-					source: this.source,
-					label: pluginId,
-					summary: `Connect ${pluginId}/${serverName}`,
-					capabilities: [`mcp.tools:${server.serverName}`],
-					reason: "not_connected"
-				}];
-			});
-		});
-	}
-	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, {
-					conversationId: this.deps.getConversationId(),
-					isMcpTool: true,
-					mcpServerId: tool.serverName
-				});
-				if (!hook.allowed) throw new Error(hook.reason ?? "MCP tool call blocked by policy hook.");
-				executionArgs = hook.params ?? args;
-			}
-			try {
-				const result = await runtime.callTool(tool.serverName, tool.toolName, executionArgs, this.executionSignal(tool, context.signal));
-				if (tool.serverName.startsWith("plugin/") && hasAuthorizationChallenge(result)) return this.requestConnection(tool.serverName, tool.toolName);
-				return toAgentToolResult({
-					serverName: tool.serverName,
-					toolName: tool.toolName,
-					result
-				});
-			} catch (error) {
-				if (tool.serverName.startsWith("plugin/") && (isMcpAuthorizationError(error) || error?.code === 401)) return this.requestConnection(tool.serverName, tool.toolName);
-				throw error;
-			}
-		});
-	}
-	requestConnection(serverId, toolName) {
-		const [, encodedPluginId, encodedServerName] = serverId.split("/");
-		const conversationId = this.deps.getConversationId();
-		if (!encodedPluginId || !encodedServerName || !conversationId) return {
-			content: [{
-				type: "text",
-				text: "This MCP tool requires an account connection in xopc."
-			}],
-			details: { status: "connection_required" }
-		};
-		const pluginId = decodeURIComponent(encodedPluginId);
-		const serverName = decodeURIComponent(encodedServerName);
-		const principal = connectorPrincipalForSession(conversationId);
-		if (!principal.isLocalOwner) return {
-			content: [{
-				type: "text",
-				text: "This MCP connection must be completed by the xopc owner."
-			}],
-			details: { status: "connection_required" }
-		};
-		const result = requireSessionConnection({
-			conversationId,
-			principalId: principal.principalId,
-			agentId: principal.agentId ?? this.deps.agentId ?? "main",
-			summary: `Continue ${toolName} using ${pluginId}`,
-			needs: [{
-				key: serverId,
-				target: {
-					type: "plugin-mcp",
-					pluginId,
-					serverId,
-					serverName
-				},
-				label: pluginId,
-				capabilities: [`mcp.tool:${serverId}:${toolName}`]
-			}]
-		});
-		publishConnectionWait(conversationId);
-		return {
-			content: [{
-				type: "text",
-				text: "Account connection required. The objective is preserved in xopc."
-			}],
-			details: 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.safeServerName === parsed.namespace && candidate.toolName === parsed.toolName);
-		return tool && this.isAllowed(tool) ? tool : void 0;
-	}
-	isAllowed(tool) {
-		const cfg = this.deps.getConfig();
-		const conversationId = this.deps.getConversationId();
-		const profile = cfg && conversationId ? resolveEffectiveAgentProfileForSession(conversationId) : void 0;
-		const policyName = policyToolId(tool);
-		return !profile?.tools.denied.has(policyName);
-	}
-	executionSignal(tool, signal) {
-		const cfg = this.deps.getConfig();
-		const conversationId = this.deps.getConversationId();
-		const timeoutMs = (cfg && conversationId ? resolveEffectiveAgentProfileForSession(conversationId) : void 0)?.config.tools[policyToolId(tool)]?.timeoutMs;
-		if (!timeoutMs) return signal;
-		const timeoutSignal = AbortSignal.timeout(timeoutMs);
-		return signal ? AbortSignal.any([signal, timeoutSignal]) : timeoutSignal;
-	}
-	async withRuntime(run) {
-		const cfg = this.deps.getConfig();
-		const conversationId = this.deps.getConversationId();
-		const sessionId = conversationId ?? `agent:${this.deps.agentId ?? "main"}`;
-		const runtime = await (this.deps.getRuntime ?? getOrCreateSessionMcpRuntime)({
-			sessionId,
-			conversationId,
-			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/mcp/bundle-mcp-config.d.ts

@@ -1,20 +0,0 @@
-import type { Config } from '../../config/schema.js';
-export type BundleMcpServerConfig = Record<string, unknown>;
-export type BundleMcpDiagnostic = {
-    extensionId: string;
-    connectorId: string;
-    message: string;
-};
-export type BundleMcpConfig = {
-    mcpServers: Record<string, BundleMcpServerConfig>;
-};
-export type MergedBundleMcpConfig = {
-    config: BundleMcpConfig;
-    diagnostics: BundleMcpDiagnostic[];
-};
-export type BundleMcpServerMapper = (server: BundleMcpServerConfig, name: string) => BundleMcpServerConfig;
-export declare function loadMergedBundleMcpConfig(params: {
-    workspaceDir: string;
-    cfg?: Config;
-    mapConfiguredServer?: BundleMcpServerMapper;
-}): MergedBundleMcpConfig;

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

@@ -1,79 +0,0 @@
-import type { Config } from '../../config/schema.js';
-export type McpGatewayToolEntry = {
-    name: string;
-    shortName: string;
-    description: string;
-    readOnly: boolean;
-};
-export type McpGatewayResourceEntry = {
-    id: string;
-    version: string;
-    serverId: string;
-    uri: string;
-    name: string;
-    title?: string;
-    description?: string;
-    mimeType?: string;
-};
-export type McpGatewayPromptEntry = {
-    name: string;
-    title?: string;
-    description?: string;
-    argumentCount: number;
-};
-export type McpGatewayCapabilitySummary = {
-    serverId: string;
-    toolCount: number;
-    resourceCount: number;
-    promptCount: number;
-    tools: McpGatewayToolEntry[];
-    resources: McpGatewayResourceEntry[];
-    prompts: McpGatewayPromptEntry[];
-    error?: import('./bundle-mcp-types.js').McpServerCatalog['error'];
-};
-export declare function listBundleMcpResourcesForGateway(params: {
-    workspaceDir: string;
-    cfg?: Config;
-}): Promise<McpGatewayResourceEntry[]>;
-export declare function readBundleMcpResourceForGateway(params: {
-    workspaceDir: string;
-    cfg?: Config;
-    sourceId: string;
-}): Promise<{
-    resource: McpGatewayResourceEntry;
-    contents: {
-        [x: string]: unknown;
-        contents: ({
-            uri: string;
-            text: string;
-            mimeType?: string;
-            _meta?: {
-                [x: string]: unknown;
-            };
-        } | {
-            uri: string;
-            blob: string;
-            mimeType?: string;
-            _meta?: {
-                [x: string]: unknown;
-            };
-        })[];
-        _meta?: {
-            [x: string]: unknown;
-            progressToken?: string | number;
-            "io.modelcontextprotocol/related-task"?: {
-                taskId: string;
-            };
-        };
-    };
-}>;
-export declare function listBundleMcpServerToolsForGateway(params: {
-    workspaceDir: string;
-    cfg?: Config;
-    serverId: string;
-}): Promise<McpGatewayToolEntry[]>;
-export declare function listBundleMcpServerCapabilitiesForGateway(params: {
-    workspaceDir: string;
-    cfg?: Config;
-    serverId: string;
-}): Promise<McpGatewayCapabilitySummary>;

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

@@ -1,93 +0,0 @@
-import { mcpToolPolicyId } from "./bundle-mcp-policy.js";
-import { createSessionMcpRuntime } from "./bundle-mcp-runtime.js";
-import { decodeMcpResourceId, encodeMcpResourceId } from "./mcp-resource-id.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,
-		readOnly: tool.annotations?.readOnlyHint === true
-	}));
-}
-function mapResources(resources, serverId) {
-	return resources.filter((resource) => resource.serverName === serverId).map((resource) => ({
-		id: encodeMcpResourceId({
-			serverId: resource.serverName,
-			uri: resource.uri
-		}),
-		version: crypto.createHash("sha256").update(JSON.stringify(resource)).digest("hex"),
-		serverId: resource.serverName,
-		uri: resource.uri,
-		name: resource.name,
-		title: resource.title,
-		description: resource.description,
-		mimeType: resource.mimeType
-	}));
-}
-async function listBundleMcpResourcesForGateway(params) {
-	const catalog = await loadCatalog(params);
-	return Object.keys(catalog.servers).sort().flatMap((serverId) => mapResources(catalog.resources, serverId));
-}
-async function readBundleMcpResourceForGateway(params) {
-	const identity = decodeMcpResourceId(params.sourceId);
-	if (!identity) throw new Error("Invalid MCP resource id");
-	const runtime = createSessionMcpRuntime({
-		sessionId: `mcp-resource:${crypto.randomUUID()}`,
-		workspaceDir: params.workspaceDir,
-		cfg: params.cfg
-	});
-	try {
-		const resource = (await runtime.getCatalog()).resources.find((item) => item.serverName === identity.serverId && item.uri === identity.uri);
-		if (!resource) throw new Error("MCP resource is unavailable");
-		const contents = await runtime.readResource(identity.serverId, identity.uri);
-		return {
-			resource: mapResources([resource], identity.serverId)[0],
-			contents
-		};
-	} finally {
-		await runtime.dispose();
-	}
-}
-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,
-		error: catalog.servers[params.serverId]?.error,
-		toolCount: tools.length,
-		resourceCount: resources.length,
-		promptCount: prompts.length,
-		tools,
-		resources,
-		prompts
-	};
-}
-//#endregion
-export { listBundleMcpResourcesForGateway, listBundleMcpServerCapabilitiesForGateway, listBundleMcpServerToolsForGateway, readBundleMcpResourceForGateway };

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

@@ -1 +0,0 @@
-export declare function sanitizeServerName(raw: string, usedNames: Set<string>): string;

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

@@ -1,25 +0,0 @@
-import { init_string_coerce, normalizeLowercaseStringOrEmpty } from "../../utils/string-coerce.js";
-import { createHash } from "node:crypto";
-//#region src/agent/mcp/bundle-mcp-names.ts
-init_string_coerce();
-const TOOL_NAME_SAFE_RE = /[^A-Za-z0-9_-]/g;
-const TOOL_NAME_MAX_PREFIX = 30;
-function sanitizeToolFragment(raw, fallback, maxChars) {
-	const normalized = raw.trim().replace(TOOL_NAME_SAFE_RE, "-") || fallback;
-	if (!maxChars) return normalized;
-	return normalized.length > maxChars ? normalized.slice(0, maxChars) : normalized;
-}
-function sanitizeServerName(raw, usedNames) {
-	const base = raw.startsWith("plugin/") ? `plugin-${createHash("sha256").update(raw).digest("hex").slice(0, 20)}` : sanitizeToolFragment(raw, "mcp", TOOL_NAME_MAX_PREFIX);
-	let candidate = base;
-	let n = 2;
-	while (usedNames.has(normalizeLowercaseStringOrEmpty(candidate))) {
-		const suffix = `-${n}`;
-		candidate = `${base.slice(0, Math.max(1, TOOL_NAME_MAX_PREFIX - suffix.length))}${suffix}`;
-		n += 1;
-	}
-	usedNames.add(normalizeLowercaseStringOrEmpty(candidate));
-	return candidate;
-}
-//#endregion
-export { sanitizeServerName };

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

@@ -1 +0,0 @@
-export declare function mcpToolPolicyId(serverId: string, toolName: string): string;

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

@@ -1,6 +0,0 @@
-//#region src/agent/mcp/bundle-mcp-policy.ts
-function mcpToolPolicyId(serverId, toolName) {
-	return `mcp:${encodeURIComponent(serverId)}:${encodeURIComponent(toolName)}`;
-}
-//#endregion
-export { mcpToolPolicyId };

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

@@ -1,46 +0,0 @@
-import type { jsonSchemaValidator } from "@modelcontextprotocol/sdk/validation/types.js";
-import type { Config } from "../../config/schema.js";
-import type { SessionMcpRuntime, SessionMcpRuntimeManager } from "./bundle-mcp-types.js";
-type CreateSessionMcpRuntime = (params: Parameters<typeof createSessionMcpRuntime>[0] & {
-    configFingerprint?: string;
-}) => SessionMcpRuntime;
-export declare function createBundleMcpJsonSchemaValidator(): jsonSchemaValidator;
-declare function resolveSessionMcpRuntimeIdleTtlMs(cfg?: Config): number;
-export declare function createSessionMcpRuntime(params: {
-    sessionId: string;
-    conversationId?: string;
-    workspaceDir: string;
-    cfg?: Config;
-}): SessionMcpRuntime;
-declare function createSessionMcpRuntimeManager(opts?: {
-    createRuntime?: CreateSessionMcpRuntime;
-    now?: () => number;
-    enableIdleSweepTimer?: boolean;
-    idleSweepIntervalMs?: number;
-}): SessionMcpRuntimeManager;
-export declare function getSessionMcpRuntimeManager(): SessionMcpRuntimeManager;
-export declare function getOrCreateSessionMcpRuntime(params: {
-    sessionId: string;
-    conversationId?: string;
-    workspaceDir: string;
-    cfg?: Config;
-}): Promise<SessionMcpRuntime>;
-export declare function disposeSessionMcpRuntime(sessionId: string): Promise<void>;
-export declare function retireSessionMcpRuntime(params: {
-    sessionId?: string | null;
-    reason: string;
-    onError?: (error: unknown, sessionId: string, reason: string) => void;
-}): Promise<boolean>;
-export declare function retireSessionMcpRuntimeForConversationId(params: {
-    conversationId?: string | null;
-    reason: string;
-    onError?: (error: unknown, sessionId: string, reason: string) => void;
-}): Promise<boolean>;
-export declare function disposeAllSessionMcpRuntimes(): Promise<void>;
-export declare const __testing: {
-    createSessionMcpRuntimeManager: typeof createSessionMcpRuntimeManager;
-    resetSessionMcpRuntimeManager(): Promise<void>;
-    getCachedSessionIds(): string[];
-    resolveSessionMcpRuntimeIdleTtlMs: typeof resolveSessionMcpRuntimeIdleTtlMs;
-};
-export {};