openmausbot 0.1.80 → 0.1.81

package/dist-server/server/cli.js

@@ -90,6 +90,15 @@ export function parseArgs(argv, env = process.env) {
                 options.tunnel = true;
             else if (arg === "--client")
                 options.client = true;
+            // Which phone is about to scan, for a run with nobody at the keyboard.
+            // `docker compose exec … pair` and any scripted pairing never reach the
+            // interactive chooser, and only an Android phone needs a different QR.
+            else if (arg === "--phone") {
+                const kind = value().toLowerCase();
+                if (kind !== "ios" && kind !== "android")
+                    return { error: "--phone takes ios or android" };
+                options.phone = kind;
+            }
             else if (arg === "--no-pair")
                 options.pair = false;
             else if (arg === "--no-open")
@@ -194,7 +203,8 @@ export const USAGE = `openmausbot — your team of AI bots, ready in a few steps
   openmausbot start [the same options as serve]
   openmausbot serve [--port 8799] [--data-dir DIR] [--label NAME]
                     [--public-url https://host] [--tailscale | --tunnel | --domain HOST] [--no-pair]
-  openmausbot pair  [--label NAME] [--client] [--public-url https://host]
+  openmausbot pair  [--label NAME] [--client] [--phone ios|android]
+                    [--public-url https://host]
   openmausbot sessions [revoke ID]
   openmausbot status
   openmausbot login [--email you@example.com]
@@ -381,25 +391,73 @@ async function showPhonePairing(options, origin, log) {
     }
     for (const line of phonePairingInstructions(options.phone ?? "ios", { origin: origin, ready }))
         log(line);
-    log(await mintPairing(options.port, { client: true, label: options.label ?? (options.phone === "android" ? "Android" : "iPhone / iPad"), publicUrl: origin }));
+    log(await mintPairing(options.port, { client: true, label: options.label ?? (options.phone === "android" ? "Android" : "iPhone / iPad"), publicUrl: origin, phone: options.phone }));
     log("Waiting for you to connect on the phone. Keep this terminal and the code private.");
     return true;
 }
-/** The pairing link a device opens, rendered as text and a QR code. */
+/** The pairing link a device opens, rendered as text and a QR code.
+ *
+ * One window has two links. `url` opens the web app and is what a browser and
+ * the iOS app read. `inviteUrl` is the openmausbot:// scheme the native
+ * companion scanners accept, and it is the ONLY thing an Android app can
+ * scan — its parser rejects any https QR outright. Which one becomes the QR
+ * therefore depends on which app is about to scan it; the other is still
+ * printed as text so neither route is hidden. */
 export function pairingBlock(input) {
     const lines = [`pairing code:  ${input.code}`, `expires:       ${new Date(input.expiresAt).toLocaleTimeString()} (single use)`];
-    if (input.url) {
-        lines.push(`open or scan:  ${input.url}`);
-        lines.push("");
-        lines.push(qrToString(input.url));
-    }
-    else {
+    if (!input.url && !input.inviteUrl) {
         lines.push(`open:          /pair on the address you use for this server, and type the code`);
         if (input.hint)
             lines.push(`               (${input.hint})`);
+        return lines.join("\n");
+    }
+    // One QR, and it belongs to whichever app is about to scan it. Android's
+    // scanner rejects an https payload outright, so an Android phone gets the
+    // app-scheme invite; everyone else gets the web link, which Camera opens
+    // and which the iOS app also accepts.
+    const scanInvite = input.phone === "android" && !!input.inviteUrl;
+    // Print every link this window has, and label them by what the QR below
+    // actually encodes: "scan" belongs only to the link it is a picture of. A
+    // link that is named but never shown is worse than one that is absent —
+    // the iOS app takes a pasted invite, so the text form is the fallback when
+    // a QR cannot be scanned off a terminal.
+    if (input.url)
+        lines.push(scanInvite ? `web browser:   ${input.url}` : `open or scan:  ${input.url}`);
+    if (input.inviteUrl)
+        lines.push(`phone app:     ${input.inviteUrl}`);
+    const target = scanInvite ? input.inviteUrl : input.url;
+    if (target) {
+        lines.push("");
+        lines.push(qrToString(target));
+        lines.push("");
+        if (scanInvite) {
+            lines.push(`Scan that in the OpenMausBot app. For a browser instead, open the web`);
+            lines.push(`address above and type the code.`);
+        }
+        else if (input.phone === "android") {
+            // Android asked for an app invite this server cannot build. Say so,
+            // rather than leave a QR its scanner will reject under instructions
+            // telling someone to scan it.
+            lines.push(`That QR opens the web app. The Android app needs the phone-app link,`);
+            lines.push(`which this server cannot build without a public address: set`);
+            lines.push(`OMB_PUBLIC_URL, or open the web address above and type the code.`);
+        }
+        else if (input.inviteUrl) {
+            lines.push(`Scan that with Camera for the browser, or paste the phone-app link`);
+            lines.push(`above into the OpenMausBot app.`);
+        }
     }
     return lines.join("\n");
 }
+/** The scheme and host of a link, or null if it is not one we can dial. */
+function originOf(link) {
+    try {
+        return new URL(link).origin;
+    }
+    catch {
+        return null;
+    }
+}
 export function qrToString(text) {
     let out = "";
     qrcode.generate(text, { small: true }, (rendered) => {
@@ -417,7 +475,21 @@ async function mintPairing(port, options) {
     if (status !== 200)
         throw new Error(`server refused to mint a pairing code: ${typeof body?.error === "string" ? body.error : status}`);
     const url = options.publicUrl ? `${options.publicUrl}/pair#code=${body.code}` : typeof body.url === "string" ? body.url : null;
-    return pairingBlock({ code: body.code, url, expiresAt: body.expiresAt, hint: typeof body.hint === "string" ? body.hint : null });
+    // A server too old to mint a credential simply has no invite: the web link
+    // still works, so an upgrade is never required to pair a browser.
+    // The address the phone will dial. `--public-url` wins, exactly as it does
+    // for the web link above: a server behind someone else's proxy often does
+    // not know its own public name, which is what that flag is for. Gate on the
+    // credential, never on the server's own invite — a server started without
+    // OMB_PUBLIC_URL returns a credential and no invite, and gating on the
+    // invite would throw away a secret the CLI has every part it needs to use.
+    const address = options.publicUrl ?? (typeof body.url === "string" ? originOf(body.url) : null);
+    // A server too old to mint a credential simply has no invite: the web link
+    // still works, so an upgrade is never required to pair a browser.
+    const invite = typeof body.credential === "string" && address
+        ? `openmausbot://pair?address=${encodeURIComponent(address)}&token=${encodeURIComponent(body.credential)}${typeof body.serverName === "string" ? `&name=${encodeURIComponent(body.serverName)}` : ""}`
+        : typeof body.inviteUrl === "string" ? body.inviteUrl : null;
+    return pairingBlock({ code: body.code, url, inviteUrl: invite, expiresAt: body.expiresAt, hint: typeof body.hint === "string" ? body.hint : null, phone: options.phone });
 }
 // ── commands ───────────────────────────────────────────────────────────
 export async function runPair(options) {
@@ -450,7 +522,7 @@ export async function runPair(options) {
         }
         const ui = defaultSetupIo();
         try {
-            const selected = await ui.choose("Which phone are you connecting?", ["iPhone / iPad — app or Safari", "Android — web browser", "Cancel"], 0);
+            const selected = await ui.choose("Which phone are you connecting?", ["iPhone / iPad — app or Safari", "Android — app or browser", "Cancel"], 0);
             if (selected === 2)
                 return 0;
             launch = { ...launch, phone: selected === 0 ? "ios" : "android" };
@@ -463,7 +535,7 @@ export async function runPair(options) {
             return 130;
         }
     }
-    console.log(await mintPairing(options.port, { label: options.label, client: options.client, publicUrl: options.publicUrl }));
+    console.log(await mintPairing(options.port, { label: options.label, client: options.client, publicUrl: options.publicUrl, phone: options.phone }));
     if (options.client)
         console.log("(client scope: chat and approvals only; cannot change settings or pair others)");
     return 0;

package/dist-server/server/config.js

@@ -7,8 +7,8 @@ import { join } from "node:path";
 import { z } from "zod";
 import { normalizeImageGenerationUrl } from "../shared/image-generation.js";
 import { writeFileAtomic } from "./atomic.js";
-import { EFFORT_LEVELS } from "./contracts.js";
-import { parseStoredMcpServer } from "./mcp-registry.js";
+import { EFFORT_LEVELS, isModelVariant } from "./contracts.js";
+import { isRemoteMcpServer, parseStoredMcpServer } from "./mcp-registry.js";
 import { parseJson, schemaIssue } from "./schema.js";
 const optionalText = z.string().optional();
 const SSH_ALIAS = /^[A-Za-z0-9][A-Za-z0-9_.-]{0,127}$/;
@@ -19,6 +19,11 @@ export const MIN_ROOM_TURN_TIMEOUT_MINUTES = 1;
 export const MAX_ROOM_TURN_TIMEOUT_MINUTES = 1_440;
 export const DEFAULT_MAX_CONCURRENT_BOT_THREADS = 3;
 export const MAX_CONCURRENT_BOT_THREADS = 10;
+/** Bounds for threads.eventLogMaxBytes: the floor keeps the kept tail large
+ * enough to still serve the event inspector's recent-line window; the
+ * ceiling just rejects absurd hand edits. */
+export const MIN_THREAD_EVENT_LOG_BYTES = 256 * 1024;
+export const MAX_THREAD_EVENT_LOG_BYTES = 4 * 1024 * 1024 * 1024;
 export const DEFAULT_LOCAL_VM_MODE = "shared";
 export const DEFAULT_LOCAL_VM_MAX_INSTANCES = 2;
 export const MIN_LOCAL_VM_MAX_INSTANCES = 1;
@@ -212,6 +217,10 @@ const featureConfigSchema = z.object({
      * computer control to a workspace). Off until explicitly enabled; there is
      * no Settings toggle — see sharedComputersEnabled. */
     sharedComputers: z.boolean().optional(),
+    /** Claude bots also load the MCP servers and connectors from this
+     * machine's own Claude Code setup (Plugins → MCP servers switch). Off by
+     * default: each extra tool costs tokens on every model call. */
+    claudeUserMcp: z.boolean().optional(),
 });
 /** First-run progress. Kept in the workspace config rather than a browser so
  * it survives cleared site data and is shared by every paired client. Hint
@@ -238,7 +247,8 @@ const defaultModelSelectionSchema = z.object({
     instanceId: z.string().trim().min(1),
     model: z.string().trim().min(1),
     effort: z.enum(EFFORT_LEVELS).optional(),
-});
+    variant: z.string().refine(isModelVariant, "invalid model variant").optional(),
+}).refine((selection) => selection.variant === undefined || selection.effort === undefined, "choose either a model variant or an effort level");
 const appConfigSchema = z.object({
     /** Verified by the dedicated domain endpoint, never a generic config patch. */
     customDomain: z.string().optional(),
@@ -292,13 +302,16 @@ const appConfigSchema = z.object({
     /** Optional OpenCode key; persisted write-only and passed only to its child. */
     opencodeGo: z.object({ apiKey: optionalText }).optional(),
     /** Voice settings and the selected voice id. `provider` picks the
-     * engine: "elevenlabs" (default; needs a key), "system" (the Mac's
-     * built-in voices, no key), or "chatterbox" (a local OpenAI-compatible
-     * Chatterbox server; `baseUrl` and `model` are settings, not secrets). */
+     * engine: "elevenlabs" (default; needs `key`), "fish" (needs its own
+     * `fishKey`), "system" (the Mac's built-in voices, no key), or
+     * "chatterbox" (a local OpenAI-compatible Chatterbox server; `baseUrl`
+     * and `model` are settings, not secrets). Cloud keys stay separate so
+     * switching providers never overwrites or misuses the other key. */
     tts: z.object({
         key: optionalText,
+        fishKey: optionalText,
         voice: optionalText,
-        provider: z.enum(["elevenlabs", "system", "chatterbox"]).optional(),
+        provider: z.enum(["elevenlabs", "fish", "system", "chatterbox"]).optional(),
         baseUrl: z
             .string()
             .trim()
@@ -331,7 +344,12 @@ const appConfigSchema = z.object({
      * system language. Unknown tags degrade to English in the renderer. */
     language: optionalText,
     rooms: roomConfigSchema.optional(),
-    threads: z.object({ maxConcurrentPerBot: z.number().int().min(1).max(MAX_CONCURRENT_BOT_THREADS) }).strict().optional(),
+    threads: z.object({
+        maxConcurrentPerBot: z.number().int().min(1).max(MAX_CONCURRENT_BOT_THREADS),
+        /** Cap each per-thread events/ and native/ NDJSON log at this many
+         * bytes; absent (the default) keeps today's unbounded growth (#1280). */
+        eventLogMaxBytes: z.number().int().min(MIN_THREAD_EVENT_LOG_BYTES).max(MAX_THREAD_EVENT_LOG_BYTES).optional(),
+    }).strict().optional(),
     localVm: localVmConfigSchema.optional(),
     features: featureConfigSchema.optional(),
     onboarding: onboardingConfigSchema.optional(),
@@ -432,6 +450,12 @@ export function roomTurnTimeoutMinutes(cfg) {
 export function maxConcurrentBotThreads(cfg) {
     return cfg.threads?.maxConcurrentPerBot ?? DEFAULT_MAX_CONCURRENT_BOT_THREADS;
 }
+/** Size cap for each per-thread events/ and native/ NDJSON log. Null (the
+ * default) means unbounded growth — rotation is strictly opt-in (#1280). */
+export function threadEventLogMaxBytes(cfg) {
+    const cap = cfg.threads?.eventLogMaxBytes;
+    return typeof cap === "number" && Number.isFinite(cap) && cap > 0 ? cap : null;
+}
 export function localVmMode(cfg) {
     return cfg.localVm?.mode ?? DEFAULT_LOCAL_VM_MODE;
 }
@@ -463,6 +487,14 @@ export function builtInBrowserEnabled(cfg) {
 export function sharedComputersEnabled(cfg) {
     return cfg.features?.sharedComputers === true;
 }
+/** Claude bots also see the MCP servers of this machine's own Claude Code
+ * setup — the way Codex bots already read ~/.codex/config.toml. Off unless
+ * the person switched it on under Plugins → MCP servers; the Claude driver
+ * then omits --strict-mcp-config while keeping skills, hooks and the
+ * personal CLAUDE.md out. */
+export function claudeUserMcpEnabled(cfg) {
+    return cfg.features?.claudeUserMcp === true;
+}
 /** Config sections no provider driver reads. A write that touches only
  * these must not rebuild the fleet: rebuilding disposes every engine child
  * and reloads it, seconds of work that would also interrupt in-flight
@@ -583,6 +615,8 @@ export function loadConfig() {
     cfg.tts = { ...cfg.tts };
     if (process.env.OMB_TTS_KEY !== undefined)
         cfg.tts.key = process.env.OMB_TTS_KEY;
+    if (process.env.OMB_FISH_AUDIO_API_KEY !== undefined)
+        cfg.tts.fishKey = process.env.OMB_FISH_AUDIO_API_KEY;
     cfg.imageGen = { ...cfg.imageGen };
     if (process.env.OMB_OPENAI_IMAGE_KEY !== undefined)
         cfg.imageGen.key = process.env.OMB_OPENAI_IMAGE_KEY;
@@ -616,6 +650,7 @@ export function syncCredentialEnv(patch) {
         [patch.box?.token, "BOX_TOKEN"],
         [patch.opencodeGo?.apiKey, "OPENCODE_API_KEY"],
         [patch.tts?.key, "OMB_TTS_KEY"],
+        [patch.tts?.fishKey, "OMB_FISH_AUDIO_API_KEY"],
         [patch.imageGen?.key, "OMB_OPENAI_IMAGE_KEY"],
         [patch.imageGen?.customApiKey, "OMB_CUSTOM_IMAGE_KEY"],
     ];
@@ -658,6 +693,7 @@ export const WORKSPACE_CREDENTIAL_ENV = [
     "BOX_TOKEN",
     "OPENCODE_API_KEY",
     "OMB_TTS_KEY",
+    "OMB_FISH_AUDIO_API_KEY",
     "OMB_OPENAI_IMAGE_KEY",
     "OMB_CUSTOM_IMAGE_KEY",
     "COMPOSIO_API_KEY",
@@ -967,22 +1003,16 @@ export function customMcpServers(cfg, only) {
         // keeps getting every enabled server, as before this field existed
         if (only && !only.includes(name))
             continue;
-        if (raw && typeof raw === "object" && "url" in raw) {
-            skipMcpEntry(name, 'only stdio servers ("command") are supported so far — HTTP transports are a planned follow-up');
-            continue;
-        }
         const parsed = parseStoredMcpServer(name, raw);
         if (!parsed.ok) {
-            skipMcpEntry(name, `${parsed.error} Expected { "command": "npx", "args": [...], "env": { ... } }`);
+            skipMcpEntry(name, `${parsed.error} Expected { "command": "npx", "args": [...], "env": { ... } } or { "type": "http", "url": "https://…", "headers": { ... } }`);
             continue;
         }
         if (!parsed.server.enabled)
             continue;
-        out[name] = {
-            command: parsed.server.command,
-            args: parsed.server.args,
-            env: parsed.server.env,
-        };
+        out[name] = isRemoteMcpServer(parsed.server)
+            ? { type: parsed.server.type, url: parsed.server.url, headers: parsed.server.headers }
+            : { command: parsed.server.command, args: parsed.server.args, env: parsed.server.env };
     }
     return out;
 }

package/dist-server/server/container-computer.js

@@ -282,6 +282,13 @@ export function localVmRecreatableOnDemand(status) {
         && status.container === "missing"
         && status.create_supported;
 }
+/** Whether Auto may attach this Local VM without a person choosing it: the
+ * desktop is ready, or its image is prepared and the container can simply be
+ * recreated after idling away. Anything else — no runtime, daemon down, image
+ * never prepared, an unmanaged or unsafe container — stays the person's call. */
+export function autoLocalVmAttachable(status) {
+    return status.ready === true || localVmRecreatableOnDemand(status);
+}
 function statusProblem(status) {
     if (!status.runtime)
         return "Install a supported container runtime first";

package/dist-server/server/contracts.js

@@ -19,6 +19,11 @@ export const EFFORT_LEVELS = ["none", "low", "medium", "high", "xhigh", "max"];
 export function isEffortLevel(value) {
     return typeof value === "string" && EFFORT_LEVELS.includes(value);
 }
+/** Variants are opaque provider IDs, not the cross-engine effort enum. */
+export function isModelVariant(value) {
+    return typeof value === "string" && value.length > 0 && value.length <= 256 &&
+        value.trim() === value && !/\p{Cc}/u.test(value);
+}
 let eventCounter = 0;
 export const newEventId = () => `ev-${Date.now().toString(36)}-${(eventCounter++).toString(36)}`;
 export const newId = () => crypto.randomUUID();

package/dist-server/server/default-model-selection.js

@@ -5,6 +5,7 @@ export function selectDefaultModelSelection(instances, preferred) {
         const instance = instances.find((candidate) => candidate.instanceId === preferred.instanceId);
         if (instance?.snapshot.state !== "available" ||
             instance.snapshot.authenticated === false ||
+            (preferred.variant !== undefined && !instance.capabilities?.modelVariants) ||
             !(instance.models.default === preferred.model || instance.models.options.some((model) => model.id === preferred.model))) {
             return { instanceId: "", model: "" };
         }

package/dist-server/server/drivers/acp/core.js

@@ -12,7 +12,8 @@
 // unless the agent explicitly offered an `allow`-kind option — option ORDER
 // is never a security contract). session/load REPLAYS history as ordinary
 // session/update notifications, so updates are double-gated: nothing emits
-// before the prompt is sent, and `_meta.isReplay` updates are dropped.
+// before the prompt is sent, and `_meta.isReplay` updates are dropped. Session
+// configuration is the exception: its live updates apply before prompting too.
 import { homedir } from "node:os";
 import { lstat, mkdir, readFile, realpath, stat, writeFile } from "node:fs/promises";
 import { basename, dirname, isAbsolute, relative, resolve } from "node:path";
@@ -37,6 +38,32 @@ const SESSION_CONFIG_TIMEOUT = envOr("OPENMAUS_ACP_SESSION_CONFIG_TIMEOUT_MS", 3
 const NEW_SESSION_TIMEOUT = envOr("OPENMAUS_ACP_NEW_SESSION_TIMEOUT_MS", 300_000);
 const LOAD_SESSION_TIMEOUT = envOr("OPENMAUS_ACP_LOAD_SESSION_TIMEOUT_MS", 120_000); // history replay on a long thread is slow
 const CLIENT_FILE_MAX_BYTES = 8 * 1024 * 1024;
+function acpVariantOption(result) {
+    const option = (Array.isArray(result?.configOptions) ? result.configOptions : []).find((entry) => entry?.type === "select" && typeof entry.id === "string"
+        && (entry.id === "effort" || entry.category === "thought_level"));
+    if (!option)
+        return;
+    const options = [];
+    const seen = new Set();
+    const collect = (entries) => {
+        if (!Array.isArray(entries))
+            return;
+        for (const entry of entries) {
+            if (typeof entry?.value === "string" && !seen.has(entry.value)) {
+                seen.add(entry.value);
+                options.push({ id: entry.value, label: typeof entry.name === "string" ? entry.name : entry.value });
+            }
+            else if (Array.isArray(entry?.options))
+                collect(entry.options);
+        }
+    };
+    collect(option.options);
+    return {
+        configId: option.id,
+        options,
+        ...(typeof option.currentValue === "string" ? { currentValue: option.currentValue } : {}),
+    };
+}
 const TOOL_LOG_TEXT_LIMIT = 64_000;
 async function readAcpImageBlocks(images) {
     return Promise.all(images.map(async (image) => ({
@@ -224,10 +251,6 @@ export function createAcpDriver(support) {
                 turnId,
                 createdAt: new Date().toISOString(),
             });
-            // ACP session mcpServers: stdio is the baseline every ACP agent
-            // supports (mcpCapabilities.http/.sse only add EXTRA transports), so
-            // an injected stdio proxy — e.g. the peer-agent comms tool — attaches
-            // fine here. env is the ACP {name,value}[] shape.
             const acpMcpServers = (turn) => {
                 const servers = [];
                 const acpEnv = (env) => Object.entries(env).map(([name, value]) => ({ name, value: String(value) }));
@@ -266,6 +289,10 @@ export function createAcpDriver(support) {
                 for (const [name, server] of Object.entries(turn.integrations?.custom ?? {})) {
                     if (servers.some((existing) => existing.name === name))
                         continue;
+                    if ("url" in server) {
+                        servers.push({ type: server.type, name, url: server.url, headers: acpEnv(server.headers) });
+                        continue;
+                    }
                     servers.push({ name, command: server.command, args: server.args, env: acpEnv(server.env) });
                 }
                 return servers;
@@ -331,6 +358,38 @@ export function createAcpDriver(support) {
                 const asks = new Map();
                 let nextId = 1;
                 let sessionId = null;
+                let sessionConfigResult = null;
+                const modelOf = (result) => {
+                    const option = (Array.isArray(result?.configOptions) ? result.configOptions : []).find((entry) => entry?.id === (support.selectModel?.configId ?? "model"));
+                    return typeof option?.currentValue === "string" ? option.currentValue : null;
+                };
+                const receiveModelVariants = (result) => {
+                    sessionConfigResult = result;
+                    if (!support.modelVariants)
+                        return;
+                    const nativeModel = modelOf(result) ?? cliTurn.model;
+                    if (!nativeModel)
+                        return;
+                    const option = acpVariantOption(result);
+                    emit({
+                        ...base(threadId, turnId),
+                        type: "session.model-variants",
+                        model: nativeModel === cliTurn.model ? (turn.model ?? nativeModel) : nativeModel,
+                        variants: {
+                            options: option?.options ?? [],
+                            ...(option?.currentValue !== undefined ? { currentValue: option.currentValue } : {}),
+                        },
+                    });
+                };
+                const requestedVariantOption = () => {
+                    if (!support.modelVariants)
+                        throw new Error(`${support.displayName} does not support model variants`);
+                    const option = acpVariantOption(sessionConfigResult);
+                    if (!option || !option.options.some((entry) => entry.id === turn.variant)) {
+                        throw new Error(`${support.displayName} does not advertise variant ${turn.variant} for this model`);
+                    }
+                    return option;
+                };
                 let interruptTimer = null;
                 const rpcPending = new Map();
                 const send = (obj) => {
@@ -340,7 +399,7 @@ export function createAcpDriver(support) {
                     catch { }
                     appendNative(threadId, { dir: "out", source: SOURCE, msg: nativeLogMessage(obj) });
                 };
-                const request = (method, params, timeoutMs) => new Promise((resolve, reject) => {
+                const request = (method, params, timeoutMs, receive) => new Promise((resolve, reject) => {
                     const id = nextId++;
                     let timer = null;
                     if (timeoutMs) {
@@ -350,7 +409,13 @@ export function createAcpDriver(support) {
                         }, timeoutMs);
                         timer.unref?.();
                     }
-                    rpcPending.set(id, { resolve, reject, timer });
+                    rpcPending.set(id, {
+                        // Consume configuration in wire order: an update following this
+                        // response may arrive before the awaiting continuation resumes.
+                        resolve: (result) => { receive?.(result); resolve(result); },
+                        reject,
+                        timer,
+                    });
                     send({ jsonrpc: "2.0", id, method, params });
                 });
                 const stop = () => killCliTree(child);
@@ -566,7 +631,14 @@ export function createAcpDriver(support) {
                     if (msg.method !== "session/update")
                         return;
                     const p = msg.params ?? {};
-                    if (!state.promptSent || p._meta?.isReplay === true)
+                    if (p._meta?.isReplay === true)
+                        return;
+                    if (support.modelVariants && p.update?.sessionUpdate === "config_option_update") {
+                        if (!state.settled && sessionId && p.sessionId === sessionId)
+                            receiveModelVariants(p.update);
+                        return;
+                    }
+                    if (!state.promptSent)
                         return;
                     const u = p.update ?? {};
                     switch (u.sessionUpdate) {
@@ -737,6 +809,10 @@ export function createAcpDriver(support) {
                         if (images.length && support.images === true && !runtimeAcceptsImages) {
                             throw new Error(`${support.displayName} is configured for image attachments, but this installed runtime does not advertise ACP image input. Update the ${support.displayName} CLI or send the message without an image.`);
                         }
+                        // stdio is every agent's baseline; a url server rides only with
+                        // an agent that advertised its transport, so an agent without
+                        // http/sse never sees an entry it would refuse the session over
+                        const sessionServers = mcpServers.filter((server) => !("type" in server) || init?.agentCapabilities?.mcpCapabilities?.[server.type] === true);
                         const cursor = typeof turn.resumeCursor === "string" ? turn.resumeCursor : null;
                         // a fresh native session forgets what the previous one allowed
                         if (!cursor)
@@ -744,17 +820,22 @@ export function createAcpDriver(support) {
                         let sessionResult = null;
                         if (cursor) {
                             try {
-                                sessionResult = await request(support.resumeMethod === "resume" ? "session/resume" : "session/load", { sessionId: cursor, cwd, mcpServers }, LOAD_SESSION_TIMEOUT);
-                                if (sessionResult)
-                                    sessionId = cursor;
+                                sessionResult = await request(support.resumeMethod === "resume" ? "session/resume" : "session/load", { sessionId: cursor, cwd, mcpServers: sessionServers }, LOAD_SESSION_TIMEOUT, (result) => {
+                                    if (result) {
+                                        sessionId = cursor;
+                                        receiveModelVariants(result);
+                                    }
+                                });
                             }
                             catch {
                                 /* session gone, load unsupported, or too slow — start fresh */
                             }
                         }
                         if (!sessionId) {
-                            sessionResult = await request("session/new", { cwd, mcpServers }, NEW_SESSION_TIMEOUT);
-                            sessionId = typeof sessionResult?.sessionId === "string" ? sessionResult.sessionId : null;
+                            sessionResult = await request("session/new", { cwd, mcpServers: sessionServers }, NEW_SESSION_TIMEOUT, (result) => {
+                                sessionId = typeof result?.sessionId === "string" ? result.sessionId : null;
+                                receiveModelVariants(result);
+                            });
                             if (!sessionId)
                                 throw new Error("session/new returned no sessionId");
                         }
@@ -774,11 +855,10 @@ export function createAcpDriver(support) {
                         try {
                             if (support.selectModel) {
                                 const { configId } = support.selectModel;
-                                const currentOf = (r) => (Array.isArray(r?.configOptions) ? r.configOptions : []).find((o) => o?.id === configId)
-                                    ?.currentValue ?? null;
-                                selectedModel = currentOf(sessionResult);
+                                selectedModel = modelOf(sessionConfigResult);
                                 if (cliTurn.model && cliTurn.model !== selectedModel) {
-                                    selectedModel = currentOf(await request("session/set_config_option", { sessionId, configId, value: cliTurn.model }, INIT_TIMEOUT));
+                                    sessionResult = await request("session/set_config_option", { sessionId, configId, value: cliTurn.model }, INIT_TIMEOUT, receiveModelVariants);
+                                    selectedModel = modelOf(sessionConfigResult);
                                     // an agent that answers OK but keeps its old model is worse than
                                     // one that errors: it burns a paid turn on the wrong thing
                                     if (selectedModel !== cliTurn.model) {
@@ -802,6 +882,13 @@ export function createAcpDriver(support) {
                                 if (!selectedModel && cliTurn.model)
                                     selectedModel = cliTurn.model;
                             }
+                            if (turn.variant !== undefined) {
+                                const option = requestedVariantOption();
+                                await request("session/set_config_option", { sessionId, configId: option.configId, value: turn.variant }, SESSION_CONFIG_TIMEOUT, receiveModelVariants);
+                                if (requestedVariantOption().currentValue !== turn.variant) {
+                                    throw new Error(`${support.displayName} did not apply variant ${turn.variant}`);
+                                }
+                            }
                         }
                         catch (error) {
                             // session.started is the only place the resume cursor is recorded,
@@ -810,7 +897,6 @@ export function createAcpDriver(support) {
                             throw error;
                         }
                         emitSessionStarted();
-                        state.promptSent = true;
                         const text = support.buildPromptText
                             ? support.buildPromptText(turn)
                             : turn.system
@@ -819,6 +905,13 @@ export function createAcpDriver(support) {
                         const imageBlocks = support.images === true && runtimeAcceptsImages
                             ? await readAcpImageBlocks(images)
                             : [];
+                        if (support.modelVariants && cliTurn.model && modelOf(sessionConfigResult) !== cliTurn.model) {
+                            throw new Error(`${support.displayName} changed model before the prompt`);
+                        }
+                        if (turn.variant !== undefined && requestedVariantOption().currentValue !== turn.variant) {
+                            throw new Error(`${support.displayName} changed variant before the prompt`);
+                        }
+                        state.promptSent = true;
                         const result = await request("session/prompt", {
                             sessionId,
                             prompt: [{ type: "text", text }, ...imageBlocks],
@@ -907,6 +1000,7 @@ export function createAcpDriver(support) {
                         images: support.images !== false,
                         nativeImageInput: support.images === true,
                         effortLevels: support.effortLevels,
+                        modelVariants: support.modelVariants === true,
                         // OpenMausBot supplies a per-bot approvalMode on every harness
                         // turn, which safely overrides a legacy instance fullAuto value.
                         // Direct adapter calls that omit it still fail closed in sendTurn.

package/dist-server/server/drivers/acp/opencode-go.js

@@ -97,12 +97,17 @@ export function parseOpenCodeModelsOutput(stdout) {
         const contextWindow = typeof limit.context === "number" && Number.isFinite(limit.context) && limit.context > 0
             ? Math.floor(limit.context)
             : undefined;
+        const variants = record.variants && typeof record.variants === "object" && !Array.isArray(record.variants)
+            ? Object.entries(record.variants).filter(([, settings]) => (settings && typeof settings === "object" && !Array.isArray(settings)
+                && settings.disabled !== true)).map(([id]) => ({ id, label: labelForModel(id) }))
+            : undefined;
         seen.add(slug);
         options.push({
             id: slug,
             label: `${providerLabel(provider)} · ${name}`,
             ...(localModelRecord(record) ? { custom: true, loaded: true } : {}),
             ...(contextWindow ? { contextWindow } : {}),
+            ...(variants ? { variants } : {}),
         });
     };
     for (const line of stdout.split(/\r?\n/u)) {
@@ -330,6 +335,7 @@ const support = (loadCatalog) => ({
     spawnArgs: () => ["acp"],
     credentialEnv: ["OPENCODE_API_KEY"],
     selectModel: { configId: "model" },
+    modelVariants: true,
     resolveTurnModel: (model, env) => model
         ? ensureOpenCodeInjectModel(normalizeLegacyOpenCodeModel(model, env), env)
         : model,