openmausbot 0.1.91 → 0.1.92

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

@@ -10,10 +10,16 @@ import { codexToolSurfaceArgs } from "./codex-tool-surface.js";
 //
 // resumeCursor is the codex thread id; a later turn tries thread/resume
 // and preserves that history or reports a failed resume.
-import { existsSync } from "node:fs";
+import { existsSync, mkdirSync } from "node:fs";
+import { createHash } from "node:crypto";
+import { join } from "node:path";
 import { homedir } from "node:os";
 import { codexConfigMcpServerNames, mountedMcpServerName } from "./codex-mcp-names.js";
-import { stripWorkspaceCredentialEnv } from "../config.js";
+import { DATA_DIR, stripWorkspaceCredentialEnv } from "../config.js";
+import { hostedWorkspaceConfigured } from "../enterprise.js";
+import { cloudHomeConfigured } from "../cloud-home.js";
+import { serverVersion } from "../environment.js";
+import { ChatGptPlanAuthController } from "./chatgpt-plan-auth.js";
 import { describeSpawnFailure, execCli, killCliTree, spawnCli } from "../procs.js";
 import { isHarnessOwnedMcpEnvName } from "../mcp-registry.js";
 import { newEventId, newId } from "../contracts.js";
@@ -34,6 +40,17 @@ import { parseProtocolAskQuestions, questionAnswersById, questionChoices } from
 import { codexVersionBehind, readLatestCodexRelease } from "./codex-release.js";
 export { decodeCodexSelection, readCodexModelCatalog, STATIC_CODEX_MODELS } from "./codex-catalog.js";
 const DRIVER_KIND = "codex";
+export function codexUserError(value, chatgptPlan) {
+    if (chatgptPlan && value.includes("subscription_sharing_usage_limit_exceeded")) {
+        return "subscription_sharing_usage_limit_exceeded: Your ChatGPT plan usage limit was reached. Manage usage in ChatGPT Settings, or explicitly choose another provider.";
+    }
+    if (value.includes("provider_not_configured")) {
+        return chatgptPlan
+            ? "provider_not_configured: ChatGPT has not enabled this model for the selected account. Refresh models or reconnect ChatGPT plan in Settings. API billing will not be used."
+            : "provider_not_configured: This Codex account cannot use the selected route. For the new ChatGPT plan models, choose ChatGPT plan in Settings → Engines and Continue with ChatGPT, then select a model from that account.";
+    }
+    return value.slice(0, 400);
+}
 class CodexRpcError extends Error {
     code;
     constructor(error) {
@@ -79,12 +96,32 @@ async function codexReleaseUpdate(version, cli) {
 }
 function decodeConfig(raw) {
     const o = (raw ?? {});
+    if (o.authMode !== undefined && o.authMode !== "chatgpt-plan")
+        throw new Error("Unknown Codex sign-in mode.");
+    if (o.authMode && o.managed)
+        throw new Error("ChatGPT plan and Company billing cannot be combined.");
     return {
         cli: typeof o.cli === "string" ? o.cli : "codex",
         fullAuto: o.fullAuto === true,
+        ...(o.authMode === "chatgpt-plan" ? { authMode: "chatgpt-plan" } : {}),
         ...(o.managed && typeof o.managed === "object" ? { managed: decodeManagedCodex(o.managed) } : {}),
     };
 }
+export function chatgptPlanCodexArgs() {
+    return [
+        "-c", 'model_provider="openai_chatgpt_plan"',
+        "-c", 'model_providers.openai_chatgpt_plan.name="ChatGPT plan"',
+        "-c", 'model_providers.openai_chatgpt_plan.base_url="https://api.openai.com/v1"',
+        "-c", 'model_providers.openai_chatgpt_plan.env_key="OPENMAUSBOT_CHATGPT_TOKEN"',
+        "-c", 'model_providers.openai_chatgpt_plan.wire_api="responses"',
+        "-c", "model_providers.openai_chatgpt_plan.requires_openai_auth=false",
+        "-c", "model_providers.openai_chatgpt_plan.supports_websockets=false",
+        "-c", 'cli_auth_credentials_store="ephemeral"',
+        "-c", "features.tool_search=false",
+        "-c", "shell_environment_policy.ignore_default_excludes=false",
+        "-c", 'shell_environment_policy.exclude=["OPENMAUSBOT_CHATGPT_TOKEN"]',
+    ];
+}
 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))) {
@@ -226,6 +263,16 @@ function mcpAppApprovalForm(params) {
     const tool = boundedLabel(appName) ?? boundedLabel(request.serverName) ?? "app_access";
     return { tool, summary: message, allowResult: { action: "accept", content } };
 }
+/** What a guest-driven turn's app-server starts with: the shell, unified
+ * exec and image reads off (codex-cli 0.159.0 `features`), web search too. */
+export const GUEST_CONFINED_CODEX_ARGS = [
+    "-c", "features.shell_tool=false", "-c", "features.unified_exec=false", "-c", "features.view_image=false", "-c", 'web_search="disabled"',
+];
+/** Whether the effective config (config/read) shows the shell turned off. */
+export function codexShellDisabled(config) {
+    const features = plainRecord(plainRecord(config)?.features);
+    return features?.shell_tool === false && features?.unified_exec === false && features?.view_image === false;
+}
 /** Codex persists these values on its native thread. Keep them explicit on
  * start, resume, and every turn so switching modes cannot leave a more
  * permissive sandbox/reviewer stuck to the next request. */
@@ -492,6 +539,12 @@ export const CodexDriver = {
     defaultConfig: () => decodeConfig({}),
     async create(input) {
         const { instanceId, config } = input;
+        const plan = config.authMode === "chatgpt-plan";
+        const planUnavailable = plan && (hostedWorkspaceConfigured() || cloudHomeConfigured())
+            ? "ChatGPT plan sign-in for hosted Pro requires OpenAI's hosted-app approval. Use a Company model or API key until that integration is approved; the local desktop flow cannot be used here."
+            : undefined;
+        // Provider homes are excluded from portable backups and Move to Cloud.
+        const planDirectory = join(DATA_DIR, "providers", "chatgpt-plan", createHash("sha256").update(instanceId).digest("hex"));
         const childEnv = () => {
             const env = {
                 ...process.env,
@@ -505,13 +558,31 @@ export const CodexDriver = {
             // The harness process may hold workspace credentials (xai/box/voice
             // keys, env-injected at boot); none of them are this CLI's to see.
             stripWorkspaceCredentialEnv(env);
+            delete env.OPENMAUSBOT_CHATGPT_TOKEN;
+            if (plan)
+                env.CODEX_HOME = join(planDirectory, "codex");
             return env;
         };
         const catalogEnv = childEnv();
-        let models = config.managed ? { default: config.managed.models[0], options: config.managed.models.map(id => ({ id, label: id })) } : STATIC_CODEX_MODELS;
+        const planAuth = plan ? new ChatGptPlanAuthController({ directory: planDirectory }) : null;
+        let planGeneration = 0;
+        let planSigningOut = false;
+        let disposed = false;
+        let planWarning;
+        let models = plan ? { default: "", options: [] } : 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;
+            if (planAuth) {
+                const generation = planGeneration;
+                models = { default: "", options: [] };
+                if (!planUnavailable && !planSigningOut && !disposed) {
+                    const catalog = await planAuth.models();
+                    if (generation === planGeneration && !planSigningOut && !disposed)
+                        models = catalog;
+                }
+                return;
+            }
             try {
                 const resolved = await readCodexModelCatalog(catalogEnv, fetch, config.cli);
                 if (resolved.options.length)
@@ -521,7 +592,16 @@ export const CodexDriver = {
                 // Keep the last usable catalog when a local provider is down.
             }
         };
-        await refreshModels();
+        // A revoked grant or a temporary catalog outage must leave the account
+        // reachable in Settings for reconnect; it must not become a shadow.
+        if (planAuth) {
+            try {
+                await refreshModels();
+            }
+            catch { /* Explicit refresh reports the error. */ }
+        }
+        else
+            await refreshModels();
         const authentication = new CodexDeviceAuthController({
             cli: config.cli,
             environment: childEnv,
@@ -541,6 +621,27 @@ export const CodexDriver = {
             createdAt: new Date().toISOString(),
         });
         const sendTurn = async (turn) => {
+            const generation = planGeneration;
+            const assertPlanCurrent = () => {
+                if (disposed)
+                    throw new Error("This provider was removed. Select a connected account and send again.");
+                if (planAuth && (planSigningOut || generation !== planGeneration))
+                    throw new Error("The ChatGPT account changed while this message was preparing. Select a connected account and send again.");
+            };
+            assertPlanCurrent();
+            if (planUnavailable)
+                throw new Error(planUnavailable);
+            const planToken = planAuth ? await planAuth.accessToken() : undefined;
+            assertPlanCurrent();
+            if (planAuth) {
+                if (!turn.model || !models.options.some(model => model.id === turn.model)) {
+                    await refreshModels();
+                    assertPlanCurrent();
+                    if (!turn.model || !models.options.some(model => model.id === turn.model))
+                        throw new Error("This model is not available to the selected ChatGPT plan. Refresh models and choose a listed model; API billing will not be used.");
+                }
+                mkdirSync(join(planDirectory, "codex"), { recursive: true, mode: 0o700 });
+            }
             if (config.managed) {
                 // One blanket refusal hides which prerequisite broke; name it so the
                 // person can fix the actual gap instead of reconnecting blind.
@@ -587,7 +688,13 @@ 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)), ...codexToolSurfaceArgs()];
+                if (planToken)
+                    env.OPENMAUSBOT_CHATGPT_TOKEN = planToken;
+                const appServerArgs = ["app-server", ...(plan ? chatgptPlanCodexArgs() : config.managed ? managedCodexArgs(config.managed) : codexLocalProviderArgs(env, turn.model)), ...codexToolSurfaceArgs(),
+                    // A guest-driven turn (SendTurnInput.guestConfined): no shell and
+                    // no file reads, whatever the person's own config says (-c wins
+                    // over config files). The turn also starts with no environment.
+                    ...(turn.guestConfined ? GUEST_CONFINED_CODEX_ARGS : [])];
                 if (turn.integrations?.composio) {
                     mountMcpServer(appServerArgs, env, "openmausbot_connectors", turn.integrations.composio);
                 }
@@ -746,8 +853,8 @@ export const CodexDriver = {
                         while (!state.settled && Date.now() < deadline) {
                             await new Promise((wake) => setTimeout(wake, 15));
                         }
-                        if (state.settled)
-                            return true;
+                        // Protocol completion is not process termination. In particular,
+                        // sign-out must wait until the child holding its token has exited.
                     }
                     const stopped = await terminate();
                     if (stopped)
@@ -960,6 +1067,24 @@ export const CodexDriver = {
                             (params.additionalPermissions != null || params.networkApprovalContext != null)) || undefined,
                     });
                 };
+                const seenReviews = new Set();
+                let reviewWarning = false;
+                let timedOutReview = false;
+                const retryMode = approvalMode[0].toUpperCase() + approvalMode.slice(1);
+                const reviewNotice = (status, action) => {
+                    if (status === "warning") {
+                        emit({ ...base(threadId, turnId), type: "runtime.error",
+                            message: `Codex automatic review reported a timeout. Check what ran before retrying. Retry stays ${retryMode}. Select Ask for human approval in approval settings.`,
+                        });
+                        return;
+                    }
+                    const command = action?.type === "command" ? commandSummary({ command: action.command }) : undefined;
+                    const target = command ? `: "${command.slice(0, 30)}"` : " for the requested action";
+                    const outcome = status === "timedOut" ? "timed out" : "denied";
+                    emit({ ...base(threadId, turnId), type: "runtime.error",
+                        message: `Codex automatic review ${outcome}${target}. Action did not run. Retry stays ${retryMode}. Select Ask for human approval in approval settings.`,
+                    });
+                };
                 const handleNotification = (msg) => {
                     const p = msg.params ?? {};
                     // An app-server also emits notifications for native helper threads.
@@ -997,10 +1122,32 @@ export const CodexDriver = {
                         }
                         const eventTurnId = msg.method === "turn/started" || msg.method === "turn/completed"
                             ? p.turn?.id : p.turnId;
-                        if (eventTurnId !== codexTurnId)
+                        // guardianWarning is thread-scoped in Codex 0.147; this child
+                        // process belongs to one app turn. Never admit a mismatched turnId.
+                        if (eventTurnId !== codexTurnId && !(msg.method === "guardianWarning" && eventTurnId === undefined))
                             return;
                     }
                     switch (msg.method) {
+                        case "guardianWarning":
+                            if (typeof p.message === "string" && /automatic approval review.*timed out/i.test(p.message))
+                                reviewWarning = true;
+                            break;
+                        case "item/autoApprovalReview/completed": {
+                            const status = p.review?.status;
+                            if (status !== "timedOut" && status !== "denied")
+                                break;
+                            // Completed reviews carry a reviewId. Without it distinct
+                            // failures cannot be separated from duplicate notifications.
+                            if (typeof p.reviewId !== "string" || !p.reviewId)
+                                break;
+                            if (!seenReviews.has(p.reviewId)) {
+                                seenReviews.add(p.reviewId);
+                                if (status === "timedOut")
+                                    timedOutReview = true;
+                                reviewNotice(status, p.action);
+                            }
+                            break;
+                        }
                         // token-level chat text; the item/completed frame follows with the
                         // whole message, so its delta is only a fallback when none streamed
                         case "item/agentMessage/delta": {
@@ -1135,8 +1282,10 @@ export const CodexDriver = {
                             break;
                         }
                         case "turn/completed": {
+                            if (reviewWarning && !timedOutReview)
+                                reviewNotice("warning");
                             const t = p.turn ?? {};
-                            const message = typeof t.error?.message === "string" ? t.error.message.slice(0, 400) : "";
+                            const message = typeof t.error?.message === "string" ? codexUserError(t.error.message, plan) : "";
                             if (t.status !== "completed" && message && message !== state.lastError) {
                                 state.lastError = message;
                                 emit({ ...base(threadId, turnId), type: "runtime.error", message,
@@ -1153,7 +1302,7 @@ export const CodexDriver = {
                             {
                                 const message = p.message ?? p.error?.message;
                                 if (message) {
-                                    state.lastError = String(message).slice(0, 400);
+                                    state.lastError = codexUserError(String(message), plan);
                                     emit({ ...base(threadId, turnId), type: "runtime.error", message: state.lastError });
                                 }
                             }
@@ -1310,7 +1459,7 @@ export const CodexDriver = {
                 // nothing streamed yet, and never for auth/shape errors or interrupts
                 try {
                     await request("initialize", {
-                        clientInfo: { name: "openmausbot", version: "1" },
+                        clientInfo: { name: "openmausbot", title: "OpenMausBot", version: serverVersion() },
                         // Named permission profiles are an experimental app-server field in
                         // Codex 0.151. Negotiate them explicitly; older servers ignore this
                         // capability and remain on the legacy Custom fallback below.
@@ -1338,6 +1487,11 @@ export const CodexDriver = {
                             ? "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.");
                     }
+                    // Proven before the turn starts: a Codex that did not take the
+                    // overrides runs nothing for a guest.
+                    if (turn.guestConfined && !codexShellDisabled(effectiveConfig)) {
+                        throw new Error(`This Codex could not turn its shell off, so it can't run this turn. Update Codex, or switch this bot to Claude.${turn.confinedWhy ? ` ${turn.confinedWhy}` : ""}`);
+                    }
                     // 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
@@ -1368,6 +1522,11 @@ export const CodexDriver = {
                     // Each turn launches a new app-server. Reassert current bot instructions
                     // on start AND resume so Codex owns their lifetime through compaction.
                     // Removed bot rules are cleared without dropping native configured rules.
+                    const selection = config.managed
+                        ? { model: turn.model, modelProvider: "openmaus_company" }
+                        : config.authMode === "chatgpt-plan"
+                            ? { model: turn.model, modelProvider: "openai_chatgpt_plan" }
+                            : decodeCodexSelection(turn.model);
                     const cursor = typeof turn.resumeCursor === "string" ? turn.resumeCursor : null;
                     let startedModel = null;
                     let resumedNativeThread = false;
@@ -1377,6 +1536,8 @@ export const CodexDriver = {
                         const resumeThread = () => request("thread/resume", {
                             threadId: cursor,
                             developerInstructions,
+                            model: selection.model,
+                            ...(selection.modelProvider ? { modelProvider: selection.modelProvider } : {}),
                             ...approvalParams.thread,
                         });
                         try {
@@ -1419,13 +1580,13 @@ export const CodexDriver = {
                         }
                     }
                     if (!codexThreadId) {
-                        const selection = config.managed ? { model: turn.model, modelProvider: "openmaus_company" } : decodeCodexSelection(turn.model);
                         const startThread = () => request("thread/start", {
                             developerInstructions,
                             cwd: turn.cwd ?? homedir(),
                             model: selection.model,
                             ...(selection.modelProvider ? { modelProvider: selection.modelProvider } : {}),
                             ...approvalParams.thread,
+                            ...(turn.guestConfined ? { environments: [] } : {}),
                             ephemeral: false,
                         });
                         let started;
@@ -1464,6 +1625,10 @@ export const CodexDriver = {
                             threadId: codexThreadId,
                             input: turnInput,
                             ...approvalParams.turn,
+                            // No environment: no exec_command, apply_patch or view_image, and
+                            // any call to them is refused (probed against codex-cli 0.159.0).
+                            // Without the experimental API the field is rejected, not ignored.
+                            ...(turn.guestConfined ? { environments: [] } : {}),
                             // Spread, not `effort: turn.effort ?? null`. Probed against
                             // codex-cli 0.146.0: null is indistinguishable from an absent key
                             // — both leave the thread's current effort alone, emitting no
@@ -1492,7 +1657,7 @@ export const CodexDriver = {
                 }
                 catch (e) {
                     const failure = e instanceof Error ? e : { text: String(e) };
-                    const message = e instanceof Error ? e.message : String(e);
+                    const message = codexUserError(e instanceof Error ? e.message : String(e), plan);
                     const needsAuth = /(?:\b401\b|unauthorized|missing bearer|authentication required)/i.test(message);
                     const verdict = classifyError(failure);
                     // Three guards hold here: main's abandoned attempt never retries,
@@ -1541,12 +1706,17 @@ export const CodexDriver = {
             return { turnId };
         };
         const snapshot = async () => {
+            if (planUnavailable)
+                return { state: "unavailable", authenticated: false, chatgptPlan: true, reason: planUnavailable, authenticationUnavailableReason: planUnavailable };
             const env = childEnv();
             const version = await new Promise((resolve) => {
                 execCli(config.cli, ["--version"], { timeout: 8000, env }, (err, stdout) => resolve(err ? null : stdout.trim()));
             });
             if (!version)
-                return { state: "unavailable", reason: `\`${config.cli}\` CLI not found` };
+                return { state: "unavailable", reason: `\`${config.cli}\` CLI not found`, ...(plan ? { chatgptPlan: true } : {}) };
+            if (planAuth)
+                return { state: "available", version, chatgptPlan: true, billing: "subscription", ...await planAuth.snapshot(), update: await codexReleaseUpdate(version, config.cli),
+                    ...(planWarning ? { warning: { title: "Check ChatGPT connection", message: planWarning } } : {}) };
             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) => {
@@ -1574,15 +1744,52 @@ export const CodexDriver = {
                 return models;
             },
             refreshModels,
-            startAuthentication: () => authentication.start(),
-            getAuthentication: (flowId) => authentication.get(flowId),
-            cancelAuthentication: () => authentication.cancel(),
-            signOut: () => authentication.signOut(),
+            ...(plan ? { authenticationMethod: "browser-pkce" } : {}),
+            startAuthentication: async () => {
+                if (planUnavailable)
+                    throw new Error(planUnavailable);
+                if (planSigningOut || disposed)
+                    throw new Error("This account is being disconnected. Wait before signing in again.");
+                return (planAuth ?? authentication).start();
+            },
+            getAuthentication: async (flowId) => {
+                const result = await (planAuth ?? authentication).get(flowId);
+                if (planAuth && result.phase === "succeeded")
+                    planWarning = undefined;
+                if (planAuth && result.phase === "succeeded" && !models.options.length)
+                    await refreshModels();
+                return result;
+            },
+            cancelAuthentication: () => (planAuth ?? authentication).cancel(),
+            signOut: async () => {
+                if (!planAuth)
+                    return authentication.signOut();
+                planSigningOut = true;
+                planGeneration++;
+                try {
+                    const stopped = await Promise.all([...active.values()].map(({ stop }) => stop()));
+                    if (stopped.some(value => !value))
+                        throw new Error("A ChatGPT task could not stop safely. Stop the task before signing out.");
+                    models = { default: "", options: [] };
+                    await planAuth.signOut();
+                    planWarning = undefined;
+                }
+                catch (error) {
+                    if (error.code !== "chatgpt_revocation_unconfirmed")
+                        throw error;
+                    planWarning = error.message;
+                }
+                finally {
+                    planSigningOut = false;
+                }
+            },
             snapshot,
             adapter: {
                 provider: DRIVER_KIND,
                 capabilities: {
                     sessionModelSwitch: "unsupported",
+                    // A guest's turn runs with no environment and the shell off (guestConfined).
+                    guestTurns: "confined",
                     queueing: true,
                     computerMcp: true,
                     localComputerMcp: true,
@@ -1622,7 +1829,10 @@ export const CodexDriver = {
                 },
             },
             dispose: async () => {
+                disposed = true;
+                planGeneration++;
                 await authentication.dispose();
+                await planAuth?.dispose();
                 await Promise.all([...active.values()].map(({ stop }) => stop()));
                 listeners.clear();
             },

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

@@ -38,8 +38,8 @@ export const GrokDriver = {
             models: () => MODELS,
             requestBody: (model, messages, stream) => ({ model, messages, stream }),
             httpErrorLabel: "xAI",
-            missingKeyError: `no xAI key — set ${config.apiKeyEnv} or config.json xai.key`,
-            unavailableReason: `no xAI API key — add {"xai":{"key":"xai-…"}} to ~/.openmausbot/config.json or set ${config.apiKeyEnv}`,
+            missingKeyError: `Save an xAI API key in Settings → API keys, or set ${config.apiKeyEnv}.`,
+            unavailableReason: "No xAI API key — open Settings → API keys.",
             timeoutMs: 120_000,
             retryScale: Number(process.env.FAKE_GROK_RETRY_SCALE ?? "1"),
             generateModel: () => "grok-3-mini",

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

@@ -45,7 +45,8 @@ export const MistralDriver = {
     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.",
+        settings: "connections",
+        signInCommand: "Save a Mistral API key in Settings → API keys, or set MISTRAL_API_KEY on the server.",
     },
     decodeConfig,
     defaultConfig: () => decodeConfig({}),
@@ -102,8 +103,8 @@ export const MistralDriver = {
             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.",
+            missingKeyError: "Save a Mistral API key in Settings → API keys, or set MISTRAL_API_KEY.",
+            unavailableReason: "No Mistral API key — open Settings → API keys.",
             timeoutMs: 180_000, billing: "metered", includeUsageInCompleted: true,
             nativeLog: {
                 source: "mistral.chat.completions",

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

@@ -32,6 +32,7 @@ export class ChatToolCalls {
             return;
         if (!Array.isArray(value))
             throw new ChatProtocolError("provider returned invalid tool_calls");
+        const omitted = (field) => field === undefined || (streaming && field === null);
         for (const [position, raw] of value.entries()) {
             const delta = object(raw);
             const index = streaming ? delta?.index : position;
@@ -39,9 +40,9 @@ export class ChatToolCalls {
                 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")
+            if (!omitted(delta.type) && delta.type !== "function")
                 throw new ChatProtocolError("unsupported tool-call type");
-            if (delta.id !== undefined) {
+            if (!omitted(delta.id)) {
                 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");
                 }
@@ -52,7 +53,7 @@ export class ChatToolCalls {
                 if (!fn)
                     throw new ChatProtocolError("provider returned an invalid tool-call function");
                 for (const field of ["name", "arguments"]) {
-                    if (fn[field] === undefined)
+                    if (omitted(fn[field]))
                         continue;
                     if (typeof fn[field] !== "string")
                         throw new ChatProtocolError("provider returned invalid tool-call arguments or name");

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

@@ -48,11 +48,32 @@ function rejectsToolsParameter(status, body) {
         /\b(?:tools|tool calling|function calling) (?:is|are) not supported\b/i.test(message) ||
         /^(?:unsupported|unknown|unrecognized) (?:parameter|field):?\s*['"]?tools['"]?[.!]?$/i.test(message.trim()));
 }
+class UnsupportedReasoningReplayError extends Error {
+}
+/** DeepSeek-style providers need `reasoning_content` echoed on a tool-call
+ *  assistant message; strict endpoints such as Groq reject the property. */
+function rejectsReasoningReplay(status, body) {
+    if (status !== 400 && status !== 422)
+        return false;
+    let envelope;
+    try {
+        envelope = object(JSON.parse(body));
+    }
+    catch {
+        return false;
+    }
+    const message = object(envelope?.error)?.message ?? envelope?.error;
+    return typeof message === "string" && /\breasoning_content\b/.test(message) &&
+        /\b(?:unsupported|not supported|unknown|unrecognized|unexpected|not permitted|not allowed)\b/i.test(message);
+}
 /** Shared runtime for the three providers that speak OpenAI chat completions. */
 export function createOpenAIChatRuntime(options) {
     const { input } = options;
     const listeners = new Set();
     const active = new Map();
+    /** Models whose endpoint rejected an echoed `reasoning_content`. In memory
+     * only: later rounds and turns omit the field instead of failing again. */
+    const reasoningReplayRejected = new Set();
     const emit = (event) => {
         for (const listener of Array.from(listeners))
             listener(event);
@@ -95,6 +116,9 @@ export function createOpenAIChatRuntime(options) {
                 const message = `${options.httpErrorLabel} HTTP ${response.status}${body ? `: ${body.slice(0, 200)}` : ""}`;
                 if (rejectsToolsParameter(response.status, body))
                     throw new UnsupportedChatToolsError(message);
+                if (messages.some((entry) => entry.reasoning_content !== undefined) && rejectsReasoningReplay(response.status, body)) {
+                    throw new UnsupportedReasoningReplayError(message);
+                }
                 throw new Error(message);
             }
             if (!stream || response.headers.get("content-type")?.includes("application/json")) {
@@ -377,7 +401,7 @@ export function createOpenAIChatRuntime(options) {
                     const parked = turnEntry.asides.splice(0);
                     if (parked.length)
                         messages.push({ role: "user", content: parked.join("\n\n") });
-                    native("out", options.nativeLog.outgoing(turn, messages, model));
+                    native("out", options.nativeLog.outgoing(turn, messages, model, tools.definitions));
                     let attempt = 0;
                     let completion;
                     for (;;) {
@@ -419,6 +443,16 @@ export function createOpenAIChatRuntime(options) {
                         catch (value) {
                             const error = asError(value);
                             const verdict = classifyError(error);
+                            // A schema rejection of the echoed reasoning executed nothing
+                            // upstream, so the same transcript without that one property
+                            // repeats no operation. The error needs the field in the
+                            // request, so the stripped resend cannot loop.
+                            if (error instanceof UnsupportedReasoningReplayError && !streamed && !abort.signal.aborted) {
+                                reasoningReplayRejected.add(model);
+                                for (const message of messages)
+                                    delete message.reasoning_content;
+                                continue;
+                            }
                             // Only our optional question changed a previously plain request.
                             // A structured parameter rejection has executed nothing; never
                             // downgrade mounted tools, streamed output or a handled call.
@@ -474,7 +508,7 @@ export function createOpenAIChatRuntime(options) {
                     if (seenCalls.size > MAX_CHAT_TOOL_CALLS)
                         throw new ChatProtocolError("tool-call limit reached");
                     messages.push({ role: "assistant", content: completion.text || null, tool_calls: completion.toolCalls,
-                        ...(completion.protocolReasoning ? { reasoning_content: completion.protocolReasoning } : {}),
+                        ...(completion.protocolReasoning && !reasoningReplayRejected.has(model) ? { reasoning_content: completion.protocolReasoning } : {}),
                         ...(completion.protocolReasoningDetails.length ? { reasoning_details: completion.protocolReasoningDetails } : {}),
                     });
                     const screenshotParts = [];
@@ -637,7 +671,11 @@ export function createOpenAIChatRuntime(options) {
                 sessionModelSwitch: "in-session", customMcp: options.tools !== false, agentsMcp: options.tools !== false, composioMcp: options.tools !== false,
                 // The runtime owns the whole tool loop, so it can always take a
                 // user message mid-turn: park it, deliver before the next completion.
-                queueing: true },
+                queueing: true,
+                // No shell and no file tool on the host at all: only MCP tools, each
+                // call a card in Ask (the Boat's `exec` runs on the Boat). A guest's
+                // turn is as confined as it gets.
+                guestTurns: "confined" },
             sendTurn,
             interruptTurn: async (threadId, turnId) => {
                 const turn = active.get(threadId);