openmausbot 0.1.85 → 0.1.87

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

@@ -1,3 +1,4 @@
+import { codexToolSurfaceArgs } from "./codex-tool-surface.js";
 // Codex driver — upstream CodexDriver skeleton over agentcal's
 // drivers/codex.js runtime: the official `codex` CLI headless over its
 // app-server JSON-RPC protocol (newline-delimited JSON on stdio).
@@ -11,6 +12,7 @@
 // and preserves that history or reports a failed resume.
 import { existsSync } from "node:fs";
 import { homedir } from "node:os";
+import { codexConfigMcpServerNames, mountedMcpServerName } from "./codex-mcp-names.js";
 import { stripWorkspaceCredentialEnv } from "../config.js";
 import { describeSpawnFailure, execCli, killCliTree, spawnCli } from "../procs.js";
 import { isHarnessOwnedMcpEnvName } from "../mcp-registry.js";
@@ -20,12 +22,15 @@ import { codexLocalProviderArgs } from "./local-inject.js";
 import { augmentedPath, splitCliString } from "../env-path.js";
 import { classifyError, computeBackoff, interruptibleDelay, RETRY_MAX_ATTEMPTS } from "./retry.js";
 import { appendNative } from "./native.js";
+import { permissionCommand, permissionLaunchCwd } from "./permission-command.js";
 import { commandSummary, toolDetailPreview } from "../tool-summary.js";
 import { codexDeveloperInstructions, syncCodexInstructions } from "./codex-instructions.js";
+import { volatileContextNote, withContextNote } from "./prompt-split.js";
 import { CodexDeviceAuthController } from "./codex-device-auth.js";
 import { codexAccountEmail } from "./codex-identity.js";
 import { classifyResumeFailure, mayReplay, recoveryPromptFor } from "../resume-recovery.js";
 import { extractMcpImages } from "../mcp-tool-images.js";
+import { parseProtocolAskQuestions, questionAnswersById, questionChoices } from "../../shared/ask-question.js";
 export { decodeCodexSelection, readCodexModelCatalog, STATIC_CODEX_MODELS } from "./codex-catalog.js";
 const DRIVER_KIND = "codex";
 const ASTRA_MODEL_ID = "gpt-6-astra";
@@ -125,9 +130,16 @@ export function managedCodexArgs(config) {
         "-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.";
 const skippedSseServers = new Set();
+const renamedMcpServers = new Set();
+/** Logged once per name: the rename is deliberate, not a lost server. */
+function noteRenamedMcpServer(name, mountName) {
+    if (renamedMcpServers.has(name))
+        return;
+    renamedMcpServers.add(name);
+    console.error(`codex: MCP server ${JSON.stringify(name)} is also declared in Codex's own config.toml — mounted as ${JSON.stringify(mountName)} for this bot so the two do not merge`);
+}
 function noteSkippedSseServer(name) {
     if (skippedSseServers.has(name))
         return;
@@ -266,6 +278,21 @@ function namedApprovalParams(mode) {
         },
     };
 }
+/** Keep the turn on the complete sandbox resolved by native start/resume. */
+function withResolvedSandbox(params, session) {
+    const requested = plainRecord(params.turn.sandboxPolicy);
+    // Named permission profiles own their policy; do not mix both selectors.
+    if (!requested)
+        return params;
+    const sandbox = plainRecord(plainRecord(session)?.sandbox);
+    if (!sandbox || typeof sandbox.type !== "string") {
+        throw new Error("Codex did not return its resolved sandbox policy. Update Codex, then retry; the turn was not started because its permissions could not be verified.");
+    }
+    if (sandbox.type !== requested.type) {
+        throw new Error("Codex did not apply the requested sandbox mode; cannot safely start the turn.");
+    }
+    return { ...params, turn: { ...params.turn, sandboxPolicy: sandbox } };
+}
 function effectiveApprovalPolicy(value) {
     if (value === "untrusted" || value === "on-request" || value === "never")
         return value;
@@ -578,7 +605,7 @@ export const CodexDriver = {
             const retryScale = Number(process.env.FAKE_CODEX_RETRY_SCALE ?? "1");
             const launchAttempt = async (attempt) => {
                 const env = childEnv();
-                const appServerArgs = ["app-server", ...(config.managed ? managedCodexArgs(config.managed) : codexLocalProviderArgs(env, turn.model))];
+                const appServerArgs = ["app-server", ...(config.managed ? managedCodexArgs(config.managed) : codexLocalProviderArgs(env, turn.model)), ...codexToolSurfaceArgs()];
                 if (turn.integrations?.composio) {
                     mountMcpServer(appServerArgs, env, "openmausbot_connectors", turn.integrations.composio);
                 }
@@ -593,6 +620,11 @@ export const CodexDriver = {
                 if (turn.integrations?.browser) {
                     mountMcpServer(appServerArgs, env, "browser", turn.integrations.browser);
                 }
+                // A custom server named like one in the user's own config.toml would
+                // be merged with it by the `-c` override — a stdio command over a
+                // remote url is "invalid configuration" and kills the turn before the
+                // model is asked. Such a server mounts under a name of its own.
+                const declaredInCodexConfig = codexConfigMcpServerNames(env);
                 for (const [name, server] of Object.entries(turn.integrations?.custom ?? {})) {
                     // codex speaks streamable HTTP to a remote server, not the older
                     // SSE transport: such an entry still reaches Claude bots, and is
@@ -601,7 +633,10 @@ export const CodexDriver = {
                         noteSkippedSseServer(name);
                         continue;
                     }
-                    mountMcpServer(appServerArgs, env, name, server, false);
+                    const mountName = mountedMcpServerName(name, declaredInCodexConfig);
+                    if (mountName !== name)
+                        noteRenamedMcpServer(name, mountName);
+                    mountMcpServer(appServerArgs, env, mountName, server, false);
                 }
                 if (turn.integrations?.phone) {
                     const bridge = turn.integrations.phone;
@@ -609,6 +644,7 @@ export const CodexDriver = {
                     const prefix = "mcp_servers.openmausbot_phone";
                     appServerArgs.push("-c", `${prefix}.command=${JSON.stringify(bridge.command)}`, "-c", `${prefix}.args=${JSON.stringify(bridge.args)}`, "-c", `${prefix}.env_vars=${JSON.stringify(Object.keys(bridge.env))}`, "-c", `${prefix}.default_tools_approval_mode="auto"`);
                 }
+                const commandCwd = permissionLaunchCwd(turn.cwd ?? homedir());
                 const child = spawnCli(config.cli, appServerArgs, {
                     cwd: turn.cwd ?? homedir(),
                     env,
@@ -821,23 +857,22 @@ export const CodexDriver = {
                         }
                         return;
                     }
-                    // One ask card carries one question honestly: its choices would come
-                    // from the first question alone and its one reply (including the
-                    // timeout note) would be copied into every question id (#1237).
-                    // Refuse the bundled call with a teaching error instead of
-                    // fabricating per-question answers.
-                    if (isQuestion && (!Array.isArray(params.questions) || params.questions.length !== 1)) {
-                        const bundled = Array.isArray(params.questions) && params.questions.length > 1;
+                    // The whole set rides one card, answered per id: the protocol pairs
+                    // each question with its own id, and the card's single reply is
+                    // mapped back block by block (or as the flat single-question
+                    // fallback). The only refusal left is an ask with nothing answerable
+                    // — #1237 is closed: a bundle no longer copies one answer into
+                    // every id.
+                    const protocolQuestions = isQuestion ? parseProtocolAskQuestions(params.questions) : null;
+                    if (isQuestion && !protocolQuestions) {
                         send({
                             jsonrpc: "2.0",
                             id: msg.id,
                             error: {
                                 code: -32602,
-                                message: bundled
-                                    ? `ask supports one question per call; this request bundled ${params.questions.length}. Split it into separate asks, one question each.`
-                                    : Array.isArray(params.questions)
-                                        ? "ask supports one question per call; this request sent none."
-                                        : "ask supports one question per call; params.questions must be an array with exactly one question.",
+                                message: Array.isArray(params.questions)
+                                    ? "ask needs at least one answerable question — a string id and question text each; this request sent none."
+                                    : "ask needs params.questions to be an array of questions, each with a string id and question text.",
                             },
                         });
                         return;
@@ -877,23 +912,36 @@ export const CodexDriver = {
                             ? (mcpAppApproval?.summary ?? (typeof params.message === "string" ? params.message : "MCP access requested"))
                             : typeof params.command === "string"
                                 ? params.command
-                                : Array.isArray(params.questions)
-                                    ? params.questions.map((q) => q.question ?? q.header).filter(Boolean).join(" · ")
-                                    : typeof params.reason === "string"
-                                        ? params.reason
-                                        : tool;
-                    const choices = isQuestion
-                        ? (params.questions?.[0]?.options ?? []).map((o) => o.label).slice(0, 5)
-                        : undefined;
+                                : protocolQuestions
+                                    ? protocolQuestions.map(({ question }) => question.question).join(" · ")
+                                    : Array.isArray(params.questions)
+                                        ? params.questions.map((q) => q.question ?? q.header).filter(Boolean).join(" · ")
+                                        : typeof params.reason === "string"
+                                            ? params.reason
+                                            : tool;
+                    // Flat choices only when one non-multiselect question can actually
+                    // be answered by a bare reply; a bundle's first-question buttons
+                    // would be an unusable lie for flat clients.
+                    const choices = isQuestion && protocolQuestions ? questionChoices(protocolQuestions.map(({ question }) => question)) : undefined;
                     const finish = (behavior, message, source = "user") => {
                         if (!asks.delete(requestId))
                             return;
                         clearTimeout(timer);
                         if (isQuestion) {
-                            const answers = {};
-                            for (const q of Array.isArray(params.questions) ? params.questions : []) {
-                                answers[q.id] = { answers: [message || QUESTION_TIMEOUT_NOTE] };
-                            }
+                            // Only the person's reply is filed: Q:/A: blocks mapped to the
+                            // id that asked them, or the flat fallback for a single
+                            // question. Timeout and turn teardown send empty answers so
+                            // every id reads unanswered — system notes never occupy the
+                            // slot the model reads as the person's words (the rule
+                            // permission-proxy already follows).
+                            const mapped = behavior === "answer" && source === "user" && typeof message === "string"
+                                ? questionAnswersById(message, protocolQuestions ?? [])
+                                : {};
+                            // Null prototype so an opaque id like __proto__ becomes a real
+                            // answer key instead of hitting the inherited setter.
+                            const answers = Object.create(null);
+                            for (const [id, answer] of Object.entries(mapped))
+                                answers[id] = { answers: [answer] };
                             send({ jsonrpc: "2.0", id: msg.id, result: { answers } });
                         }
                         else {
@@ -905,7 +953,11 @@ export const CodexDriver = {
                         }
                         emit({ ...base(threadId, turnId), type: "request.resolved", requestId, behavior, source });
                     };
-                    const timer = setTimeout(() => (isQuestion ? finish("answer", QUESTION_TIMEOUT_NOTE, "timeout") : finish("deny", DENY_TIMEOUT_NOTE, "timeout")), 15 * 60_000);
+                    const timer = setTimeout(
+                    // A timed-out question resolves as denied, not answered: the card
+                    // closes with no reply (answers stay empty either way), and the
+                    // resolve event must not claim an answer that never happened.
+                    () => finish("deny", isQuestion ? undefined : DENY_TIMEOUT_NOTE, "timeout"), 15 * 60_000);
                     timer.unref?.();
                     asks.set(requestId, finish);
                     emit({
@@ -915,9 +967,15 @@ export const CodexDriver = {
                         requestType: isQuestion ? "question" : "permission",
                         tool,
                         summary,
+                        command: method === "execCommandApproval" || method === "item/commandExecution/requestApproval"
+                            ? permissionCommand(params.command, params.cwd ?? (
+                            // Helpers may have a different workspace from their parent.
+                            !params.threadId || params.threadId === codexThreadId ? commandCwd : undefined)) : undefined,
                         choices,
+                        ...(protocolQuestions ? { questions: protocolQuestions.map((pair) => pair.question) } : {}),
                         approvalScope: controlsHost ? "local-computer" : undefined,
-                        requiresExplicitApproval: isAdditionalPermission || undefined,
+                        requiresExplicitApproval: isAdditionalPermission || ((method === "execCommandApproval" || method === "item/commandExecution/requestApproval") &&
+                            (params.additionalPermissions != null || params.networkApprovalContext != null)) || undefined,
                     });
                 };
                 const handleNotification = (msg) => {
@@ -1288,12 +1346,28 @@ export const CodexDriver = {
                         });
                         effectiveConfig = configured?.config;
                     }
-                    catch {
+                    catch (error) {
                         // Do not expose a possibly secret-bearing native config error or
-                        // overwrite unknown instructions with an empty fallback.
-                        throw new Error("Could not read Codex configuration; cannot safely update bot instructions. Retry after checking Codex.");
+                        // overwrite unknown instructions with an empty fallback. A config
+                        // codex itself rejected is the one case worth naming: the person
+                        // can act on it, and the message carries no credential.
+                        const invalid = error instanceof CodexRpcError && /^invalid configuration\b/i.test(error.message);
+                        throw new Error(invalid
+                            ? "Codex rejected its configuration as invalid. Check ~/.codex/config.toml (or CODEX_HOME) for a broken entry, then retry."
+                            : "Could not read Codex configuration; cannot safely update bot instructions. Retry after checking Codex.");
                     }
-                    const developerInstructions = codexDeveloperInstructions(effectiveConfig, turn.system ?? "");
+                    // Only the stable half of the prompt belongs in the developer slot:
+                    // it is the part that must survive compaction unchanged, and any
+                    // change to it invalidates the provider's cached prefix. The volatile
+                    // half (memory, mentions, outstanding teammate work) is delivered
+                    // inside the turn that changed it, after the cached prefix, the same
+                    // contract SendTurnInput.systemStable documents. Without the split
+                    // the driver keeps the previous single-block behaviour.
+                    const stableInstructions = typeof turn.systemStable === "string" && typeof turn.systemVolatile === "string"
+                        ? turn.systemStable
+                        : null;
+                    const promptSplit = stableInstructions !== null;
+                    const developerInstructions = codexDeveloperInstructions(effectiveConfig, stableInstructions ?? turn.system ?? "");
                     let approvalParams;
                     if (approvalMode === "custom") {
                         // config/read returns the effective global + project config for this
@@ -1336,6 +1410,7 @@ export const CodexDriver = {
                                 approvalParams = approvalParams.fallback;
                                 resumed = await resumeThread();
                             }
+                            approvalParams = withResolvedSandbox(approvalParams, resumed);
                             codexThreadId = resumed?.thread?.id ?? cursor;
                             resumedNativeThread = true;
                         }
@@ -1381,12 +1456,20 @@ export const CodexDriver = {
                             approvalParams = approvalParams.fallback;
                             started = await startThread();
                         }
+                        approvalParams = withResolvedSandbox(approvalParams, started);
                         codexThreadId = started?.thread?.id ?? null;
                         startedModel = started?.model ?? null;
                     }
                     if (!codexThreadId)
                         throw new Error("Codex did not return a native thread id");
-                    await syncCodexInstructions(threadId, codexThreadId, developerInstructions, resumedNativeThread, request);
+                    const { deliverVolatile, hadVolatile, commitVolatile } = await syncCodexInstructions(threadId, codexThreadId, developerInstructions, promptSplit ? turn.systemVolatile ?? "" : "", resumedNativeThread, request, Boolean(turn.mentionTurn));
+                    // A changed volatile half rides the next user input as a labelled
+                    // context block. It never touches the developer slot, so an
+                    // ordinary memory write or roster change neither appends a second
+                    // copy of the prompt to history nor re-uploads the conversation.
+                    if (deliverVolatile) {
+                        promptText = withContextNote(volatileContextNote(promptSplit ? turn.systemVolatile ?? "" : "", hadVolatile), promptText);
+                    }
                     emit({ ...base(threadId, turnId), type: "session.started", sessionId: codexThreadId, model: startedModel ?? turn.model ?? null, ...(rebuiltFromReplay ? { rebuilt: true } : {}) });
                     const turnInput = [
                         ...(promptText ? [{ type: "text", text: promptText }] : []),
@@ -1420,6 +1503,10 @@ export const CodexDriver = {
                         approvalParams = approvalParams.fallback;
                         await startTurn();
                     }
+                    // turn/start accepted the input: only now may the receipt claim the
+                    // volatile half was delivered, so a rejected turn redelivers on retry.
+                    if (commitVolatile)
+                        commitVolatile();
                 }
                 catch (e) {
                     const failure = e instanceof Error ? e : { text: String(e) };

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

@@ -2,8 +2,9 @@ import { createOpenAIChatRuntime } from "./openai-chat.js";
 const DRIVER_KIND = "grok";
 const DEFAULT_URL = "https://api.x.ai/v1";
 const MODELS = {
-    default: "grok-4",
+    default: "grok-4.7",
     options: [
+        { id: "grok-4.7", label: "Grok 4.7", contextWindow: 500_000 },
         { id: "grok-4", label: "Grok 4" },
         { id: "grok-4-fast", label: "Grok 4 Fast" },
         { id: "grok-3-mini", label: "Grok 3 Mini" },

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

@@ -0,0 +1,115 @@
+import { z } from "zod";
+import { createOpenAIChatRuntime } from "./openai-chat.js";
+const DEFAULT_URL = "https://api.mistral.ai/v1";
+const DEFAULT_MODELS = {
+    default: "mistral-large-latest",
+    options: [
+        { id: "mistral-large-latest", label: "Mistral Large (latest)" },
+        { id: "mistral-small-latest", label: "Mistral Small (latest)" },
+    ],
+};
+const configSchema = z.object({
+    url: z.string().trim().url().default(DEFAULT_URL),
+    model: z.string().trim().min(1).optional(),
+    tools: z.boolean().optional(),
+});
+function decodeConfig(raw) {
+    const config = configSchema.parse(raw ?? {});
+    config.url = config.url.replace(/\/+$/, "");
+    const url = new URL(config.url);
+    if (url.protocol !== "https:" && !(url.protocol === "http:" &&
+        ["localhost", "127.0.0.1", "[::1]"].includes(url.hostname))) {
+        throw new Error("Mistral requires HTTPS, except for a local test endpoint.");
+    }
+    return config;
+}
+const modelCard = z.object({
+    id: z.string().min(1),
+    name: z.string().nullable().optional(),
+    aliases: z.array(z.string()).optional(),
+    archived: z.boolean().optional(),
+    capabilities: z.object({ completion_chat: z.boolean().optional() }).optional(),
+    max_context_length: z.number().int().positive().optional(),
+});
+/** Mistral can return plain text or a list of typed content chunks. */
+function contentText(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    return content.map((chunk) => chunk?.type === "text" && typeof chunk.text === "string" ? chunk.text : "").join("");
+}
+export const MistralDriver = {
+    driverKind: "mistral",
+    metadata: { displayName: "Mistral (API)", supportsMultipleInstances: true, access: "api" },
+    models: DEFAULT_MODELS,
+    install: {
+        docsUrl: "https://console.mistral.ai/api-keys",
+        signInCommand: "Save a Mistral API key in Settings → Connections, or set MISTRAL_API_KEY on the server.",
+    },
+    decodeConfig,
+    defaultConfig: () => decodeConfig({}),
+    async create(input) {
+        const { config } = input;
+        const apiKey = (input.environment.MISTRAL_API_KEY ?? process.env.MISTRAL_API_KEY ?? "").trim();
+        const withConfiguredModel = (options) => {
+            const preferred = config.model ?? DEFAULT_MODELS.default;
+            if (config.model && !options.some((option) => option.id === config.model)) {
+                options = [{ id: config.model, label: config.model }, ...options];
+            }
+            return { default: options.some((option) => option.id === preferred) ? preferred : options[0].id, options };
+        };
+        let catalog = withConfiguredModel(DEFAULT_MODELS.options);
+        const refreshModels = async () => {
+            if (!apiKey)
+                return;
+            try {
+                const response = await fetch(`${config.url}/models`, {
+                    headers: { authorization: `Bearer ${apiKey}` },
+                    redirect: "error",
+                    signal: AbortSignal.timeout(8_000),
+                });
+                if (!response.ok)
+                    return;
+                const json = await response.json();
+                const rows = Array.isArray(json) ? json : z.object({ data: z.array(z.unknown()) }).parse(json).data;
+                const options = [];
+                const seen = new Set();
+                for (const row of rows) {
+                    const parsed = modelCard.safeParse(row);
+                    if (!parsed.success || parsed.data.archived || parsed.data.capabilities?.completion_chat === false)
+                        continue;
+                    const card = parsed.data;
+                    for (const id of [card.id, ...(card.aliases ?? [])]) {
+                        if (!id.trim() || seen.has(id))
+                            continue;
+                        seen.add(id);
+                        options.push({ id, label: id === card.id ? card.name?.trim() || id : id,
+                            ...(card.max_context_length ? { contextWindow: card.max_context_length } : {}) });
+                    }
+                }
+                if (options.length)
+                    catalog = withConfiguredModel(options);
+            }
+            catch {
+                // A failed refresh keeps the last usable catalog, including custom models.
+            }
+        };
+        if (apiKey)
+            void refreshModels();
+        return createOpenAIChatRuntime({
+            input, driverKind: "mistral", apiKey, apiUrl: config.url,
+            tools: config.tools, models: () => catalog, refreshModels, contentText,
+            requestBody: (model, messages, stream) => ({ model, messages, stream }),
+            httpErrorLabel: "Mistral",
+            missingKeyError: "Save a Mistral API key in Settings → Connections, or set MISTRAL_API_KEY.",
+            unavailableReason: "No Mistral API key — open Settings → Connections.",
+            timeoutMs: 180_000, billing: "metered", includeUsageInCompleted: true,
+            nativeLog: {
+                source: "mistral.chat.completions",
+                outgoing: (_turn, messages, model) => ({ model, messageCount: messages.length }),
+                incoming: ({ text, usage }) => ({ textLength: text.length, usage }),
+            },
+        });
+    },
+};