@xopcai/xopc 0.0.321 → 0.0.324

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

@@ -19,6 +19,7 @@ import { capabilityActions, isToolInputSchema, missingConnectionCapabilities } f
 import { resolveConnectionCandidate } from "./connection-candidates.js";
 import { installConnector } from "./install.js";
 import { persistConfigMutation } from "../config/config-mutation.js";
+import { HostPluginMcpRecovery } from "./plugin-mcp-recovery.js";
 import { randomUUID } from "node:crypto";
 //#region src/connectors/connection-recovery-service.ts
 init_transaction();
@@ -36,6 +37,9 @@ const SCOPE_ORDER = {
 };
 const INTENT_TTL = 30 * 6e4;
 const ATTEMPT_TTL = 10 * 6e4;
+function isConnectorNeed(need) {
+	return need.target.type === "connector";
+}
 /** Authorization lives at click time. Chat history contains only immutable explanations. */
 var ConnectionRecoveryService = class {
 	busy = /* @__PURE__ */ new Set();
@@ -77,6 +81,9 @@ 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);
@@ -90,13 +97,25 @@ var ConnectionRecoveryService = class {
 	}
 	view(wait, verifiedIds) {
 		const needs = wait.needs.map((need) => {
-			const instance = listConnectorInstances(this.deps.getConfig()).find((instance) => instance.connectorId === need.connectorId);
-			const installation = getConnectorInstallation(`${need.connectorId}-${wait.principalId}`);
+			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,
+					phase,
+					accounts: [],
+					alternatives: [],
+					...availability.reason || need.capabilityError ? { reason: availability.reason ?? need.capabilityError } : {}
+				};
+			}
+			const id = need.target.connectorId;
+			const instance = listConnectorInstances(this.deps.getConfig()).find((instance) => instance.connectorId === id);
+			const installation = getConnectorInstallation(`${id}-${wait.principalId}`);
 			const cli = instance?.materialized.type === "cli" ? getCliAdapter(instance.materialized.adapterId) : void 0;
 			const scopeBlocked = Math.max(1, ...need.capabilities.filter((capability) => cli || /^[A-Z]+_/.test(capability)).map((capability) => SCOPE_ORDER[cli ? cli.curatedActions[capability] ?? "read" : scopeForComposioAction(capability).scope])) > SCOPE_ORDER[installation?.maxScope ?? "read"];
 			const all = listConnectorConnections({
 				principalId: wait.principalId,
-				connectorId: need.connectorId
+				connectorId: id
 			});
 			const requested = need.accountId ? all.find((connection) => connection.accountId === need.accountId) : void 0;
 			const blocked = scopeBlocked || instance?.enabled === false || installation?.enabled === false || installation?.selectedAccountIds?.length === 0 || Boolean(installation && requested && !canAccessConnectorAccount(requested, installation, wait.agentId)) || Boolean(installation?.allowedAgentIds.length && !installation.allowedAgentIds.includes(wait.agentId));
@@ -115,9 +134,9 @@ var ConnectionRecoveryService = class {
 				"revoked",
 				"failed"
 			].includes(connection.status)) ? "reconnect" : "connect";
-			const alternatives = ["composio-gmail", "composio-outlook"].includes(need.connectorId) ? ["composio-gmail", "composio-outlook"].filter((id) => id !== need.connectorId).map((id) => ({
-				candidateRef: id,
-				label: getConnectorDefinition(id)?.displayName ?? id
+			const alternatives = ["composio-gmail", "composio-outlook"].includes(id) ? ["composio-gmail", "composio-outlook"].filter((candidate) => candidate !== id).map((candidate) => ({
+				candidateRef: candidate,
+				label: getConnectorDefinition(candidate)?.displayName ?? candidate
 			})) : [];
 			return {
 				...need,
@@ -174,14 +193,16 @@ var ConnectionRecoveryService = class {
 			}))
 		}, verified).needs;
 		return Promise.all(wait.needs.map(async (need) => {
+			if (need.target.type === "plugin-mcp") return need;
 			if (views.find((view) => view.key === need.key)?.phase !== "ready") return {
 				...need,
 				capabilityError: void 0
 			};
 			try {
-				const instance = listConnectorInstances(this.deps.getConfig()).find((instance) => instance.connectorId === need.connectorId && instance.enabled);
+				const id = need.target.connectorId;
+				const instance = listConnectorInstances(this.deps.getConfig()).find((instance) => instance.connectorId === id && instance.enabled);
 				if (!instance) throw new Error("Connector setup is unavailable");
-				const definition = getInstalledConnectorDefinition(this.deps.getConfig(), instance.instanceId) ?? getConnectorDefinition(need.connectorId);
+				const definition = getInstalledConnectorDefinition(this.deps.getConfig(), instance.instanceId) ?? getConnectorDefinition(id);
 				if (definition?.runtime.type === "cli") {
 					const selected = views.find((view) => view.key === need.key);
 					const connection = selected?.connectionId ? getConnectorConnection(selected.connectionId) : void 0;
@@ -211,7 +232,7 @@ var ConnectionRecoveryService = class {
 				const missing = missingConnectionCapabilities(need, new Set(Object.entries(schemas && typeof schemas === "object" ? schemas : {}).filter(([action, value]) => value && typeof value === "object" && isToolInputSchema(value.inputSchema) && isComposioActionAllowedByCatalog(action)).map(([action]) => action)));
 				if (missing.length) log.warn({
 					conversationId: wait.conversationId,
-					connectorId: need.connectorId,
+					connectorId: id,
 					missingCapabilities: missing
 				}, "Connected app lacks required tool contracts");
 				return {
@@ -222,7 +243,7 @@ var ConnectionRecoveryService = class {
 				log.warn({
 					err,
 					conversationId: wait.conversationId,
-					connectorId: need.connectorId
+					connectorId: need.target.connectorId
 				}, "Connected app capability check failed");
 				return {
 					...need,
@@ -235,9 +256,10 @@ var ConnectionRecoveryService = class {
 		const config = this.deps.getConfig();
 		const instances = listConnectorInstances(config);
 		const cliIds = new Set(instances.filter((item) => item.materialized.type === "cli").map((item) => item.connectorId));
-		const fresh = wait.needs.some((need) => !cliIds.has(need.connectorId)) ? await this.adapter.syncConnections({ principalId: wait.principalId }) : [];
+		const connectorNeeds = wait.needs.filter(isConnectorNeed);
+		const fresh = connectorNeeds.some((need) => !cliIds.has(need.target.connectorId)) ? await this.adapter.syncConnections({ principalId: wait.principalId }) : [];
 		for (const connection of currentAccountConnections(listConnectorConnections({ principalId: wait.principalId }))) {
-			if (connection.provider !== "cli" || !wait.needs.some((need) => need.connectorId === connection.connectorId)) continue;
+			if (connection.provider !== "cli" || !connectorNeeds.some((need) => need.target.connectorId === connection.connectorId)) continue;
 			const policy = getConnectorInstallation(`${connection.connectorId}-${wait.principalId}`);
 			if (!policy || !canAccessConnectorAccount(connection, policy, wait.agentId)) continue;
 			const instanceId = connection.metadata.runtimeInstanceId;
@@ -247,6 +269,38 @@ 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;
@@ -255,12 +309,13 @@ 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.checkCapabilities(wait, verified);
-			const ready = this.view(wait, verified).needs.every((need) => need.phase === "ready");
-			wait.needs = wait.needs.map((need) => ({
+			wait.needs = await this.syncPluginMcpNeeds(wait);
+			wait.needs = wait.needs.map((need) => need.target.type === "plugin-mcp" ? 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;
 			if (ready && wait.intent && wait.intent.validUntil > Date.now() && wait.intent.objectiveRevision === wait.objectiveRevision) return true;
 		} catch {}
@@ -319,8 +374,51 @@ 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.");
-				const instance = listConnectorInstances(this.deps.getConfig()).find((item) => item.connectorId === need.connectorId);
-				const definition = (instance ? getInstalledConnectorDefinition(this.deps.getConfig(), instance.instanceId) : void 0) ?? getConnectorDefinition(need.connectorId);
+				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);
 				if (definition?.runtime.type === "cli") {
 					updateConnectionWait({
 						...wait,
@@ -332,7 +430,7 @@ var ConnectionRecoveryService = class {
 					publishConnectionWait(conversationId);
 					return {
 						snapshot: this.snapshot(conversationId),
-						authorizationUrl: `/#/connectors?connector=${encodeURIComponent(need.connectorId)}`
+						authorizationUrl: `/#/connectors?connector=${encodeURIComponent(id)}`
 					};
 				}
 				if (definition?.runtime.type !== "composio" || definition.runtime.role !== "toolkit") throw new Error("Unsupported connector.");
@@ -353,8 +451,8 @@ var ConnectionRecoveryService = class {
 				}, wait.version);
 				publishConnectionWait(conversationId);
 				const config = this.deps.getConfig();
-				await this.ensureInstallation(wait, need.connectorId);
-				const installationId = `${need.connectorId}-${wait.principalId}`;
+				await this.ensureInstallation(wait, id);
+				const installationId = `${id}-${wait.principalId}`;
 				const auth = await this.adapter.authorize({
 					principalId: wait.principalId,
 					toolkit: definition.runtime.toolkit,
@@ -388,12 +486,20 @@ 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) => {
-					const authorized = fresh.find((item) => item.providerConnectionId === need.attempt?.connectionId && item.status === "active" && item.connectorId === need.connectorId && (!need.accountId || item.accountId === need.accountId));
+					if (need.target.type === "plugin-mcp") return need;
+					const id = need.target.connectorId;
+					const authorized = fresh.find((item) => item.providerConnectionId === need.attempt?.connectionId && item.status === "active" && item.connectorId === id && (!need.accountId || item.accountId === need.accountId));
 					return authorized ? {
 						...need,
 						unavailable: false,
@@ -404,13 +510,19 @@ var ConnectionRecoveryService = class {
 						attempt: void 0
 					} : {
 						...need,
-						unavailable: !fresh.some((item) => item.connectorId === need.connectorId && item.status === "active" && (!need.connectionId || item.id === need.connectionId) && (!need.accountId || item.accountId === need.accountId))
+						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);
-					const connection = currentAccountConnections(fresh).find((item) => item.accountId === action.accountId && item.connectorId === need?.connectorId);
-					if (!need || !connection || !this.view(wait, verified).needs.find((item) => item.key === need.key)?.accounts.some((item) => item.id === connection.accountId)) throw new Error("Account is unavailable.");
+					if (!need || need.target.type !== "connector") throw new Error("Account selection is unavailable.");
+					const id = need.target.connectorId;
+					const connection = currentAccountConnections(fresh).find((item) => item.accountId === action.accountId && item.connectorId === id);
+					if (!connection || !this.view(wait, verified).needs.find((item) => item.key === need.key)?.accounts.some((item) => item.id === connection.accountId)) throw new Error("Account is unavailable.");
 					needs = needs.map((item) => item.key === need.key ? {
 						...item,
 						connectionId: connection.id,
@@ -422,7 +534,7 @@ var ConnectionRecoveryService = class {
 				for (const selected of this.view({
 					...wait,
 					needs
-				}, verified).needs) if (selected.phase === "ready" || selected.capabilityError && selected.connectionId) await this.ensureInstallation(wait, selected.connectorId);
+				}, verified).needs) if (selected.target.type === "connector" && (selected.phase === "ready" || selected.capabilityError && selected.connectionId)) await this.ensureInstallation(wait, selected.target.connectorId);
 				needs = await this.checkCapabilities({
 					...wait,
 					needs

package/dist/src/connectors/content-enrichment.js

@@ -1,6 +1,6 @@
 import { getConnectorConnection, getConnectorInstallation } from "../storage/sqlite/connector-repository.js";
 import { getKnowledgeSourceItem, listKnowledgeSourceItems, upsertKnowledgeSourceItems } from "../storage/sqlite/knowledge-repository.js";
-import "../storage/sqlite/index.js";
+import { init_sqlite } from "../storage/sqlite/index.js";
 import { ComposioSessionsAdapter } from "./composio-sessions.js";
 import { ConnectedKnowledgePipeline } from "../knowledge/connected-knowledge-pipeline.js";
 import { sanitizeConnectedSourceValue } from "./connected-source-sanitization.js";
@@ -9,6 +9,7 @@ import { isAbsolute, join, relative, sep } from "node:path";
 import { createHash } from "node:crypto";
 import { mkdtemp, readFile, realpath, rm } from "node:fs/promises";
 //#region src/connectors/content-enrichment.ts
+init_sqlite();
 const MAX_SELECTION = 5;
 const MAX_CONTENT_BYTES = 1e6;
 const MAX_CONTENT_CHARS = 24e3;

package/dist/src/connectors/learning-coordinator.js

@@ -4,7 +4,7 @@ import { claimNextConnectorLearningJob, enqueueConnectorLearningJob, listConnect
 import { getConnectorAccount, reconcileConnectorAccount } from "../storage/sqlite/connector-account-repository.js";
 import { getConnectorInstallation, listConnectorConnections, upsertConnectorConnection } from "../storage/sqlite/connector-repository.js";
 import { getConnectorSyncPolicyForConnection } from "../storage/sqlite/connector-sync-policy-repository.js";
-import "../storage/sqlite/index.js";
+import { init_sqlite } from "../storage/sqlite/index.js";
 import { connectorIdentityKey, normalizeConnectorIdentity } from "./connector-identity.js";
 import { ComposioSessionsAdapter } from "./composio-sessions.js";
 import { buildConnectorLearningArguments, getConnectorLearningPlan } from "./learning-recipes.js";
@@ -17,6 +17,7 @@ import { deriveConnectedSourceUnderstanding } from "./connected-source-understan
 import { listConnectedContentCandidates, readConnectedContent } from "./content-enrichment.js";
 import { getConnectorUnderstandingSourceRun, getOrCreateConnectorUnderstandingSourceRun, getUnderstandingSourceGrant, listUnderstandingSourceGrants, updateUnderstandingSourceGrantCheckpoint, updateUnderstandingSourceRun, upsertUnderstandingSourceGrant } from "../user-context/sources/repository.js";
 //#region src/connectors/learning-coordinator.ts
+init_sqlite();
 init_logger();
 const log = createLogger("ConnectorLearning");
 const CONNECTED_ACCOUNT_UNAVAILABLE = "connected_account_unavailable";

package/dist/src/connectors/plugin-mcp-recovery.d.ts

@@ -0,0 +1,28 @@
+import type { PluginMcpConnectionTarget } from '@xopcai/gateway-contract';
+import { type McpOAuthStatus } from '../agent/mcp/oauth/mcp-oauth-manager.js';
+import type { Config } from '../config/schema.js';
+export type PluginMcpAvailability = {
+    available: boolean;
+    reason?: string;
+};
+export type PluginMcpVerification = {
+    ready: boolean;
+    error?: string;
+};
+export interface PluginMcpRecovery {
+    availability(target: PluginMcpConnectionTarget): PluginMcpAvailability;
+    status(target: PluginMcpConnectionTarget): Promise<McpOAuthStatus>;
+    start(target: PluginMcpConnectionTarget): Promise<McpOAuthStatus>;
+    verify(target: PluginMcpConnectionTarget): Promise<PluginMcpVerification>;
+    submitCallback(target: PluginMcpConnectionTarget, callbackUrl: string): Promise<McpOAuthStatus>;
+}
+export declare class HostPluginMcpRecovery implements PluginMcpRecovery {
+    private readonly getConfig;
+    constructor(getConfig: () => Config);
+    availability(target: PluginMcpConnectionTarget): PluginMcpAvailability;
+    status(target: PluginMcpConnectionTarget): Promise<McpOAuthStatus>;
+    start(target: PluginMcpConnectionTarget): Promise<McpOAuthStatus>;
+    verify(target: PluginMcpConnectionTarget): Promise<PluginMcpVerification>;
+    submitCallback(target: PluginMcpConnectionTarget, callbackUrl: string): Promise<McpOAuthStatus>;
+    private resolveServer;
+}

package/dist/src/connectors/plugin-mcp-recovery.js

@@ -0,0 +1,90 @@
+import { AgentPluginStore } from "../extensions/agent-plugins/store.js";
+import { savePluginAuthBinding } from "../extensions/agent-plugins/auth.js";
+import { loadMergedBundleMcpConfig } from "../agent/mcp/bundle-mcp-config.js";
+import { getWorkspacePath } from "../config/workspace-path-helpers.js";
+import { getMcpOAuthManager } from "../agent/mcp/oauth/mcp-oauth-manager.js";
+import { listBundleMcpServerCapabilitiesForGateway } from "../agent/mcp/bundle-mcp-gateway.js";
+//#region src/connectors/plugin-mcp-recovery.ts
+var HostPluginMcpRecovery = class {
+	constructor(getConfig) {
+		this.getConfig = getConfig;
+	}
+	availability(target) {
+		const plugin = new AgentPluginStore().get(target.pluginId);
+		if (!plugin) return {
+			available: false,
+			reason: "The plugin is no longer installed."
+		};
+		if (!plugin.receipt.enabled) return {
+			available: false,
+			reason: "Enable the plugin before connecting its account."
+		};
+		if (plugin.readiness === "blocked") return {
+			available: false,
+			reason: "Repair the plugin before connecting its account."
+		};
+		if (plugin.servers[target.serverName]?.type !== "streamable-http") return {
+			available: false,
+			reason: "This plugin server does not support OAuth."
+		};
+		return { available: true };
+	}
+	async status(target) {
+		const server = this.resolveServer(target);
+		return getMcpOAuthManager(server).status(target.serverId, server);
+	}
+	async start(target) {
+		const availability = this.availability(target);
+		if (!availability.available) throw new Error(availability.reason);
+		await savePluginAuthBinding(new AgentPluginStore(), target.pluginId, target.serverName, { mode: "oauth" });
+		const server = this.resolveServer(target);
+		return getMcpOAuthManager(server).start({
+			serverId: target.serverId,
+			rawServer: server,
+			cfg: this.getConfig()
+		});
+	}
+	async verify(target) {
+		const availability = this.availability(target);
+		if (!availability.available) return {
+			ready: false,
+			error: availability.reason
+		};
+		const status = await this.status(target);
+		if (status.status !== "connected") return {
+			ready: false,
+			error: status.session?.error
+		};
+		const cfg = this.getConfig();
+		const capabilities = await listBundleMcpServerCapabilitiesForGateway({
+			workspaceDir: getWorkspacePath(cfg) || "./workspace",
+			cfg,
+			serverId: target.serverId
+		});
+		if (capabilities.error) return {
+			ready: false,
+			error: capabilities.error.message
+		};
+		if (capabilities.toolCount === 0) return {
+			ready: false,
+			error: "The connected MCP server did not expose any tools."
+		};
+		return { ready: true };
+	}
+	async submitCallback(target, callbackUrl) {
+		const server = this.resolveServer(target);
+		return getMcpOAuthManager(server).submitCallback(target.serverId, server, callbackUrl);
+	}
+	resolveServer(target) {
+		const cfg = this.getConfig();
+		const server = loadMergedBundleMcpConfig({
+			workspaceDir: getWorkspacePath(cfg) || "./workspace",
+			cfg
+		}).config.mcpServers[target.serverId];
+		const origin = server?.xopcPlugin;
+		if (!server || origin?.id !== target.pluginId || origin.serverName !== target.serverName) throw new Error("Plugin MCP server is unavailable.");
+		return server;
+	}
+};
+//#endregion
+export { HostPluginMcpRecovery };

package/dist/src/connectors/runtime-adapter-registry.js

@@ -1,6 +1,6 @@
 import { isXopcDatabaseOpen } from "../storage/sqlite/connection.js";
 import { deleteConnectorInstallation, getConnectorInstallation, upsertConnectorInstallation } from "../storage/sqlite/connector-repository.js";
-import "../storage/sqlite/index.js";
+import { init_sqlite } from "../storage/sqlite/index.js";
 import { getCliAdapter } from "./cli/adapterRegistry.js";
 import { assertComposioAccessConfigured } from "./composio-sessions.js";
 import { saveConnectorSecrets } from "./secret-store.js";
@@ -10,6 +10,7 @@ import { listConnectorInstances } from "./instances.js";
 import { installCli } from "./cli/installer.js";
 import { stopCliInstance } from "./cli/lifecycle.js";
 //#region src/connectors/runtime-adapter-registry.ts
+init_sqlite();
 const adapters = /* @__PURE__ */ new Map();
 function registerConnectorRuntimeAdapter(adapter) {
 	if (adapters.has(adapter.type)) throw new Error(`Connector runtime adapter is already registered: ${adapter.type}`);

package/dist/src/connectors/workflow-preflight.d.ts

@@ -1,5 +1,5 @@
 import type { Config } from '../config/schema.js';
-import type { WorkflowDefinition } from '../workflows/domain/definition.js';
+import type { WorkflowConnectorRequirement, WorkflowDefinition } from '../workflows/domain/definition.js';
 export type ConnectorPreflightIssueCode = 'not_installed' | 'disabled' | 'agent_not_allowed' | 'scope_too_narrow' | 'connection_missing' | 'account_selection_required' | 'reauthorization_required';
 export type ConnectorPreflightIssue = {
     connectorId: string;
@@ -13,6 +13,13 @@ export type ConnectorPreflightResult = {
     issues: ConnectorPreflightIssue[];
     optionalIssues: ConnectorPreflightIssue[];
 };
+export type ConnectorRequirementPreflightInput = {
+    requirements: readonly WorkflowConnectorRequirement[];
+    config: Config;
+    agentId: string;
+    principalId?: string;
+};
+export declare function preflightConnectorRequirements(input: ConnectorRequirementPreflightInput): ConnectorPreflightResult;
 export declare function preflightWorkflowConnectors(input: {
     definition: WorkflowDefinition;
     config: Config;

package/dist/src/connectors/workflow-preflight.js

@@ -18,7 +18,7 @@ function issue(requirement, code, message) {
 		recoveryPath: `/connectors?connector=${encodeURIComponent(requirement.connectorId)}`
 	};
 }
-function preflightWorkflowConnectors(input) {
+function preflightConnectorRequirements(input) {
 	const principalId = input.principalId ?? "local-owner";
 	const instances = listConnectorInstances(input.config);
 	const issues = [];
@@ -27,7 +27,7 @@ function preflightWorkflowConnectors(input) {
 	const add = (requirement, value) => {
 		(requirement.optional ? optionalIssues : issues).push(value);
 	};
-	for (const requirement of input.definition.connectors ?? []) {
+	for (const requirement of input.requirements) {
 		const instance = instances.find((candidate) => candidate.connectorId === requirement.connectorId);
 		if (!instance) {
 			add(requirement, issue(requirement, "not_installed", `${requirement.connectorId} is not installed.`));
@@ -85,5 +85,13 @@ function preflightWorkflowConnectors(input) {
 		optionalIssues
 	};
 }
+function preflightWorkflowConnectors(input) {
+	return preflightConnectorRequirements({
+		requirements: input.definition.connectors ?? [],
+		config: input.config,
+		agentId: input.agentId,
+		...input.principalId ? { principalId: input.principalId } : {}
+	});
+}
 //#endregion
-export { preflightWorkflowConnectors };
+export { preflightConnectorRequirements, preflightWorkflowConnectors };

package/dist/src/discussions/analyzer.js

@@ -151,7 +151,7 @@ async function summarizeMeetingOverview(chapters, reduce) {
 	return latest;
 }
 async function analyzeDiscussion(input) {
-	const modelRef = getAgentDefaultModelRef(input.config);
+	const modelRef = getAgentDefaultModelRef();
 	if (!modelRef) throw new Error("No model configured for discussion organization");
 	const batches = partitionDiscussionSegments(input.segments);
 	if (!batches.length) throw new Error("Discussion transcript is empty");
@@ -275,7 +275,7 @@ async function analyzeDiscussion(input) {
 	};
 }
 async function enrichLiveDiscussion(input) {
-	const modelRef = getAgentDefaultModelRef(input.config);
+	const modelRef = getAgentDefaultModelRef();
 	if (!modelRef) throw new Error("No default model configured for discussion enrichment");
 	const transcript = input.transcript.trim().slice(0, 12e3);
 	if (!transcript) throw new Error("Discussion transcript is empty");

package/dist/src/endpoint-tools/runtime.js

@@ -5,7 +5,7 @@ import { deleteEndpointSessionBinding, getEndpointSessionBinding, setEndpointSes
 import { deleteBrowserTabBindingsByEndpoint } from "../storage/sqlite/browser-tab-binding-repository.js";
 import { bindEndpointPrincipal, getEndpointPrincipal, touchEndpointPrincipal } from "../storage/sqlite/endpoint-principal-repository.js";
 import { finishEndpointToolInvocationAudit, startEndpointToolInvocationAudit } from "../storage/sqlite/endpoint-tool-invocation-repository.js";
-import "../storage/sqlite/index.js";
+import { init_sqlite } from "../storage/sqlite/index.js";
 import { init_paths } from "../config/paths.js";
 import { EndpointAuthenticator } from "./auth.js";
 import { EndpointBindingService } from "./binding-service.js";
@@ -16,6 +16,7 @@ import { EndpointUploadService } from "./upload-service.js";
 import { join } from "node:path";
 //#region src/endpoint-tools/runtime.ts
 init_paths();
+init_sqlite();
 init_logger();
 const log = createLogger("EndpointTools");
 const MAX_MESSAGE_CLOCK_SKEW_MS = 6e4;

package/dist/src/execution-environments/subject.js

@@ -1,7 +1,8 @@
 import { isXopcDatabaseOpen } from "../storage/sqlite/connection.js";
-import "../storage/sqlite/index.js";
+import { init_sqlite } from "../storage/sqlite/index.js";
 import { ExecutionEnvironmentStore } from "./store.js";
 //#region src/execution-environments/subject.ts
+init_sqlite();
 function getExecutionEnvironmentForSession(conversationId) {
 	if (!isXopcDatabaseOpen()) return void 0;
 	const store = new ExecutionEnvironmentStore();

package/dist/src/extensions/activation-context.js

@@ -1,3 +1,4 @@
+import { getAgentDefaultModelRef, init_schema } from "../config/schema.js";
 import { PROVIDER_ENV_MAP, init_env_keys } from "../providers/env-keys.js";
 import { init_providers, isProviderConfiguredSync } from "../providers/index.js";
 import { collectSttProviderConfigEntries } from "../voice/stt/config-slice.js";
@@ -10,6 +11,7 @@ import { isSttProviderConfigured } from "../voice/stt/list-providers.js";
 //#region src/extensions/activation-context.ts
 init_providers();
 init_env_keys();
+init_schema();
 function isRecord(x) {
 	return typeof x === "object" && x !== null && !Array.isArray(x);
 }
@@ -89,21 +91,6 @@ function collectConfiguredProviderIds(config) {
 	]);
 	return ids.size > 0 ? [...ids] : void 0;
 }
-function defaultModelId(config) {
-	const agents = config?.agents;
-	if (!isRecord(agents)) return void 0;
-	const list = agents.list;
-	if (!Array.isArray(list)) return void 0;
-	const defaultId = typeof agents.default === "string" ? agents.default : void 0;
-	const entry = list.find((candidate) => isRecord(candidate) && candidate.id === defaultId) ?? list.find((candidate) => isRecord(candidate) && candidate.enabled !== false);
-	const overrideModels = isRecord(entry) && isRecord(entry.models) ? entry.models : void 0;
-	const overrideChat = overrideModels && isRecord(overrideModels.chat) ? overrideModels.chat : void 0;
-	if (typeof overrideChat?.primary === "string" && overrideChat.primary.trim()) return overrideChat.primary;
-	const defaults = isRecord(agents.defaults) ? agents.defaults : void 0;
-	const models = defaults && isRecord(defaults.models) ? defaults.models : void 0;
-	const chat = models && isRecord(models.chat) ? models.chat : void 0;
-	return typeof chat?.primary === "string" && chat.primary.trim() ? chat.primary : void 0;
-}
 /**
 * Merge partial activation context over values inferred from loaded app config.
 */
@@ -112,7 +99,7 @@ function mergeActivationContext(appConfig, partial) {
 	const base = {
 		enabledIds: Array.isArray(ext?.enabled) ? ext.enabled.filter((x) => typeof x === "string") : void 0,
 		disabledIds: Array.isArray(ext?.disabled) ? ext.disabled.filter((x) => typeof x === "string") : void 0,
-		requestedModelId: defaultModelId(appConfig),
+		requestedModelId: getAgentDefaultModelRef(),
 		configuredProviderIds: collectConfiguredProviderIds(appConfig),
 		configuredChannelIds: collectConfiguredChannelIds(appConfig),
 		env: process.env