@xopcai/xopc 0.0.425 → 0.0.427

package/dist/packages/gateway-contract/src/capabilities.js

@@ -554,7 +554,7 @@ var init_capabilities = __esmMin((() => {
 			})
 		},
 		"xopc.automations.get_run": {
-			input: CapabilityResourceInputSchema,
+			input: CapabilityResourceInputSchema.extend({ waitMs: z.number().int().min(0).max(3e4).optional() }),
 			output: z.object({
 				ok: z.literal(true),
 				run: AutomationRunSchema.loose()

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

@@ -100,6 +100,7 @@ export interface AgentManagerConfig {
     canConfigureEndpoint?: (endpointId: string) => boolean;
     getPhoneSetupService?: () => import('../phone/setup/service.js').PhoneSetupService | undefined;
     getBrowserSetupService?: () => import('../browser/setup/service.js').BrowserSetupService | undefined;
+    getMcpSetupService?: () => import('./mcp/conversation-setup.js').McpConversationSetup | undefined;
     getBrowserAutomationService?: () => import('../browser/automations/index.js').BrowserAutomationService | undefined;
     emitBrowserEvent?: (type: string, payload: unknown) => void;
     /** Gateway: exposes first-class xopc product objects for the `xopc_use` tool. */

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

@@ -287,6 +287,7 @@ var AgentManager = class {
 			getAutomationService: this.config.getAutomationService,
 			getBrowserAutomationService: this.config.getBrowserAutomationService,
 			getBrowserSetupService: this.config.getBrowserSetupService,
+			getMcpSetupService: this.config.getMcpSetupService,
 			getPhoneSetupService: this.config.getPhoneSetupService,
 			canConfigureEndpoint: this.config.canConfigureEndpoint,
 			emitBrowserEvent: this.config.emitBrowserEvent,

package/dist/src/agent/child-agent-factory.js

@@ -3,6 +3,7 @@ import { init_logger } from "../utils/logger.js";
 import { cloudCreditBudgetStopMessage, isCloudCreditBudgetExhausted } from "../providers/xopc-cloud-credit-budget.js";
 import { resolveAgentAbortReason } from "./orchestration/run-termination.js";
 import { executeWithTimeout } from "./lifecycle/timeout-wrapper.js";
+import { resolveResponseLanguageForSession } from "./prompt/response-language.js";
 import { withDataToolPermissions } from "./tools/dataBatch.js";
 import { withSearchCache } from "./tools/search/cache.js";
 import { evictEmbeddedSessionRunner } from "./embedded/session-runner.js";
@@ -11,7 +12,6 @@ import { runXopcEmbeddedTurn } from "./embedded/run-turn.js";
 import { createAgentTurnPolicy } from "./orchestration/agent-turn-policy.js";
 import { createDelegationBudgetPolicy, resolveDelegationBudget } from "./orchestration/delegation-budget.js";
 import { buildSubagentSystemPrompt } from "./prompt/subagent-context.js";
-import { resolveResponseLanguageForSession } from "./prompt/response-language.js";
 import { createResearchCheckpointTool } from "./tools/research-checkpoint-tool.js";
 import { randomUUID } from "node:crypto";
 //#region src/agent/child-agent-factory.ts

package/dist/src/agent/data-acquisition/service.js

@@ -1,7 +1,7 @@
 import { executeWithTimeout } from "../lifecycle/timeout-wrapper.js";
 import { checkedFilePath, readWorkspaceFileAsync } from "../sandbox/fileAccess.js";
-import { dataScheduler } from "./scheduler.js";
 import { checkFileSafety } from "../prompt/safety.js";
+import { dataScheduler } from "./scheduler.js";
 import { parseRepositoryMatch, repositorySearch } from "../tools/repository-search.js";
 import { DATA_OPERATION_TOOLS, nativeDataArgs, validateDataBatch } from "./schema.js";
 import { readGitData } from "./git.js";

package/dist/src/agent/embedded/configuration-capability-correction.d.ts

@@ -0,0 +1,3 @@
+import type { AgentMessage } from '@earendil-works/pi-agent-core';
+/** Correct an unverified capability denial once; never infer authorization or execute a write. */
+export declare function configurationCapabilityCorrection(toolNames: readonly string[], userText: string, answer: string, messages: readonly AgentMessage[]): string | undefined;

package/dist/src/agent/embedded/configuration-capability-correction.js

@@ -0,0 +1,14 @@
+//#region src/agent/embedded/configuration-capability-correction.ts
+/** Correct an unverified capability denial once; never infer authorization or execute a write. */
+function configurationCapabilityCorrection(toolNames, userText, answer, messages) {
+	const explicitSkillInstall = /^(?:请|帮我)?安装(?:这个|此)|^(?:please\s+)?install\s+(?:this|the)\b/i.test(userText.trim()) && /skill|技能|能力|周报/i.test(userText) && /https?:\/\//i.test(userText) && !/mcp/i.test(userText) && !/不要|别|暂不|先不|只推荐|仅查看|do not|don't|not now|only recommend|review only/i.test(userText);
+	const skillAttempted = messages.some((message) => message.role === "assistant" && Array.isArray(message.content) && message.content.some((block) => block.type === "toolCall" && ["skill_install", "skill_manage"].includes(block.name)));
+	const promiseOnly = /^(?:我会|我将|I will|I'll).{0,100}(?:安装|install)/i.test(answer.trim()) && !/需要.{0,20}(?:确认|授权|权限)|cannot|can.t|denied|不可|无法|失败|拒绝/i.test(answer);
+	if (explicitSkillInstall && promiseOnly && !skillAttempted && toolNames.includes("skill_install")) return "Host execution check: the user explicitly requested installing the supplied Skill and using it. The registered skill_install tool has not been attempted; a promise to act is not execution. Continue that exact authorized request with the actual Skill tools and inspect the result, or report an actual blocker. Do not add permissions, force an overwrite, use shell/file configuration, or ask for duplicate consent. This is one bounded continuation, not a new user request.";
+	if (!toolNames.includes("mcp_setup") || !/mcp|https?:\/\//i.test(userText)) return;
+	if (messages.some((message) => message.role === "assistant" && Array.isArray(message.content) && message.content.some((block) => block.type === "toolCall" && (block.name === "mcp_setup" || block.name === "xopc_use" && block.arguments?.mode === "mcp_setup")))) return;
+	if (!/(?:tool|工具|能力).{0,45}(?:not available|isn.t available|unavailable|未提供|不可用|不存在|缺少)|(?:未提供|没有|缺少).{0,30}(?:MCP|配置工具)|(?:cannot|can.t|无法).{0,40}(?:MCP|连接).{0,30}(?:local|回环|localhost|127\.0\.0\.1)/i.test(answer)) return;
+	return "Host capability correction: mcp_setup is registered and directly callable in the current function schemas. No MCP setup call was attempted in this turn, so tool absence or endpoint reachability has not been verified. Correct that statement using the actual inspect/probe tools for the existing user request. Probes execute on the Gateway host, including user-provided loopback addresses. This fact grants no additional authorization: preserve the user's scope, do not mutate for advice-only requests, and honor any actual permission refusal or probe failure. Do not ask the user to repeat the request.";
+}
+//#endregion
+export { configurationCapabilityCorrection };

package/dist/src/agent/embedded/run-for-session.js

@@ -12,8 +12,9 @@ import { resolveAgentTurnTimeoutMs } from "../orchestration/run-agent-turn-with-
 import { isPersonalConversation } from "../../personal-agent/repository.js";
 import { filterExecutionTools, resolveExecutionToolPolicy } from "./execution-tool-policy.js";
 import { runWithEmbeddedExecutionSession } from "./execution-context.js";
-import { resolvePromptCachePolicy } from "../../providers/prompt-cache-plan.js";
 import { prepareNativeMcpConfig } from "../mcp/native-mcp.js";
+import { boundAutomationMcpSource, restrictAutomationMcpConfig } from "../../automations/mcp-source.js";
+import { resolvePromptCachePolicy } from "../../providers/prompt-cache-plan.js";
 import { assessContext, recoverContext as recoverContext$1 } from "../memory/context-recovery.js";
 import { resolveCompactionPolicy } from "../memory/compaction-policy.js";
 import { runXopcEmbeddedTurn } from "./run-turn.js";
@@ -157,10 +158,22 @@ async function runEmbeddedTurnForSessionInner(params) {
 		if (typeof mm.applyResolvedModel === "function") mm.applyResolvedModel(agent, model, modelRef);
 		else await mm.applyModelForSession(agent, conversationId);
 		agentManager.setModelForSession(conversationId, modelRef);
-		const executionToolPolicy = resolveExecutionToolPolicy(conversationId);
-		const tools = filterExecutionTools(executionToolPolicy, agent.state.tools);
+		const source = boundAutomationMcpSource(runId, conversationId);
+		const baseToolPolicy = resolveExecutionToolPolicy(conversationId);
+		if (source && !baseToolPolicy.nativeMcp) throw new Error("This execution surface does not permit native MCP tools.");
+		const executionToolPolicy = source ? {
+			...baseToolPolicy,
+			codemode: false,
+			externalMaterialization: false,
+			revision: `${baseToolPolicy.revision}:${source.id}`
+		} : baseToolPolicy;
+		const tools = source ? [] : filterExecutionTools(executionToolPolicy, agent.state.tools);
 		const turnPolicy = agentManager.createAgentTurnPolicy(conversationId);
-		const systemPrompt = appendDynamicPromptSection([agent.state.systemPrompt ?? "", params.presentation === "voice" ? voicePresentationPrompt : ""].filter(Boolean).join("\n\n"), [params.dynamicSystemContext, connectionObjectiveContext(conversationId)].filter(Boolean).join("\n\n"));
+		const systemPrompt = appendDynamicPromptSection([agent.state.systemPrompt ?? "", params.presentation === "voice" ? voicePresentationPrompt : ""].filter(Boolean).join("\n\n"), [
+			params.dynamicSystemContext,
+			connectionObjectiveContext(conversationId),
+			source ? `The host pinned this automation to MCP server ${source.serverId} and tools ${JSON.stringify(source.tools.map((tool) => tool.name))}. Use these exact tools for the requested read. No other external source, configuration change or local file/shell fallback is permitted. An answer without a successful pinned tool call will fail verification.` : ""
+		].filter(Boolean).join("\n\n"));
 		const idlePolicy = resolveCompactionPolicy(config);
 		if (personal && idlePolicy.enabled && idlePolicy.personalIdle.enabled) idleJob = async (signal, isCurrent) => {
 			const messages = await sessionStore.load(conversationId);
@@ -202,7 +215,9 @@ async function runEmbeddedTurnForSessionInner(params) {
 			conversationId,
 			tools
 		}));
-		const mcp = config && executionToolPolicy.nativeMcp ? await prepareNativeMcpConfig(config, workspaceDir, resolveEffectiveAgentProfileForSession(conversationId).agentId) : void 0;
+		const preparedMcp = config && executionToolPolicy.nativeMcp ? await prepareNativeMcpConfig(config, workspaceDir, resolveEffectiveAgentProfileForSession(conversationId).agentId) : void 0;
+		if (source && !preparedMcp) throw new Error("The bound MCP source cannot be loaded.");
+		const mcp = preparedMcp ? restrictAutomationMcpConfig(runId, conversationId, preparedMcp) : void 0;
 		const promptCachePolicy = resolvePromptCachePolicy(config ? resolveEffectiveAgentProfileForSession(conversationId).config.runtime.promptCache : void 0);
 		let userMessageForTurn = userMessage;
 		if (params.applyStartupContext !== false) {

package/dist/src/agent/embedded/run-turn.js

@@ -22,6 +22,7 @@ import { allowsExecutionTool, filterExecutionTools, resolveExecutionToolPolicy }
 import { isPhoneAssistanceSuspended, phoneAssistance, phoneResumeForRun } from "../../phone/assistance.js";
 import { runWithEmbeddedExecutionSession } from "./execution-context.js";
 import { externalPolicyContext, getXopcToolMetadata } from "./tool-metadata.js";
+import { withDelegationScope } from "../orchestration/delegation-scope.js";
 import { isNestedCodemodePolicy } from "./codemode-extension.js";
 import { isComputerControlActive, isComputerLeaseTool, stopComputerControl } from "../../computer/control-guard.js";
 import { bindComputerAgentTurn, computerImagesForRequest, computerRequestFrameCleanup, endComputerAgentTurn, setComputerProgramAuthorization } from "../../computer/agent-context.js";
@@ -34,6 +35,7 @@ import { getActiveTranscriptUserText } from "../inbound/attachment-pipeline.js";
 import { resolvePromptCachePolicy } from "../../providers/prompt-cache-plan.js";
 import { wrapStreamFnForXopcExtensions } from "./xopc-stream-bridge.js";
 import { acquireEmbeddedSessionRunner, evictEmbeddedSessionRunner } from "./session-runner.js";
+import { configurationCapabilityCorrection } from "./configuration-capability-correction.js";
 import { createSqliteTranscriptRuntime } from "./transcript-runtime.js";
 import { assessContext, recoverContext as recoverContext$1 } from "../memory/context-recovery.js";
 import { resolveCompactionPolicy } from "../memory/compaction-policy.js";
@@ -43,7 +45,6 @@ import { markTurnToolResult } from "../memory/turn-provenance.js";
 import { RepositoryInstructions } from "../coding/repository-instructions.js";
 import { RunVerification } from "../coding/run-verification.js";
 import { projectWorkEvidence } from "../coding/projectEvidence.js";
-import { withDelegationScope } from "../orchestration/delegation-scope.js";
 import { getModelThinking } from "../../providers/model-thinking.js";
 import "../messaging/no-reply.js";
 import { createAssistantMessageEventStream, getCurrentSystemPrompt, getCurrentTools, isRecoverableLength } from "@earendil-works/pi-ai";
@@ -373,6 +374,7 @@ async function runXopcEmbeddedTurnInner(params) {
 			transcriptRuntime
 		});
 		const { session, reused } = runner;
+		const configurationTurnStart = session.agent.state.messages.length;
 		await runLease.attach(session, async () => session.abort());
 		const runAbortSignal = params.abortSignal ? AbortSignal.any([runLease.signal, params.abortSignal]) : runLease.signal;
 		if (runAbortSignal.aborted) {
@@ -1005,6 +1007,16 @@ async function runXopcEmbeddedTurnInner(params) {
 					});
 				};
 				await recoverSettledTurn();
+				const capabilityCorrection = configurationCapabilityCorrection(session.getAllTools().filter((tool) => tool.exposure !== "hidden").map((tool) => tool.name), userMessageToPromptText(userMessage), lastAssistantPlainText(session), session.agent.state.messages.slice(configurationTurnStart));
+				if (capabilityCorrection && !policyStopped && !connectionStopped && !clarificationStopped && !phoneStopped && !runAbortSignal.aborted && !isAssistantTurnFailed(session.agent) && !isAssistantTurnAborted(session.agent)) {
+					await session.sendCustomMessage({
+						customType: "configuration_capability_current",
+						content: capabilityCorrection,
+						display: false
+					}, { triggerTurn: true });
+					await session.agent.waitForIdle();
+					await recoverSettledTurn();
+				}
 				if (params.requireVisibleReply && !sentVisibleMessage && !policyStopped && !runAbortSignal.aborted && !isAssistantTurnFailed(session.agent) && !isAssistantTurnAborted(session.agent) && lastAssistantPlainText(session).trim() === "NO_REPLY") {
 					await session.sendCustomMessage({
 						customType: "visible_reply_required",

package/dist/src/agent/embedded/session-runner.js

@@ -3,15 +3,16 @@ import { init_logger } from "../../utils/logger.js";
 import { filterExecutionTools, resolveExecutionToolPolicy } from "./execution-tool-policy.js";
 import { deferredToolContract, getXopcToolMetadata } from "./tool-metadata.js";
 import { isCodemodeCoreRead } from "../tools/codemode-permissions.js";
+import { createEmbeddedModelRuntime, resolveEmbeddedProviderApiKeySync } from "./model-runtime.js";
+import { getNativePiAgentDir } from "../mcp/native-mcp.js";
+import { createAutomationMcpSourceGuard } from "../../automations/mcp-source.js";
 import { createXopcCodemodeExtension } from "./codemode-extension.js";
 import { abortEmbeddedRun } from "./runs.js";
 import { guardSessionManager } from "./session-tool-result-guard.js";
 import { transformUserMessageForPersistence } from "../inbound/attachment-pipeline.js";
-import { createEmbeddedModelRuntime, resolveEmbeddedProviderApiKeySync } from "./model-runtime.js";
 import { wrapStreamFnForXopcExtensions } from "./xopc-stream-bridge.js";
 import { xopcToolsToDefinitions } from "./xopc-tools-bridge.js";
 import { TOOL_DISCOVERY_STATE, createXopcToolSearchExtension } from "./tool-search-extension.js";
-import { getNativePiAgentDir } from "../mcp/native-mcp.js";
 import { AGENT_PROFILE_CONTEXT_STATE, createAgentProfileContextExtension } from "./agent-profile-context.js";
 import { join } from "node:path";
 import { createHash } from "node:crypto";
@@ -46,7 +47,8 @@ function buildEmbeddedRunnerFingerprint(input) {
 		JSON.stringify(input.mcp ? {
 			servers: input.mcp.servers,
 			errors: input.mcp.errors,
-			credentialAliases: input.mcp.credentialAliases
+			credentialAliases: input.mcp.credentialAliases,
+			automationSourceRunId: input.mcp.automationSourceRunId
 		} : null),
 		JSON.stringify(input.executionToolPolicy ?? null)
 	].join("\0")).digest("base64url");
@@ -284,6 +286,7 @@ var EmbeddedSessionRunnerPool = class {
 			noContextFiles: true,
 			noExtensions: true,
 			extensionFactories: [
+				...mcp?.automationSourceRunId ? [createAutomationMcpSourceGuard(mcp.automationSourceRunId)] : [],
 				...codemode ? [createXopcCodemodeExtension(codemode, tools, () => boundSession)] : [],
 				...discovery ? [createXopcToolSearchExtension(tools)] : [],
 				...mcp ? [createMcpExtension({

package/dist/src/agent/image/generation/openai-images-provider.js

@@ -1,11 +1,11 @@
 import { createLogger } from "../../../utils/logger/index.js";
 import { init_logger } from "../../../utils/logger.js";
-import { imageFileExtensionForMimeType } from "./image-assets.js";
 import { pickTimeoutMsOrFallback } from "../../../media-shared/http/deadline.js";
 import { privateNetworkPolicyToSsrfGuardOptions } from "../../../media-shared/http/private-network.js";
 import { resolveProviderHttpRequestConfig } from "../../../media-shared/http/resolve-provider-http-request-config.js";
 import { postJsonRequest, postMultipartRequest, readJsonResponseLimited } from "../../../media-shared/http/provider-http.js";
 import "../../../media-shared/http/index.js";
+import { imageFileExtensionForMimeType } from "./image-assets.js";
 import { ImageProviderError, validateImageRequest } from "../../../../packages/image-providers/src/validation.js";
 import { decodeBase64, imageFromBytes } from "../../../../packages/image-providers/src/http.js";
 import "../../../../packages/image-providers/src/index.js";

package/dist/src/agent/image/load-image-media.js

@@ -1,5 +1,5 @@
-import { checkFileSafety } from "../prompt/safety.js";
 import { decodeDataUrl } from "./image-helpers.js";
+import { checkFileSafety } from "../prompt/safety.js";
 import { homedir } from "node:os";
 import path from "node:path";
 import { promises } from "node:fs";

package/dist/src/agent/inbound/inbound-loop.js

@@ -92,7 +92,10 @@ var InboundLoop = class {
 					type: "channel",
 					channel: context.channel
 				},
-				metadata: { transcribedVoice: msg.metadata?.transcribedVoice === true }
+				metadata: {
+					accountId: msg.metadata?.accountId,
+					transcribedVoice: msg.metadata?.transcribedVoice === true
+				}
 			};
 			const sessionMetadata = await this.cfg.sessionStore.getMetadata(sessionContext.conversationId).catch(() => null);
 			updateAsyncLogContext({

package/dist/src/agent/independent-execution.js

@@ -1,8 +1,8 @@
 import { withoutCloudCreditBudget } from "../providers/xopc-cloud-credit-budget.js";
 import { withoutEmbeddedExecutionSession } from "./embedded/execution-context.js";
+import { withoutDelegationScope } from "./orchestration/delegation-scope.js";
 import { withoutDataToolPermissions } from "./tools/dataBatch.js";
 import { withoutSearchCache } from "./tools/search/cache.js";
-import { withoutDelegationScope } from "./orchestration/delegation-scope.js";
 //#region src/agent/independent-execution.ts
 /** Discard caller-owned execution scopes before resolving the target Agent. */
 function runInIndependentAgentExecution(run) {

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 {};