openmausbot 0.1.88 → 0.1.89

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

@@ -40,7 +40,7 @@ import { describeSpawnFailure, execCli, killCliTree, spawnCli } from "../../proc
 export function skipSubscriptionAuthForLocalInject(model) {
     return Boolean(decodeInjectId(model));
 }
-import { newEventId, newId } from "../../contracts.js";
+import { newEventId, newId, TurnNotStartedError } from "../../contracts.js";
 import { augmentedPath } from "../../env-path.js";
 import { supportsApprovalMode } from "../../../shared/approval-mode.js";
 import { parseAskQuestions, parseChoices, questionAnswersByQuestion } from "../../../shared/ask-question.js";
@@ -51,6 +51,7 @@ import { extractMcpImages } from "../../mcp-tool-images.js";
 import { redactSecretsInText } from "../../redact.js";
 import { recoveryPromptFor } from "../../resume-recovery.js";
 import { sessionIdlePolicy } from "../session-idle.js";
+import { classifyError } from "../retry.js";
 /** 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. */
@@ -98,6 +99,20 @@ const promptIdleTimeoutMs = () => {
     const ms = Number(raw);
     return Number.isFinite(ms) && ms > 0 ? ms : 0;
 };
+/** Keep a turn's set of running tool calls in step with the agent's
+ * `tool_call` / `tool_call_update` notifications: a call is running from
+ * the first update that is not terminal until one that is. A `tool_call`
+ * without a status is pending (ACP's default); a `tool_call_update` without
+ * one leaves the call as it was. */
+function trackRunningTool(current, update, defaultStatus) {
+    if (typeof update.toolCallId !== "string" || !update.toolCallId)
+        return;
+    const status = update.status ?? defaultStatus;
+    if (status === "completed" || status === "failed")
+        current.runningTools.delete(update.toolCallId);
+    else if (status === "pending" || status === "in_progress")
+        current.runningTools.add(update.toolCallId);
+}
 const CLIENT_FILE_MAX_BYTES = 8 * 1024 * 1024;
 function acpVariantOption(result) {
     const option = (Array.isArray(result?.configOptions) ? result.configOptions : []).find((entry) => entry?.type === "select" && typeof entry.id === "string"
@@ -296,6 +311,23 @@ export function createAcpDriver(support) {
             // contract prompts the live session instead of paying the handshake
             // again. An idle session closes after SESSION_IDLE_MS of quiet.
             const sessions = new Map();
+            // Closing removes a session from the pool, not its native writer lease.
+            // Retain every closing Qwen child until its process tree is gone, even
+            // when Stop or a failed turn lets another turn start during cleanup.
+            const retiring = new Map();
+            const retireChild = async (threadId, child) => {
+                let children = retiring.get(threadId);
+                if (!children)
+                    retiring.set(threadId, children = new Set());
+                children.add(child);
+                const stopped = await killCliTree(child);
+                if (stopped) {
+                    children.delete(child);
+                    if (!children.size && retiring.get(threadId) === children)
+                        retiring.delete(threadId);
+                }
+                return stopped;
+            };
             const { idleMs: SESSION_IDLE_MS } = sessionIdlePolicy("ACP");
             const closeSession = (threadId, why) => {
                 const session = sessions.get(threadId);
@@ -308,16 +340,20 @@ export function createAcpDriver(support) {
                 // a new turn must never adopt a closing session
                 sessions.delete(threadId);
                 session.acp.close();
-                // stdin EOF asks the agent to exit; EOF is not a guaranteed exit
-                // signal for ACP agents, so insist after a grace period
+                // EOF is not a guaranteed exit signal. Qwen must be tracked before
+                // another turn can resume its history; other agents keep their grace.
                 try {
                     session.child.stdin.end();
                 }
                 catch { }
-                const kill = setTimeout(() => {
-                    void killCliTree(session.child);
-                }, 5_000);
-                kill.unref?.();
+                if (support.restartOnMcpChange)
+                    void retireChild(threadId, session.child);
+                else {
+                    const kill = setTimeout(() => {
+                        void killCliTree(session.child);
+                    }, 5_000);
+                    kill.unref?.();
+                }
             };
             const armIdle = (threadId) => {
                 const session = sessions.get(threadId);
@@ -436,6 +472,7 @@ export function createAcpDriver(support) {
                 if (!current || current.state.settled)
                     return;
                 current.state.settled = true;
+                current.acknowledge();
                 if (current.interruptTimer)
                     clearTimeout(current.interruptTimer);
                 for (const finish of current.asks.values())
@@ -521,8 +558,9 @@ export function createAcpDriver(support) {
                         if (idleTimer)
                             clearTimeout(idleTimer);
                         idleTimer = setTimeout(() => {
-                            // Waiting for a person is not an unresponsive agent.
-                            if (session.current?.asks.size) {
+                            // Waiting for a person, or for a tool the agent is running,
+                            // is not an unresponsive agent.
+                            if (session.current?.asks.size || session.current?.runningTools.size) {
                                 armIdle();
                                 return;
                             }
@@ -639,6 +677,7 @@ export function createAcpDriver(support) {
                 // server→client permission request → canonical request.opened,
                 // answered fail-closed for the running turn
                 const handleServerRequest = (msg, current) => {
+                    current.state.startupActivity = true;
                     if (msg.method === "fs/read_text_file" || msg.method === "fs/write_text_file") {
                         void handleClientFileRequest(msg);
                         return;
@@ -778,6 +817,9 @@ export function createAcpDriver(support) {
                             current.receiveModelVariants(p.update);
                         return;
                     }
+                    if (current && ["agent_message_chunk", "agent_thought_chunk", "tool_call", "tool_call_update"].includes(p.update?.sessionUpdate)) {
+                        current.state.startupActivity = true;
+                    }
                     if (!current || !current.state.promptSent)
                         return;
                     const u = p.update ?? {};
@@ -811,6 +853,7 @@ export function createAcpDriver(support) {
                         }
                         case "tool_call": {
                             current.flushAssistantText();
+                            trackRunningTool(current, u, "pending");
                             emit({
                                 ...base(threadId, current.turnId),
                                 type: "item.started",
@@ -823,6 +866,7 @@ export function createAcpDriver(support) {
                             break;
                         }
                         case "tool_call_update": {
+                            trackRunningTool(current, u);
                             if (u.status === "completed" || u.status === "failed") {
                                 current.state.producedItem = true;
                                 emit({
@@ -1010,8 +1054,8 @@ export function createAcpDriver(support) {
                 // transformEnv-policy supports (opencode). mcpServers are session
                 // establishment inputs — they ride session/new and session/load over
                 // the wire — and the harness mints fresh integration bearer tokens
-                // every turn, so they must not respawn the process; a change instead
-                // re-establishes the session below (see sessionKey).
+                // every turn. Most agents apply changes on live load; those that cache
+                // the old MCP clients must resume on a fresh process (see sessionKey).
                 // The env the spawned child actually receives is part of the
                 // contract too, and arrives hashed as envFingerprint for the same
                 // reason.
@@ -1030,7 +1074,8 @@ export function createAcpDriver(support) {
                 }
                 const pooled = sessions.get(threadId);
                 let session;
-                if (pooled && !pooled.dead && !pooled.closing && pooled.contractKey === contractKey) {
+                if (pooled && !pooled.dead && !pooled.closing && pooled.contractKey === contractKey
+                    && (!support.restartOnMcpChange || pooled.sessionKey === sessionKey)) {
                     // adoption cancels the idle countdown — a running turn is not quiet
                     if (pooled.idleTimer)
                         clearTimeout(pooled.idleTimer);
@@ -1053,7 +1098,13 @@ export function createAcpDriver(support) {
                 // respawns the child, every wire call must reach the live record, so
                 // nothing captures the connection off it.
                 const request = (method, params, timeoutMs, receive, idleMs, idleMessage) => session.acp.request(method, params, timeoutMs, receive, idleMs, idleMessage);
-                const state = { settled: false, promptSent: false, text: "", producedItem: false };
+                const state = { settled: false, promptSent: false, text: "", producedItem: false, startupActivity: false, stopped: false };
+                let acknowledge = () => { };
+                let rejectStartup = (_error) => { };
+                const startupAck = turn.startupRecovery ? new Promise((resolve, reject) => {
+                    acknowledge = () => resolve({ turnId });
+                    rejectStartup = reject;
+                }) : null;
                 const asks = new Map();
                 const modelOf = (result) => {
                     const option = (Array.isArray(result?.configOptions) ? result.configOptions : []).find((entry) => entry?.id === (support.selectModel?.configId ?? "model"));
@@ -1101,12 +1152,15 @@ export function createAcpDriver(support) {
                     turnConfig,
                     controlsHost,
                     state,
+                    acknowledge,
                     asks,
+                    runningTools: new Set(),
                     interruptTimer: null,
                     flushAssistantText,
                     receiveModelVariants,
                 };
                 const interrupt = () => {
+                    state.stopped = true;
                     if (session.sessionId) {
                         session.acp.send({ jsonrpc: "2.0", method: "session/cancel", params: { sessionId: session.sessionId } });
                         if (current.interruptTimer)
@@ -1123,7 +1177,7 @@ export function createAcpDriver(support) {
                         closeSession(threadId, "stop");
                     }
                 };
-                active.set(threadId, { stop: () => closeSession(threadId, "stop"), interrupt, turnId, asks });
+                active.set(threadId, { stop: () => { state.stopped = true; closeSession(threadId, "stop"); }, interrupt, turnId, asks });
                 emit({ ...base(threadId, turnId), type: "turn.started" });
                 session.current = current;
                 (async () => {
@@ -1134,6 +1188,19 @@ export function createAcpDriver(support) {
                         // Returns whether this runtime accepts image prompts, for the
                         // prompt phase below.
                         const handshake = async () => {
+                            // Also covers timeout/reset/re-establishment, not just rotated
+                            // MCP credentials. Stop remains wired while cleanup is pending.
+                            for (const child of retiring.get(threadId) ?? []) {
+                                const stopped = await retireChild(threadId, child);
+                                if (state.settled || session.closing)
+                                    throw new Error("session closed");
+                                if (!stopped) {
+                                    closeSession(threadId, "replace-failed");
+                                    throw new Error(`${support.displayName} could not close its previous tool session. Try again.`);
+                                }
+                            }
+                            if (state.settled || session.closing)
+                                throw new Error("session closed");
                             if (!session.initResult) {
                                 session.initResult = await request("initialize", {
                                     protocolVersion: 1,
@@ -1356,10 +1423,13 @@ export function createAcpDriver(support) {
                         if (turn.variant !== undefined && requestedVariantOption().currentValue !== turn.variant) {
                             throw new Error(`${support.displayName} changed variant before the prompt`);
                         }
+                        if (state.settled || state.stopped || session.closing)
+                            throw new Error("turn stopped");
                         state.promptSent = true;
+                        acknowledge();
                         const promptIdleMs = promptIdleTimeoutMs();
-                        const result = await request("session/prompt", { sessionId, prompt: [{ type: "text", text }, ...imageBlocks] }, undefined, undefined, promptIdleMs, `${DRIVER_KIND} went fully silent ${Math.round(promptIdleMs / 1000)} s after the message and the turn was stopped. ` +
-                            "Raise OPENMAUS_ACP_PROMPT_IDLE_TIMEOUT_MS if this model legitimately takes longer to answer.");
+                        const result = await request("session/prompt", { sessionId, prompt: [{ type: "text", text }, ...imageBlocks] }, undefined, undefined, promptIdleMs, `${DRIVER_KIND} sent nothing for ${Math.round(promptIdleMs / 1000)} s with no tool running, so the turn was stopped as stuck. ` +
+                            "Send the message again to retry. On a self-hosted server, OPENMAUS_ACP_PROMPT_IDLE_TIMEOUT_MS sets this limit (0 turns it off).");
                         if (pendingSplitReceipt) {
                             // session/prompt resolving is the acceptance boundary: a
                             // rejected prompt leaves the receipt unwritten, so the next
@@ -1405,6 +1475,35 @@ export function createAcpDriver(support) {
                             // fallback for existing ACP supports.
                             const needsAuth = code === "invalid_credentials" || code === "inactive_subscription"
                                 || message === support.loginNote;
+                            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)
+                                && !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
+                                // publish a terminal completion before the harness can recover.
+                                state.settled = true;
+                                session.current = null;
+                                if (current.interruptTimer)
+                                    clearTimeout(current.interruptTimer);
+                                closeSession(threadId, "startup-recovery");
+                                const stopped = await killCliTree(session.child).catch(() => false);
+                                if (current.interruptTimer)
+                                    clearTimeout(current.interruptTimer);
+                                active.delete(threadId);
+                                if (stopped && !state.stopped) {
+                                    rejectStartup(new TurnNotStartedError(turnId, message));
+                                    return;
+                                }
+                                acknowledge();
+                                if (!state.stopped)
+                                    emit({ ...base(threadId, turnId), type: "runtime.error", message });
+                                emit({ ...base(threadId, turnId), type: "turn.completed", ok: state.stopped,
+                                    stopReason: state.stopped ? "cancelled" : "rpc_error", cost: null });
+                                return;
+                            }
                             emit({
                                 ...base(threadId, turnId),
                                 type: "runtime.error",
@@ -1424,7 +1523,7 @@ export function createAcpDriver(support) {
                         }
                     }
                 })();
-                return { turnId };
+                return startupAck ?? { turnId };
             };
             const snapshot = async () => {
                 const env = childEnv();
@@ -1481,6 +1580,10 @@ export function createAcpDriver(support) {
                         // idle pooled sessions have no running turn — close them too
                         for (const threadId of Array.from(sessions.keys()))
                             closeSession(threadId, "stopAll");
+                        for (const [threadId, children] of retiring) {
+                            for (const child of children)
+                                void retireChild(threadId, child);
+                        }
                     },
                     onEvent: (listener) => {
                         listeners.add(listener);
@@ -1492,6 +1595,10 @@ export function createAcpDriver(support) {
                         stop();
                     for (const threadId of Array.from(sessions.keys()))
                         closeSession(threadId, "dispose");
+                    for (const [threadId, children] of retiring) {
+                        for (const child of children)
+                            void retireChild(threadId, child);
+                    }
                     listeners.clear();
                 },
             };

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

@@ -235,6 +235,9 @@ const support = {
     // A raw -m only changes the model within the saved provider. ACP switches
     // the complete route and confirms it before any prompt leaves OMB.
     spawnArgs: (config, turn) => ["--acp", ...qwenApprovalArgs(config.fullAuto, turn.approvalMode)],
+    // Qwen's live session/load returns its cached MCP clients, ignoring fresh
+    // credentials. Cold-load the same conversation when those inputs change.
+    restartOnMcpChange: true,
     selectModel: { configId: "model" },
     pickAuthMethod: () => null,
     authFailure: "continue",

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

@@ -374,7 +374,7 @@ export const BoxAgentDriver = {
             snapshot,
             adapter: {
                 provider: DRIVER_KIND,
-                capabilities: { sessionModelSwitch: "in-session" },
+                capabilities: { sessionModelSwitch: "in-session", remoteAgent: true, usesCloudComputer: true },
                 sendTurn,
                 interruptTurn: async (threadId) => active.get(threadId)?.cancel(),
                 respondToRequest: async (threadId, requestId, decision) => {

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

@@ -617,7 +617,11 @@ export function createOpenAIChatRuntime(options) {
             : { state: "unavailable", reason: options.unavailableReason },
         adapter: {
             provider: options.driverKind,
-            capabilities: { ...(options.computerUse ? { computerMcp: options.tools !== false, cloudComputerMcp: options.tools !== false, localComputerMcp: options.tools !== false,
+            capabilities: { ...(options.computerUse ? { computerMcp: options.tools !== false,
+                    // Same gate as cloudComputerMcp: with tools off the runtime cannot
+                    // mount the leased Box descriptor either. The fleet invariant test
+                    // pins usesCloudComputer === (remoteAgent || cloudComputerMcp).
+                    usesCloudComputer: options.tools !== false, cloudComputerMcp: options.tools !== false, localComputerMcp: options.tools !== false,
                     browserMcp: options.tools !== false, nativeImageInput: true, images: true } : {}),
                 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

package/dist-server/server/harness-capabilities.js

@@ -7,7 +7,7 @@
 // uses one envelope profile and lets the per-driver capability decide the
 // delta; the tool names themselves come from the real catalog, so this
 // never drifts from what a turn is actually shown.
-import { APPROVAL_MODES, supportsApprovalMode } from "../shared/approval-mode.js";
+import { APPROVAL_MODES, supportsApprovalMode as driverKindSupportsApprovalMode } from "../shared/approval-mode.js";
 import { availableTools } from "./drivers/agents-catalog.js";
 /** The widest turn the harness can build: every optional integration on and
  * a coordinating (room) turn, where the room-only coordination tools exist.
@@ -35,8 +35,8 @@ export function harnessCapabilityLines(from, to) {
             : "Loses peer coordination and every team tool: " + names.length + " tools including " + coordination.join(", ") + " go away.");
     }
     if (from.driverKind !== to.driverKind) {
-        const lost = APPROVAL_MODES.filter((mode) => supportsApprovalMode(from.driverKind, mode) && !supportsApprovalMode(to.driverKind, mode));
-        const gained = APPROVAL_MODES.filter((mode) => !supportsApprovalMode(from.driverKind, mode) && supportsApprovalMode(to.driverKind, mode));
+        const lost = APPROVAL_MODES.filter((mode) => driverKindSupportsApprovalMode(from.driverKind, mode) && !driverKindSupportsApprovalMode(to.driverKind, mode));
+        const gained = APPROVAL_MODES.filter((mode) => !driverKindSupportsApprovalMode(from.driverKind, mode) && driverKindSupportsApprovalMode(to.driverKind, mode));
         if (lost.length)
             lines.push("Loses approval levels: " + lost.join(", ") + ".");
         if (gained.length)
@@ -44,3 +44,18 @@ export function harnessCapabilityLines(from, to) {
     }
     return lines;
 }
+/** Binds the registry to the approval-support check so each gate passes its
+ * model selection — or a driver view it already holds — and stops
+ * unwrapping registry.cliTarget(...)?.driverKind at every call site. The
+ * lookup prefers shadow state, so a mid-reconfig instance answers with the
+ * driver it would actually run. */
+export function createApprovalModeSupport(registry) {
+    return function supportsApprovalMode(target, mode) {
+        const driverKind = target === undefined
+            ? undefined
+            : "driverKind" in target
+                ? target.driverKind
+                : registry.cliTarget(target.instanceId)?.driverKind;
+        return driverKindSupportsApprovalMode(driverKind, mode);
+    };
+}