cli-wechat-bridge 1.1.7 → 1.1.8

package/bin/_run-entry.mjs

@@ -8,6 +8,8 @@ const BIN_DIR = path.dirname(fileURLToPath(import.meta.url));
 const PROJECT_DIR = path.resolve(BIN_DIR, "..");
 export const MIN_NODE_VERSION = Object.freeze([22, 13, 0]);
 export const MIN_NODE_VERSION_TEXT = MIN_NODE_VERSION.join(".");
+export const MIN_PI_NODE_VERSION = Object.freeze([22, 19, 0]);
+export const MIN_PI_NODE_VERSION_TEXT = MIN_PI_NODE_VERSION.join(".");
 
 export function isSupportedNodeVersion(version) {
   const match = /^v?(\d+)(?:\.(\d+))?(?:\.(\d+))?/.exec(version);
@@ -24,19 +26,21 @@ export function isSupportedNodeVersion(version) {
   return true;
 }
 
-function ensureSupportedNodeVersion() {
+function ensureSupportedNodeVersion(extraArgs = []) {
   if (process.env.CLI_BRIDGE_SKIP_NODE_CHECK === "1") {
     return;
   }
 
+  const piRequested = extraArgs.some((arg, index) => arg === "pi" && extraArgs[index - 1] === "--adapter");
   if (isSupportedNodeVersion(process.versions.node)) {
-    return;
+    if (!piRequested || compareNodeVersion(process.versions.node, MIN_PI_NODE_VERSION) >= 0) return;
   }
 
+  const minimumText = piRequested ? MIN_PI_NODE_VERSION_TEXT : MIN_NODE_VERSION_TEXT;
   process.stderr.write(
     [
-      `[cli-wechat-bridge] Node.js >= ${MIN_NODE_VERSION_TEXT} is required, but you are running ${process.version}.`,
-      `[cli-wechat-bridge] 需要 Node.js >= ${MIN_NODE_VERSION_TEXT}，当前版本为 ${process.version}。`,
+      `[cli-wechat-bridge] Node.js >= ${minimumText} is required, but you are running ${process.version}.`,
+      `[cli-wechat-bridge] 需要 Node.js >= ${minimumText}，当前版本为 ${process.version}。`,
       "Install the latest LTS from https://nodejs.org/ (or via nvm), then retry.",
       "Set CLI_BRIDGE_SKIP_NODE_CHECK=1 to bypass this check at your own risk.",
       "",
@@ -45,8 +49,22 @@ function ensureSupportedNodeVersion() {
   process.exit(1);
 }
 
+function compareNodeVersion(version, minimum) {
+  const match = /^v?(\d+)(?:\.(\d+))?(?:\.(\d+))?/.exec(version);
+  if (!match) return -1;
+  const current = [Number(match[1]), Number(match[2] ?? 0), Number(match[3] ?? 0)];
+  for (let index = 0; index < minimum.length; index += 1) {
+    if (current[index] !== minimum[index]) return current[index] > minimum[index] ? 1 : -1;
+  }
+  return 0;
+}
+
+export function isSupportedPiNodeVersion(version) {
+  return compareNodeVersion(version, MIN_PI_NODE_VERSION) >= 0;
+}
+
 export function runJsEntry(relativeEntryPath, extraArgs = []) {
-  ensureSupportedNodeVersion();
+  ensureSupportedNodeVersion([...extraArgs, ...process.argv.slice(2)]);
   const entryPath = path.join(PROJECT_DIR, relativeEntryPath);
   const child = spawn(
     process.execPath,

package/dist/bridge/adapter-control.js

@@ -0,0 +1,58 @@
+const snapshots = new WeakMap();
+export const MODEL_SNAPSHOT_TTL_MS = 5 * 60_000;
+export function invalidateModelSnapshot(adapter) {
+    snapshots.delete(adapter);
+}
+function snapshotOwner(adapter, senderId) {
+    const state = adapter.getState();
+    return JSON.stringify([
+        senderId, state.kind, state.cwd, state.pid, state.startedAt,
+        state.resumeConversationId ?? state.sharedSessionId ?? state.sharedThreadId,
+        state.lastSessionSwitchAt ?? state.lastThreadSwitchAt,
+    ]);
+}
+export async function handleAdapterControl(adapter, senderId, command) {
+    const kind = adapter.getState().kind;
+    const name = kind === "claude" ? "Claude Code" : kind === "opencode" ? "OpenCode" : kind === "codex" ? "Codex" : "Pi";
+    try {
+        if (command.type === "plan") {
+            if (!adapter.setPlanMode)
+                throw new Error(`Plan mode is not available for ${name}.`);
+            const enabled = await adapter.setPlanMode(command.enabled);
+            return enabled
+                ? `${name} plan mode enabled. Send /plan off to restore the previous mode.`
+                : `${name} plan mode disabled.`;
+        }
+        if (!adapter.listModels || !adapter.selectModel)
+            throw new Error(`Model selection is not available for ${name}.`);
+        const owner = snapshotOwner(adapter, senderId);
+        if (!command.target) {
+            snapshots.delete(adapter);
+            const models = await adapter.listModels();
+            if (snapshotOwner(adapter, senderId) !== owner)
+                throw new Error("The active session changed. Send /model again.");
+            if (!models.length)
+                return `${name} did not return any available models.`;
+            snapshots.set(adapter, { owner, createdAtMs: Date.now(), models });
+            return [
+                `Available ${name} models:`, "",
+                ...models.map((model, index) => `${index + 1}. ${model.displayName}${model.isCurrent ? "  (current)" : ""}`),
+                "", "Reply with /model <number> to switch. The list is valid for 5 minutes.",
+            ].join("\n");
+        }
+        const snapshot = snapshots.get(adapter);
+        if (!snapshot || snapshot.owner !== owner || Date.now() - snapshot.createdAtMs > MODEL_SNAPSHOT_TTL_MS) {
+            throw new Error("The model list has expired or belongs to another session. Send /model again.");
+        }
+        const index = Number(command.target);
+        if (!/^\d+$/.test(command.target) || !Number.isSafeInteger(index) || index < 1 || index > snapshot.models.length) {
+            throw new Error("Model selection is outside the displayed range. Send /model again to refresh the list.");
+        }
+        const model = await adapter.selectModel(snapshot.models[index - 1].id);
+        snapshots.delete(adapter);
+        return `${name} model switched to ${model.displayName}.`;
+    }
+    catch (error) {
+        return error instanceof Error ? error.message : String(error);
+    }
+}

package/dist/bridge/bridge-adapters.claude.js

@@ -1,3 +1,5 @@
+import { NativeTerminalControl, readClaudePermissionMode } from "./native-terminal-control.js";
+import { ClaudeNativeControls } from "./claude-native-controls.js";
 import fs from "node:fs";
 import net from "node:net";
 import os from "node:os";
@@ -345,6 +347,20 @@ export class ClaudeCompanionAdapter extends AbstractPtyAdapter {
     remoteSubmitRetryTimer = null;
     remoteSubmitRetryIndex = 0;
     remoteSubmitText = null;
+    terminalControl = new NativeTerminalControl({
+        write: (text) => this.writeToPty(text),
+        identity: () => JSON.stringify([this.state.pid, this.runtimeSessionId, this.resumeConversationId]),
+        isPromptEmpty: () => readClaudePermissionMode(this.terminalControl.text) !== null,
+        assertReady: () => {
+            if (!this.pty || this.state.status !== "idle" || this.pendingApproval || this.pendingResume) {
+                throw new Error("Claude must be idle with no pending approval before using remote controls.");
+            }
+        },
+    });
+    nativeControls = new ClaudeNativeControls(this.terminalControl, () => this.resumeConversationId ?? this.runtimeSessionId ?? "");
+    async listModels() { return this.nativeControls.listModels(); }
+    async selectModel(modelId) { return this.nativeControls.selectModel(modelId); }
+    async setPlanMode(enabled) { return this.nativeControls.setPlanMode(enabled); }
     constructor(options) {
         super(options);
         const shouldRestoreInitialSession = options.sessionStartMode !== "new";
@@ -408,6 +424,8 @@ export class ClaudeCompanionAdapter extends AbstractPtyAdapter {
         }
     }
     async sendInput(text) {
+        if (this.terminalControl.active)
+            throw new Error("A Claude control operation is in progress.");
         if (!this.pty) {
             throw new Error("claude adapter is not running.");
         }
@@ -452,6 +470,8 @@ export class ClaudeCompanionAdapter extends AbstractPtyAdapter {
         return listClaudeResumeSessions(this.options.cwd, limit);
     }
     async resumeSession(sessionId) {
+        if (this.terminalControl.active)
+            throw new Error("A CLI control operation is in progress. Wait for it to finish before switching sessions.");
         if (!this.pty) {
             throw new Error("Claude is not running yet.");
         }
@@ -548,6 +568,7 @@ export class ClaudeCompanionAdapter extends AbstractPtyAdapter {
         return findClaudeResumeSessionFile(this.options.cwd, sessionId);
     }
     async interrupt() {
+        this.terminalControl.cancel("The remote control operation was interrupted.");
         if (!this.pty) {
             return false;
         }
@@ -578,6 +599,8 @@ export class ClaudeCompanionAdapter extends AbstractPtyAdapter {
         return true;
     }
     async reset() {
+        if (this.terminalControl.active)
+            throw new Error("A CLI control operation is in progress. Wait for it to finish before switching sessions.");
         this.rejectPendingResume(new Error("Claude was reset during session switching."));
         this.clearWechatWorkingNotice(true);
         this.pendingCliApprovalHints = null;
@@ -647,6 +670,7 @@ export class ClaudeCompanionAdapter extends AbstractPtyAdapter {
         return ok ? 1 : 0;
     }
     async dispose() {
+        this.terminalControl.cancel("Claude is shutting down.");
         this.rejectPendingResume(new Error("Claude is shutting down during session switching."));
         this.detachLocalTerminal();
         this.clearWechatWorkingNotice(true);
@@ -676,6 +700,7 @@ export class ClaudeCompanionAdapter extends AbstractPtyAdapter {
         this.startHookHealthCheck();
     }
     handleData(rawText) {
+        this.terminalControl.feed(rawText);
         this.renderLocalOutput(rawText);
         const text = normalizeOutput(rawText);
         if (!text) {
@@ -747,6 +772,7 @@ export class ClaudeCompanionAdapter extends AbstractPtyAdapter {
         return true;
     }
     handleExit(exitCode) {
+        this.terminalControl.cancel("Claude exited during the control operation.");
         this.detachLocalTerminal();
         this.clearWechatWorkingNotice(true);
         this.clearRemoteSubmitRetry();
@@ -903,6 +929,7 @@ export class ClaudeCompanionAdapter extends AbstractPtyAdapter {
         }
         this.localTerminalInputListener = (chunk) => {
             const text = typeof chunk === "string" ? chunk : chunk.toString("utf8");
+            this.terminalControl.localInput(text);
             this.writeToPty(text);
         };
         process.stdin.on("data", this.localTerminalInputListener);
@@ -931,10 +958,11 @@ export class ClaudeCompanionAdapter extends AbstractPtyAdapter {
         }
     }
     resizePtyToTerminal() {
-        if (!this.pty || !process.stdout.isTTY) {
+        if (!this.pty) {
             return;
         }
         try {
+            this.terminalControl.resize(process.stdout.columns || DEFAULT_COLS, process.stdout.rows || DEFAULT_ROWS);
             this.pty.resize?.(process.stdout.columns || DEFAULT_COLS, process.stdout.rows || DEFAULT_ROWS);
         }
         catch {

package/dist/bridge/bridge-adapters.codex.js

@@ -7,7 +7,8 @@ import { normalizeOutput, nowIso, summarizeOutput, truncatePreview, } from "../c
 import { AbstractPtyAdapter } from "./bridge-adapters.core.js";
 import { killProcessTreeSync } from "./bridge-process-reaper.js";
 import * as shared from "./bridge-adapters.shared.js";
-import { requestCodexVisibleThreadSwitch } from "../companion/codex-visible-client-link.js";
+import { requestCodexVisibleClientShutdown, requestCodexVisibleThreadSwitch, } from "../companion/codex-visible-client-link.js";
+import { readLocalCompanionEndpoint } from "../companion/local-companion-link.js";
 import { ensureWorkspaceChannelDir } from "../wechat/channel-config.js";
 import { CODEX_REMOTE_AUTH_TOKEN_ENV, LOCAL_CLIENT_PROTOCOL_VERSION, } from "../runtime/runtime-types.js";
 export function parseCodexCliVersion(output) {
@@ -21,7 +22,7 @@ export function isCodexVersionInCompatibilityRange(version) {
     }
     const major = parts[0] ?? -1;
     const minor = parts[1] ?? -1;
-    return major === 0 && minor >= 149 && minor <= 151;
+    return major === 0 && minor >= 149 && minor <= 155;
 }
 const { CODEX_APP_SERVER_HOST, CODEX_APP_SERVER_READY_TIMEOUT_MS, CODEX_FINAL_REPLY_SETTLE_DELAY_MS, CODEX_RECENT_SESSION_KEY_LIMIT, CODEX_RPC_CONNECT_RETRY_MS, CODEX_RPC_RECONNECT_TIMEOUT_MS, CODEX_SESSION_FALLBACK_SCAN_INTERVAL_MS, CODEX_SESSION_LOCAL_MIRROR_FALLBACK_WINDOW_MS, CODEX_SESSION_POLL_INTERVAL_MS, CODEX_STARTUP_WARMUP_MS, CODEX_THREAD_SIGNAL_TTL_MS, INTERRUPT_SETTLE_DELAY_MS, appendBoundedLog, buildCodexApprovalRequest, buildCodexCliArgs, buildCodexDynamicToolCallFailureResponse, buildCodexMcpServerElicitationDeclineResponse, buildCodexPermissionsRequestApprovalResponse, buildCodexUserInputRequest, coerceWebSocketMessageData, delay, describeUnknownError, extractCodexFinalTextFromItem, extractCodexThreadFollowIdFromStatusChanged, extractCodexThreadStartedThreadId, extractCodexUserMessageText, findCodexSessionFile, findRecentCodexSessionFileForCwd, getCodexRpcRequestId, getCodexApprovalAutoResponse, getCodexWechatOutboundAttachmentDenyMessage, getNotificationThreadId, getNotificationTurnId, isRecord, isRecentIsoTimestamp, listCodexResumeSessions, normalizeComparablePath, normalizeCodexRpcError, reserveLocalPort, resolveSpawnTarget, shouldAutoCompleteCodexWechatTurnAfterFinalReply, shouldIgnoreCodexSessionReplayEntry, shouldRecoverCodexStaleBusyState, waitForTcpPort, } = shared;
 const CODEX_LOCAL_THREAD_ANNOUNCE_SETTLE_MS = 150;
@@ -78,6 +79,7 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
     appServerAuthToken = null;
     appServerAuthTokenFilePath = null;
     rpcSocket = null;
+    lastRpcCloseDetail = "";
     rpcShuttingDown = false;
     rpcReconnectPromise = null;
     cleanPanelExitInProgress = false;
@@ -86,6 +88,7 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
     subscribedThreadIds = new Set();
     pendingThreadSubscriptions = new Map();
     sharedThreadId = null;
+    previousCollaborationMode = null;
     announcedThreadId = null;
     localThreadFollowBlockedUntilMs = 0;
     pendingThreadStatusChecks = new Map();
@@ -182,6 +185,13 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
             throw err;
         }
     }
+    async prepareVisibleClientSession() {
+        if (this.isNativePanelMode() || this.sharedThreadId) {
+            return Boolean(this.sharedThreadId);
+        }
+        const threadId = await this.ensureThreadStarted();
+        return Boolean(threadId);
+    }
     buildSpawnArgs() {
         if (!this.appServerPort) {
             throw new Error("Codex app-server is not ready.");
@@ -248,6 +258,74 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         }
         await this.resumeVisibleSharedThread(threadId);
     }
+    async listModels() {
+        if (!this.usesRpcTurnTransport() || !this.sharedThreadId) {
+            throw new Error("Codex model selection requires an active app-server thread.");
+        }
+        const response = await this.sendRpcRequest("model/list", { includeHidden: false });
+        const data = isRecord(response) && Array.isArray(response.data) ? response.data : [];
+        const current = await this.readCodexThreadSettings();
+        const models = data.flatMap((item) => {
+            if (!isRecord(item))
+                return [];
+            const id = typeof item.id === "string" ? item.id : typeof item.model === "string" ? item.model : "";
+            if (!id)
+                return [];
+            const displayName = typeof item.displayName === "string" ? item.displayName : id;
+            const efforts = Array.isArray(item.supportedReasoningEfforts)
+                ? item.supportedReasoningEfforts.filter((value) => typeof value === "string")
+                : undefined;
+            return [{ id, displayName, isCurrent: id === current.model, supportedReasoningEfforts: efforts }];
+        });
+        return models;
+    }
+    async selectModel(modelId) {
+        const models = await this.listModels();
+        const selected = models.find((model) => model.id === modelId);
+        if (!selected)
+            throw new Error(`Codex model ${modelId} is not available.`);
+        await this.sendRpcRequest("thread/settings/update", { threadId: this.sharedThreadId, model: selected.id });
+        return selected;
+    }
+    async setPlanMode(enabled) {
+        if (!this.usesRpcTurnTransport() || !this.sharedThreadId) {
+            throw new Error("Codex plan mode requires an active app-server thread.");
+        }
+        const settings = await this.readCodexThreadSettings();
+        if (enabled) {
+            const response = await this.sendRpcRequest("collaborationMode/list", {});
+            const modes = isRecord(response) && Array.isArray(response.data) ? response.data : [];
+            const plan = modes.find((item) => isRecord(item) && (item.mode === "plan" || item.name?.toString().toLowerCase() === "plan"));
+            if (!isRecord(plan))
+                throw new Error("Codex plan mode is not available in this app-server.");
+            this.previousCollaborationMode = isRecord(settings.collaborationMode) ? settings.collaborationMode : null;
+            const mode = typeof plan.mode === "string" ? plan.mode : "plan";
+            const model = typeof plan.model === "string" ? plan.model : settings.model;
+            const effort = plan.reasoning_effort ?? plan.reasoningEffort ?? null;
+            await this.sendRpcRequest("thread/settings/update", {
+                threadId: this.sharedThreadId,
+                collaborationMode: { mode, settings: { model, reasoning_effort: effort, developer_instructions: null } },
+            });
+            return true;
+        }
+        const previous = this.previousCollaborationMode ?? {
+            mode: "default",
+            settings: { model: settings.model, reasoning_effort: settings.effort ?? null, developer_instructions: null },
+        };
+        await this.sendRpcRequest("thread/settings/update", {
+            threadId: this.sharedThreadId,
+            collaborationMode: previous,
+        });
+        this.previousCollaborationMode = null;
+        return false;
+    }
+    async readCodexThreadSettings() {
+        const response = await this.sendRpcRequest("thread/read", { threadId: this.sharedThreadId, includeTurns: false });
+        const thread = isRecord(response) && isRecord(response.thread) ? response.thread : null;
+        if (!thread || typeof thread.model !== "string")
+            throw new Error("Codex did not return the current thread model.");
+        return { model: thread.model, effort: thread.reasoningEffort, collaborationMode: thread.collaborationMode };
+    }
     async interrupt() {
         if (this.usesRpcTurnTransport()) {
             return await this.interruptPanelTurn();
@@ -315,6 +393,7 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         return true;
     }
     async dispose() {
+        await this.shutdownVisibleClient();
         this.resetTurnTracking({ preserveThread: false });
         if (this.isEmbeddedCliMode()) {
             this.detachLocalInputForwarding();
@@ -346,6 +425,25 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         }
         await this.stopAppServer();
     }
+    async shutdownVisibleClient() {
+        const endpoint = readLocalCompanionEndpoint(this.options.cwd, { adapter: "codex" });
+        if (!endpoint?.companionPid ||
+            endpoint.instanceId !== this.localClientInstanceId ||
+            !endpoint.codexControlPort ||
+            !endpoint.codexControlToken) {
+            return;
+        }
+        try {
+            await requestCodexVisibleClientShutdown({
+                cwd: this.options.cwd,
+                instanceId: endpoint.instanceId,
+            });
+        }
+        catch {
+            // The visible client may already be exiting. Its endpoint is cleared
+            // by the supervisor when the child process finishes.
+        }
+    }
     getLocalClientEndpoint() {
         if (!this.isHeadlessRuntimeMode() || !this.appServerPort || !this.appServerAuthToken) {
             return null;
@@ -1192,8 +1290,8 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         socket.addEventListener("message", (event) => {
             this.handleRpcMessageData(event.data);
         });
-        socket.addEventListener("close", () => {
-            this.handleRpcSocketClosed();
+        socket.addEventListener("close", (event) => {
+            this.handleRpcSocketClosed(event.code, event.reason);
         });
     }
     async disconnectRpcClient() {
@@ -1231,13 +1329,14 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         });
         this.rpcShuttingDown = false;
     }
-    handleRpcSocketClosed() {
+    handleRpcSocketClosed(code, reason) {
         const expectedShutdown = shouldSuppressCodexTransportFatalError({
             transportShuttingDown: this.rpcShuttingDown,
             shuttingDown: this.shuttingDown,
             cleanPanelExitInProgress: this.cleanPanelExitInProgress,
         });
         this.rpcSocket = null;
+        this.lastRpcCloseDetail = `close_code=${code ?? "unknown"}${reason ? ` reason=${truncatePreview(reason, 240)}` : ""}`;
         this.subscribedThreadIds.clear();
         this.rejectPendingRpcRequests("Codex websocket connection closed.");
         this.rpcShuttingDown = false;
@@ -1269,7 +1368,7 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
                 const details = this.describeAppServerLog();
                 this.emit({
                     type: "fatal_error",
-                    message: `codex app-server websocket closed unexpectedly.${details}`,
+                    message: `codex app-server websocket closed unexpectedly (${this.lastRpcCloseDetail || "no close details"}).${details}`,
                     timestamp: nowIso(),
                 });
                 this.terminateCodexClient();
@@ -1307,7 +1406,7 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
             }
             this.emit({
                 type: "fatal_error",
-                message: `codex app-server websocket closed unexpectedly and could not reconnect: ${lastError}.${details}`,
+                message: `codex app-server websocket closed unexpectedly and could not reconnect (${this.lastRpcCloseDetail || "no close details"}): ${lastError}.${details}`,
                 timestamp: nowIso(),
             });
             this.terminateCodexClient();
@@ -1460,6 +1559,9 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         if (typeof thread.parentThreadId === "string") {
             throw new Error(`Codex thread ${targetThreadId} is a subagent thread and cannot be resumed.`);
         }
+        if (thread.canAcceptDirectInput === false) {
+            throw new Error(`Codex thread ${targetThreadId} is owned by a parent agent and cannot accept direct input.`);
+        }
         if (thread.ephemeral === true) {
             throw new Error(`Codex thread ${targetThreadId} is ephemeral and cannot be resumed.`);
         }
@@ -1483,6 +1585,9 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         if (typeof thread.parentThreadId === "string") {
             throw new Error(`Codex thread ${targetThreadId} is a subagent thread.`);
         }
+        if (thread.canAcceptDirectInput === false) {
+            throw new Error(`Codex thread ${targetThreadId} is owned by a parent agent.`);
+        }
         if (thread.ephemeral === true) {
             throw new Error(`Codex thread ${targetThreadId} is ephemeral.`);
         }

package/dist/bridge/bridge-adapters.core.js

@@ -15,7 +15,7 @@ const { CODEX_APP_SERVER_HOST, INTERRUPT_SETTLE_DELAY_MS, buildCliEnvironment, b
  * the script path contains spaces: node-pty quotes the already-quoted path,
  * making cmd.exe treat the literal quotes as part of the filename.
  */
-function unwrapCmdExeForPty(rawTarget) {
+export function unwrapCmdExeForPty(rawTarget) {
     if (process.platform !== "win32") {
         return rawTarget;
     }
@@ -166,6 +166,15 @@ export class LocalCompanionProxyAdapter {
             command: "create_session",
         });
     }
+    async listModels() {
+        return await this.sendRequest({ command: "list_models" });
+    }
+    async selectModel(modelId) {
+        return await this.sendRequest({ command: "select_model", modelId });
+    }
+    async setPlanMode(enabled) {
+        return await this.sendRequest({ command: "set_plan_mode", enabled });
+    }
     async interrupt() {
         const result = await this.sendRequest({
             command: "interrupt",
@@ -612,6 +621,15 @@ export class AbstractPtyAdapter {
     setEventSink(sink) {
         this.eventSink = sink;
     }
+    async listModels() {
+        throw new Error(`/${this.options.kind} model selection is not available.`);
+    }
+    async selectModel(_modelId) {
+        throw new Error(`/${this.options.kind} model selection is not available.`);
+    }
+    async setPlanMode(_enabled) {
+        throw new Error(`/${this.options.kind} plan mode is not available.`);
+    }
     async start() {
         if (this.pty) {
             return;

package/dist/bridge/bridge-adapters.opencode.js

@@ -85,6 +85,139 @@ export class OpenCodeServerAdapter {
     pendingLocalSessionCreateFollowUntilMs = 0;
     pendingPermission = null;
     pendingQuestion = null;
+    previousAgentBySession = new Map();
+    async listModels() {
+        this.assertRemoteControlReady();
+        const session = await this.ensureControlSession();
+        const models = await this.listControlModels();
+        return models.map((model) => ({
+            id: model.id,
+            displayName: model.displayName,
+            isCurrent: session.model?.providerID === model.providerID &&
+                session.model.id === model.modelID,
+        }));
+    }
+    async selectModel(modelId) {
+        this.assertRemoteControlReady();
+        const session = await this.ensureControlSession();
+        const models = await this.listControlModels();
+        const target = models.find((model) => model.id === modelId);
+        if (!target) {
+            throw new Error("This OpenCode model is no longer available. Send /model again.");
+        }
+        const currentVariant = session.model?.variant;
+        const variant = currentVariant && currentVariant !== "default" && target.variants.includes(currentVariant)
+            ? currentVariant
+            : "default";
+        const result = await this.client.v2.session.switchModel({
+            sessionID: session.id,
+            model: {
+                providerID: target.providerID,
+                id: target.modelID,
+                variant,
+            },
+        });
+        this.unwrapOrThrow(result);
+        const updated = await this.getSessionForCurrentDirectory(session.id);
+        if (!updated ||
+            updated.model?.providerID !== target.providerID ||
+            updated.model.id !== target.modelID ||
+            (updated.model.variant ?? "default") !== variant) {
+            throw new Error("OpenCode did not confirm the selected model.");
+        }
+        return { id: target.id, displayName: target.displayName, isCurrent: true };
+    }
+    async setPlanMode(enabled) {
+        this.assertRemoteControlReady();
+        const session = await this.ensureControlSession();
+        const agents = await this.listPrimaryAgents();
+        const planAgent = agents.find((agent) => agent.name === "plan");
+        if (!planAgent) {
+            throw new Error("OpenCode primary agent 'plan' is not available.");
+        }
+        const currentAgent = session.agent ?? agents[0]?.name;
+        if (!currentAgent) {
+            throw new Error("OpenCode did not return any primary agents.");
+        }
+        if (enabled && currentAgent === "plan") {
+            return true;
+        }
+        if (!enabled && currentAgent !== "plan") {
+            this.previousAgentBySession.delete(session.id);
+            return false;
+        }
+        const previousAgent = this.previousAgentBySession.get(session.id);
+        const target = enabled
+            ? "plan"
+            : agents.some((agent) => agent.name === previousAgent)
+                ? previousAgent
+                : agents.find((agent) => agent.name === "build")?.name ??
+                    agents.find((agent) => agent.name !== "plan")?.name;
+        if (!target) {
+            throw new Error("OpenCode did not return an agent that can replace plan mode.");
+        }
+        const result = await this.client.v2.session.switchAgent({
+            sessionID: session.id,
+            agent: target,
+        });
+        this.unwrapOrThrow(result);
+        const updated = await this.getSessionForCurrentDirectory(session.id);
+        if (!updated || updated.agent !== target) {
+            throw new Error("OpenCode did not confirm the selected agent.");
+        }
+        if (enabled) {
+            this.previousAgentBySession.set(session.id, currentAgent);
+        }
+        else {
+            this.previousAgentBySession.delete(session.id);
+        }
+        return enabled;
+    }
+    assertRemoteControlReady() {
+        if (!this.client) {
+            throw new Error("OpenCode is not running.");
+        }
+        if (this.state.status === "busy") {
+            throw new Error("OpenCode is still working. Wait for the current reply or use /stop.");
+        }
+        if (this.pendingPermission) {
+            throw new Error("An OpenCode approval request is pending. Reply with /confirm or /deny.");
+        }
+        if (this.pendingQuestion) {
+            throw new Error("OpenCode is waiting for user input. Reply with /answer or use /stop.");
+        }
+    }
+    async ensureControlSession() {
+        const session = await this.ensureSession();
+        if (session.id !== this.activeSessionId) {
+            this.switchSharedSession(session, {
+                source: "wechat",
+                reason: "wechat_resume",
+                syncVisible: true,
+                forceVisibleSync: true,
+            });
+        }
+        return session;
+    }
+    async listPrimaryAgents() {
+        if (!this.client)
+            throw new Error("OpenCode is not running.");
+        const agents = this.unwrapOrThrow(await this.client.app.agents({
+            directory: this.options.cwd,
+            workspace: this.activeWorkspaceId ?? undefined,
+        }, { signal: AbortSignal.timeout(10_000) }));
+        return agents.filter((agent) => agent.mode !== "subagent" && !agent.hidden);
+    }
+    async listControlModels() {
+        if (!this.client)
+            throw new Error("OpenCode is not running.");
+        const providers = this.unwrapOrThrow(await this.client.provider.list({ directory: this.options.cwd, workspace: this.activeWorkspaceId ?? undefined }, { signal: AbortSignal.timeout(10_000) }));
+        return providers.all.filter((provider) => providers.connected.includes(provider.id)).flatMap((provider) => Object.entries(provider.models).filter(([id, model]) => model.status !== "deprecated" && !(provider.id === "opencode" && id.includes("-nano"))).map(([id, model]) => ({
+            id: `${provider.id}/${id}`, displayName: `${model.name || id} (${provider.name})`,
+            providerID: provider.id, modelID: id,
+            variants: Object.keys(model.variants ?? {}),
+        })));
+    }
     constructor(options) {
         this.options = options;
         this.state = {
@@ -170,10 +303,21 @@ export class OpenCodeServerAdapter {
         this.recordPendingWechatPromptMirrorSuppression(session.id, normalized);
         this.beginTrackedTurn(normalized, "wechat");
         try {
+            const selection = await this.getSessionForCurrentDirectory(session.id) ?? session;
             const result = await this.client.session.promptAsync({
                 sessionID: session.id,
                 directory: this.options.cwd,
                 workspace: session.workspaceID ?? this.activeWorkspaceId ?? undefined,
+                ...(selection.agent ? { agent: selection.agent } : {}),
+                ...(selection.model
+                    ? {
+                        model: {
+                            providerID: selection.model.providerID,
+                            modelID: selection.model.id,
+                        },
+                        variant: selection.model.variant ?? "default",
+                    }
+                    : {}),
                 parts: [{ type: "text", text: normalized }],
             });
             if (result.error !== undefined) {
@@ -411,6 +555,7 @@ export class OpenCodeServerAdapter {
         this.pendingLocalSessionCreateFollowUntilMs = 0;
         this.clearObservedMessageTracking();
         this.recentSdkEventObservations.clear();
+        this.previousAgentBySession.clear();
         this.outputBatcher.clear();
         this.clearStreamedPartState();
         this.clearPendingPermissionState();
@@ -1535,7 +1680,11 @@ export class OpenCodeServerAdapter {
             return;
         }
         const sessionId = this.extractSessionId(properties);
-        if (!sessionId || sessionId !== this.activeSessionId) {
+        if (!sessionId) {
+            return;
+        }
+        this.previousAgentBySession.delete(sessionId);
+        if (sessionId !== this.activeSessionId) {
             return;
         }
         this.clearTrackedTurnForLocalSessionSwitch();