@xopcai/xopc 0.0.369 → 0.0.371

package/dist/src/config/schema.js

@@ -42,7 +42,7 @@ function parseModelRef(ref) {
 		model: trimmed.slice(idx + 1).trim()
 	};
 }
-var AgentModelRefSchema, AgentImageGenerationModelSchema, AgentModelsSchema, BrowserDriverSchema, BrowserHostnameSchema, BrowserConfigSchema, SessionDmScopeSchema, SessionStorageConfigSchema, SessionResetModeSchema, SessionResetConfigSchema, SessionResetByTypeSchema, SessionScopeSchema, SessionConfigSchema, ChannelsConfigSchema, SearchProviderEntrySchema, WebSearchConfigSchema, WebsiteBlocklistSchema, WebToolsConfigSchema, ToolsConfigSchema, RuntimePreferenceSchema, RuntimeProvisionSchema, RuntimeVersionRequestSchema, LanguageRuntimeSchema, DEFAULT_RUNTIME_TOOLS_CONFIG, RuntimeToolsConfigSchema, GatewayAuthRateLimitSchema, GatewaySecuritySchema, GatewayTrustedProxySchema, GatewayAuthSchema, GatewayTailscaleConsentSchema, GatewayTailscaleSchema, GatewayRemoteSchema, GatewayTlsSchema, GatewayModeSchema, GatewayChannelConnectDeferModeSchema, TunnelConsentSchema, TunnelConfigSchema, WorkspaceImportConfigSchema, WorkspaceConfigSchema, GatewayBindModeSchema, GatewayWebchatConfigSchema, GatewayScenesConfigSchema, GatewayConfigSchema, ModelsDevConfigSchema, ModelCatalogConfigSchema, SttProviderConfigCatchallSchema, STTProviderConfigSchema, STTFallbackConfigSchema, MediaUnderstandingCapabilitiesSchema, MediaUnderstandingModelSchema, STTConfigSchema, TtsProviderConfigCatchallSchema, TTSProviderConfigSchema, TTSFallbackConfigSchema, TTSModelOverridesConfigSchema, TTSEdgeConfigSchema, TTSSummarizationConfigSchema, TTSConfigSchema, VoiceRefinementConfigSchema, VoiceConfigSchema, MessagesConfigSchema, ToolsMediaAudioConfigSchema, ToolsMediaConfigSchema, ProviderAzureConfigSchema, ProviderRequestOverridesSchema, ProviderAuthConfigSchema, ProvidersConfigSchema, ExtensionSecurityConfigSchema, ExtensionSlotsConfigSchema, ExtensionsConfigSchema, UpdateAutoConfigSchema, UpdateConfigSchema, CommandsConfigSchema, McpHttpUrlSchema, ConnectorSecretReferenceSchema, McpConfigScalarSchema, McpOAuthConfigSchema, McpServerSchema, McpConfigSchema, ConnectorsConfigSchema, ExperimentalConfigSchema, ConfigSchema;
+var AgentModelRefSchema, AgentImageGenerationModelSchema, AgentModelsSchema, BrowserDriverSchema, BrowserHostnameSchema, BrowserConfigSchema, SessionDmScopeSchema, SessionStorageConfigSchema, SessionResetModeSchema, SessionResetConfigSchema, SessionResetByTypeSchema, SessionScopeSchema, SessionConfigSchema, ChannelsConfigSchema, SearchProviderEntrySchema, WebSearchConfigSchema, WebsiteBlocklistSchema, WebToolsConfigSchema, ToolsConfigSchema, RuntimePreferenceSchema, RuntimeProvisionSchema, RuntimeVersionRequestSchema, LanguageRuntimeSchema, DEFAULT_RUNTIME_TOOLS_CONFIG, RuntimeToolsConfigSchema, GatewayAuthRateLimitSchema, GatewaySecuritySchema, GatewayTrustedProxySchema, GatewayAuthSchema, GatewayTailscaleConsentSchema, GatewayTailscaleSchema, GatewayRemoteSchema, GatewayTlsSchema, GatewayModeSchema, GatewayChannelConnectDeferModeSchema, TunnelConsentSchema, TunnelConfigSchema, WorkspaceImportConfigSchema, WorkspaceConfigSchema, GatewayBindModeSchema, GatewayWebchatConfigSchema, GatewayScenesConfigSchema, GatewayConfigSchema, ModelsDevConfigSchema, ModelCatalogConfigSchema, SttProviderConfigCatchallSchema, STTProviderConfigSchema, STTFallbackConfigSchema, MediaUnderstandingCapabilitiesSchema, MediaUnderstandingModelSchema, STTConfigSchema, TtsProviderConfigCatchallSchema, TTSProviderConfigSchema, TTSFallbackConfigSchema, TTSModelOverridesConfigSchema, TTSEdgeConfigSchema, TTSSummarizationConfigSchema, TTSConfigSchema, VoiceRefinementConfigSchema, VoiceConfigSchema, MessagesConfigSchema, ToolsMediaAudioConfigSchema, ToolsMediaConfigSchema, ProviderAzureConfigSchema, ProviderRequestOverridesSchema, ProviderAuthConfigSchema, ProvidersConfigSchema, ExtensionSecurityConfigSchema, ExtensionSlotsConfigSchema, ExtensionsConfigSchema, UpdateAutoConfigSchema, UpdateConfigSchema, CommandsConfigSchema, McpHttpUrlSchema, ConnectorSecretReferenceSchema, McpConfigScalarSchema, McpExposureSchema, McpOAuthConfigSchema, McpServerSchema, McpConfigSchema, ConnectorsConfigSchema, ExperimentalConfigSchema, ConfigSchema;
 var init_schema = __esmMin((() => {
 	init_config();
 	init_config$1();
@@ -903,59 +903,76 @@ tts: TTSConfigSchema.optional() }).optional();
 		prefix: z.string().optional(),
 		suffix: z.string().optional()
 	}) });
-	McpConfigScalarSchema = z.union([
-		z.string(),
-		z.number(),
-		z.boolean(),
-		ConnectorSecretReferenceSchema
+	McpConfigScalarSchema = z.union([z.string(), ConnectorSecretReferenceSchema]);
+	McpExposureSchema = z.enum([
+		"codemode",
+		"deferred",
+		"direct",
+		"hidden"
 	]);
 	McpOAuthConfigSchema = z.object({
-		type: z.literal("oauth"),
-		/** Optional public client id for authorization servers without dynamic registration. */
-		clientId: z.string().min(1).optional()
+		clientId: z.string().min(1).optional(),
+		clientSecret: z.string().optional(),
+		callbackPort: z.number().int().min(1).max(65535).optional(),
+		callbackUrl: z.string().url().optional(),
+		scope: z.string().optional(),
+		clientName: z.string().optional(),
+		clientRegistration: z.enum(["dcr", "cimd"]).optional(),
+		authServerMetadataUrl: z.string().url().optional()
 	}).strict();
 	McpServerSchema = z.object({
-		command: z.string().optional(),
+		type: z.enum([
+			"stdio",
+			"http",
+			"streamable-http"
+		]).optional(),
+		command: z.string().min(1).optional(),
 		args: z.array(z.string()).optional(),
 		env: z.record(z.string(), McpConfigScalarSchema).optional(),
 		cwd: z.string().optional(),
-		workingDirectory: z.string().optional(),
 		url: McpHttpUrlSchema.optional(),
-		transport: z.enum(["sse", "streamable-http"]).optional(),
 		headers: z.record(z.string(), McpConfigScalarSchema).optional(),
-		auth: McpOAuthConfigSchema.optional(),
-		connectionTimeoutMs: z.number().finite().positive().optional(),
-		requestTimeoutMs: z.number().finite().positive().optional()
+		oauth: McpOAuthConfigSchema.optional(),
+		auth: z.object({ provider: z.string().min(1) }).strict().optional(),
+		timeout: z.number().finite().positive().optional(),
+		enabled: z.boolean().optional(),
+		exposure: McpExposureSchema.optional(),
+		toolExposure: z.record(z.string(), McpExposureSchema).optional(),
+		description: z.string().optional(),
+		transport: z.never().optional(),
+		workingDirectory: z.never().optional(),
+		connectionTimeoutMs: z.never().optional(),
+		requestTimeoutMs: z.never().optional()
 	}).catchall(z.unknown()).superRefine((value, ctx) => {
-		const hasCommand = typeof value.command === "string" && value.command.trim().length > 0;
-		const hasUrl = typeof value.url === "string" && value.url.trim().length > 0;
-		if (hasCommand && hasUrl) ctx.addIssue({
+		if (Boolean(value.command) === Boolean(value.url)) ctx.addIssue({
 			code: "custom",
-			message: "MCP server cannot define both command and url"
+			message: "MCP server requires exactly one command or url"
 		});
-		if (value.auth && !hasUrl) ctx.addIssue({
+		if (value.type === "stdio" && !value.command) ctx.addIssue({
 			code: "custom",
-			path: ["auth"],
-			message: "MCP OAuth requires an HTTP server URL"
+			message: "stdio requires command"
 		});
-		if (value.auth && value.transport === "sse") ctx.addIssue({
+		if ((value.type === "http" || value.type === "streamable-http") && !value.url) ctx.addIssue({
 			code: "custom",
-			path: ["auth"],
-			message: "MCP OAuth currently supports streamable HTTP only"
+			message: "HTTP requires url"
 		});
-		if (value.auth && value.headers) {
-			const authorizationHeader = Object.keys(value.headers).find((key) => key.toLowerCase() === "authorization");
-			if (authorizationHeader) ctx.addIssue({
+		if ((value.oauth || value.auth) && !value.url) ctx.addIssue({
+			code: "custom",
+			message: "MCP authentication requires HTTP"
+		});
+	});
+	McpConfigSchema = z.object({ servers: z.record(z.string().regex(/^[a-zA-Z0-9_-]+$/), McpServerSchema).optional() }).strict().superRefine((value, ctx) => {
+		const names = /* @__PURE__ */ new Set();
+		for (const name of Object.keys(value.servers ?? {})) {
+			const normalized = name.replace(/-/g, "_");
+			if (names.has(normalized)) ctx.addIssue({
 				code: "custom",
-				path: ["headers", authorizationHeader],
-				message: "MCP OAuth cannot be combined with a static Authorization header"
+				path: ["servers", name],
+				message: "MCP names differing only by hyphens and underscores collide"
 			});
+			names.add(normalized);
 		}
-	});
-	McpConfigSchema = z.object({
-		servers: z.record(z.string(), McpServerSchema).optional(),
-		sessionIdleTtlMs: z.number().finite().min(0).optional()
-	}).strict().optional();
+	}).optional();
 	ConnectorsConfigSchema = z.object({ instances: z.record(z.string(), z.record(z.string(), z.unknown())).optional() }).strict().optional();
 	ExperimentalConfigSchema = z.object({ 
 	/** First-run activation that analyzes one explicitly selected local folder. */

package/dist/src/connectors/auth-provider-registry.d.ts

@@ -8,4 +8,4 @@ export type ConnectorAuthStartResult = {
     connectionId?: string;
     attemptId?: string;
 };
-export declare function startConnectorAuthorization(definition: ConnectorDefinition, config?: Config, instanceId?: string): Promise<ConnectorAuthStartResult>;
+export declare function startConnectorAuthorization(definition: ConnectorDefinition, config?: Config, _instanceId?: string): Promise<ConnectorAuthStartResult>;

package/dist/src/connectors/auth-provider-registry.js

@@ -1,28 +1,8 @@
 import { startComposioAuthorize } from "./composio.js";
-import { isManagedConnectorServer } from "./materialize.js";
 import { getConnectorInstance } from "./instances.js";
-import { getMcpOAuthManager } from "../agent/mcp/oauth/mcp-oauth-manager.js";
 //#region src/connectors/auth-provider-registry.ts
-async function startConnectorAuthorization(definition, config, instanceId) {
+async function startConnectorAuthorization(definition, config, _instanceId) {
 	if (definition.auth.mode !== "oauth") throw new Error(`Connector "${definition.id}" does not use OAuth.`);
-	if (definition.runtime.type === "mcp") {
-		if (!config) throw new Error("Connector configuration is required for MCP authorization.");
-		const serverId = instanceId ?? definition.runtime.serverId;
-		const server = config.mcp?.servers?.[serverId];
-		if (!server) throw new Error(`Connector MCP server not found: ${serverId}`);
-		if (!isManagedConnectorServer(server) || server.xopcConnector.connectorId !== definition.id) throw new Error(`MCP server "${serverId}" is not managed by connector "${definition.id}".`);
-		const status = await getMcpOAuthManager().start({
-			serverId,
-			rawServer: server,
-			cfg: config
-		});
-		return {
-			connectorId: definition.id,
-			provider: "mcp",
-			status: status.status,
-			authorizationUrl: status.session?.authorizationUrl
-		};
-	}
 	if (definition.auth.provider !== "composio" || definition.runtime.type !== "composio" || definition.runtime.role !== "toolkit") throw new Error(`Connector "${definition.id}" does not support OAuth authorization.`);
 	const configuredAuthConfigId = config ? getConnectorInstance(config, definition.id)?.config?.authConfigId : void 0;
 	const authConfigId = typeof configuredAuthConfigId === "string" && configuredAuthConfigId.trim() ? configuredAuthConfigId.trim() : void 0;

package/dist/src/connectors/china-catalog.js

@@ -284,7 +284,7 @@ const CHINA_CONNECTORS = [
 			serverId: "tencent_meeting",
 			serverTemplate: {
 				url: "https://mcp.meeting.tencent.com/mcp",
-				transport: "streamable-http",
+				type: "http",
 				headers: { "X-Tencent-Meeting-Token": "{{secrets.token}}" }
 			}
 		},
@@ -352,7 +352,7 @@ const CHINA_CONNECTORS = [
 			serverId: "tencent_docs",
 			serverTemplate: {
 				url: "https://docs.qq.com/openapi/mcp",
-				transport: "streamable-http",
+				type: "http",
 				headers: { Authorization: "{{secrets.token}}" }
 			}
 		},
@@ -576,7 +576,7 @@ const CHINA_CONNECTORS = [
 			serverId: "bailian_web_search",
 			serverTemplate: {
 				url: "https://dashscope.aliyuncs.com/api/v1/mcps/WebSearch/mcp",
-				transport: "streamable-http",
+				type: "http",
 				headers: { Authorization: "Bearer {{secrets.apiKey}}" }
 			}
 		},
@@ -647,7 +647,7 @@ const CHINA_CONNECTORS = [
 			serverId: "dida365",
 			serverTemplate: {
 				url: "https://mcp.dida365.com",
-				transport: "streamable-http",
+				type: "http",
 				headers: { Authorization: "Bearer {{secrets.token}}" }
 			}
 		},
@@ -721,7 +721,7 @@ const CHINA_CONNECTORS = [
 			serverId: "flomo",
 			serverTemplate: {
 				url: "https://flomoapp.com/mcp",
-				transport: "streamable-http",
+				type: "http",
 				headers: { Authorization: "Bearer {{secrets.token}}" }
 			}
 		},

package/dist/src/connectors/connection-recovery-service.d.ts

@@ -1,18 +1,16 @@
 import type { Config } from '../config/schema.js';
 import type { SessionInput } from '../storage/sqlite/session-input-repository.js';
 import { ComposioSessionsAdapter } from './composio-sessions.js';
-import { type PluginMcpRecovery } from './plugin-mcp-recovery.js';
 import type { ConnectionWaitSnapshot } from '@xopcai/gateway-contract';
 export type ConnectionAction = {
     waitId: string;
     expectedTranscriptId: string;
     expectedVersion: number;
     idempotencyKey: string;
-    action: 'install_complete' | 'connect' | 'check' | 'skip' | 'cancel' | 'select_account' | 'confirm_scope' | 'replace_source' | 'submit_callback';
+    action: 'install_complete' | 'connect' | 'check' | 'skip' | 'cancel' | 'select_account' | 'confirm_scope' | 'replace_source';
     needKey?: string;
     accountId?: string;
     candidateRef?: string;
-    callbackUrl?: string;
     instanceId?: string;
 };
 /** Authorization lives at click time. Chat history contains only immutable explanations. */
@@ -34,16 +32,13 @@ export declare class ConnectionRecoveryService {
         drain: (conversationId: string) => void;
         onPersonalRequestDelivered?: (conversationId: string, requestId: string) => void;
         adapter?: ComposioSessionsAdapter;
-        pluginMcp?: PluginMcpRecovery;
     });
     private get adapter();
-    private get pluginMcp();
     snapshot(conversationId: string): ConnectionWaitSnapshot;
     private view;
     private ensureInstallation;
     private checkCapabilities;
     private syncConnections;
-    private syncPluginMcpNeeds;
     preflight(input: SessionInput): Promise<boolean>;
     act(conversationId: string, action: ConnectionAction): Promise<{
         snapshot: ConnectionWaitSnapshot;

package/dist/src/connectors/connection-recovery-service.js

@@ -22,7 +22,6 @@ import { resolveConnectionCandidate } from "./connection-candidates.js";
 import { cancelPersonalRequest, resolvePersonalRequestConnection } from "../personal-agent/request-service.js";
 import { persistConfigMutation } from "../config/config-mutation.js";
 import { drainPersonalRequestContinuations, drainPersonalRequestResults } from "../personal-agent/request-delivery.js";
-import { HostPluginMcpRecovery } from "./plugin-mcp-recovery.js";
 import { randomUUID } from "node:crypto";
 //#region src/connectors/connection-recovery-service.ts
 init_transaction();
@@ -95,9 +94,6 @@ var ConnectionRecoveryService = class {
 	get adapter() {
 		return this.deps.adapter ?? new ComposioSessionsAdapter();
 	}
-	get pluginMcp() {
-		return this.deps.pluginMcp ?? new HostPluginMcpRecovery(this.deps.getConfig);
-	}
 	snapshot(conversationId) {
 		if (!connectorPrincipalForSession(conversationId).isLocalOwner) throw new Error("This connection belongs to another principal.");
 		const transcriptId = readCurrentTranscriptId(getSqliteDatabase(), conversationId);
@@ -111,18 +107,6 @@ var ConnectionRecoveryService = class {
 	}
 	view(wait, verifiedIds) {
 		const needs = wait.needs.map((need) => {
-			if (need.target.type === "plugin-mcp") {
-				const availability = this.pluginMcp.availability(need.target);
-				const phase = !availability.available || need.connectionId && need.capabilityError ? "blocked" : need.connectionId === need.target.serverId ? "ready" : need.attempt && need.attempt.expiresAt > Date.now() ? "authorizing" : need.unavailable ? "reconnect" : "connect";
-				return {
-					...need,
-					authorizationMode: "desktop",
-					phase,
-					accounts: [],
-					alternatives: [],
-					...availability.reason || need.capabilityError ? { reason: availability.reason ?? need.capabilityError } : {}
-				};
-			}
 			if (need.target.type === "store-connector") {
 				const target = need.target;
 				const instance = listConnectorInstances(this.deps.getConfig()).find((item) => item.connectorId === target.connectorId);
@@ -238,7 +222,7 @@ var ConnectionRecoveryService = class {
 			}))
 		}, verified).needs;
 		return Promise.all(wait.needs.map(async (need) => {
-			if (need.target.type === "plugin-mcp" || need.target.type === "store-connector") return need;
+			if (need.target.type === "store-connector") return need;
 			if (views.find((view) => view.key === need.key)?.phase !== "ready") return {
 				...need,
 				capabilityError: void 0
@@ -314,38 +298,6 @@ var ConnectionRecoveryService = class {
 		}
 		return fresh;
 	}
-	async syncPluginMcpNeeds(wait) {
-		return Promise.all(wait.needs.map(async (need) => {
-			if (need.target.type !== "plugin-mcp") return need;
-			const status = await this.pluginMcp.status(need.target);
-			if (status.status === "connected") {
-				const verified = await this.pluginMcp.verify(need.target);
-				return {
-					...need,
-					connectionId: need.target.serverId,
-					unavailable: false,
-					attempt: void 0,
-					capabilityError: verified.ready ? void 0 : verified.error ?? "The connected MCP tools are unavailable."
-				};
-			}
-			if (status.status === "authorizing") return {
-				...need,
-				connectionId: void 0,
-				unavailable: false,
-				attempt: {
-					id: status.session?.id ?? need.attempt?.id ?? randomUUID(),
-					expiresAt: status.session?.expiresAt ?? Date.now() + ATTEMPT_TTL
-				}
-			};
-			return {
-				...need,
-				connectionId: void 0,
-				unavailable: true,
-				attempt: void 0,
-				capabilityError: status.status === "error" ? status.session?.error : void 0
-			};
-		}));
-	}
 	async preflight(input) {
 		if (input.kind !== "connection_resume") return true;
 		const wait = input.payload ? getConnectionWait(input.payload.waitId) : void 0;
@@ -354,11 +306,10 @@ var ConnectionRecoveryService = class {
 		try {
 			const fresh = await this.syncConnections(wait);
 			const verified = new Set(fresh.filter((item) => item.status === "active").map((item) => item.id));
-			wait.needs = await this.syncPluginMcpNeeds(wait);
-			wait.needs = wait.needs.map((need) => need.target.type === "plugin-mcp" ? need : {
+			wait.needs = wait.needs.map((need) => ({
 				...need,
 				unavailable: !fresh.some((item) => item.id === need.connectionId && item.status === "active")
-			});
+			}));
 			wait.needs = await this.checkCapabilities(wait, verified);
 			const ready = this.view(wait, verified).needs.every((need) => need.phase === "ready");
 			if (getConnectionWait(wait.id)?.version !== wait.version) return false;
@@ -466,48 +417,6 @@ var ConnectionRecoveryService = class {
 				const need = wait.needs.find((need) => need.key === action.needKey);
 				if (!need) throw new Error("Unknown connection requirement.");
 				if (this.view(wait).needs.find((item) => item.key === need.key)?.phase === "blocked") throw new Error("Connector policy blocks this connection.");
-				if (need.target.type === "plugin-mcp") {
-					const serverId = need.target.serverId;
-					const attemptId = randomUUID();
-					wait = updateConnectionWait({
-						...wait,
-						intent: {
-							objectiveRevision: wait.objectiveRevision,
-							validUntil: Date.now() + INTENT_TTL
-						},
-						needs: wait.needs.map((item) => item.key === need.key ? {
-							...item,
-							unavailable: false,
-							capabilityError: void 0,
-							attempt: {
-								id: attemptId,
-								expiresAt: Date.now() + ATTEMPT_TTL
-							}
-						} : item)
-					}, wait.version);
-					publishConnectionWait(conversationId);
-					const auth = await this.pluginMcp.start(need.target);
-					const latest = getConnectionWait(wait.id);
-					if (!latest || latest.version !== wait.version || latest.status !== "open") throw new Error("WAIT_CHANGED");
-					wait = updateConnectionWait({
-						...wait,
-						needs: wait.needs.map((item) => item.key === need.key ? {
-							...item,
-							attempt: auth.status === "authorizing" ? {
-								id: auth.session?.id ?? attemptId,
-								expiresAt: auth.session?.expiresAt ?? Date.now() + ATTEMPT_TTL
-							} : void 0,
-							connectionId: auth.status === "connected" ? serverId : void 0,
-							unavailable: auth.status === "error",
-							capabilityError: auth.status === "error" ? auth.session?.error : void 0
-						} : item)
-					}, wait.version);
-					publishConnectionWait(conversationId);
-					return {
-						snapshot: this.snapshot(conversationId),
-						authorizationUrl: auth.session?.authorizationUrl
-					};
-				}
 				const id = need.target.connectorId;
 				const instance = listConnectorInstances(this.deps.getConfig()).find((item) => item.connectorId === id);
 				const definition = (instance ? getInstalledConnectorDefinition(this.deps.getConfig(), instance.instanceId) : void 0) ?? getConnectorDefinition(id);
@@ -578,18 +487,11 @@ var ConnectionRecoveryService = class {
 					authorizationUrl: auth.connectUrl
 				};
 			} else {
-				if (action.action === "submit_callback") {
-					const need = wait.needs.find((need) => need.key === action.needKey);
-					if (!need || need.target.type !== "plugin-mcp") throw new Error("OAuth callback is unavailable.");
-					if (!action.callbackUrl || action.callbackUrl.length > 16384) throw new Error("Expected the complete OAuth callback URL.");
-					await this.pluginMcp.submitCallback(need.target, action.callbackUrl);
-				}
 				const fresh = await this.syncConnections(wait);
 				const verified = new Set(fresh.filter((item) => item.status === "active").map((item) => item.id));
 				const latest = getConnectionWait(wait.id);
 				if (!latest || latest.version !== wait.version || latest.status !== "open") throw new Error("WAIT_CHANGED");
 				let needs = wait.needs.map((need) => {
-					if (need.target.type === "plugin-mcp") return need;
 					if (need.target.type === "store-connector") {
 						const selected = this.view({
 							...wait,
@@ -617,10 +519,6 @@ var ConnectionRecoveryService = class {
 						unavailable: !fresh.some((item) => item.connectorId === id && item.status === "active" && (!need.connectionId || item.id === need.connectionId) && (!need.accountId || item.accountId === need.accountId))
 					};
 				});
-				needs = await this.syncPluginMcpNeeds({
-					...wait,
-					needs
-				});
 				if (action.action === "select_account") {
 					const need = needs.find((item) => item.key === action.needKey);
 					if (!need || need.target.type !== "connector") throw new Error("Account selection is unavailable.");

package/dist/src/connectors/health.d.ts

@@ -1,4 +1,3 @@
 import type { Config } from '../config/schema.js';
-import type { ConnectorDefinition, ConnectorHealthResult, ConnectorInstallInput } from './types.js';
+import type { ConnectorHealthResult } from './types.js';
 export declare function testConnectorInstance(config: Config, serverId: string): Promise<ConnectorHealthResult>;
-export declare function previewConnectorDefinition(config: Config, definition: ConnectorDefinition, input?: ConnectorInstallInput): Promise<ConnectorHealthResult>;

package/dist/src/connectors/health.js

@@ -1,10 +1,7 @@
 import { init_connector_repository, listConnectorConnections } from "../storage/sqlite/connector-repository.js";
 import { currentAccountConnections } from "./account-access.js";
-import { materializeConnectorMcpServer } from "./materialize.js";
 import { getConnectorInstance } from "./instances.js";
 import { describeCliAction, verifyCliConnection } from "./cli/runtime.js";
-import { getWorkspacePath } from "../config/workspace-path-helpers.js";
-import { listBundleMcpServerCapabilitiesForGateway } from "../agent/mcp/bundle-mcp-gateway.js";
 //#region src/connectors/health.ts
 init_connector_repository();
 function classifyConnectorHealthError(error) {
@@ -17,12 +14,6 @@ function classifyConnectorHealthError(error) {
 	if (/spawn|command|start|connect/i.test(message)) return "startup_failed";
 	return "unknown_error";
 }
-function healthActionForStatus(status) {
-	if (status === "missing_secret") return "Reconnect the connector and provide the required secret.";
-	if (status === "timeout" || status === "network_failed") return "Check network access and retry the connector health check.";
-	if (status === "startup_failed") return "Verify the connector runtime dependency is installed and reachable.";
-	if (status === "unauthorized") return "Reconnect the connector or refresh its credentials.";
-}
 async function testConnectorInstance(config, serverId) {
 	const instance = getConnectorInstance(config, serverId);
 	if (!instance) return {
@@ -97,97 +88,7 @@ async function testConnectorInstance(config, serverId) {
 			};
 		}
 	}
-	const workspaceDir = getWorkspacePath(config) || "./workspace";
-	try {
-		const capabilities = await listBundleMcpServerCapabilitiesForGateway({
-			workspaceDir,
-			cfg: config,
-			serverId
-		});
-		return {
-			serverId,
-			ok: true,
-			status: "ok",
-			toolCount: capabilities.toolCount,
-			resourceCount: capabilities.resourceCount,
-			promptCount: capabilities.promptCount,
-			tools: capabilities.tools,
-			resources: capabilities.resources,
-			prompts: capabilities.prompts
-		};
-	} catch (error) {
-		const status = classifyConnectorHealthError(error);
-		return {
-			serverId,
-			ok: false,
-			status,
-			toolCount: 0,
-			resourceCount: 0,
-			promptCount: 0,
-			tools: [],
-			resources: [],
-			prompts: [],
-			error: error instanceof Error ? error.message : String(error),
-			action: healthActionForStatus(status)
-		};
-	}
-}
-async function previewConnectorDefinition(config, definition, input = {}) {
-	if (definition.runtime.type !== "mcp") return {
-		serverId: definition.id,
-		ok: false,
-		status: "unknown_error",
-		toolCount: 0,
-		resourceCount: 0,
-		promptCount: 0,
-		tools: [],
-		resources: [],
-		prompts: [],
-		error: `Connector type "${definition.runtime.type}" does not support MCP capability preview.`
-	};
-	try {
-		const { serverId, server } = materializeConnectorMcpServer(definition, input);
-		const capabilities = await listBundleMcpServerCapabilitiesForGateway({
-			workspaceDir: getWorkspacePath(config) || "./workspace",
-			cfg: {
-				...config,
-				mcp: {
-					...config.mcp ?? {},
-					servers: {
-						...config.mcp?.servers ?? {},
-						[serverId]: server
-					}
-				}
-			},
-			serverId
-		});
-		return {
-			serverId,
-			ok: true,
-			status: "ok",
-			toolCount: capabilities.toolCount,
-			resourceCount: capabilities.resourceCount,
-			promptCount: capabilities.promptCount,
-			tools: capabilities.tools,
-			resources: capabilities.resources,
-			prompts: capabilities.prompts
-		};
-	} catch (error) {
-		const status = classifyConnectorHealthError(error);
-		return {
-			serverId: definition.id,
-			ok: false,
-			status,
-			toolCount: 0,
-			resourceCount: 0,
-			promptCount: 0,
-			tools: [],
-			resources: [],
-			prompts: [],
-			error: error instanceof Error ? error.message : String(error),
-			action: healthActionForStatus(status)
-		};
-	}
+	throw new Error("MCP diagnostics are provided by xopc mcp list.");
 }
 //#endregion
-export { previewConnectorDefinition, testConnectorInstance };
+export { testConnectorInstance };

package/dist/src/connectors/types.d.ts

@@ -1,6 +1,6 @@
 export type ConnectorKind = 'mcp' | 'cli' | 'http' | 'browser' | 'extension' | 'builtin' | 'composio' | 'memorySource';
 export type ConnectorCategory = 'code' | 'docs' | 'browser' | 'data' | 'automation' | 'custom';
-export type ConnectorCapability = 'tools' | 'resources' | 'prompts' | 'context' | 'channel' | 'events' | 'ui' | 'memory_source' | 'workflows' | 'auth.apiKey' | 'auth.oauth' | 'runtime.mcp.stdio' | 'runtime.mcp.sse' | 'runtime.mcp.streamableHttp';
+export type ConnectorCapability = 'tools' | 'resources' | 'prompts' | 'context' | 'channel' | 'events' | 'ui' | 'memory_source' | 'workflows' | 'auth.apiKey' | 'auth.oauth' | 'runtime.mcp.stdio' | 'runtime.mcp.streamableHttp';
 export type ConnectorAuthMode = 'none' | 'apiKey' | 'oauth' | 'cli';
 export type ConnectorAuthDefinition = {
     mode: 'cli';

package/dist/src/endpoint-tools/binding-service.d.ts

@@ -13,6 +13,8 @@ export interface EndpointSessionBindingStore {
 export declare class EndpointBindingService {
     private readonly registry;
     private readonly store;
+    private readonly changeListeners;
+    onChange(listener: (conversationId: string) => void): () => void;
     constructor(registry: EndpointRegistry, store?: EndpointSessionBindingStore);
     bind(conversationId: string, endpointId: string, now?: number): EndpointSessionBinding;
     get(conversationId: string): EndpointSessionBinding | undefined;

package/dist/src/endpoint-tools/binding-service.js

@@ -11,6 +11,13 @@ function memoryStore() {
 	};
 }
 var EndpointBindingService = class {
+	changeListeners = /* @__PURE__ */ new Set();
+	onChange(listener) {
+		this.changeListeners.add(listener);
+		return () => {
+			this.changeListeners.delete(listener);
+		};
+	}
 	constructor(registry, store = memoryStore()) {
 		this.registry = registry;
 		this.store = store;
@@ -23,7 +30,9 @@ var EndpointBindingService = class {
 			endpointId,
 			boundAt: now
 		};
-		return this.store.set(binding);
+		const stored = this.store.set(binding);
+		for (const listener of this.changeListeners) listener(normalizedConversationId);
+		return stored;
 	}
 	get(conversationId) {
 		return this.store.get(this.normalizeConversationId(conversationId));
@@ -33,7 +42,10 @@ var EndpointBindingService = class {
 		return binding ? this.registry.get(binding.endpointId) : void 0;
 	}
 	unbind(conversationId) {
-		return this.store.delete(this.normalizeConversationId(conversationId));
+		const normalized = this.normalizeConversationId(conversationId);
+		const removed = this.store.delete(normalized);
+		if (removed) for (const listener of this.changeListeners) listener(normalized);
+		return removed;
 	}
 	normalizeConversationId(conversationId) {
 		const normalized = conversationId.trim();

package/dist/src/endpoint-tools/bridge-host.d.ts

@@ -0,0 +1,15 @@
+import { type EndpointToolRegistry } from '@xopcai/endpoint-tools-client';
+export interface DeviceBridgeHostOptions {
+    gatewayUrl: string;
+    token: string;
+    identityPath: string;
+    registry: EndpointToolRegistry;
+    displayName?: string;
+    onStateChange?: (state: string) => void;
+}
+/** Connects a Node hardware adapter through the existing signed Endpoint v2 transport. */
+export declare function connectDeviceBridge(options: DeviceBridgeHostOptions): Promise<{
+    endpointId: string;
+    principalId: string;
+    close: () => void;
+}>;