@xopcai/xopc 0.0.321 → 0.0.323

package/dist/src/agent/agent-manager.d.ts

@@ -98,6 +98,7 @@ export interface AgentManagerConfig {
     getProjectService?: () => ProjectService | undefined;
     getWorkDiscovery?: () => import('../work-discovery/service.js').WorkDiscoveryService | undefined;
     getLocalAppService?: () => import('../local-apps/index.js').LocalAppService | undefined;
+    getChatPreviewService?: () => import('../chat-previews/index.js').ChatPreviewService | undefined;
     dispatchTaskEvents?: () => void;
     dispatchTaskRuns?: () => void;
     /** Gateway: starts persisted workflow runs (dedicated chat session per run). */

package/dist/src/agent/agent-manager.js

@@ -270,6 +270,7 @@ var AgentManager = class {
 			getProjectService: this.config.getProjectService,
 			getWorkDiscovery: this.config.getWorkDiscovery,
 			getLocalAppService: this.config.getLocalAppService,
+			getChatPreviewService: this.config.getChatPreviewService,
 			dispatchTaskEvents: this.config.dispatchTaskEvents,
 			dispatchTaskRuns: this.config.dispatchTaskRuns,
 			getWorkflowRunService: this.config.getWorkflowRunService,

package/dist/src/agent/embedded/transcript-runtime.d.ts

@@ -3,6 +3,7 @@ import { SessionManager } from '@earendil-works/pi-coding-agent';
 import type { Api, Model } from '@earendil-works/pi-ai';
 import { type CompactionExecutionOptions, type CompactionResult } from '../memory/compaction.js';
 import type { SessionStore } from '../../session/store.js';
+import type { TranscriptSourceEntry } from '../../storage/sqlite/transcript-repository.js';
 export interface EmbeddedTranscriptRuntime {
     readonly runtimeId: string;
     readonly transcriptId: string;
@@ -32,6 +33,8 @@ export declare class InMemoryTranscriptRuntime implements EmbeddedTranscriptRunt
     loadMessages(): Promise<AgentMessage[]>;
     captureBaseline(): void;
     loadConversationMessages(): AgentMessage[];
+    loadBaselineMessages(): AgentMessage[];
+    loadConversationRows(): TranscriptSourceEntry['row'][];
     private sourceEntries;
     compact(_messages: AgentMessage[], model: Model<Api>, instructions?: string, force?: boolean, options?: CompactionExecutionOptions): Promise<CompactionResult>;
 }

package/dist/src/agent/embedded/transcript-runtime.js

@@ -49,6 +49,12 @@ var InMemoryTranscriptRuntime = class {
 	loadConversationMessages() {
 		return this.sessionManager.getBranch().slice(this.baselineEntryCount).flatMap((entry) => entry.type === "message" ? [entry.message] : []);
 	}
+	loadBaselineMessages() {
+		return buildSessionContextForLlm(this.sourceEntries().slice(0, this.baselineEntryCount).map((entry) => entry.row));
+	}
+	loadConversationRows() {
+		return structuredClone(this.sourceEntries().slice(this.baselineEntryCount).map((entry) => entry.row));
+	}
 	sourceEntries() {
 		return this.sessionManager.getBranch().flatMap((entry, index) => {
 			const compaction = this.compactionRows.get(entry.id);

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

@@ -202,7 +202,10 @@ var CliToolProvider = class {
 				summary: `Confirm ${action.id}`,
 				needs: [{
 					key: `${item.instance.connectorId}:${connection.accountId}`,
-					connectorId: item.instance.connectorId,
+					target: {
+						type: "connector",
+						connectorId: item.instance.connectorId
+					},
 					accountId: connection.accountId,
 					connectionId: connection.id,
 					label: item.instance.displayName,

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

@@ -260,7 +260,7 @@ var ComposioToolProvider = class {
 		}).filter((connection) => connection.status === "active" && fresh.some((item) => item.id === connection.id) && canAccessConnectorAccount(connection, resolved.installation, available.agentId)));
 		const boundConnection = available.context ? connectionBinding(available.context.conversationId, resolved.installation.connectorId) : void 0;
 		const requestedAccount = typeof executionArgs[CONNECTION_ARGUMENT] === "string" ? executionArgs[CONNECTION_ARGUMENT] : boundConnection ? getConnectorConnection(boundConnection)?.accountId : void 0;
-		const bindings = available.context ? connectionBindings(available.context.conversationId).filter((need) => need.connectorId === resolved.installation.connectorId) : [];
+		const bindings = available.context ? connectionBindings(available.context.conversationId).filter((need) => need.target.type === "connector" && need.target.connectorId === resolved.installation.connectorId) : [];
 		if (bindings.length > 1 && !requestedAccount) return textResult({
 			status: "account_selection_required",
 			accounts: bindings,
@@ -277,7 +277,10 @@ var ComposioToolProvider = class {
 				summary: `Continue ${action.actionId} using ${toolkit}`,
 				needs: [{
 					key: `${resolved.installation.connectorId}:default`,
-					connectorId: resolved.installation.connectorId,
+					target: {
+						type: "connector",
+						connectorId: resolved.installation.connectorId
+					},
 					accountId: requestedAccount,
 					label: getConnectorDefinition(resolved.installation.connectorId)?.displayName ?? toolkit,
 					capabilities: [action.actionId]
@@ -388,7 +391,10 @@ var ComposioToolProvider = class {
 				summary: `Confirm ${action.actionId}`,
 				needs: [{
 					key: `${resolved.installation.connectorId}:${connection.accountId}`,
-					connectorId: resolved.installation.connectorId,
+					target: {
+						type: "connector",
+						connectorId: resolved.installation.connectorId
+					},
 					accountId: connection.accountId,
 					connectionId: connection.id,
 					label: toolkit,

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

@@ -2,6 +2,7 @@ import { init_connector_repository, listConnectorConnections } from "../../stora
 import { connectionBindings, getActiveConnectionWait, init_connection_wait_repository, publishConnectionWait, requireSessionConnection, reviseCurrentConnectionObjective } from "../../storage/sqlite/connection-wait-repository.js";
 import { connectorPrincipalForSession } from "../../connectors/principal.js";
 import { connectionCandidates, resolveConnectionCandidate } from "../../connectors/connection-candidates.js";
+import { parsePluginMcpCandidateRef, resolvePluginMcpConnectionCandidate } from "../../extensions/agent-plugins/connection.js";
 import { ExternalToolService } from "./service.js";
 import { EXTERNAL_TOOL_SOURCES } from "./types.js";
 import { Type } from "@sinclair/typebox";
@@ -57,13 +58,15 @@ function createExternalToolGatewayTools(providers, getContext) {
 		async execute(_toolCallId, params) {
 			const selectedSources = new Set(params.sources ?? []);
 			const excludedSources = selectedSources.size ? EXTERNAL_TOOL_SOURCES.filter((source) => !selectedSources.has(source)) : [];
+			const result = await service.search(params);
+			const candidates = [...result.connectionCandidates, ...connectionCandidates(params.query)].filter((candidate, index, all) => all.findIndex((item) => item.candidateRef === candidate.candidateRef) === index);
 			return textResult({
-				...await service.search(params),
+				...result,
+				connectionCandidates: candidates,
 				...excludedSources.length ? { searchScope: {
 					excludedSources,
 					instruction: "This search excluded these sources. Results from other apps do not establish that the requested app is unavailable. Retry without sources before declaring a capability unavailable or requesting authorization. Feishu/Lark, WeCom and WPS 365 connectors use cli."
 				} } : {},
-				connectionCandidates: connectionCandidates(params.query),
 				selectedConnections: getContext?.()?.conversationId ? connectionBindings(getContext().conversationId) : [],
 				waitingObjective: getContext?.()?.conversationId ? getActiveConnectionWait(getContext().conversationId)?.summary : void 0
 			});
@@ -147,10 +150,13 @@ function createExternalToolGatewayTools(providers, getContext) {
 			const principal = connectorPrincipalForSession(context.conversationId);
 			if (!principal.isLocalOwner) throw new Error("Connection recovery is available in the owner chat.");
 			const selected = connectionBindings(context.conversationId);
-			if (params.requirements.every((item) => selected.some((need) => need.connectorId === item.candidateRef && need.connectionId && (!item.accountId || item.accountId === need.accountId) && (!item.accountSelector || item.accountSelector === need.accountSelector) && listConnectorConnections({
-				principalId: principal.principalId,
-				connectorId: need.connectorId
-			}).some((connection) => connection.id === need.connectionId && connection.status === "active")))) return textResult({
+			if (params.requirements.every((item) => {
+				const pluginTarget = parsePluginMcpCandidateRef(item.candidateRef);
+				return selected.some((need) => need.target.type === "connector" ? need.target.connectorId === item.candidateRef && Boolean(need.connectionId) && (!item.accountId || item.accountId === need.accountId) && (!item.accountSelector || item.accountSelector === need.accountSelector) && listConnectorConnections({
+					principalId: principal.principalId,
+					connectorId: need.target.connectorId
+				}).some((connection) => connection.id === need.connectionId && connection.status === "active") : Boolean(pluginTarget && need.target.pluginId === pluginTarget.pluginId && need.target.serverName === pluginTarget.serverName && need.connectionId === need.target.serverId));
+			})) return textResult({
 				status: "already_connected",
 				selectedConnections: selected,
 				instruction: "These accounts were already checked for this objective. Missing tool contracts are a tool availability problem. Do not request authorization again or invent a revision. Explain the unavailable capability and stop retrying the same tools."
@@ -162,16 +168,17 @@ function createExternalToolGatewayTools(providers, getContext) {
 				summary: params.purpose,
 				checkpoint: params.checkpoint,
 				needs: params.requirements.map((item) => {
-					const need = resolveConnectionCandidate(item.candidateRef);
-					if (item.accountId && !listConnectorConnections({
+					const need = resolvePluginMcpConnectionCandidate(item.candidateRef) ?? resolveConnectionCandidate(item.candidateRef);
+					if (item.accountId && need.target.type !== "connector") throw new Error("Plugin MCP connections do not support account selection.");
+					if (item.accountId && need.target.type === "connector" && !listConnectorConnections({
 						principalId: principal.principalId,
-						connectorId: need.connectorId
+						connectorId: need.target.connectorId
 					}).some((connection) => connection.accountId === item.accountId)) throw new Error("Unknown account for this app.");
 					return {
 						...need,
 						accountId: item.accountId,
 						accountSelector: item.accountSelector,
-						key: `${need.connectorId}:${item.accountId ?? item.accountSelector ?? "default"}`
+						key: need.target.type === "connector" ? `${need.target.connectorId}:${item.accountId ?? item.accountSelector ?? "default"}` : need.key
 					};
 				})
 			});

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

@@ -2,7 +2,7 @@ import type { AgentToolResult } from '@earendil-works/pi-agent-core';
 import type { Config } from '../../config/schema.js';
 import type { ExtensionHookRunner } from '../../extensions/index.js';
 import type { SessionMcpRuntime } from '../mcp/bundle-mcp-types.js';
-import type { ExternalToolDescriptor, ExternalToolExecutionContext, ExternalToolProvider, ExternalToolSearchHit } from './types.js';
+import type { ExternalToolDescriptor, ExternalConnectionCandidate, ExternalToolExecutionContext, ExternalToolProvider, ExternalToolSearchHit } from './types.js';
 export interface McpToolProviderDeps {
     workspace: string;
     getConfig: () => Config | undefined;
@@ -21,8 +21,10 @@ export declare class McpToolProvider implements ExternalToolProvider {
     readonly source: "mcp";
     constructor(deps: McpToolProviderDeps);
     search(_query: string): Promise<ExternalToolSearchHit[]>;
+    connectionCandidates(query: string): Promise<ExternalConnectionCandidate[]>;
     describe(toolRef: string): Promise<ExternalToolDescriptor | undefined>;
     execute(toolRef: string, args: Record<string, unknown>, _approvalId: string | undefined, context: ExternalToolExecutionContext): Promise<AgentToolResult<Record<string, unknown>>>;
+    private requestConnection;
     private resolve;
     private isAllowed;
     private executionSignal;

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

@@ -1,8 +1,13 @@
+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);
 }
@@ -25,6 +30,10 @@ function toAgentToolResult(params) {
 		}
 	};
 }
+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) {
@@ -41,6 +50,30 @@ var McpToolProvider = class {
 			}));
 		});
 	}
+	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);
@@ -71,13 +104,65 @@ var McpToolProvider = class {
 				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, this.executionSignal(tool, context.signal));
-			return toAgentToolResult({
-				serverName: tool.serverName,
-				toolName: tool.toolName,
-				result
-			});
+			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);

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

@@ -1,5 +1,5 @@
 import { searchFailureDetails } from './search-error.js';
-import type { ExternalToolExecutionContext, ExternalToolProvider, ExternalToolSearchHit, ExternalToolSource, VersionedExternalToolDescriptor } from './types.js';
+import type { ExternalToolExecutionContext, ExternalConnectionCandidate, ExternalToolProvider, ExternalToolSearchHit, ExternalToolSource, VersionedExternalToolDescriptor } from './types.js';
 export declare class ExternalToolService {
     private readonly providerBySource;
     private readonly ajv;
@@ -10,6 +10,7 @@ export declare class ExternalToolService {
         limit?: number;
     }): Promise<{
         tools: ExternalToolSearchHit[];
+        connectionCandidates: ExternalConnectionCandidate[];
         unavailableSources: ExternalToolSource[];
         sourceErrors?: Array<ReturnType<typeof searchFailureDetails> & {
             source: ExternalToolSource;

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

@@ -52,13 +52,17 @@ var ExternalToolService = class {
 		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)
+			hits: await provider.search(params.query),
+			candidates: await provider.connectionCandidates?.(params.query) ?? []
 		})));
 		const unavailableSources = [];
 		const sourceErrors = [];
 		const hits = [];
-		for (const [index, result] of settled.entries()) if (result.status === "fulfilled") hits.push(...result.value.hits);
-		else {
+		const connectionCandidates = [];
+		for (const [index, result] of settled.entries()) if (result.status === "fulfilled") {
+			hits.push(...result.value.hits);
+			connectionCandidates.push(...result.value.candidates);
+		} else {
 			const provider = selected[index];
 			if (provider) {
 				unavailableSources.push(provider.source);
@@ -87,6 +91,7 @@ var ExternalToolService = class {
 				title: hit.title,
 				summary: hit.summary.slice(0, 300)
 			})),
+			connectionCandidates: connectionCandidates.filter((candidate, index, all) => all.findIndex((item) => item.candidateRef === candidate.candidateRef) === index).slice(0, limit),
 			unavailableSources,
 			...sourceErrors.length ? { sourceErrors } : {}
 		};

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

@@ -9,6 +9,14 @@ export interface ExternalToolSearchHit {
     title: string;
     summary: string;
 }
+export interface ExternalConnectionCandidate {
+    candidateRef: string;
+    source: ExternalToolSource;
+    label: string;
+    summary: string;
+    capabilities: string[];
+    reason: 'not_connected' | 'reauthorize';
+}
 export interface ExternalToolDescriptor extends ExternalToolSearchHit {
     description: string;
     inputSchema: Record<string, unknown>;
@@ -32,6 +40,7 @@ export interface ExternalToolTurnContext {
 export interface ExternalToolProvider {
     readonly source: ExternalToolSource;
     search(query: string): Promise<ExternalToolSearchHit[]>;
+    connectionCandidates?(query: string): Promise<ExternalConnectionCandidate[]>;
     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/mcp/bundle-mcp-config.js

@@ -1,5 +1,7 @@
+import { AgentPluginStore } from "../../extensions/agent-plugins/store.js";
 import { normalizeConfiguredMcpServers } from "../../config/mcp-config-normalize.js";
 import { inspectExtensionConnectorDependencies } from "../../extensions/connector-dependencies.js";
+import { materializePluginServers } from "../../extensions/agent-plugins/mcp-adapter.js";
 //#region src/agent/mcp/bundle-mcp-config.ts
 function listConfiguredMcpServers(params) {
 	const configuredMcp = normalizeConfiguredMcpServers(params.cfg?.mcp?.servers);
@@ -11,12 +13,42 @@ function listConfiguredMcpServers(params) {
 function loadMergedBundleMcpConfig(params) {
 	const mapConfiguredServer = params.mapConfiguredServer ?? ((server) => server);
 	params.workspaceDir;
+	const configured = listConfiguredMcpServers({
+		cfg: params.cfg,
+		mapConfiguredServer
+	});
+	const diagnostics = inspectExtensionConnectorDependencies({ cfg: params.cfg });
+	for (const id of Object.keys(configured)) if (id.startsWith("plugin/")) {
+		delete configured[id];
+		diagnostics.push({
+			extensionId: "",
+			connectorId: id,
+			message: "Configured MCP cannot use the reserved plugin/ namespace"
+		});
+	}
+	const store = new AgentPluginStore();
+	const plugins = Object.create(null);
+	for (const plugin of store.active()) try {
+		const componentDiagnostics = [...plugin.diagnostics];
+		for (const [id, server] of Object.entries(materializePluginServers(plugin, store, componentDiagnostics))) plugins[id] = mapConfiguredServer(server, id);
+		diagnostics.push(...componentDiagnostics.map((d) => ({
+			extensionId: plugin.id,
+			connectorId: d.component,
+			message: d.message
+		})));
+	} catch (error) {
+		diagnostics.push({
+			extensionId: plugin.id,
+			connectorId: "mcp",
+			message: error instanceof Error ? error.message : String(error)
+		});
+	}
 	return {
-		config: { mcpServers: { ...listConfiguredMcpServers({
-			cfg: params.cfg,
-			mapConfiguredServer
-		}) } },
-		diagnostics: inspectExtensionConnectorDependencies({ cfg: params.cfg })
+		config: { mcpServers: {
+			...configured,
+			...plugins
+		} },
+		diagnostics
 	};
 }
 //#endregion

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

@@ -29,6 +29,7 @@ export type McpGatewayCapabilitySummary = {
     tools: McpGatewayToolEntry[];
     resources: McpGatewayResourceEntry[];
     prompts: McpGatewayPromptEntry[];
+    error?: import('./bundle-mcp-types.js').McpServerCatalog['error'];
 };
 export declare function listBundleMcpResourcesForGateway(params: {
     workspaceDir: string;

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

@@ -80,6 +80,7 @@ async function listBundleMcpServerCapabilitiesForGateway(params) {
 	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,

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

@@ -1,4 +1,5 @@
 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;
@@ -9,7 +10,7 @@ function sanitizeToolFragment(raw, fallback, maxChars) {
 	return normalized.length > maxChars ? normalized.slice(0, maxChars) : normalized;
 }
 function sanitizeServerName(raw, usedNames) {
-	const base = sanitizeToolFragment(raw, "mcp", TOOL_NAME_MAX_PREFIX);
+	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))) {

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

@@ -3,9 +3,11 @@ 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";
@@ -176,7 +178,24 @@ function createSessionMcpRuntime(params) {
 			try {
 				for (const [serverName, rawServer] of Object.entries(loaded.mcpServers)) {
 					failIfDisposed();
-					const resolved = await resolveMcpTransport(serverName, await resolveConnectorSecretReferences(rawServer), params.cfg);
+					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({
@@ -202,6 +221,7 @@ function createSessionMcpRuntime(params) {
 						await connectWithTimeout(client, resolved.transport, resolved.connectionTimeoutMs);
 						failIfDisposed();
 						const listedTools = await listAllTools(client);
+						recordPluginMcpHealth(rawServer, "ready");
 						const listedResources = await listOptionalMcpCapability({
 							serverName,
 							capability: "resources",
@@ -259,6 +279,18 @@ function createSessionMcpRuntime(params) {
 							});
 						}
 					} 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);

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

@@ -7,6 +7,10 @@ export type McpServerCatalog = {
     toolCount: number;
     resourceCount: number;
     promptCount: number;
+    error?: {
+        code: 'MCP_AUTHORIZATION_REQUIRED' | 'MCP_CONNECTION_FAILED';
+        message: string;
+    };
 };
 export type McpCatalogTool = {
     serverName: string;

package/dist/src/agent/mcp/index.js

@@ -1,8 +1,8 @@
 import { mcpToolPolicyId } from "./bundle-mcp-policy.js";
+import { McpOAuthStore, canonicalMcpServerUrl, mcpOAuthServerKey } from "./oauth/mcp-oauth-store.js";
 import { loadMergedBundleMcpConfig } from "./bundle-mcp-config.js";
 import { loadEmbeddedMcpConfig } from "./embedded-mcp.js";
 import { McpAuthorizationRequiredError, isMcpAuthorizationError } from "./oauth/mcp-oauth-errors.js";
-import { McpOAuthStore, canonicalMcpServerUrl, mcpOAuthServerKey } from "./oauth/mcp-oauth-store.js";
 import { XopcMcpOAuthClientProvider } from "./oauth/mcp-oauth-provider.js";
 import { __testing, createSessionMcpRuntime, disposeAllSessionMcpRuntimes, disposeSessionMcpRuntime, getOrCreateSessionMcpRuntime, getSessionMcpRuntimeManager, retireSessionMcpRuntime, retireSessionMcpRuntimeForConversationId } from "./bundle-mcp-runtime.js";
 import "./bundle-mcp-tools.js";

package/dist/src/agent/mcp/mcp-stdio-transport.d.ts

@@ -6,6 +6,7 @@ export type XopcStdioServerParameters = {
     env?: Record<string, string>;
     cwd?: string;
     stderr?: "pipe" | "overlapped" | "inherit" | "ignore";
+    pluginDataDir?: string;
 };
 export declare class XopcStdioClientTransport implements Transport {
     private readonly serverParams;

package/dist/src/agent/mcp/mcp-stdio-transport.js

@@ -1,5 +1,7 @@
 import { terminateProcess } from "../../process/kill-tree.js";
+import { containedPath } from "../../extensions/agent-plugins/validation.js";
 import { spawn } from "node:child_process";
+import { mkdir } from "node:fs/promises";
 import { getDefaultEnvironment } from "@modelcontextprotocol/sdk/client/stdio.js";
 import process from "node:process";
 import { PassThrough } from "node:stream";
@@ -24,6 +26,14 @@ var XopcStdioClientTransport = class {
 	}
 	async start() {
 		if (this.process) throw new Error("XopcStdioClientTransport already started; Client.connect() starts transports automatically.");
+		if (this.serverParams.pluginDataDir) {
+			const data = this.serverParams.pluginDataDir;
+			await mkdir(data, {
+				recursive: true,
+				mode: 448
+			});
+			if (this.serverParams.cwd) containedPath(this.serverParams.cwd.startsWith(data) ? data : this.serverParams.env?.PLUGIN_ROOT ?? data, this.serverParams.cwd);
+		}
 		await new Promise((resolve, reject) => {
 			const baseEnv = {
 				...getDefaultEnvironment(),