@myagentroam/node 0.1.7 → 0.9.0

package/dist/runner/abstract-runner.d.ts

@@ -21,14 +21,15 @@ export declare abstract class AbstractRunner<TName extends RegisteredRunnerName
     abstract profile(capabilities: NodeCapabilities): RunnerProfile | undefined;
     refreshProfile(capabilities: NodeCapabilities, workspace?: NodeWorkspace, environment?: Readonly<Record<string, string>>): Promise<RunnerProfile | undefined>;
     abstract available(capabilities: NodeCapabilities): boolean;
-    abstract defaultConfiguration(workspace?: NodeWorkspace): RunnerDefaultConfiguration;
-    supportsConfiguration(configuration: RunnerDefaultConfiguration, workspace?: NodeWorkspace): boolean;
+    abstract defaultConfiguration(workspace?: NodeWorkspace, environment?: Readonly<Record<string, string>>): RunnerDefaultConfiguration;
+    supportsConfiguration(configuration: RunnerDefaultConfiguration, workspace?: NodeWorkspace, environment?: Readonly<Record<string, string>>): boolean;
     protected abstract profileForValidation(): RunnerProfile;
     abstract resumeExternal(session: NodeAgentSession, context: ExternalResumeContext, force?: boolean): Promise<ExternalResumeResult>;
     abstract discoverSessions(context: RunnerDiscoveryContext, workspace?: NodeWorkspace): Promise<readonly NodeAgentSession[]>;
     abstract readContextUsage(session: NodeAgentSession): Promise<RunnerContextUsage | undefined>;
     presentSession(session: NodeAgentSession, capabilities: NodeCapabilities, context: RunnerSessionPresentationContext): RunnerSessionPresentation;
     prepareMessageInput(input: string, collaborationMode: 'default' | 'plan'): string;
+    mcpConfiguration(rawInstallations: unknown, secretEnvironment: Readonly<Record<string, string>>): unknown;
     channelToken(sessionId: string): string | undefined;
     deliverChannel(sessionId: string, messageId: string, senderId: string, token: string, content: string, notify: (runId: string, messageId: string, delivery: ChannelDelivery) => void): ChannelDelivery;
     executeGlobalCommand(commandId: string, input: string): unknown;
@@ -66,6 +67,15 @@ export declare abstract class AbstractRunner<TName extends RegisteredRunnerName
         readonly secretEnvironment: Readonly<Record<string, string>>;
     }): Promise<unknown>;
 }
+export interface ResolvedMcpServer {
+    readonly name: string;
+    readonly transport: 'STDIO' | 'HTTP';
+    readonly command?: string;
+    readonly args?: readonly string[];
+    readonly environment?: Readonly<Record<string, string>>;
+    readonly url?: string;
+    readonly headers?: Readonly<Record<string, string>>;
+}
 export type RunnerCancellationIntent = 'CANCEL' | 'INTERRUPT';
 export interface RunnerControl {
     start(envelope: NodeEnvelope): void;

package/dist/runner/abstract-runner.js

@@ -1,3 +1,4 @@
+import { mcpRuntimeDescriptorSchema } from '@myagentroam/protocol';
 /**
  * Stable lifecycle boundary for every Node Runner implementation.
  *
@@ -15,8 +16,8 @@ export class AbstractRunner {
         void [workspace, environment];
         return this.profile(capabilities);
     }
-    supportsConfiguration(configuration, workspace) {
-        void workspace;
+    supportsConfiguration(configuration, workspace, environment) {
+        void [workspace, environment];
         const profile = this.profileForValidation();
         const model = profile.models.find((candidate) => candidate.id === configuration.model);
         return (configuration.runner === this.name &&
@@ -32,6 +33,9 @@ export class AbstractRunner {
         void collaborationMode;
         return input;
     }
+    mcpConfiguration(rawInstallations, secretEnvironment) {
+        return resolvedMcpServers(rawInstallations, secretEnvironment);
+    }
     channelToken(sessionId) {
         void sessionId;
         return undefined;
@@ -143,6 +147,76 @@ export class AbstractRunner {
         return this.commandControl.execute(session, command, input, context);
     }
 }
+function resolvedMcpServers(raw, secrets) {
+    if (!Array.isArray(raw))
+        return [];
+    const result = [];
+    for (const value of raw) {
+        if (value === null || typeof value !== 'object' || Array.isArray(value))
+            continue;
+        const record = value;
+        if (typeof record['serverName'] !== 'string' || record['enabled'] !== true)
+            continue;
+        const runtime = mcpRuntimeDescriptorSchema.safeParse(record['runtime']);
+        if (!runtime.success)
+            continue;
+        const configuration = isRecord(record['configuration']) ? record['configuration'] : {};
+        const resolveReferences = (candidate) => {
+            if (!isRecord(candidate))
+                return {};
+            const result = {};
+            for (const [name, reference] of Object.entries(candidate)) {
+                if (!isRecord(reference) || typeof reference['secretName'] !== 'string')
+                    return undefined;
+                const secret = secrets[reference['secretName']];
+                if (secret === undefined)
+                    return undefined;
+                result[name] = secret;
+            }
+            return result;
+        };
+        if (runtime.data.transport === 'STDIO') {
+            const runtimeEnvironment = resolveReferences(runtime.data.environment);
+            const configuredEnvironment = resolveReferences(configuration['environment']);
+            if (runtimeEnvironment === undefined || configuredEnvironment === undefined)
+                continue;
+            result.push({
+                name: record['serverName'],
+                transport: 'STDIO',
+                command: runtime.data.command,
+                args: [
+                    ...runtime.data.args,
+                    ...(Array.isArray(configuration['arguments'])
+                        ? configuration['arguments'].filter((item) => typeof item === 'string')
+                        : [])
+                ],
+                environment: {
+                    ...runtimeEnvironment,
+                    ...configuredEnvironment
+                }
+            });
+        }
+        else {
+            const runtimeHeaders = resolveReferences(runtime.data.headers);
+            const configuredHeaders = resolveReferences(configuration['headers']);
+            if (runtimeHeaders === undefined || configuredHeaders === undefined)
+                continue;
+            result.push({
+                name: record['serverName'],
+                transport: 'HTTP',
+                url: runtime.data.url,
+                headers: {
+                    ...runtimeHeaders,
+                    ...configuredHeaders
+                }
+            });
+        }
+    }
+    return result;
+}
+function isRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
 export class RunnerCapabilityError extends Error {
     runner;
     capability;

package/dist/runner/claude/managed-run-controller.js

@@ -27,7 +27,7 @@ export class ClaudeManagedRunController {
                 detail: '后续消息将以标签式规划模式运行，只读规划并输出计划卡。',
                 closable: true,
                 closeInput: '/plan',
-                continuation: { label: 'Implement', prompt: '请根据上述计划开始实施。' }
+                continuation: { label: '执行', prompt: '请根据上述计划开始实施。' }
             });
         return { command: command.id, states: this.host.commandStates(session.id) };
     }
@@ -138,6 +138,7 @@ export class ClaudeManagedRunController {
                 ...(typeof payload.effort === 'string' ? { effort: payload.effort } : {}),
                 ...(typeof payload.access === 'string' ? { access: payload.access } : {}),
                 environment: secretEnvironment,
+                mcpServers: this.runner.mcpConfiguration(payload.mcpInstallations, secretEnvironment),
                 ...(attachments.length === 0
                     ? {}
                     : {

package/dist/runner/claude-code-runner.d.ts

@@ -17,6 +17,7 @@ export declare class ClaudeCodeRunner extends AbstractRunner<'claude-code'> {
     available(capabilities: NodeCapabilities): boolean;
     protected profileForValidation(): RunnerProfile;
     defaultConfiguration(): RunnerDefaultConfiguration;
+    mcpConfiguration(raw: unknown, secrets: Readonly<Record<string, string>>): unknown;
     resumeExternal(external: NodeAgentSession, context: ExternalResumeContext): Promise<ExternalResumeResult>;
     discoverSessions(context: RunnerDiscoveryContext, workspace?: NodeWorkspace): Promise<readonly NodeAgentSession[]>;
     readContextUsage(session: NodeAgentSession): Promise<import("../native-session-history.js").NativeClaudeContextUsage | undefined>;

package/dist/runner/claude-code-runner.js

@@ -45,6 +45,20 @@ export class ClaudeCodeRunner extends AbstractRunner {
             access: 'default'
         };
     }
+    mcpConfiguration(raw, secrets) {
+        const servers = super.mcpConfiguration(raw, secrets);
+        return Object.fromEntries(servers.map((server) => [
+            server.name,
+            server.transport === 'STDIO'
+                ? {
+                    type: 'stdio',
+                    command: server.command,
+                    args: [...(server.args ?? [])],
+                    env: { ...(server.environment ?? {}) }
+                }
+                : { type: 'http', url: server.url, headers: { ...(server.headers ?? {}) } }
+        ]));
+    }
     async resumeExternal(external, context) {
         if (external.runner !== this.name ||
             external.nativeControl !== 'EXTERNAL' ||

package/dist/runner/codex/managed-run-controller.js

@@ -35,7 +35,7 @@ export class CodexManagedRunController {
                     detail: '后续消息将以协作规划模式运行。',
                     closable: true,
                     closeInput: '/plan',
-                    continuation: { label: 'Implement', prompt: '请根据上述计划开始实施。' }
+                    continuation: { label: '执行', prompt: '请根据上述计划开始实施。' }
                 });
             return { command: command.id, states: this.host.commandStates(session.id) };
         }
@@ -325,7 +325,8 @@ export class CodexManagedRunController {
             effort: payload.effort,
             access: payload.access,
             collaborationMode: payload.collaborationMode,
-            serviceTier: payload.serviceTier
+            serviceTier: payload.serviceTier,
+            mcpServers: this.runner.mcpConfiguration(payload.mcpInstallations, secretEnvironment)
         }, attachments);
     }
     async run(payload, attachments) {
@@ -340,7 +341,8 @@ export class CodexManagedRunController {
             const configuration = {
                 ...(typeof payload.model === 'string' ? { model: payload.model } : {}),
                 ...(typeof payload.effort === 'string' ? { effort: payload.effort } : {}),
-                ...(typeof payload.access === 'string' ? { access: payload.access } : {})
+                ...(typeof payload.access === 'string' ? { access: payload.access } : {}),
+                ...(payload.mcpServers === undefined ? {} : { mcpServers: payload.mcpServers })
             };
             const threadResult = typeof payload.externalSessionId === 'string'
                 ? await this.runner.resumeThread(payload.externalSessionId, cwd, configuration)

package/dist/runner/codex-runner.d.ts

@@ -5,17 +5,29 @@ import type { NodeAgentSession, NodeDatabase } from '../database.js';
 import type { NodeWorkspace } from '../database.js';
 export declare class CodexRunner extends AbstractRunner<'codex'> {
     private readonly client;
+    private readonly profileClientFactory;
     readonly name: "codex";
     readonly discoveryScope: "ALL_WORKSPACES";
     readonly execution: CodexExecutionState;
     private fastEnabled;
     private environmentFingerprint;
     private readonly environmentRuns;
-    constructor(client?: CodexAppServerClient);
+    private readonly profileCache;
+    private readonly profileRefreshes;
+    private readonly profileClients;
+    private readonly profileKeyByEnvironment;
+    private latestProfileCache;
+    private selectedProfileKey;
+    constructor(client?: CodexAppServerClient, profileClientFactory?: () => CodexAppServerClient);
     profile(capabilities: NodeCapabilities): RunnerProfile;
+    refreshProfile(capabilities: NodeCapabilities, workspace?: NodeWorkspace, environment?: Readonly<Record<string, string>>): Promise<RunnerProfile>;
+    private refreshCodexProfile;
+    private selectCachedProfile;
+    private fetchCodexProfile;
     available(capabilities: NodeCapabilities): boolean;
     executeGlobalCommand(commandId: string, input: string): unknown;
     serviceTier(): 'fast' | undefined;
+    mcpConfiguration(raw: unknown, secrets: Readonly<Record<string, string>>): unknown;
     usesRunnerTitleForRename(): boolean;
     renameNative(session: NodeAgentSession, input: {
         readonly title?: string | null;
@@ -35,7 +47,9 @@ export declare class CodexRunner extends AbstractRunner<'codex'> {
     nativeImageRoot(session: NodeAgentSession): string | undefined;
     managedRunForNativeTurn(nativeTurnId: string): string | undefined;
     protected profileForValidation(): RunnerProfile;
-    defaultConfiguration(): RunnerDefaultConfiguration;
+    defaultConfiguration(_workspace?: NodeWorkspace, environment?: Readonly<Record<string, string>>): RunnerDefaultConfiguration;
+    supportsConfiguration(configuration: RunnerDefaultConfiguration, _workspace?: NodeWorkspace, environment?: Readonly<Record<string, string>>): boolean;
+    private profileCacheForEnvironment;
     resumeExternal(external: NodeAgentSession, context: ExternalResumeContext, force?: boolean): Promise<ExternalResumeResult>;
     discoverSessions(context: RunnerDiscoveryContext, workspace?: NodeWorkspace): Promise<readonly NodeAgentSession[]>;
     readContextUsage(session: NodeAgentSession): Promise<import("../native-session-history.js").NativeCodexContextUsage | undefined>;

package/dist/runner/codex-runner.js

@@ -9,24 +9,147 @@ import { readCodexNativeContextUsage } from '../native-session-history.js';
 import { codexActiveTurnId, codexOfficialConversationPage, codexThreadCwd, codexThreadActivity, deduplicateDirectSessions, externalResumeFailureDetail, extractCodexThreads, isWithinWorkspace, latestNativeActivity } from './codex/conversation-parser.js';
 import { codexSessionControl } from '../codex-app-server.js';
 import { extractId } from '../util/runner-native-session-parsers.js';
+import { nodeLog } from '../operational.js';
+const CODEX_MODEL_CACHE_MS = 10 * 60 * 1_000;
+const CODEX_MODEL_FAILURE_RETRY_MS = 30 * 1_000;
+const CODEX_MODEL_PAGE_SIZE = 100;
 export class CodexRunner extends AbstractRunner {
     client;
+    profileClientFactory;
     name = 'codex';
     discoveryScope = 'ALL_WORKSPACES';
     execution = new CodexExecutionState();
     fastEnabled = false;
     environmentFingerprint;
     environmentRuns = new Set();
-    constructor(client = new CodexAppServerClient()) {
+    profileCache = new Map();
+    profileRefreshes = new Map();
+    profileClients = new Set();
+    profileKeyByEnvironment = new Map();
+    latestProfileCache;
+    selectedProfileKey;
+    constructor(client = new CodexAppServerClient(), profileClientFactory = () => new CodexAppServerClient()) {
         super();
         this.client = client;
+        this.profileClientFactory = profileClientFactory;
     }
     profile(capabilities) {
-        return declaredRunnerProfiles({
+        const base = declaredRunnerProfiles({
             codexAvailable: capabilities.codex.available,
             claudeCodeAvailable: capabilities.claudeCode.available,
             openCodeAvailable: capabilities.openCode?.available === true
         }).find((profile) => profile.runner === this.name);
+        return { ...base, models: this.latestProfileCache?.profile.models ?? [] };
+    }
+    async refreshProfile(capabilities, workspace, environment = {}) {
+        void workspace;
+        const base = this.profile(capabilities);
+        if (!capabilities.codex.available)
+            return { ...base, models: [] };
+        const key = codexEnvironmentFingerprint(environment, capabilities.codex.version);
+        this.profileKeyByEnvironment.set(codexSecretEnvironmentFingerprint(environment), key);
+        this.selectedProfileKey = key;
+        const now = Date.now();
+        const cached = this.profileCache.get(key);
+        if (cached?.successful === true && now < cached.fetchedAt + CODEX_MODEL_CACHE_MS)
+            return this.selectCachedProfile(key, cached);
+        if (cached?.successful === true) {
+            if (now >= cached.retryAt)
+                void this.refreshCodexProfile(key, base, environment);
+            return this.selectCachedProfile(key, cached);
+        }
+        if (cached !== undefined && now < cached.retryAt)
+            return cached.profile;
+        return this.refreshCodexProfile(key, base, environment);
+    }
+    refreshCodexProfile(key, base, environment) {
+        const existing = this.profileRefreshes.get(key);
+        if (existing !== undefined)
+            return existing;
+        const refresh = this.fetchCodexProfile(base, environment)
+            .then((value) => {
+            const cache = {
+                ...value,
+                fetchedAt: Date.now(),
+                successful: true,
+                retryAt: 0
+            };
+            this.profileCache.set(key, cache);
+            if (this.selectedProfileKey === key)
+                this.latestProfileCache = cache;
+            return cache.profile;
+        })
+            .catch((error) => {
+            nodeLog('runner.codex.models.refresh-failed', {
+                error: error instanceof Error ? error.message : String(error)
+            });
+            const cached = this.profileCache.get(key);
+            if (cached !== undefined) {
+                cached.retryAt = Date.now() + CODEX_MODEL_FAILURE_RETRY_MS;
+                return cached.profile;
+            }
+            this.profileCache.set(key, {
+                profile: { ...base, models: [] },
+                defaultConfiguration: emptyCodexConfiguration(),
+                fetchedAt: 0,
+                successful: false,
+                retryAt: Date.now() + CODEX_MODEL_FAILURE_RETRY_MS
+            });
+            return { ...base, models: [] };
+        })
+            .finally(() => this.profileRefreshes.delete(key));
+        this.profileRefreshes.set(key, refresh);
+        return refresh;
+    }
+    selectCachedProfile(key, cached) {
+        if (cached.successful && this.selectedProfileKey === key)
+            this.latestProfileCache = cached;
+        return cached.profile;
+    }
+    async fetchCodexProfile(base, environment) {
+        const client = this.profileClientFactory();
+        this.profileClients.add(client);
+        if (Object.keys(environment).length > 0)
+            client.configureEnvironment(environment);
+        try {
+            await client.start();
+            const models = [];
+            let cursor = null;
+            const cursors = new Set();
+            do {
+                const page = codexModelPage(await client.listModels({ cursor, limit: CODEX_MODEL_PAGE_SIZE, includeHidden: false }));
+                models.push(...page.models);
+                cursor = page.nextCursor;
+                if (cursor !== null && cursors.has(cursor))
+                    throw new Error('CODEX_MODELS_CURSOR_REPEATED');
+                if (cursor !== null)
+                    cursors.add(cursor);
+            } while (cursor !== null);
+            const uniqueModels = models.filter((model, index) => models.findIndex((candidate) => candidate.model === model.model) === index);
+            const profileModels = uniqueModels.map((model) => ({
+                id: model.model,
+                label: model.displayName,
+                supportedEfforts: [...model.supportedEfforts],
+                isDefault: model.isDefault,
+                defaultEffort: model.defaultEffort
+            }));
+            const selected = uniqueModels.find((model) => model.isDefault) ?? uniqueModels[0];
+            return {
+                profile: { ...base, models: profileModels },
+                defaultConfiguration: selected === undefined
+                    ? emptyCodexConfiguration()
+                    : {
+                        runner: this.name,
+                        model: selected.model,
+                        effort: selected.defaultEffort,
+                        access: 'on-request'
+                    }
+            };
+        }
+        finally {
+            if (this.profileClients.delete(client))
+                client.stop();
+        }
     }
     available(capabilities) {
         return capabilities.codex.available;
@@ -44,6 +167,19 @@ export class CodexRunner extends AbstractRunner {
     serviceTier() {
         return this.fastEnabled ? 'fast' : undefined;
     }
+    mcpConfiguration(raw, secrets) {
+        const servers = super.mcpConfiguration(raw, secrets);
+        return Object.fromEntries(servers.map((server) => [
+            server.name,
+            server.transport === 'STDIO'
+                ? {
+                    command: server.command,
+                    args: [...(server.args ?? [])],
+                    env: { ...(server.environment ?? {}) }
+                }
+                : { url: server.url, http_headers: { ...(server.headers ?? {}) } }
+        ]));
+    }
     usesRunnerTitleForRename() {
         return true;
     }
@@ -131,8 +267,23 @@ export class CodexRunner extends AbstractRunner {
             openCode: { available: false }
         });
     }
-    defaultConfiguration() {
-        return { runner: this.name, model: 'gpt-5.6-sol', effort: 'medium', access: 'on-request' };
+    defaultConfiguration(_workspace, environment) {
+        return (this.profileCacheForEnvironment(environment)?.defaultConfiguration ??
+            emptyCodexConfiguration());
+    }
+    supportsConfiguration(configuration, _workspace, environment) {
+        if (configuration.runner !== this.name)
+            return false;
+        const profile = this.profileCacheForEnvironment(environment)?.profile;
+        return (profile !== undefined &&
+            profile.models.some((model) => model.id === configuration.model && model.supportedEfforts.includes(configuration.effort)) &&
+            profile.accessOptions.some((option) => option.id === configuration.access));
+    }
+    profileCacheForEnvironment(environment) {
+        if (environment === undefined)
+            return this.latestProfileCache;
+        const key = this.profileKeyByEnvironment.get(codexSecretEnvironmentFingerprint(environment));
+        return key === undefined ? undefined : this.profileCache.get(key);
     }
     async resumeExternal(external, context, force = false) {
         if (external.runner !== this.name ||
@@ -305,6 +456,9 @@ export class CodexRunner extends AbstractRunner {
         this.environmentFingerprint = undefined;
     }
     stop() {
+        for (const profileClient of this.profileClients)
+            profileClient.stop();
+        this.profileClients.clear();
         this.client.stop();
         if (this.environmentFingerprint !== undefined)
             this.client.clearEnvironment();
@@ -357,6 +511,63 @@ export class CodexRunner extends AbstractRunner {
         return this.client.listCollaborationModes();
     }
 }
+function emptyCodexConfiguration() {
+    return { runner: 'codex', model: '', effort: '', access: 'on-request' };
+}
+function codexEnvironmentFingerprint(environment, version) {
+    return createHash('sha256')
+        .update(JSON.stringify({
+        environment: Object.entries(environment).sort(([left], [right]) => left.localeCompare(right)),
+        version: version ?? null
+    }))
+        .digest('base64url');
+}
+function codexSecretEnvironmentFingerprint(environment) {
+    return createHash('sha256')
+        .update(JSON.stringify(Object.entries(environment).sort(([left], [right]) => left.localeCompare(right))))
+        .digest('base64url');
+}
+function codexModelPage(value) {
+    if (!isPlainRecord(value) || !Array.isArray(value.data))
+        throw new Error('CODEX_MODELS_INVALID');
+    return {
+        models: value.data.flatMap((entry) => {
+            if (!isPlainRecord(entry) || entry.hidden === true)
+                return [];
+            const model = typeof entry.model === 'string' ? entry.model.trim() : '';
+            const displayName = typeof entry.displayName === 'string' ? entry.displayName.trim() : '';
+            const defaultEffort = typeof entry.defaultReasoningEffort === 'string' ? entry.defaultReasoningEffort.trim() : '';
+            const supportedEfforts = Array.isArray(entry.supportedReasoningEfforts)
+                ? entry.supportedReasoningEfforts.flatMap((option) => isPlainRecord(option) && typeof option.reasoningEffort === 'string'
+                    ? [option.reasoningEffort.trim()]
+                    : [])
+                : [];
+            if (model.length === 0 ||
+                model.length > 128 ||
+                displayName.length === 0 ||
+                displayName.length > 128 ||
+                defaultEffort.length === 0 ||
+                defaultEffort.length > 64 ||
+                supportedEfforts.length > 32 ||
+                supportedEfforts.some((effort) => effort.length === 0 || effort.length > 64) ||
+                !supportedEfforts.includes(defaultEffort))
+                return [];
+            return [
+                {
+                    model,
+                    displayName,
+                    isDefault: entry.isDefault === true,
+                    defaultEffort,
+                    supportedEfforts: [...new Set(supportedEfforts.filter(Boolean))]
+                }
+            ];
+        }),
+        nextCursor: typeof value.nextCursor === 'string' && value.nextCursor.length > 0 ? value.nextCursor : null
+    };
+}
+function isPlainRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
 export class CodexExecutionState {
     runs = new Map();
     managedTurns = new Map();

package/dist/runner/opencode/managed-run-controller.js

@@ -32,7 +32,7 @@ export class OpenCodeManagedRunController {
                 detail: '后续消息将由 OpenCode 原生 Plan Agent 只读分析并制定计划。',
                 closable: true,
                 closeInput: '/plan',
-                continuation: { label: 'Implement', prompt: '请根据上述计划开始实施。' }
+                continuation: { label: '执行', prompt: '请根据上述计划开始实施。' }
             });
         return { command: command.id, states: this.host.commandStates(session.id) };
     }
@@ -48,9 +48,11 @@ export class OpenCodeManagedRunController {
             this.host.active.has(payload.runId))
             return;
         let environment;
+        let mcp;
         let attachments;
         try {
             environment = parseSecretEnvironment(payload.secretEnvironment);
+            mcp = this.runner.mcpConfiguration(payload.mcpInstallations, environment);
             attachments = this.host.parseAttachments(payload.attachments);
         }
         catch (error) {
@@ -70,7 +72,8 @@ export class OpenCodeManagedRunController {
             environment,
             attachments,
             access: typeof payload.access === 'string' ? payload.access : 'default',
-            agent: payload.collaborationMode === 'plan' ? 'plan' : 'build'
+            agent: payload.collaborationMode === 'plan' ? 'plan' : 'build',
+            mcp
         });
     }
     cancel(runId, intent) {
@@ -119,12 +122,16 @@ export class OpenCodeManagedRunController {
         return true;
     }
     async run(input) {
-        const client = this.runner.managedClient(input.environment);
+        // OpenCode 的动态 MCP 注册属于 Server 进程状态。加载 MCP 的 Run 使用独立 Server，
+        // 避免同一工作区的并行会话共享 MCP 进程、配置或浏览器上下文。
+        const client = this.runner.managedClient(input.environment, hasMcpConfiguration(input.mcp) ? input.runId : undefined);
         this.startingClients.set(input.runId, client);
         this.startingCwds.set(input.runId, input.cwd);
         this.host.active.add(input.runId);
         this.host.emit(input.runId, 'run.started', {}, 'STARTING');
         try {
+            if (hasMcpConfiguration(input.mcp))
+                await client.configureMcp(input.cwd, input.mcp);
             const nativeSessionId = input.externalSessionId ?? openCodeSessionId(await client.createSession(input.cwd));
             if (nativeSessionId === undefined)
                 throw new Error('OPENCODE_SESSION_INVALID');
@@ -359,6 +366,9 @@ export class OpenCodeManagedRunController {
             void this.host.captureSnapshot(runId, cwd);
     }
 }
+function hasMcpConfiguration(value) {
+    return value !== null && typeof value === 'object' && Object.keys(value).length > 0;
+}
 function openCodePart(part, planMode = false) {
     const id = typeof part?.id === 'string' ? part.id : undefined;
     if (id === undefined || typeof part?.type !== 'string')

package/dist/runner/opencode-runner.d.ts

@@ -30,6 +30,7 @@ export declare class OpenCodeRunner extends AbstractRunner<'opencode'> {
     protected profileForValidation(): RunnerProfile;
     supportsConfiguration(configuration: RunnerDefaultConfiguration, workspace?: NodeWorkspace): boolean;
     defaultConfiguration(workspace?: NodeWorkspace): RunnerDefaultConfiguration;
+    mcpConfiguration(raw: unknown, secrets: Readonly<Record<string, string>>): unknown;
     discoverSessions(context: RunnerDiscoveryContext, workspace?: NodeWorkspace): Promise<readonly NodeAgentSession[]>;
     resumeExternal(external: NodeAgentSession, context: ExternalResumeContext): Promise<ExternalResumeResult>;
     readExternalActivity(session: NodeAgentSession): Promise<"UNAVAILABLE" | "EXTERNAL_ACTIVE" | "IDLE">;
@@ -55,6 +56,6 @@ export declare class OpenCodeRunner extends AbstractRunner<'opencode'> {
         maxTokens: number;
     } | undefined>;
     stop(): Promise<void>;
-    managedClient(environment: Readonly<Record<string, string>>): OpenCodeServerClient;
+    managedClient(environment: Readonly<Record<string, string>>, isolationKey?: string): OpenCodeServerClient;
     releaseManagedClient(client: OpenCodeServerClient): void;
 }

package/dist/runner/opencode-runner.js

@@ -87,6 +87,24 @@ export class OpenCodeRunner extends AbstractRunner {
             access: 'default'
         };
     }
+    mcpConfiguration(raw, secrets) {
+        const servers = super.mcpConfiguration(raw, secrets);
+        return Object.fromEntries(servers.map((server) => [
+            server.name,
+            server.transport === 'STDIO'
+                ? {
+                    type: 'local',
+                    command: [server.command, ...(server.args ?? [])],
+                    environment: { ...(server.environment ?? {}) }
+                }
+                : {
+                    type: 'remote',
+                    url: server.url,
+                    headers: { ...(server.headers ?? {}) },
+                    oauth: false
+                }
+        ]));
+    }
     async discoverSessions(context, workspace) {
         const result = [];
         for (const target of workspace === undefined ? context.workspaces : [workspace]) {
@@ -270,11 +288,13 @@ export class OpenCodeRunner extends AbstractRunner {
         await Promise.allSettled(stopping);
         this.stoppingClients.clear();
     }
-    managedClient(environment) {
+    managedClient(environment, isolationKey) {
         const entries = Object.entries(environment).sort(([left], [right]) => left.localeCompare(right));
-        if (entries.length === 0)
+        if (entries.length === 0 && isolationKey === undefined)
             return this.client;
-        const fingerprint = createHash('sha256').update(JSON.stringify(entries)).digest('hex');
+        const fingerprint = createHash('sha256')
+            .update(JSON.stringify({ entries, isolationKey }))
+            .digest('hex');
         const existing = this.environmentClients.get(fingerprint);
         if (existing !== undefined) {
             existing.leases += 1;

package/dist/runner/runner-registry.d.ts

@@ -10,7 +10,7 @@ export declare class RunnerRegistry {
     product(name: unknown): AbstractRunner<RunnerName> | undefined;
     profiles(capabilities: NodeCapabilities): readonly RunnerProfile[];
     refreshProfiles(capabilities: NodeCapabilities, workspace?: import('../database.js').NodeWorkspace, environment?: Readonly<Record<string, string>>): Promise<readonly RunnerProfile[]>;
-    supportsConfiguration(configuration: RunnerDefaultConfiguration, workspace?: import('../database.js').NodeWorkspace): boolean;
+    supportsConfiguration(configuration: RunnerDefaultConfiguration, workspace?: import('../database.js').NodeWorkspace, environment?: Readonly<Record<string, string>>): boolean;
     startManagedRun(envelope: NodeEnvelope): boolean;
     cancelManagedRun(runId: string, intent: RunnerCancellationIntent): boolean;
     decideApproval(input: RunnerApprovalDecision): boolean;

package/dist/runner/runner-registry.js

@@ -38,8 +38,8 @@ export class RunnerRegistry {
         const profiles = await Promise.all(this.advertised().map((runner) => runner.refreshProfile(capabilities, workspace, environment)));
         return profiles.flatMap((profile) => (profile === undefined ? [] : [profile]));
     }
-    supportsConfiguration(configuration, workspace) {
-        return (this.product(configuration.runner)?.supportsConfiguration(configuration, workspace) === true);
+    supportsConfiguration(configuration, workspace, environment) {
+        return (this.product(configuration.runner)?.supportsConfiguration(configuration, workspace, environment) === true);
     }
     startManagedRun(envelope) {
         const runnerName = envelope.payload.runner;