@unlinearity/cli-wechat-bridge 1.1.6 → 1.2.1

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

@@ -1,3 +1,9 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// Copyright (c) 2026 UNLINEARITY <unlinearity@gmail.com>
+// Source: https://github.com/UNLINEARITY/CLI-WeChat-Bridge
+// This file is part of CLI-WeChat-Bridge. Modifications and derivative works
+// must be released under AGPL-3.0-or-later with full source code; see
+// LICENSE.txt. Network services built on it must offer source to users.
 import fs from "node:fs";
 import path from "node:path";
 import crypto from "node:crypto";
@@ -6,9 +12,11 @@ import { detectCliApproval, } from "./bridge-utils.js";
 import { normalizeOutput, nowIso, summarizeOutput, truncatePreview, } from "../core/text-utils.js";
 import { AbstractPtyAdapter } from "./bridge-adapters.core.js";
 import { killProcessTreeSync } from "./bridge-process-reaper.js";
+import { CodexVisibleThreadProxy } from "./codex-visible-thread-proxy.js";
 import * as shared from "./bridge-adapters.shared.js";
-import { requestCodexVisibleThreadSwitch } from "../companion/codex-visible-client-link.js";
-import { ensureWorkspaceChannelDir } from "../wechat/channel-config.js";
+import { requestCodexVisibleClientShutdown, requestCodexVisibleThreadSwitch, } from "../companion/codex-visible-client-link.js";
+import { readLocalCompanionEndpoint } from "../companion/local-companion-link.js";
+import { appendBoundedLog as appendBridgeLog, BRIDGE_LOG_FILE, 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) {
     const match = output.match(/\b(\d+\.\d+\.\d+)\b/);
@@ -21,7 +29,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 <= 157;
 }
 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;
@@ -73,11 +81,14 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
     appServer = null;
     nativeProcess = null;
     appServerPort = null;
+    visibleThreadProxy = null;
+    visibleOutOfWorkspaceThreadId = null;
     appServerShuttingDown = false;
     appServerLog = "";
     appServerAuthToken = null;
     appServerAuthTokenFilePath = null;
     rpcSocket = null;
+    lastRpcCloseDetail = "";
     rpcShuttingDown = false;
     rpcReconnectPromise = null;
     cleanPanelExitInProgress = false;
@@ -86,6 +97,7 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
     subscribedThreadIds = new Set();
     pendingThreadSubscriptions = new Map();
     sharedThreadId = null;
+    previousCollaborationMode = null;
     announcedThreadId = null;
     localThreadFollowBlockedUntilMs = 0;
     pendingThreadStatusChecks = new Map();
@@ -157,8 +169,18 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         this.setStatus("starting", `Codex protocol compatibility: ${compatibility}.`);
         await this.startAppServer();
         await this.connectRpcClient();
-        await this.restoreInitialSharedThreadIfNeeded();
         try {
+            if (this.isHeadlessRuntimeMode() && this.appServerPort && this.appServerAuthToken) {
+                const trace = (message) => appendBridgeLog(BRIDGE_LOG_FILE, `[${nowIso()}] codex_visible_proxy: ${message}\n`);
+                this.visibleThreadProxy = await CodexVisibleThreadProxy.start({
+                    upstreamUrl: `ws://${CODEX_APP_SERVER_HOST}:${this.appServerPort}`,
+                    token: this.appServerAuthToken,
+                    onTrace: trace,
+                    onThreadOpened: (threadId, cwd) => this.handleVisibleCodexThreadOpened(threadId, cwd, trace),
+                    onVisibleTurn: (threadId) => this.handleVisibleCodexTurn(threadId, trace),
+                });
+            }
+            await this.restoreInitialSharedThreadIfNeeded();
             if (this.isNativePanelMode()) {
                 await this.startNativeClient();
             }
@@ -182,6 +204,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 +277,76 @@ 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) {
+        this.assertVisibleCodexWorkspace();
+        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) {
+        this.assertVisibleCodexWorkspace();
+        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 +414,7 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         return true;
     }
     async dispose() {
+        await this.shutdownVisibleClient();
         this.resetTurnTracking({ preserveThread: false });
         if (this.isEmbeddedCliMode()) {
             this.detachLocalInputForwarding();
@@ -346,6 +446,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;
@@ -360,7 +479,7 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
             renderMode: "headless",
             bridgeOwnerPid: process.pid,
             serverPort: this.appServerPort,
-            serverUrl: `ws://${CODEX_APP_SERVER_HOST}:${this.appServerPort}`,
+            serverUrl: this.visibleThreadProxy?.url ?? `ws://${CODEX_APP_SERVER_HOST}:${this.appServerPort}`,
             remoteAuthTokenEnv: CODEX_REMOTE_AUTH_TOKEN_ENV,
             cwd: this.options.cwd,
             command: this.options.command,
@@ -916,6 +1035,7 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         }
     }
     async sendPanelTurn(text) {
+        this.assertVisibleCodexWorkspace();
         if (this.isNativePanelMode() && !this.nativeProcess) {
             throw new Error("codex panel is not running.");
         }
@@ -1064,6 +1184,8 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
             });
             this.appServer = null;
             this.appServerPort = null;
+            void this.visibleThreadProxy?.close();
+            this.visibleThreadProxy = null;
             this.appServerShuttingDown = false;
             this.deleteAppServerAuthTokenFile();
             this.appServerAuthToken = null;
@@ -1086,6 +1208,8 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
             });
             this.appServer = null;
             this.appServerPort = null;
+            void this.visibleThreadProxy?.close();
+            this.visibleThreadProxy = null;
             this.appServerShuttingDown = false;
             this.deleteAppServerAuthTokenFile();
             this.appServerAuthToken = null;
@@ -1192,8 +1316,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 +1355,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 +1394,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 +1432,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 +1585,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 +1611,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.`);
         }
@@ -1549,6 +1680,7 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
                 reason: "wechat_resume",
                 notify: true,
             });
+            this.clearVisibleCodexWorkspaceBlock();
             this.bridgeResumeReplayThreadId = targetThreadId;
             this.bridgeResumeReplayUntilMs = Date.now() + CODEX_RESUME_REPLAY_SETTLE_MS;
             this.setStatus("starting", `Codex resume committed thread ${targetThreadId.slice(0, 12)}.`);
@@ -1770,6 +1902,7 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         if (!options.preserveThread) {
             this.clearPendingThreadAnnouncement();
             this.announcedThreadId = null;
+            this.visibleOutOfWorkspaceThreadId = null;
         }
         if (!options.preserveThread) {
             this.updateSharedThread(null);
@@ -1889,6 +2022,62 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         }, CODEX_LOCAL_THREAD_ANNOUNCE_SETTLE_MS);
         pending.timer.unref?.();
     }
+    handleVisibleCodexThreadOpened(threadId, cwd, trace) {
+        if (this.pendingVisibleResume || this.shuttingDown) {
+            trace?.(`ignored thread=${threadId.slice(0, 12)} reason=bridge_switch`);
+            return;
+        }
+        if (cwd && normalizeComparablePath(cwd) !== normalizeComparablePath(this.options.cwd)) {
+            trace?.(`paused thread=${threadId.slice(0, 12)} reason=workspace`);
+            this.interruptWechatTurnForLocalThreadSwitch(threadId);
+            this.clearPendingThreadAnnouncement();
+            this.pendingThreadFollowId = null;
+            if (this.visibleOutOfWorkspaceThreadId !== threadId) {
+                this.visibleOutOfWorkspaceThreadId = threadId;
+                this.emit({
+                    type: "notice",
+                    level: "warning",
+                    text: `The visible Codex terminal switched to ${cwd}, outside the bridge workspace ${this.options.cwd}. WeChat input is paused instead of being sent to the previous session. Resume a session from the bridge workspace, or restart the bridge in ${cwd}.`,
+                    timestamp: nowIso(),
+                });
+            }
+            return;
+        }
+        this.clearVisibleCodexWorkspaceBlock();
+        trace?.(`follow thread=${threadId.slice(0, 12)} source=visible_open`);
+        this.trackLocalSharedThread(threadId, { reason: "local_follow", signal: "visible_request" });
+    }
+    handleVisibleCodexTurn(threadId, trace) {
+        if (this.pendingVisibleResume || this.shuttingDown)
+            return;
+        if (threadId === this.sharedThreadId) {
+            this.clearVisibleCodexWorkspaceBlock();
+            return;
+        }
+        if (!findCodexSessionFile(this.options.cwd, Date.now(), { threadId })) {
+            trace?.(`ignored thread=${threadId.slice(0, 12)} reason=workspace_or_unpersisted`);
+            return;
+        }
+        this.clearVisibleCodexWorkspaceBlock();
+        trace?.(`follow thread=${threadId.slice(0, 12)} source=visible_turn`);
+        this.trackLocalSharedThread(threadId, { reason: "local_follow", signal: "visible_request" });
+    }
+    clearVisibleCodexWorkspaceBlock() {
+        if (!this.visibleOutOfWorkspaceThreadId)
+            return;
+        this.visibleOutOfWorkspaceThreadId = null;
+        this.emit({
+            type: "notice",
+            level: "info",
+            text: `The visible Codex terminal is back in the bridge workspace ${this.options.cwd}. WeChat input has resumed.`,
+            timestamp: nowIso(),
+        });
+    }
+    assertVisibleCodexWorkspace() {
+        if (this.visibleOutOfWorkspaceThreadId) {
+            throw new Error(`The visible Codex terminal is outside the bridge workspace ${this.options.cwd}. WeChat input is paused; resume a session from this workspace or restart the bridge in the terminal's workspace.`);
+        }
+    }
     trackLocalSharedThread(threadId, options) {
         const weakSignal = options.signal === "status_changed" ||
             options.signal === "thread_started" ||
@@ -1896,7 +2085,7 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         if (weakSignal && Date.now() < this.localThreadFollowBlockedUntilMs) {
             return;
         }
-        if (options.signal === "user_message" || options.signal === "turn_started") {
+        if (options.signal === "user_message" || options.signal === "turn_started" || options.signal === "visible_request") {
             this.localThreadFollowBlockedUntilMs = 0;
         }
         if (this.pendingVisibleResume) {
@@ -2232,7 +2421,7 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
                 origin: "local",
             };
         }
-        if (method === "turn/started" && !this.activeTurn) {
+        if (method === "turn/started" && !this.activeTurn && !this.visibleThreadProxy) {
             return {
                 threadId,
                 turnId,
@@ -2506,7 +2695,7 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         if (!threadId) {
             return;
         }
-        if (this.pendingVisibleResume) {
+        if (this.pendingVisibleResume || this.visibleThreadProxy) {
             return;
         }
         if (this.isBridgeResumeReplay(threadId)) {
@@ -2585,7 +2774,7 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         if (!threadId) {
             return;
         }
-        if (this.isBridgeResumeReplay(threadId)) {
+        if (this.visibleThreadProxy || this.isBridgeResumeReplay(threadId)) {
             return;
         }
         if (this.isRecentlyBridgeOwnedThread(threadId)) {
@@ -2863,6 +3052,9 @@ export class CodexPtyAdapter extends AbstractPtyAdapter {
         this.rememberCompletedTurn(turnId);
     }
     async stopAppServer() {
+        const visibleThreadProxy = this.visibleThreadProxy;
+        this.visibleThreadProxy = null;
+        await visibleThreadProxy?.close();
         if (!this.appServer) {
             this.appServerPort = null;
             this.appServerShuttingDown = false;

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

@@ -1,3 +1,9 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// Copyright (c) 2026 UNLINEARITY <unlinearity@gmail.com>
+// Source: https://github.com/UNLINEARITY/CLI-WeChat-Bridge
+// This file is part of CLI-WeChat-Bridge. Modifications and derivative works
+// must be released under AGPL-3.0-or-later with full source code; see
+// LICENSE.txt. Network services built on it must offer source to users.
 import net from "node:net";
 import path from "node:path";
 import { spawn as spawnPty } from "node-pty";
@@ -15,7 +21,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 +172,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 +627,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;