openmausbot 0.1.78 → 0.1.80

package/dist-server/server/drivers/codex.js

@@ -12,24 +12,37 @@
 import { existsSync } from "node:fs";
 import { homedir } from "node:os";
 import { stripWorkspaceCredentialEnv } from "../config.js";
-import { computerProxyEnv } from "../container-computer.js";
 import { describeSpawnFailure, execCli, killCliTree, spawnCli } from "../procs.js";
-import { SPAWNED_PROXIES } from "../proxy-paths.js";
 import { isHarnessOwnedMcpEnvName } from "../mcp-registry.js";
 import { newEventId, newId } from "../contracts.js";
 import { decodeCodexSelection, readCodexModelCatalog, STATIC_CODEX_MODELS } from "./codex-catalog.js";
 import { codexLocalProviderArgs } from "./local-inject.js";
 import { augmentedPath, splitCliString } from "../env-path.js";
-import { classifyError, computeBackoff, RETRY_MAX_ATTEMPTS } from "./retry.js";
+import { classifyError, computeBackoff, interruptibleDelay, RETRY_MAX_ATTEMPTS } from "./retry.js";
 import { appendNative } from "./native.js";
 import { commandSummary, toolDetailPreview } from "../tool-summary.js";
 import { codexDeveloperInstructions, syncCodexInstructions } from "./codex-instructions.js";
 import { CodexDeviceAuthController } from "./codex-device-auth.js";
 import { codexAccountEmail } from "./codex-identity.js";
+import { classifyResumeFailure, mayReplay, recoveryPromptFor } from "../resume-recovery.js";
 export { decodeCodexSelection, readCodexModelCatalog, STATIC_CODEX_MODELS } from "./codex-catalog.js";
 const DRIVER_KIND = "codex";
 const ASTRA_MODEL_ID = "gpt-6-astra";
 const ASTRA_MIN_CODEX_VERSION = [0, 153, 1];
+class CodexRpcError extends Error {
+    code;
+    constructor(error) {
+        super(error.message ?? JSON.stringify(error));
+        this.code = error.code;
+    }
+}
+function missingNativeCodexThread(error, cursor) {
+    // Codex's local thread/resume rejection, verified with an empty native home.
+    // A generic 404, auth error, timeout or prose mentioning a missing thread is
+    // not evidence that the native history was lost. Unknown versions fail closed.
+    return error instanceof CodexRpcError && error.code === -32600 &&
+        error.message === `no rollout found for thread id ${cursor}`;
+}
 /** Whether an installed Codex predates the release that exposes GPT-6 Astra
  * through app-server. Unknown version formats stay quiet: a bad guess should
  * never nag someone whose custom build may already support the model. */
@@ -81,8 +94,33 @@ function decodeConfig(raw) {
     return {
         cli: typeof o.cli === "string" ? o.cli : "codex",
         fullAuto: o.fullAuto === true,
+        ...(o.managed && typeof o.managed === "object" ? { managed: decodeManagedCodex(o.managed) } : {}),
     };
 }
+function decodeManagedCodex(raw) {
+    const value = raw;
+    if (typeof value.url !== "string" || !Array.isArray(value.models) || !value.models.length || value.models.some(model => typeof model !== "string" || !/^[\w][\w./+-]*$/.test(model))) {
+        throw new Error("Invalid Company Codex configuration.");
+    }
+    const url = new URL(value.url);
+    if (url.username || url.password || url.search || url.hash || !["https:", "http:"].includes(url.protocol))
+        throw new Error("Invalid Company Codex endpoint.");
+    return { url: url.href.replace(/\/$/, ""), models: value.models };
+}
+export function managedCodexArgs(config) {
+    // Credential stays in the instance environment, never argv or config.toml.
+    // https://learn.chatgpt.com/docs/config-file/config-reference
+    return [
+        "-c", 'model_provider="openmaus_company"',
+        "-c", 'model_providers.openmaus_company.name="Company"',
+        "-c", `model_providers.openmaus_company.base_url=${JSON.stringify(config.url)}`,
+        "-c", 'model_providers.openmaus_company.env_key="OPENMAUSBOT_COMPANY_API_KEY"',
+        "-c", 'model_providers.openmaus_company.wire_api="responses"',
+        "-c", "model_providers.openmaus_company.requires_openai_auth=false",
+        "-c", 'cli_auth_credentials_store="ephemeral"',
+        "-c", "shell_environment_policy.ignore_default_excludes=false",
+    ];
+}
 const QUESTION_TIMEOUT_NOTE = "No answer was given — use your best judgment.";
 const DENY_TIMEOUT_NOTE = "OpenMausBot: nobody answered this permission request in time. Skip this action and finish what you can without it.";
 /** RequestPermissionProfile uses null for permission families that were not
@@ -418,8 +456,10 @@ export const CodexDriver = {
             return env;
         };
         const catalogEnv = childEnv();
-        let models = STATIC_CODEX_MODELS;
+        let models = config.managed ? { default: config.managed.models[0], options: config.managed.models.map(id => ({ id, label: id })) } : STATIC_CODEX_MODELS;
         const refreshModels = async () => {
+            if (config.managed)
+                return;
             try {
                 const resolved = await readCodexModelCatalog(catalogEnv, fetch, config.cli);
                 if (resolved.options.length)
@@ -449,9 +489,17 @@ export const CodexDriver = {
             createdAt: new Date().toISOString(),
         });
         const sendTurn = async (turn) => {
+            if (config.managed && (!turn.model || !config.managed.models.includes(turn.model) || !input.environment.OPENMAUSBOT_COMPANY_API_KEY || !input.environment.CODEX_HOME)) {
+                throw new Error("Company model access is unavailable. Reconnect your organization; personal billing will not be used.");
+            }
             // One driver instance serves many threads. Interrupt state belongs to
             // this turn so activity elsewhere cannot cancel or revive its retry.
             let stopRequested = false;
+            let promptSubmitted = false;
+            let recoveredMissingSession = false;
+            // Wakes a retry backoff the moment Stop arrives, so the turn settles
+            // now rather than after the full wait.
+            const stopSignal = new AbortController();
             const { threadId } = turn;
             // Direct adapter callers predating the per-bot selector retain the
             // instance's legacy fullAuto setting. Harness turns always send an
@@ -472,30 +520,14 @@ export const CodexDriver = {
             const retryScale = Number(process.env.FAKE_CODEX_RETRY_SCALE ?? "1");
             const launchAttempt = async (attempt) => {
                 const env = childEnv();
-                const appServerArgs = ["app-server", ...codexLocalProviderArgs(env, turn.model)];
+                const appServerArgs = ["app-server", ...(config.managed ? managedCodexArgs(config.managed) : codexLocalProviderArgs(env, turn.model))];
                 if (turn.integrations?.composio) {
                     mountMcpServer(appServerArgs, env, "openmausbot_connectors", turn.integrations.composio);
                 }
                 if (turn.integrations?.agents) {
                     mountMcpServer(appServerArgs, env, "agents", turn.integrations.agents);
                 }
-                if (turn.integrations?.computer) {
-                    const proxyEnv = computerProxyEnv(turn.integrations.computer);
-                    mountMcpServer(appServerArgs, env, "computer", {
-                        command: process.execPath,
-                        args: [SPAWNED_PROXIES.computer],
-                        env: {
-                            ELECTRON_RUN_AS_NODE: "1",
-                            OGB_BOX_ID: proxyEnv.OGB_BOX_ID ?? "",
-                            OGB_BOX_TOKEN: proxyEnv.OGB_BOX_TOKEN ?? "",
-                            // who-is-driving endpoint, so a person taking the wheel in the
-                            // panel pauses this bot's hands mid-turn
-                            OMB_CONTROL_URL: proxyEnv.OMB_CONTROL_URL ?? "",
-                            OMB_CONTROL_TOKEN: proxyEnv.OMB_CONTROL_TOKEN ?? "",
-                        },
-                    });
-                }
-                else if (turn.integrations?.localComputer) {
+                if (turn.integrations?.localComputer) {
                     // The host daemon and isolated Local VM both arrive as a direct Cua
                     // Driver stdio MCP server. Codex sees the same computer tool surface.
                     mountMcpServer(appServerArgs, env, "computer", turn.integrations.localComputer);
@@ -527,9 +559,12 @@ export const CodexDriver = {
                     lastError: "",
                     lastText: "",
                     sawStreamDelta: false,
-                    // codex reports token usage as a running THREAD total; the harness
-                    // wants this turn's figure, so the last report is banked on settle
+                    // codex reports token usage as a running total for this app-server
+                    // process. The harness wants this turn's figure: the total minus
+                    // whatever the process already carried before turn/start (a resumed
+                    // thread may restore earlier usage), banked on settle.
                     usage: undefined,
+                    usageBaseline: undefined,
                 };
                 const asks = new Map();
                 let nextId = 1;
@@ -561,6 +596,18 @@ export const CodexDriver = {
                     rpcPending.set(id, {
                         resolve: (v) => {
                             clearTimeout(timer);
+                            if (method === "thread/start" || method === "thread/resume") {
+                                // Notifications can follow the thread response in the same
+                                // stdout chunk, before the handshake await resumes.
+                                const returnedId = v?.thread?.id;
+                                const requestedId = method === "thread/resume"
+                                    && params && typeof params === "object" && "threadId" in params
+                                    ? params.threadId : null;
+                                if (typeof returnedId === "string" && returnedId)
+                                    codexThreadId = returnedId;
+                                else if (typeof requestedId === "string" && requestedId)
+                                    codexThreadId = requestedId;
+                            }
                             if (method === "turn/start") {
                                 if (typeof v?.turn?.id !== "string" || !v.turn.id) {
                                     reject(new Error("Codex did not return a native turn id"));
@@ -594,6 +641,7 @@ export const CodexDriver = {
                 let completeStoppedTurn;
                 const stop = async () => {
                     stopRequested = true;
+                    stopSignal.abort();
                     const stopped = await terminate();
                     if (stopped)
                         completeStoppedTurn?.();
@@ -744,6 +792,17 @@ export const CodexDriver = {
                     if (!connectionError) {
                         if (!codexThreadId || p.threadId !== codexThreadId)
                             return;
+                        if (!codexTurnId && msg.method === "thread/tokenUsage/updated" && p.tokenUsage?.total) {
+                            // A total reported before this turn exists is what the process
+                            // carried in — a resumed thread restoring earlier usage. It is the
+                            // baseline this turn's figure is measured from, never a reading to
+                            // buffer and replay as if this turn produced it. (Codex names the
+                            // turn before any model call, so a genuine first reading cannot
+                            // land here.)
+                            const t = p.tokenUsage.total;
+                            state.usageBaseline = { input: t.inputTokens ?? 0, output: t.outputTokens ?? 0, cachedInput: t.cachedInputTokens ?? 0 };
+                            return;
+                        }
                         if (!codexTurnId) {
                             // Some servers stream before acknowledging turn/start. Retain a
                             // bounded prefix, then filter against the authoritative response.
@@ -849,32 +908,44 @@ export const CodexDriver = {
                             break;
                         }
                         case "thread/tokenUsage/updated": {
-                            // `last` is the most recent turn when the server sends it;
-                            // `total` is the thread so far — a fresh app-server per turn
-                            // makes that this turn's figure too
-                            const turnUsage = p.tokenUsage?.last ?? p.tokenUsage?.total;
-                            // codex's inputTokens already includes cachedInputTokens; the
-                            // cached share is carried alongside so the UI can say how much
-                            // of a turn was context re-read rather than new text
-                            if (turnUsage) {
+                            // `total` is everything this app-server process has used; `last`
+                            // is the most recent model call. This turn's figure is the total
+                            // minus what the process carried before turn/start went out (a
+                            // resumed thread can restore earlier usage), so it never grows by
+                            // the whole thread per message and never counts only the final
+                            // call of a multi-step turn. codex's inputTokens already includes
+                            // cachedInputTokens; the cached share rides alongside so the UI
+                            // can say how much was context re-read rather than new text.
+                            const t = p.tokenUsage?.total;
+                            const last = p.tokenUsage?.last;
+                            const shape = (u) => ({
+                                input: u.inputTokens ?? 0, output: u.outputTokens ?? 0, cachedInput: u.cachedInputTokens ?? 0,
+                            });
+                            // (A total that arrived before this turn was named became the
+                            // baseline upstream and never reaches this switch.)
+                            if (t) {
+                                const b = state.usageBaseline ?? { input: 0, output: 0, cachedInput: 0 };
+                                const now = shape(t);
                                 state.usage = {
-                                    input: turnUsage.inputTokens ?? 0,
-                                    output: turnUsage.outputTokens ?? 0,
-                                    ...(typeof turnUsage.cachedInputTokens === "number"
-                                        ? { cachedInput: turnUsage.cachedInputTokens }
-                                        : {}),
+                                    input: Math.max(0, now.input - b.input),
+                                    output: Math.max(0, now.output - b.output),
+                                    ...(typeof t.cachedInputTokens === "number" ? { cachedInput: Math.max(0, now.cachedInput - b.cachedInput) } : {}),
                                 };
                             }
-                            const t = p.tokenUsage?.total;
+                            else if (last) {
+                                state.usage = { input: last.inputTokens ?? 0, output: last.outputTokens ?? 0, ...(typeof last.cachedInputTokens === "number" ? { cachedInput: last.cachedInputTokens } : {}) };
+                            }
                             if (t) {
+                                const window = p.tokenUsage?.modelContextWindow;
                                 emit({
                                     ...base(threadId, turnId),
                                     type: "thread.token-usage.updated",
                                     input: t.inputTokens ?? 0,
                                     output: t.outputTokens ?? 0,
-                                    ...(typeof t.cachedInputTokens === "number"
-                                        ? { cachedInput: t.cachedInputTokens }
-                                        : {}),
+                                    ...(typeof t.cachedInputTokens === "number" ? { cachedInput: t.cachedInputTokens } : {}),
+                                    // the last call's prompt is what fills the window
+                                    ...(last && typeof last.inputTokens === "number" ? { contextTokens: last.inputTokens } : {}),
+                                    ...(typeof window === "number" && window > 0 ? { contextWindow: window } : {}),
                                 });
                             }
                             break;
@@ -926,6 +997,7 @@ export const CodexDriver = {
                         catch {
                             continue;
                         }
+                        stderrSinceOutput = "";
                         const loggedMessage = codexNativeIncomingLogMessage(msg, sensitiveResponseIds);
                         appendNative(threadId, { dir: "in", source: "codex.app-server", msg: loggedMessage });
                         if (msg.id !== undefined && (msg.result !== undefined || msg.error !== undefined)) {
@@ -933,7 +1005,7 @@ export const CodexDriver = {
                             if (pend) {
                                 rpcPending.delete(msg.id);
                                 if (msg.error)
-                                    pend.reject(new Error(msg.error.message ?? JSON.stringify(msg.error)));
+                                    pend.reject(new CodexRpcError(msg.error));
                                 else
                                     pend.resolve(msg.result);
                             }
@@ -947,10 +1019,20 @@ export const CodexDriver = {
                     }
                 });
                 let stderr = "";
+                // Stderr that arrived after the last parsed protocol message. The
+                // full buffer accumulates for the whole process lifetime, so its
+                // tail can name a long-past event (a websocket 426 logged at turn
+                // start, echoed half an hour later when something else kills the
+                // process). Only this slice can explain an exit; older bytes are
+                // context, not cause.
+                let stderrSinceOutput = "";
                 child.stderr.on("data", (c) => {
                     stderr += c;
+                    stderrSinceOutput += c;
                     if (stderr.length > 8192)
                         stderr = stderr.slice(-8192);
+                    if (stderrSinceOutput.length > 2048)
+                        stderrSinceOutput = stderrSinceOutput.slice(-2048);
                 });
                 child.on("error", (e) => {
                     if (abandoned)
@@ -958,7 +1040,7 @@ export const CodexDriver = {
                     emit({ ...base(threadId, turnId), type: "runtime.error", ...describeSpawnFailure(e, config.cli) });
                     void settle(false, "spawn_error");
                 });
-                child.on("close", (code) => {
+                child.on("close", (code, signal) => {
                     if (abandoned)
                         return;
                     if (state.settled) {
@@ -967,14 +1049,65 @@ export const CodexDriver = {
                         void stop();
                         return;
                     }
-                    if (!state.settled) {
+                    // The child died before the turn completed. Attribute the exit
+                    // honestly: name the signal when it was killed, and only quote
+                    // stderr that arrived after the last protocol message. A stale
+                    // tail here once misattributed a whole day of killed turns to a
+                    // websocket 426 logged at turn start.
+                    const recentStderr = stderrSinceOutput.trim();
+                    const hadStreamedOutput = codexTurnId !== null || state.sawStreamDelta;
+                    // A signal exit is terminal no matter what the stderr says:
+                    // something killed the process (OOM, kill -9), and classifyError
+                    // cannot see the signal — with code null, transient-looking recent
+                    // stderr could still mark a killed attempt retryable.
+                    // Classification also reads only stderr received after the last
+                    // protocol output; the lifetime buffer's tail can name a
+                    // long-past event (the websocket-426 misattribution).
+                    const verdict = signal !== null
+                        ? { transient: false, reason: "interrupted" }
+                        : classifyError({ exitCode: code, stderr: recentStderr });
+                    // Safe re-dispatch: relaunch only when the app-server never
+                    // acknowledged turn/start — no native turn began, nothing was
+                    // streamed, so replaying the input cannot duplicate work. After
+                    // any acknowledgement (or any buffered pre-ack event) the turn
+                    // settles instead: a replay could re-run tools the user saw.
+                    if (!stopRequested && codexTurnId === null && earlyNotifications.length === 0 &&
+                        verdict.transient && attempt < RETRY_MAX_ATTEMPTS - 1) {
+                        const delayMs = computeBackoff(attempt);
+                        attempt++;
                         emit({
                             ...base(threadId, turnId),
-                            type: "runtime.error",
-                            message: `codex exited ${code} before turn/completed${stderr ? `: ${stderr.trim().slice(-300)}` : ""}`,
+                            type: "turn.retrying",
+                            attempt,
+                            delayMs,
+                            reason: verdict.reason,
                         });
-                        void settle(false, "exit_before_result");
+                        // Retire this attempt before anything async runs, so a late
+                        // rpc timer rejection in the handshake catch cannot relaunch
+                        // a second time on top of this one.
+                        abandoned = true;
+                        void (async () => {
+                            const alreadyDead = child.exitCode !== null || child.signalCode !== null;
+                            if (!alreadyDead && !(await terminate())) {
+                                void settle(false, "shutdown_timeout");
+                                return;
+                            }
+                            await interruptibleDelay(Math.max(1, Math.round(delayMs * retryScale)), stopSignal.signal).promise;
+                            if (!stopRequested) {
+                                void launchAttempt(attempt).catch(() => { });
+                            }
+                            else {
+                                await settle(false, "interrupted");
+                            }
+                        })().catch(() => { });
+                        return;
                     }
+                    emit({
+                        ...base(threadId, turnId),
+                        type: "runtime.error",
+                        message: `codex exited ${code}${signal ? ` (signal ${signal})` : ""} before turn/completed${recentStderr ? `: ${recentStderr.slice(-300)}` : hadStreamedOutput && stderr.trim() ? "; no stderr after the last app-server output" : ""}`,
+                    });
+                    void settle(false, "exit_before_result");
                 });
                 active.set(threadId, { stop, turnId, asks });
                 // Relaunching the app-server is still the same logical turn. Keep the
@@ -1030,35 +1163,48 @@ export const CodexDriver = {
                     // Removed bot rules are cleared without dropping native configured rules.
                     const cursor = typeof turn.resumeCursor === "string" ? turn.resumeCursor : null;
                     let startedModel = null;
+                    let resumedNativeThread = false;
+                    let promptText = turn.text;
                     if (cursor) {
+                        const resumeThread = () => request("thread/resume", {
+                            threadId: cursor,
+                            developerInstructions,
+                            ...approvalParams.thread,
+                        });
                         try {
-                            const resumed = await request("thread/resume", {
-                                threadId: cursor,
-                                developerInstructions,
-                                ...approvalParams.thread,
-                            });
+                            let resumed;
+                            try {
+                                resumed = await resumeThread();
+                            }
+                            catch (error) {
+                                if (!approvalParams.fallback || !permissionProfileUnsupported(error))
+                                    throw error;
+                                // Older servers may require the legacy permission selector, but
+                                // still resume the same native thread before any user submission.
+                                approvalParams = approvalParams.fallback;
+                                resumed = await resumeThread();
+                            }
                             codexThreadId = resumed?.thread?.id ?? cursor;
+                            resumedNativeThread = true;
                         }
                         catch (error) {
-                            if (approvalParams.fallback && permissionProfileUnsupported(error)) {
-                                // A server can understand config/read before it understands the
-                                // profile selector. Retry the same resume safely rather than
-                                // losing the native thread or inheriting its previous mode.
-                                approvalParams = approvalParams.fallback;
-                                const resumed = await request("thread/resume", {
-                                    threadId: cursor,
-                                    developerInstructions,
-                                    ...approvalParams.thread,
-                                });
-                                codexThreadId = resumed?.thread?.id ?? cursor;
-                            }
-                            else {
+                            const failure = classifyResumeFailure({
+                                attempted: true,
+                                rejected: error instanceof CodexRpcError,
+                                promptSubmitted,
+                                producedOutput: state.sawStreamDelta,
+                            });
+                            if (!config.managed || recoveredMissingSession || stopRequested || state.settled ||
+                                !turn.recoveryText?.trim() || !missingNativeCodexThread(error, cursor) || !mayReplay(failure))
                                 throw error;
-                            }
+                            // The prompt has never been submitted. Rebuild only missing Company
+                            // histories, once, through the same approved model/provider below.
+                            recoveredMissingSession = true;
+                            promptText = recoveryPromptFor({ recoveryText: turn.recoveryText, currentText: turn.text, failure }).text;
                         }
                     }
                     if (!codexThreadId) {
-                        const selection = decodeCodexSelection(turn.model);
+                        const selection = config.managed ? { model: turn.model, modelProvider: "openmaus_company" } : decodeCodexSelection(turn.model);
                         const startThread = () => request("thread/start", {
                             developerInstructions,
                             cwd: turn.cwd ?? homedir(),
@@ -1082,14 +1228,14 @@ export const CodexDriver = {
                     }
                     if (!codexThreadId)
                         throw new Error("Codex did not return a native thread id");
-                    await syncCodexInstructions(threadId, codexThreadId, developerInstructions, Boolean(cursor), request);
+                    await syncCodexInstructions(threadId, codexThreadId, developerInstructions, resumedNativeThread, request);
                     emit({ ...base(threadId, turnId), type: "session.started", sessionId: codexThreadId, model: startedModel ?? turn.model ?? null });
-                    const promptText = turn.text;
                     const turnInput = [
                         ...(promptText ? [{ type: "text", text: promptText }] : []),
                         ...(turn.images ?? []).map((image) => ({ type: "localImage", path: image.path })),
                     ];
                     const startTurn = () => {
+                        promptSubmitted = true;
                         startingNativeTurn = true;
                         return request("turn/start", {
                             threadId: codexThreadId,
@@ -1122,7 +1268,10 @@ export const CodexDriver = {
                     const message = e instanceof Error ? e.message : String(e);
                     const needsAuth = /(?:\b401\b|unauthorized|missing bearer|authentication required)/i.test(message);
                     const verdict = classifyError(failure);
-                    if (!state.settled && !needsAuth && verdict.transient && attempt < RETRY_MAX_ATTEMPTS - 1 && state.sawStreamDelta === false) {
+                    // Three guards hold here: main's abandoned attempt never retries,
+                    // neither does a Company session already recovered once from canonical
+                    // history, and a Stop already asked for must not be undone by a relaunch.
+                    if (!state.settled && !abandoned && !recoveredMissingSession && !stopRequested && !needsAuth && verdict.transient && attempt < RETRY_MAX_ATTEMPTS - 1 && state.sawStreamDelta === false) {
                         const delayMs = computeBackoff(attempt);
                         attempt++;
                         emit({
@@ -1139,10 +1288,7 @@ export const CodexDriver = {
                             void settle(false, "shutdown_timeout");
                             return;
                         }
-                        await new Promise((resolve) => {
-                            const timer = setTimeout(resolve, Math.max(1, Math.round(delayMs * retryScale)));
-                            timer.unref?.();
-                        });
+                        await interruptibleDelay(Math.max(1, Math.round(delayMs * retryScale)), stopSignal.signal).promise;
                         if (!stopRequested) {
                             void launchAttempt(attempt).catch(() => { });
                         }
@@ -1151,7 +1297,9 @@ export const CodexDriver = {
                         }
                         return;
                     }
-                    if (!state.settled) {
+                    // abandoned marks an attempt retired by a retry; its late rpc
+                    // timeouts must neither report a spurious error nor relaunch again
+                    if (!state.settled && !abandoned) {
                         emit({
                             ...base(threadId, turnId),
                             type: "runtime.error",
@@ -1172,6 +1320,8 @@ export const CodexDriver = {
             });
             if (!version)
                 return { state: "unavailable", reason: `\`${config.cli}\` CLI not found` };
+            if (config.managed)
+                return { state: "available", version, authenticated: Boolean(input.environment.OPENMAUSBOT_COMPANY_API_KEY && input.environment.CODEX_HOME), billing: "metered" };
             const authenticated = await new Promise((resolve) => {
                 execCli(config.cli, ["login", "status"], { timeout: 8000, env }, (err, stdout, stderr) => resolve(!err && /^logged in\b/im.test(`${stdout}\n${stderr ?? ""}`)));
             });

package/dist-server/server/drivers/grok.js

@@ -11,7 +11,10 @@ const MODELS = {
 };
 function decodeConfig(raw) {
     const config = (raw ?? {});
+    if (config.tools !== undefined && typeof config.tools !== "boolean")
+        throw new Error("tools must be a boolean");
     return {
+        ...(config.tools !== undefined ? { tools: config.tools } : {}),
         url: typeof config.url === "string" ? config.url : DEFAULT_URL,
         apiKeyEnv: typeof config.apiKeyEnv === "string" ? config.apiKeyEnv : "XAI_API_KEY",
     };
@@ -30,6 +33,7 @@ export const GrokDriver = {
             driverKind: DRIVER_KIND,
             apiKey,
             apiUrl: config.url,
+            tools: config.tools,
             models: () => MODELS,
             requestBody: (model, messages, stream) => ({ model, messages, stream }),
             httpErrorLabel: "xAI",

package/dist-server/server/drivers/minimax.js

@@ -11,10 +11,12 @@ const DEFAULT_URL = "https://api.minimax.io/v1";
 const CN_URL = "https://api.minimaxi.com/v1";
 const MODELS = {
     default: "MiniMax-M3",
+    // `custom: true` because the driver is access "custom": the picker opens
+    // custom-access engines in the pane that lists only custom-flagged models.
     options: [
-        { id: "MiniMax-M3", label: "MiniMax M3", contextWindow: 1_000_000 },
-        { id: "MiniMax-M2.7", label: "MiniMax M2.7", contextWindow: 204_800 },
-        { id: "MiniMax-M2.7-highspeed", label: "MiniMax M2.7 Highspeed", contextWindow: 204_800 },
+        { id: "MiniMax-M3", label: "MiniMax M3", contextWindow: 1_000_000, custom: true },
+        { id: "MiniMax-M2.7", label: "MiniMax M2.7", contextWindow: 204_800, custom: true },
+        { id: "MiniMax-M2.7-highspeed", label: "MiniMax M2.7 Highspeed", contextWindow: 204_800, custom: true },
     ],
 };
 const localConfigSchema = z.object({
@@ -45,9 +47,13 @@ export function loadLocalMiniMaxConfig(home = homedir()) {
     }
 }
 export function decodeMinimaxConfig(raw) {
+    const tools = (raw ?? {}).tools;
+    if (tools !== undefined && typeof tools !== "boolean")
+        throw new Error("tools must be a boolean");
     const parsed = driverConfigSchema.safeParse(raw ?? {});
     const config = parsed.success ? parsed.data : {};
     return {
+        ...(tools !== undefined ? { tools } : {}),
         url: normalizedApiUrl(config.url?.trim() || process.env.MINIMAX_BASE_URL?.trim() || DEFAULT_URL),
     };
 }
@@ -83,6 +89,7 @@ export const MinimaxDriver = {
             driverKind: DRIVER_KIND,
             apiKey,
             apiUrl,
+            tools: input.config.tools,
             models: () => models,
             requestBody: (model, messages, stream) => ({
                 model,
@@ -95,6 +102,7 @@ export const MinimaxDriver = {
             missingKeyError: `no MiniMax key — set ${API_KEY_ENV} or run mmx auth login --api-key …`,
             unavailableReason: `no MiniMax API key — run mmx auth login --api-key … or set ${API_KEY_ENV}`,
             timeoutMs: 180_000,
+            reasoning: true,
             billing: "metered",
             includeUsageInCompleted: true,
             noBodyError: "MiniMax returned no response body",