@myagentroam/node 0.1.8 → 0.9.2

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

@@ -1,5 +1,6 @@
 import { extractId } from '../../util/runner-native-session-parsers.js';
 import { parseSecretEnvironment } from '../../util/secret-environment.js';
+import { safeErrorCode } from '../../util/safe-error.js';
 import { boundedConversationItemId, codexImageAttachments, codexLiveConversationItem, codexUserInputQuestions, compactRunnerText, isPlainRecord } from './conversation-parser.js';
 export class CodexManagedRunController {
     runner;
@@ -32,10 +33,10 @@ export class CodexManagedRunController {
                     commandId: 'plan',
                     active: true,
                     label: 'Plan Mode',
-                    detail: '后续消息将以协作规划模式运行。',
+                    detail: 'Subsequent messages run in collaborative Plan Mode.',
                     closable: true,
                     closeInput: '/plan',
-                    continuation: { label: 'Implement', prompt: '请根据上述计划开始实施。' }
+                    continuation: { label: 'Implement', prompt: 'Implement the plan above.' }
                 });
             return { command: command.id, states: this.host.commandStates(session.id) };
         }
@@ -83,7 +84,7 @@ export class CodexManagedRunController {
             };
         }
         catch (error) {
-            this.host.emit(runId, 'run.failed', { code: error instanceof Error ? error.message : 'CODEX_COMPACT_FAILED' }, 'FAILED');
+            this.host.emit(runId, 'run.failed', { code: safeErrorCode(error, 'CODEX_COMPACT_FAILED') }, 'FAILED');
             this.runner.execution.runs.delete(runId);
             this.runner.releaseEnvironment(runId);
             this.host.removeActive(runId);
@@ -283,7 +284,7 @@ export class CodexManagedRunController {
             secretEnvironment = parseSecretEnvironment(payload.secretEnvironment);
         }
         catch (error) {
-            this.host.emit(runId, 'run.rejected', { code: error instanceof Error ? error.message : 'MESSAGE_ATTACHMENTS_INVALID' }, 'FAILED');
+            this.host.emit(runId, 'run.rejected', { code: safeErrorCode(error, 'MESSAGE_ATTACHMENTS_INVALID') }, 'FAILED');
             return;
         }
         this.host.adopt({
@@ -311,7 +312,7 @@ export class CodexManagedRunController {
             this.runner.prepareEnvironment(secretEnvironment, runId);
         }
         catch (error) {
-            this.host.emit(runId, 'run.rejected', { code: error instanceof Error ? error.message : 'SECRET_ENVIRONMENT_INVALID' }, 'FAILED');
+            this.host.emit(runId, 'run.rejected', { code: safeErrorCode(error, 'SECRET_ENVIRONMENT_INVALID') }, 'FAILED');
             return;
         }
         this.host.addActive(runId);
@@ -325,7 +326,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 +342,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)
@@ -379,7 +382,7 @@ export class CodexManagedRunController {
                 this.runner.releaseEnvironment(runId);
                 return;
             }
-            this.host.emit(runId, 'run.failed', { code: error instanceof Error ? error.message : 'CODEX_RUN_FAILED' }, 'FAILED');
+            this.host.emit(runId, 'run.failed', { code: safeErrorCode(error, 'CODEX_RUN_FAILED') }, 'FAILED');
             this.runner.execution.runs.delete(runId);
             this.runner.releaseEnvironment(runId);
             this.host.removeActive(runId);

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;
@@ -32,10 +44,12 @@ export declare class CodexRunner extends AbstractRunner<'codex'> {
     readExternalActivity(session: NodeAgentSession): Promise<"UNAVAILABLE" | "MANAGED_ACTIVE" | "EXTERNAL_ACTIVE" | "IDLE" | undefined>;
     acceptsTruncatedNativeHistory(): boolean;
     readManagedRunnerTitle(session: NodeAgentSession, nativeSessionId: string): Promise<string | undefined>;
-    nativeImageRoot(session: NodeAgentSession): string | undefined;
+    nativeImageRoots(session: NodeAgentSession): readonly string[];
     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

@@ -6,27 +6,150 @@ import { resolve } from 'node:path';
 import { createHash } from 'node:crypto';
 import { discoverAllNativeSessions } from '../native-session-history.js';
 import { readCodexNativeContextUsage } from '../native-session-history.js';
-import { codexActiveTurnId, codexOfficialConversationPage, codexThreadCwd, codexThreadActivity, deduplicateDirectSessions, externalResumeFailureDetail, extractCodexThreads, isWithinWorkspace, latestNativeActivity } from './codex/conversation-parser.js';
+import { codexActiveTurnId, codexOfficialConversationPage, codexThreadCwd, codexThreadActivity, deduplicateDirectSessions, 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;
     }
@@ -112,10 +248,13 @@ export class CodexRunner extends AbstractRunner {
         await this.start();
         return extractCodexThreads(await this.listThreads()).find((thread) => thread.id === nativeSessionId)?.title;
     }
-    nativeImageRoot(session) {
-        return session.externalSessionId === null
-            ? undefined
-            : resolve(homedir(), '.codex', 'generated_images', session.externalSessionId);
+    nativeImageRoots(session) {
+        return [
+            session.cwd,
+            ...(session.externalSessionId === null
+                ? []
+                : [resolve(homedir(), '.codex', 'generated_images', session.externalSessionId)])
+        ];
     }
     managedRunForNativeTurn(nativeTurnId) {
         return this.execution.managedTurns.get(nativeTurnId)?.runId;
@@ -131,8 +270,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 ||
@@ -162,11 +316,10 @@ export class CodexRunner extends AbstractRunner {
             }
             return { activity: 'IDLE', session: context.create(external) };
         }
-        catch (error) {
+        catch {
             return {
                 activity: 'UNAVAILABLE',
-                failureCode: 'RUNNER_RESUME_FAILED',
-                failureDetail: externalResumeFailureDetail(error)
+                failureCode: 'RUNNER_RESUME_FAILED'
             };
         }
     }
@@ -305,6 +458,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 +513,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/conversation-parser.d.ts

@@ -18,10 +18,14 @@ export declare function openCodeQuestions(value: unknown): {
     allowOther: boolean;
     multiSelect: boolean;
 }[];
-export declare function openCodePatchChanges(value: unknown): {
-    path: string;
-    change: string;
-    additions: null;
-    deletions: null;
-    diffAvailable: boolean;
-}[];
+export declare function openCodePatchToolPayload(): {
+    namespace: string;
+    toolName: string;
+    title: string;
+    inputSummary: null;
+    outputSummary: string;
+    outputSummaryCode: string;
+    progressLabel: null;
+    errorCode: null;
+    truncated: boolean;
+};

package/dist/runner/opencode/conversation-parser.js

@@ -1,4 +1,3 @@
-import { basename } from 'node:path';
 import { boundedConversationItemId, compactRunnerText, compactRunnerValue } from '../codex/conversation-parser.js';
 export function openCodeConversationPage(session, messages, input, managedTurn) {
     const records = messages.flatMap((value) => {
@@ -114,10 +113,11 @@ function partItem(session, turnId, raw, planMode, startedAt, completedAt, sequen
     if (part.type === 'compaction')
         return item(session, turnId, part.id, 'context_compaction', 'COMPLETED', {
             phase: 'COMPLETED',
-            summary: '上下文已整理'
+            summary: 'Context compacted',
+            summaryCode: 'CONTEXT_COMPACTED'
         }, startedAt, completedAt, sequence);
     if (part.type === 'patch')
-        return item(session, turnId, part.id, 'file_change', 'COMPLETED', { changes: openCodePatchChanges(part.files) }, startedAt, completedAt, sequence);
+        return item(session, turnId, part.id, 'tool_call', 'COMPLETED', openCodePatchToolPayload(), startedAt, completedAt, sequence);
     if (part.type === 'step-start' || part.type === 'step-finish')
         return undefined;
     if (part.type === 'text' || part.type === 'reasoning')
@@ -162,18 +162,18 @@ export function openCodeQuestions(value) {
         ];
     });
 }
-export function openCodePatchChanges(value) {
-    return (Array.isArray(value) ? value : []).flatMap((path) => typeof path === 'string' && path.length > 0
-        ? [
-            {
-                path: basename(path),
-                change: 'MODIFIED',
-                additions: null,
-                deletions: null,
-                diffAvailable: false
-            }
-        ]
-        : []);
+export function openCodePatchToolPayload() {
+    return {
+        namespace: 'opencode',
+        toolName: 'patch',
+        title: 'patch',
+        inputSummary: null,
+        outputSummary: 'OpenCode applied the patch',
+        outputSummaryCode: 'OPENCODE_PATCH_APPLIED',
+        progressLabel: null,
+        errorCode: null,
+        truncated: false
+    };
 }
 function item(session, turnId, nativeId, kind, status, payload, startedAt, completedAt, sequence) {
     return {

package/dist/runner/opencode/managed-run-controller.d.ts

@@ -7,6 +7,7 @@ interface OpenCodeManagedRunHost {
     intercepted(): boolean;
     readonly active: Set<string>;
     parseAttachments(value: unknown): readonly RunnerImageAttachment[];
+    persistAttachments(cwd: string, runId: string, attachments: readonly RunnerImageAttachment[]): Promise<readonly string[]>;
     emit(runId: string, eventType: string, payload: unknown, status?: FakeRunnerStatus): void;
     emitItem(runId: string, item: OpenCodePublicItem): void;
     adopt(input: {
@@ -40,7 +41,7 @@ interface OpenCodeManagedRunHost {
 }
 type OpenCodePublicItem = {
     readonly itemId: string;
-    readonly kind: 'assistant_message' | 'plan' | 'reasoning_summary' | 'tool_call' | 'user_input_request' | 'context_compaction' | 'file_change' | 'unknown';
+    readonly kind: 'assistant_message' | 'plan' | 'reasoning_summary' | 'tool_call' | 'user_input_request' | 'context_compaction' | 'unknown';
     readonly status: 'PENDING' | 'IN_PROGRESS' | 'COMPLETED' | 'FAILED';
     readonly payload: Record<string, unknown>;
     readonly merge?: boolean;

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

@@ -1,6 +1,7 @@
 import { parseSecretEnvironment } from '../../util/secret-environment.js';
+import { safeErrorCode } from '../../util/safe-error.js';
 import { boundedConversationItemId, compactRunnerText, compactRunnerValue } from '../codex/conversation-parser.js';
-import { openCodePatchChanges, openCodeQuestions } from './conversation-parser.js';
+import { openCodePatchToolPayload, openCodeQuestions } from './conversation-parser.js';
 export class OpenCodeManagedRunController {
     runner;
     host;
@@ -29,10 +30,10 @@ export class OpenCodeManagedRunController {
                 commandId: 'plan',
                 active: true,
                 label: 'Plan Mode',
-                detail: '后续消息将由 OpenCode 原生 Plan Agent 只读分析并制定计划。',
+                detail: 'Subsequent messages use the OpenCode Plan Agent for read-only analysis.',
                 closable: true,
                 closeInput: '/plan',
-                continuation: { label: 'Implement', prompt: '请根据上述计划开始实施。' }
+                continuation: { label: 'Implement', prompt: 'Implement the plan above.' }
             });
         return { command: command.id, states: this.host.commandStates(session.id) };
     }
@@ -48,13 +49,15 @@ 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) {
-            this.host.emit(payload.runId, 'run.rejected', { code: error instanceof Error ? error.message : 'RUNNER_INPUT_INVALID' }, 'FAILED');
+            this.host.emit(payload.runId, 'run.rejected', { code: safeErrorCode(error, 'RUNNER_INPUT_INVALID') }, 'FAILED');
             return;
         }
         void this.run({
@@ -70,7 +73,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 +123,16 @@ export class OpenCodeManagedRunController {
         return true;
     }
     async run(input) {
-        const client = this.runner.managedClient(input.environment);
+        // OpenCode dynamic MCP registration belongs to Server process state. Runs that load MCP use an
+        // isolated Server so parallel sessions in one workspace do not share MCP processes or context.
+        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');
@@ -174,17 +182,20 @@ export class OpenCodeManagedRunController {
                     return;
                 }
                 this.finish(input.runId, 'FAILED', 'run.failed', {
-                    code: error instanceof Error ? error.message : 'OPENCODE_EVENT_FAILED'
+                    code: safeErrorCode(error, 'OPENCODE_EVENT_FAILED')
                 });
             });
             await subscriptionReady;
             this.host.emit(input.runId, 'run.running', {}, 'RUNNING');
             // The initial SSE snapshot can contain an idle event from before this prompt.
             this.pendingIdle.delete(input.runId);
+            const attachmentPaths = input.attachments.length === 0
+                ? []
+                : await this.host.persistAttachments(input.cwd, input.runId, input.attachments);
             await client.prompt({
                 directory: input.cwd,
                 sessionID: nativeSessionId,
-                text: input.input,
+                text: openCodeImageInput(input.input, attachmentPaths),
                 model: input.model,
                 variant: input.effort,
                 agent: input.agent,
@@ -196,7 +207,7 @@ export class OpenCodeManagedRunController {
         }
         catch (error) {
             this.finish(input.runId, 'FAILED', 'run.failed', {
-                code: error instanceof Error ? error.message : 'OPENCODE_RUN_START_FAILED'
+                code: safeErrorCode(error, 'OPENCODE_RUN_START_FAILED')
             });
         }
     }
@@ -359,6 +370,15 @@ export class OpenCodeManagedRunController {
             void this.host.captureSnapshot(runId, cwd);
     }
 }
+function openCodeImageInput(input, attachmentPaths) {
+    if (attachmentPaths.length === 0)
+        return input;
+    const paths = attachmentPaths.map((path) => `- ${JSON.stringify(path)}`).join('\n');
+    return `${input}\n\nIf an inline image in this message is unavailable, use the read tool on the corresponding copy below. Do not read it again when the inline image is already visible:\n${paths}`;
+}
+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')
@@ -415,14 +435,18 @@ function openCodePart(part, planMode = false) {
             itemId,
             kind: 'context_compaction',
             status: 'COMPLETED',
-            payload: { phase: 'COMPLETED', summary: '上下文已整理' }
+            payload: {
+                phase: 'COMPLETED',
+                summary: 'Context compacted',
+                summaryCode: 'CONTEXT_COMPACTED'
+            }
         };
     if (part.type === 'patch')
         return {
             itemId,
-            kind: 'file_change',
+            kind: 'tool_call',
             status: 'COMPLETED',
-            payload: { changes: openCodePatchChanges(part.files) },
+            payload: openCodePatchToolPayload(),
             merge: true
         };
     if (part.type === 'step-start' || part.type === 'step-finish')