openmausbot 0.1.91 → 0.1.92

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

@@ -52,6 +52,10 @@ import { redactSecretsInText } from "../../redact.js";
 import { recoveryPromptFor } from "../../resume-recovery.js";
 import { sessionIdlePolicy } from "../session-idle.js";
 import { classifyError } from "../retry.js";
+const ACCOUNT_ERROR_CODES = new Set([
+    "invalid_credentials", "inactive_subscription", "insufficient_funds", "quota_or_region_restriction",
+]);
+const isAccountError = (code) => code !== undefined && ACCOUNT_ERROR_CODES.has(code);
 /** ACP vendors put the actionable cause in error.data while keeping the
  * JSON-RPC message generic. Only surface known text fields, never a response
  * body/config dump, and redact before bounding the displayed diagnostic. */
@@ -141,6 +145,24 @@ function acpVariantOption(result) {
     };
 }
 const TOOL_LOG_TEXT_LIMIT = 64_000;
+/** Every model id a session config snapshot offers under `configId`,
+ * flattening grouped options. Empty when the agent listed none. */
+export function offeredModels(result, configId) {
+    const option = (Array.isArray(result?.configOptions) ? result.configOptions : []).find((entry) => entry?.id === configId);
+    const ids = [];
+    const visit = (entries) => {
+        if (!Array.isArray(entries))
+            return;
+        for (const entry of entries) {
+            if (typeof entry?.value === "string")
+                ids.push(entry.value);
+            else if (Array.isArray(entry?.options))
+                visit(entry.options);
+        }
+    };
+    visit(option?.options);
+    return ids;
+}
 async function readAcpImageBlocks(images) {
     return Promise.all(images.map(async (image) => ({
         type: "image",
@@ -250,6 +272,11 @@ export function versionAtLeast(installed, floor) {
     return true;
 }
 export function createAcpDriver(support) {
+    // Without a per-turn configureSession nothing would ever apply the mode
+    // that sessionScopedApproval keeps out of the spawn contract.
+    if (support.sessionScopedApproval && !support.configureSession) {
+        throw new Error(`${support.displayName}: sessionScopedApproval needs configureSession to apply each turn's mode`);
+    }
     const DRIVER_KIND = support.driverKind;
     const SOURCE = support.nativeSource;
     const decodeConfig = decodeAcpConfig(support.defaultCli);
@@ -289,13 +316,18 @@ export function createAcpDriver(support) {
                 return env;
             };
             let models = support.models;
+            // Models this account itself offered (see sessionModelEnv): the
+            // discovered catalog, never the static one, or a live session's list.
+            let accountModels = null;
             const refreshModels = async () => {
                 if (!support.resolveModels)
                     return;
                 try {
                     const resolved = await support.resolveModels(childEnv(), config, instanceId);
-                    if (resolved.options.length)
+                    if (resolved.options.length) {
                         models = resolved;
+                        accountModels = new Set(resolved.options.map((option) => option.id));
+                    }
                 }
                 catch {
                     // Keep the last usable catalog when an optional discovery source is down.
@@ -1026,8 +1058,12 @@ export function createAcpDriver(support) {
                     return { turnId };
                 }
                 const resolvedModel = support.resolveTurnModel?.(turn.model, env);
-                support.applyTurnEnv?.(env, { model: resolvedModel, requestedModel: turn.model, fullAuto: turnConfig.fullAuto === true });
-                const cliTurn = resolvedModel !== undefined && resolvedModel !== turn.model
+                support.applyTurnEnv?.(env, {
+                    model: resolvedModel, requestedModel: turn.model, fullAuto: turnConfig.fullAuto === true, botId: turn.botId, cwd,
+                });
+                // Rebound once, before the prompt, when a fallbackModel support swaps
+                // a model this session does not offer for one it does.
+                let cliTurn = resolvedModel !== undefined && resolvedModel !== turn.model
                     ? { ...turn, model: resolvedModel }
                     : turn;
                 const mcpServers = acpMcpServers(turn);
@@ -1067,7 +1103,31 @@ export function createAcpDriver(support) {
                 // riding a child spawned under the old env. Hash it so secrets
                 // never sit in the key itself.
                 const envFingerprint = createHash("sha256").update(JSON.stringify(spawnEnv)).digest("hex").slice(0, 16);
-                const contractKey = JSON.stringify([launch.command, launch.args ?? [], spawnArgs, cwd, turnConfig.fullAuto === true, envFingerprint]);
+                // A support that applies the approval mode to the session on every
+                // turn gets the same process whatever the mode: an approval change
+                // is one RPC, not a cold start.
+                const contractKey = JSON.stringify([
+                    launch.command, launch.args ?? [], spawnArgs, cwd,
+                    support.sessionScopedApproval ? null : turnConfig.fullAuto === true, envFingerprint,
+                    support.spawnFingerprint?.(spawnEnv) ?? null,
+                ]);
+                // The new-session default model rides the spawn env but stays out of
+                // the fingerprint above: only session/new reads it, and a pooled
+                // process switches later models over the wire as before.
+                const launchModel = support.sessionModelEnv && cliTurn.model && /^[\w.:/-]{1,200}$/u.test(cliTurn.model)
+                    && accountModels?.has(cliTurn.model) ? cliTurn.model : undefined;
+                const launchEnv = support.sessionModelEnv && launchModel
+                    ? { ...spawnEnv, [support.sessionModelEnv]: launchModel }
+                    : spawnEnv;
+                // whether this turn's process was started by this turn: its model
+                // list is then current, not a pooled process's older one
+                let launchedThisTurn = false;
+                const launchSession = () => {
+                    const opened = openSession(threadId, launch, [...(launch.args ?? []), ...spawnArgs], launchEnv, cwd, contractKey);
+                    opened.launchModel = launchModel;
+                    launchedThisTurn = true;
+                    return opened;
+                };
                 const sessionKey = JSON.stringify(mcpServers);
                 if (turn.sessionReset) {
                     closeSession(threadId, "reset");
@@ -1092,7 +1152,7 @@ export function createAcpDriver(support) {
                         else
                             closeSession(threadId, "contract");
                     }
-                    session = openSession(threadId, launch, [...(launch.args ?? []), ...spawnArgs], spawnEnv, cwd, contractKey);
+                    session = launchSession();
                     sessions.set(threadId, session);
                 }
                 // `session` rebinds mid-turn: when the establishment retry below
@@ -1107,6 +1167,16 @@ export function createAcpDriver(support) {
                     rejectStartup = reject;
                 }) : null;
                 const asks = new Map();
+                // What this turn reports and applies. A model fallback (below)
+                // replaces both: a saved variant belongs to the model it replaced.
+                let reportedModel = turn.model;
+                let variant = turn.variant;
+                // set below when this process lists fewer models than the catalog
+                let staleProcess = false;
+                // Set while a sessionScopedApproval support applies this turn's mode.
+                // Still set if that throws: the pooled session may be left on an
+                // earlier turn's looser mode, so its process must not be reused.
+                let approvalUnconfirmed = false;
                 const modelOf = (result) => {
                     const option = (Array.isArray(result?.configOptions) ? result.configOptions : []).find((entry) => entry?.id === (support.selectModel?.configId ?? "model"));
                     return typeof option?.currentValue === "string" ? option.currentValue : null;
@@ -1122,7 +1192,7 @@ export function createAcpDriver(support) {
                     emit({
                         ...base(threadId, turnId),
                         type: "session.model-variants",
-                        model: nativeModel === cliTurn.model ? (turn.model ?? nativeModel) : nativeModel,
+                        model: nativeModel === cliTurn.model ? (reportedModel ?? nativeModel) : nativeModel,
                         variants: {
                             options: option?.options ?? [],
                             ...(option?.currentValue !== undefined ? { currentValue: option.currentValue } : {}),
@@ -1133,8 +1203,8 @@ export function createAcpDriver(support) {
                     if (!support.modelVariants)
                         throw new Error(`${support.displayName} does not support model variants`);
                     const option = acpVariantOption(session.sessionConfigResult);
-                    if (!option || !option.options.some((entry) => entry.id === turn.variant)) {
-                        throw new Error(`${support.displayName} does not advertise variant ${turn.variant} for this model`);
+                    if (!option || !option.options.some((entry) => entry.id === variant)) {
+                        throw new Error(`${support.displayName} does not advertise variant ${variant} for this model`);
                     }
                     return option;
                 };
@@ -1304,7 +1374,7 @@ export function createAcpDriver(support) {
                                 // session/new on the replacement child.
                                 session.current = null;
                                 closeSession(threadId, "reestablish");
-                                session = openSession(threadId, launch, [...(launch.args ?? []), ...spawnArgs], spawnEnv, cwd, contractKey);
+                                session = launchSession();
                                 sessions.set(threadId, session);
                                 session.current = current;
                                 runtimeAcceptsImages = await handshake();
@@ -1352,6 +1422,43 @@ export function createAcpDriver(support) {
                             if (support.selectModel) {
                                 const { configId } = support.selectModel;
                                 selectedModel = modelOf(session.sessionConfigResult);
+                                const wanted = cliTurn.model;
+                                const offered = offeredModels(session.sessionConfigResult, configId);
+                                // A process started without a default model lists exactly
+                                // what this account offers.
+                                if (support.sessionModelEnv && !session.launchModel && offered.length)
+                                    accountModels = new Set(offered);
+                                // The instance catalog lists the model but a pooled process
+                                // does not: the process is older than the catalog (a provider
+                                // added since it started). That is no reason to run another
+                                // model. The switch below fails with the runtime's own words,
+                                // and the process is closed so the retry starts on a fresh
+                                // one. A process this turn started is current, so there the
+                                // catalog is the stale one and the fallback applies.
+                                staleProcess = Boolean(support.fallbackModel && wanted && !launchedThisTurn && offered.length
+                                    && !offered.includes(wanted) && models.options.some((option) => option.id === wanted));
+                                // A local inject writes its provider for this turn, so a
+                                // process started earlier may not list it yet: never replace it.
+                                if (support.fallbackModel && offered.length && !skipSubscriptionAuthForLocalInject(turn.model)
+                                    && !staleProcess && (!wanted || !offered.includes(wanted))) {
+                                    const fallback = support.fallbackModel(session.sessionConfigResult, models.default);
+                                    if (fallback && fallback !== wanted && offered.includes(fallback)) {
+                                        const notice = wanted ? `${wanted}\n${fallback}` : null;
+                                        if (notice && session.fallbackNotice !== notice) {
+                                            session.fallbackNotice = notice;
+                                            emit({
+                                                ...base(threadId, turnId),
+                                                type: "runtime.notice",
+                                                message: `${support.displayName} no longer offers ${wanted}, so this conversation uses ${fallback}. ` +
+                                                    "Choose another model for this bot to stop seeing this.",
+                                            });
+                                        }
+                                        cliTurn = { ...cliTurn, model: fallback };
+                                        current.turn = cliTurn;
+                                        reportedModel = fallback;
+                                        variant = undefined;
+                                    }
+                                }
                                 if (cliTurn.model && cliTurn.model !== selectedModel) {
                                     sessionResult = await request("session/set_config_option", { sessionId, configId, value: cliTurn.model }, INIT_TIMEOUT, receiveModelVariants);
                                     selectedModel = modelOf(session.sessionConfigResult);
@@ -1363,6 +1470,7 @@ export function createAcpDriver(support) {
                                 }
                             }
                             if (support.configureSession) {
+                                approvalUnconfirmed = support.sessionScopedApproval === true;
                                 await support.configureSession({
                                     request: (method, params, timeoutMs) => request(method, params, timeoutMs ?? SESSION_CONFIG_TIMEOUT),
                                     sessionId,
@@ -1372,17 +1480,18 @@ export function createAcpDriver(support) {
                                         ? sessionResult.models.availableModels
                                         : [],
                                 });
+                                approvalUnconfirmed = false;
                                 // initialize's currentModelId is the CLI default,
                                 // not the model this turn asked for. After a successful pin,
                                 // report the slug we set so the UI does not claim otherwise.
                                 if (!selectedModel && cliTurn.model)
                                     selectedModel = cliTurn.model;
                             }
-                            if (turn.variant !== undefined) {
+                            if (variant !== undefined) {
                                 const option = requestedVariantOption();
-                                await request("session/set_config_option", { sessionId, configId: option.configId, value: turn.variant }, SESSION_CONFIG_TIMEOUT, receiveModelVariants);
-                                if (requestedVariantOption().currentValue !== turn.variant) {
-                                    throw new Error(`${support.displayName} did not apply variant ${turn.variant}`);
+                                await request("session/set_config_option", { sessionId, configId: option.configId, value: variant }, SESSION_CONFIG_TIMEOUT, receiveModelVariants);
+                                if (requestedVariantOption().currentValue !== variant) {
+                                    throw new Error(`${support.displayName} did not apply variant ${variant}`);
                                 }
                             }
                         }
@@ -1421,7 +1530,7 @@ export function createAcpDriver(support) {
                         if (support.modelVariants && cliTurn.model && modelOf(session.sessionConfigResult) !== cliTurn.model) {
                             throw new Error(`${support.displayName} changed model before the prompt`);
                         }
-                        if (turn.variant !== undefined && requestedVariantOption().currentValue !== turn.variant) {
+                        if (variant !== undefined && requestedVariantOption().currentValue !== variant) {
                             throw new Error(`${support.displayName} changed variant before the prompt`);
                         }
                         if (state.settled || state.stopped || session.closing)
@@ -1441,11 +1550,31 @@ export function createAcpDriver(support) {
                         // gemini put it under _meta. Read both rather than lose the count.
                         const usage = result?.usage ?? result?._meta ?? {};
                         if (typeof usage.inputTokens === "number" || typeof usage.outputTokens === "number") {
+                            // opencode 1.18.25 keeps only the uncached share in inputTokens
+                            // and reports cache reads beside it (omitted when 0); some
+                            // agents count them inside inputTokens. `input` is the whole
+                            // prompt with `cachedInput` naming its cached part — the same
+                            // convention as the Claude driver and the store — and
+                            // totalTokens tells the two wire shapes apart. Cache writes
+                            // stay out of `input`, exactly as in the Claude driver, and an
+                            // absent cache count emits the bare shape with no cachedInput
+                            // key: absent is not zero.
+                            const input = usage.inputTokens ?? 0;
+                            const output = usage.outputTokens ?? 0;
+                            const cachedRead = typeof usage.cachedReadTokens === "number" && usage.cachedReadTokens > 0
+                                ? usage.cachedReadTokens
+                                : null;
+                            const exclusive = cachedRead !== null
+                                && (typeof usage.totalTokens !== "number"
+                                    || usage.totalTokens >= input + output + cachedRead);
                             emit({
                                 ...base(threadId, turnId),
                                 type: "thread.token-usage.updated",
-                                input: usage.inputTokens ?? 0,
-                                output: usage.outputTokens ?? 0,
+                                input: cachedRead !== null && exclusive ? input + cachedRead : input,
+                                output,
+                                ...(cachedRead !== null
+                                    ? { cachedInput: exclusive ? cachedRead : Math.min(cachedRead, input) }
+                                    : {}),
                             });
                         }
                         const reason = result?.stopReason;
@@ -1475,12 +1604,19 @@ export function createAcpDriver(support) {
                             // classifier is preferred; loginNote remains a compatibility
                             // fallback for existing ACP supports.
                             const needsAuth = code === "invalid_credentials" || code === "inactive_subscription"
-                                || message === support.loginNote;
+                                || code === "insufficient_funds" || message === support.loginNote;
+                            // A key, credit, quota or subscription problem is the account's,
+                            // not the process's: the child that reported it is healthy, so it
+                            // stays pooled and the retry after a fix starts warm.
+                            const accountError = isAccountError(code);
                             const failure = classifyError({ text: message });
                             const transientStartup = failure.transient || (failure.reason === "unknown" && code === "upstream_outage");
                             const denied = /\b(?:(?:permission|access) denied|(?:approval|permission) (?:required|denied|rejected)|requires? (?:approval|permission)|policy (?:restriction|violation)|(?:blocked|denied|restricted) by (?:the )?policy)\b/i.test(message);
-                            if (turn.startupRecovery && transientStartup && !needsAuth && !denied && (!code || code === "upstream_outage")
-                                && ![-32700, -32600, -32601, -32602].includes(e?.code)
+                            // An unconfirmed approval switch sent no prompt and its process
+                            // is discarded either way, so a fresh one can take the turn.
+                            const retryableStartup = approvalUnconfirmed || (transientStartup && (!code || code === "upstream_outage")
+                                && ![-32700, -32600, -32601, -32602].includes(e?.code));
+                            if (turn.startupRecovery && retryableStartup && !needsAuth && !accountError && !denied
                                 && !state.promptSent && !state.startupActivity && !state.producedItem && !state.text
                                 && !state.stopped && !session.closing && !asks.size && !current.runningTools.size) {
                                 // Quiesce before killing: the child's close event must not
@@ -1508,7 +1644,7 @@ export function createAcpDriver(support) {
                             emit({
                                 ...base(threadId, turnId),
                                 type: "runtime.error",
-                                message,
+                                message: accountError ? support.describeAccountError?.(code, cliTurn.model) ?? message : message,
                                 ...(needsAuth ? { setup: true } : {}),
                             });
                             // Internal RPC failures can leave a live child poisoned just
@@ -1516,10 +1652,20 @@ export function createAcpDriver(support) {
                             // start the next turn. Never replay this accepted prompt: it
                             // may already have executed tools. The next explicit turn can
                             // resume the recorded session on a fresh process.
-                            if (!needsAuth && (e?.acpPromptStall === true || e?.acpSessionFailure === true
+                            if (!needsAuth && !accountError && (e?.acpPromptStall === true || e?.acpSessionFailure === true
                                 || code === "upstream_outage") && session.child.exitCode === null && !session.closing) {
                                 closeSession(threadId, e?.acpPromptStall === true ? "prompt-stall" : "rpc-failure");
                             }
+                            else if (approvalUnconfirmed && session.child.exitCode === null && !session.closing) {
+                                // Fail closed: the session may still hold a looser mode from
+                                // an earlier turn. Nothing was prompted; the next turn starts
+                                // a fresh process, whose session begins in the runtime's own
+                                // default mode, and applies its mode there.
+                                closeSession(threadId, "approval-unconfirmed");
+                            }
+                            else if (staleProcess && !state.promptSent && session.child.exitCode === null && !session.closing) {
+                                closeSession(threadId, "stale-models");
+                            }
                             settle(threadId, session, false, needsAuth ? "auth_required" : "rpc_error");
                         }
                     }