@xopcai/xopc 0.0.426 → 0.0.427

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

@@ -1,7 +1,7 @@
 import { AgentPluginStore } from "../../extensions/agent-plugins/store.js";
+import { materializePluginServers } from "../../extensions/agent-plugins/mcp-adapter.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/config.ts
 function loadMergedMcpConfig(params) {
 	const configured = Object.fromEntries(Object.entries(normalizeConfiguredMcpServers(params.cfg?.mcp?.servers)).filter(([, server]) => server.xopcConnector?.enabled !== false));

package/dist/src/agent/mcp/connection-drafts.d.ts

@@ -31,7 +31,9 @@ export declare class McpConnectionDrafts {
         expiresAt: number;
     }>;
     probe(owner: string, id: string): Promise<McpConnectionProbe>;
-    authorize(owner: string, id: string): import("./connection-setup.js").McpAuthorization;
+    authorize(owner: string, id: string, options?: {
+        callbackRelayUrl?: string;
+    }): import("./connection-setup.js").McpAuthorization;
     authorization(owner: string, id: string): import("./connection-setup.js").McpAuthorization;
     redirect(owner: string, id: string, url: string): void;
     cancelAuthorization(owner: string, id: string): void;

package/dist/src/agent/mcp/connection-drafts.js

@@ -104,14 +104,15 @@ var McpConnectionDrafts = class {
 			draft.running = false;
 		}
 	}
-	authorize(owner, id) {
+	authorize(owner, id, options) {
 		const draft = this.get(owner, id);
 		this.assertIdle(draft);
 		if (draft.authorizationId) cancelMcpAuthorization(draft.authorizationId, owner);
 		draft.probe = void 0;
 		const attempt = startMcpAuthorization(draft.config, draft.workspace, draft.serverId, owner, {
 			credentials: draft.credentials,
-			authorizationScope: draft.id
+			authorizationScope: draft.id,
+			...options
 		});
 		draft.authorizationId = attempt.id;
 		return attempt;

package/dist/src/agent/mcp/connection-setup.js

@@ -1,10 +1,10 @@
 import { createLogger } from "../../utils/logger/index.js";
 import { init_logger } from "../../utils/logger.js";
 import { isManagedConnectorServer } from "../../connectors/materialize.js";
-import { prepareNativeMcpConfig } from "./native-mcp.js";
 import { resolveMcpSetupConfig } from "./effective-server.js";
-import { classifyMcpConnectionError } from "./connection-errors.js";
+import { prepareNativeMcpConfig } from "./native-mcp.js";
 import { McpAuthenticationRequiredError, discoverMcpTools, signInNativeMcp } from "./tool-catalog.js";
+import { classifyMcpConnectionError } from "./connection-errors.js";
 import { createHash, randomUUID } from "node:crypto";
 //#region src/agent/mcp/connection-setup.ts
 init_logger();
@@ -113,6 +113,38 @@ async function probeMcpConnection(config, workspace, serverId, options) {
 			return failed(cause);
 		}
 		if (server?.url && hasCredentials && /\b(?:401|403)\b|unauthorized|forbidden/i.test(String(error))) return { state: "token_required" };
+		if (server?.url && !server.auth && classifyMcpConnectionError(error) === "unknown" && Object.keys(server.headers ?? {}).some((name) => name.toLowerCase() === "authorization")) try {
+			const entry = (await prepareNativeMcpConfig(config, workspace)).servers.find((candidate) => candidate.name === serverId);
+			if (entry && "url" in entry.config) {
+				const response = await fetch(httpUrl(entry.config.url), {
+					method: "POST",
+					redirect: "error",
+					signal: options?.signal ? AbortSignal.any([options.signal, AbortSignal.timeout(1e4)]) : AbortSignal.timeout(1e4),
+					headers: {
+						Accept: "application/json, text/event-stream",
+						"Content-Type": "application/json",
+						...entry.config.headers
+					},
+					body: JSON.stringify({
+						jsonrpc: "2.0",
+						id: 1,
+						method: "initialize",
+						params: {
+							protocolVersion: "2025-03-26",
+							capabilities: {},
+							clientInfo: {
+								name: "xopc",
+								version: "1"
+							}
+						}
+					})
+				});
+				await response.body?.cancel();
+				if (response.status === 401 || response.status === 403) return { state: "token_required" };
+			}
+		} catch {
+			options?.signal?.throwIfAborted();
+		}
 		return failed(error);
 	}
 }

package/dist/src/agent/mcp/conversation-setup.d.ts

@@ -0,0 +1,163 @@
+import { type WeixinSetupScope } from './weixin-setup-scope.js';
+import type { Config } from '../../config/schema.js';
+type Phase = 'approval_required' | 'planned' | 'oauth_required' | 'authorizing' | 'token_required' | 'blocked' | 'ready' | 'cancelled';
+export type McpSetupContext = {
+    conversationId: string;
+    agentId: string;
+    canConfigure: boolean;
+    canRequestWeixinSetup?: boolean;
+};
+type Save = (next: Config, expected?: Config) => Promise<{
+    saved: boolean;
+    persisted?: boolean;
+    conflict?: boolean;
+}>;
+/** Coordinates HTTP MCP setup; pi remains the sole MCP and OAuth implementation. */
+export declare class McpConversationSetup {
+    private readonly options;
+    private readonly goals;
+    private readonly drafts;
+    private readonly draftIds;
+    private readonly busy;
+    private readonly authorizations;
+    private disposed;
+    constructor(options: {
+        readConfig: () => Config;
+        saveConfig: Save;
+        changed?: (conversationId: string) => void;
+        deliver?: (channel: WeixinSetupScope, text: string, setupId: string) => Promise<void>;
+        withConfigLock: <T>(operation: () => Promise<T>) => Promise<T>;
+        resume: (goal: {
+            id: string;
+            conversationId: string;
+            transcriptId: string;
+            serverId: string;
+            purpose: string;
+            channel?: WeixinSetupScope;
+        }) => Promise<boolean>;
+    });
+    private notify;
+    private save;
+    private current;
+    private get;
+    private view;
+    private cancelGoal;
+    revokeWeixinRequests(accountId: string, peerId: string): void;
+    reconcileWeixinScopes(): void;
+    private inspect;
+    currentForConversation(conversationId: string): {
+        setup: {
+            setupId: string;
+            serverId: string;
+            displayName: string;
+            version: number;
+            phase: Phase;
+            expired: boolean;
+            reloadRequired: boolean;
+            errorCode: string;
+            conversationId: string;
+            expiresAt: number;
+            interactionPath: string;
+            returnChannel: string;
+            managementPath: string;
+            continuationQueued: boolean;
+            replyDelivery: "failed" | "pending" | "delivered";
+            instruction: string;
+        };
+    };
+    command(command: string, input: Record<string, unknown>, context: McpSetupContext, dryRun?: boolean): Promise<unknown>;
+    private advance;
+    /** Owner-only UI; secret values and OAuth URLs never pass through the model API. */
+    interact(id: string, action: 'get' | 'advance' | 'token' | 'authorize' | 'cancel' | 'approve' | 'retry_delivery', value?: string, expectedVersion?: number, ownerPrincipalId?: string): Promise<{
+        setupId: string;
+        serverId: string;
+        displayName: string;
+        version: number;
+        phase: Phase;
+        expired: boolean;
+        reloadRequired: boolean;
+        errorCode: string;
+        conversationId: string;
+        expiresAt: number;
+        interactionPath: string;
+        returnChannel: string;
+        managementPath: string;
+        continuationQueued: boolean;
+        replyDelivery: "failed" | "pending" | "delivered";
+        instruction: string;
+    } | {
+        phase: string;
+        endpointOrigin: string;
+        setupId: string;
+        serverId: string;
+        displayName: string;
+        version: number;
+        expired: boolean;
+        reloadRequired: boolean;
+        errorCode: string;
+        conversationId: string;
+        expiresAt: number;
+        interactionPath: string;
+        returnChannel: string;
+        managementPath: string;
+        continuationQueued: boolean;
+        replyDelivery: "failed" | "pending" | "delivered";
+        instruction: string;
+    } | {
+        endpointOrigin: string;
+        approval: {
+            endpoint: string;
+            purpose: string;
+            accountId: string;
+            peerId: string;
+            principalId: string;
+            origin: string;
+        };
+        canReplaceToken: boolean;
+        authorizationUrl: string;
+        authState: string;
+        requiresRecheck: boolean;
+        setupId: string;
+        serverId: string;
+        displayName: string;
+        version: number;
+        phase: Phase;
+        expired: boolean;
+        reloadRequired: boolean;
+        errorCode: string;
+        conversationId: string;
+        expiresAt: number;
+        interactionPath: string;
+        returnChannel: string;
+        managementPath: string;
+        continuationQueued: boolean;
+        replyDelivery: "failed" | "pending" | "delivered";
+        instruction: string;
+    }>;
+    private settleAuthorization;
+    dispose(): void;
+    relayCallback(id: string, callbackUrl: string): string;
+    completeContinuation(input: {
+        conversationId: string;
+        clientMessageId: string;
+        expectedTranscriptId?: string;
+        origin: {
+            type: string;
+            source?: string;
+        };
+        runId?: string;
+    }, text: string): Promise<void>;
+    private deliverReply;
+    private resume;
+    permitsContinuation(input: {
+        conversationId: string;
+        clientMessageId: string;
+        expectedTranscriptId?: string;
+        origin: {
+            type: string;
+            source?: string;
+        };
+    }): boolean;
+    resumePending(runtimeReloaded?: boolean): Promise<void>;
+}
+export {};