openmausbot 0.1.77 → 0.1.79

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

@@ -12,15 +12,13 @@
 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";
@@ -452,6 +450,9 @@ export const CodexDriver = {
             // One driver instance serves many threads. Interrupt state belongs to
             // this turn so activity elsewhere cannot cancel or revive its retry.
             let stopRequested = 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
@@ -479,23 +480,7 @@ export const CodexDriver = {
                 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);
@@ -594,6 +579,7 @@ export const CodexDriver = {
                 let completeStoppedTurn;
                 const stop = async () => {
                     stopRequested = true;
+                    stopSignal.abort();
                     const stopped = await terminate();
                     if (stopped)
                         completeStoppedTurn?.();
@@ -926,6 +912,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)) {
@@ -947,10 +934,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 +955,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 +964,56 @@ 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;
+                    const verdict = classifyError({ exitCode: code, stderr: recentStderr || stderr });
+                    // 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
@@ -1122,7 +1161,7 @@ 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) {
+                    if (!state.settled && !abandoned && !needsAuth && verdict.transient && attempt < RETRY_MAX_ATTEMPTS - 1 && state.sawStreamDelta === false) {
                         const delayMs = computeBackoff(attempt);
                         attempt++;
                         emit({
@@ -1139,10 +1178,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 +1187,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",

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",

package/dist-server/server/drivers/openai-chat-protocol.js

@@ -0,0 +1,92 @@
+export const MAX_CHAT_TOOL_CALLS = 32;
+const MAX_ARGUMENT_CHARS = 256_000;
+export class ChatProtocolError extends Error {
+}
+export function object(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value)
+        ? value : undefined;
+}
+/** Opaque provider reasoning blocks must keep their original order/signatures.
+ * OpenRouter streams the sequence as arrays of blocks, not tool-call deltas. */
+export class ChatReasoningDetails {
+    blocks = [];
+    chars = 0;
+    add(value) {
+        if (value === undefined || value === null)
+            return;
+        if (!Array.isArray(value) || value.some((block) => !object(block))) {
+            throw new ChatProtocolError("provider returned invalid reasoning details");
+        }
+        this.chars += JSON.stringify(value).length;
+        if (this.chars > 256_000)
+            throw new ChatProtocolError("provider reasoning details exceeded the size limit");
+        this.blocks.push(...value);
+    }
+}
+/** One accumulator per completion: indexes identify deltas; IDs correlate results. */
+export class ChatToolCalls {
+    calls = new Map();
+    argumentChars = 0;
+    add(value, streaming) {
+        if (value === undefined || value === null)
+            return;
+        if (!Array.isArray(value))
+            throw new ChatProtocolError("provider returned invalid tool_calls");
+        for (const [position, raw] of value.entries()) {
+            const delta = object(raw);
+            const index = streaming ? delta?.index : position;
+            if (!delta || !Number.isInteger(index) || Number(index) < 0 || Number(index) >= MAX_CHAT_TOOL_CALLS) {
+                throw new ChatProtocolError("provider returned an invalid tool-call index");
+            }
+            const call = this.calls.get(Number(index)) ?? { id: "", type: "function", function: { name: "", arguments: "" } };
+            if (delta.type !== undefined && delta.type !== "function")
+                throw new ChatProtocolError("unsupported tool-call type");
+            if (delta.id !== undefined) {
+                if (typeof delta.id !== "string" || !delta.id || delta.id.length > 256 || (call.id && call.id !== delta.id)) {
+                    throw new ChatProtocolError("provider changed or omitted a tool-call ID");
+                }
+                call.id = delta.id;
+            }
+            if (delta.function !== undefined) {
+                const fn = object(delta.function);
+                if (!fn)
+                    throw new ChatProtocolError("provider returned an invalid tool-call function");
+                for (const field of ["name", "arguments"]) {
+                    if (fn[field] === undefined)
+                        continue;
+                    if (typeof fn[field] !== "string")
+                        throw new ChatProtocolError("provider returned invalid tool-call arguments or name");
+                    call.function[field] += fn[field];
+                    if (field === "arguments")
+                        this.argumentChars += fn[field].length;
+                }
+            }
+            if (call.function.name.length > 64 || this.argumentChars > MAX_ARGUMENT_CHARS) {
+                throw new ChatProtocolError("provider tool calls exceeded the size limit");
+            }
+            this.calls.set(Number(index), call);
+        }
+    }
+    finish(reason, malformedFrame) {
+        const calls = [...this.calls.entries()].sort(([a], [b]) => a - b).map(([, call]) => call);
+        if (malformedFrame)
+            throw new ChatProtocolError("provider stream contained a malformed completion frame");
+        if (reason === "function_call")
+            throw new ChatProtocolError("legacy function_call is unsupported; use structured tool_calls");
+        if (reason === "tool_calls" && !calls.length)
+            throw new ChatProtocolError("provider ended for tool calls without a complete call");
+        if (!calls.length)
+            return calls;
+        if (reason !== null && reason !== "tool_calls" && reason !== "stop") {
+            throw new ChatProtocolError("provider tool calls were truncated or malformed");
+        }
+        const ids = new Set();
+        for (const call of calls) {
+            if (!call.id || ids.has(call.id) || !/^[A-Za-z0-9_-]{1,64}$/.test(call.function.name)) {
+                throw new ChatProtocolError("provider returned an incomplete or duplicate tool call");
+            }
+            ids.add(call.id);
+        }
+        return calls;
+    }
+}