openmausbot 0.1.88 → 0.1.89

package/dist-server/pair-cli.js

@@ -17799,10 +17799,18 @@ function qualifiedModelLabel(id, qualifier, options = {}) {
   if (!qualifier || redundantWhen(id, qualifier)) return id;
   return `${id}${decorate(qualifier)}`;
 }
-var eventCounter, newEventId, newId;
+var TurnNotStartedError, eventCounter, newEventId, newId;
 var init_contracts = __esm({
   "server/contracts.ts"() {
     "use strict";
+    TurnNotStartedError = class extends Error {
+      turnId;
+      constructor(turnId, message2) {
+        super(message2);
+        this.name = "TurnNotStartedError";
+        this.turnId = turnId;
+      }
+    };
     eventCounter = 0;
     newEventId = () => `ev-${Date.now().toString(36)}-${(eventCounter++).toString(36)}`;
     newId = () => crypto.randomUUID();
@@ -19012,6 +19020,7 @@ function saveConfig(patch, options = {}) {
   if (checkedPatch.language !== void 0) disk.language = checkedPatch.language;
   if (checkedPatch.customDomain !== void 0) disk.customDomain = checkedPatch.customDomain;
   if (checkedPatch.signIn !== void 0) disk.signIn = checkedPatch.signIn;
+  if (checkedPatch.automaticRecovery !== void 0) disk.automaticRecovery = checkedPatch.automaticRecovery;
   if (checkedPatch.defaultModelSelection !== void 0) {
     disk.defaultModelSelection = checkedPatch.defaultModelSelection;
     if (disk.newBotDefaults) {
@@ -19167,7 +19176,7 @@ function instanceConfigs(cfg) {
   }
   return map3;
 }
-var optionalText, SSH_ALIAS, LEGACY_BROWSER_PROFILE_ID, BROWSER_PROFILE_ID, MIN_ROOM_TURN_TIMEOUT_MINUTES, MAX_ROOM_TURN_TIMEOUT_MINUTES, DEFAULT_ROOM_HANDOFF_LIFETIME_MINUTES, DEFAULT_ROOM_HANDOFF_MIN_RUNWAY_MINUTES, DEFAULT_ROOM_HANDOFF_HARD_CAP_MINUTES, DEFAULT_MAX_CONCURRENT_BOT_THREADS, MAX_CONCURRENT_BOT_THREADS, MIN_THREAD_EVENT_LOG_BYTES, MAX_THREAD_EVENT_LOG_BYTES, MIN_LOCAL_VM_MAX_INSTANCES, MAX_LOCAL_VM_MAX_INSTANCES, CDP_PORT, CDP_URL, vpsConfigSchema, browserEngineConfigSchema, roomConfigSchema, localVmConfigSchema, browserProfileSchema, legacyBrowserProfileSchema, legacyBrowserProfilesSchema, storedBrowserProfilesSchema, browserProfilesSchema, featureConfigSchema, onboardingConfigSchema, instanceConfigSchema, instanceConfigMapSchema, defaultModelSelectionSchema, threadsConfigSchema, newBotsConfigSchema, newBotsPatchSchema, threadsPatchSchema, appConfigSchema, storedAppConfigSchema, appConfigPatchSchema, jsonObjectSchema, DATA_DIR, LEGACY_DATA_DIR, EVENTS_DIR, NATIVE_DIR, lastIgnoredConfigWarning, WORKSPACE_CREDENTIAL_ENV, CONTROL_PLANE_ENV, CONTROL_PLANE_ENV_PREFIX, PROVIDER_CREDENTIAL_ENV, configSaveListeners;
+var optionalText, SSH_ALIAS, LEGACY_BROWSER_PROFILE_ID, BROWSER_PROFILE_ID, MIN_ROOM_TURN_TIMEOUT_MINUTES, MAX_ROOM_TURN_TIMEOUT_MINUTES, DEFAULT_ROOM_HANDOFF_LIFETIME_MINUTES, DEFAULT_ROOM_HANDOFF_MIN_RUNWAY_MINUTES, DEFAULT_ROOM_HANDOFF_HARD_CAP_MINUTES, DEFAULT_MAX_CONCURRENT_BOT_THREADS, MAX_CONCURRENT_BOT_THREADS, MIN_THREAD_EVENT_LOG_BYTES, MAX_THREAD_EVENT_LOG_BYTES, MIN_LOCAL_VM_MAX_INSTANCES, MAX_LOCAL_VM_MAX_INSTANCES, CDP_PORT, CDP_URL, vpsConfigSchema, browserEngineConfigSchema, roomConfigSchema, localVmConfigSchema, browserProfileSchema, legacyBrowserProfileSchema, legacyBrowserProfilesSchema, storedBrowserProfilesSchema, browserProfilesSchema, featureConfigSchema, onboardingConfigSchema, instanceConfigSchema, instanceConfigMapSchema, defaultModelSelectionSchema, automaticRecoverySchema, threadsConfigSchema, newBotsConfigSchema, newBotsPatchSchema, threadsPatchSchema, appConfigSchema, storedAppConfigSchema, appConfigPatchSchema, jsonObjectSchema, DATA_DIR, LEGACY_DATA_DIR, EVENTS_DIR, NATIVE_DIR, lastIgnoredConfigWarning, WORKSPACE_CREDENTIAL_ENV, CONTROL_PLANE_ENV, CONTROL_PLANE_ENV_PREFIX, PROVIDER_CREDENTIAL_ENV, configSaveListeners;
 var init_config = __esm({
   "server/config.ts"() {
     "use strict";
@@ -19307,6 +19316,13 @@ var init_config = __esm({
       (selection) => selection.variant === void 0 || selection.effort === void 0,
       "choose either a model variant or an effort level"
     );
+    automaticRecoverySchema = external_exports.object({
+      enabled: external_exports.boolean(),
+      backup: defaultModelSelectionSchema.optional()
+    }).strict().refine(
+      (recovery) => !recovery.enabled || recovery.backup !== void 0,
+      { message: "Choose a backup model before enabling automatic recovery", path: ["backup"] }
+    );
     threadsConfigSchema = external_exports.object({
       maxConcurrentPerBot: external_exports.number().int().min(1).max(MAX_CONCURRENT_BOT_THREADS),
       /** Cap each per-thread events/ and native/ NDJSON log at this many
@@ -19335,6 +19351,7 @@ var init_config = __esm({
        * addresses or `@domain` entries; admins get every scope, members chat only. */
       signIn: external_exports.object({ admins: external_exports.array(external_exports.string().max(320)).max(500).optional(), members: external_exports.array(external_exports.string().max(320)).max(5e3).optional() }).optional(),
       defaultModelSelection: defaultModelSelectionSchema.optional(),
+      automaticRecovery: automaticRecoverySchema.optional(),
       newBotDefaults: newBotDefaultsSchema.optional(),
       newBots: newBotsConfigSchema.optional(),
       /** CLI-only launch preferences. Never enable remote access implicitly. */
@@ -21501,6 +21518,101 @@ var init_session_idle = __esm({
   }
 });
 
+// shared/provider-safety.ts
+function isProviderSafetyBlock(message2) {
+  return /\bblocked by (?:our|the provider['’]s) safety systems\b|\bsafety monitoring\b.{0,100}\b(?:paused|ended|blocked)\b|\b(?:safety_check_failed|safety_policy_violation)\b/i.test(message2);
+}
+var init_provider_safety = __esm({
+  "shared/provider-safety.ts"() {
+    "use strict";
+  }
+});
+
+// server/drivers/retry.ts
+function classifyError(err) {
+  const text4 = messageOf(err);
+  if (isProviderSafetyBlock(text4)) return { transient: false, reason: "provider_safety" };
+  if (err && "exitCode" in err) {
+    const { exitCode: code } = err;
+    if (code !== null && code < 0) return { transient: false, reason: "interrupted" };
+    for (const { pattern, reason } of TRANSIENT_PATTERNS) {
+      if (pattern.test(text4)) return { transient: true, reason };
+    }
+    for (const { pattern, reason } of TERMINAL_PATTERNS) {
+      if (pattern.test(text4)) return { transient: false, reason };
+    }
+    return { transient: false, reason: "terminal_exit" };
+  }
+  for (const { pattern, reason } of TERMINAL_PATTERNS) {
+    if (pattern.test(text4)) return { transient: false, reason };
+  }
+  for (const { pattern, reason } of TRANSIENT_PATTERNS) {
+    if (pattern.test(text4)) return { transient: true, reason };
+  }
+  return { transient: false, reason: "unknown" };
+}
+function computeBackoff(attempt, random = Math.random) {
+  const base2 = BACKOFF_BASE_MS[Math.min(Math.max(attempt, 0), BACKOFF_BASE_MS.length - 1)];
+  const jitter = base2 * 0.25;
+  return Math.round(base2 - jitter + random() * jitter * 2);
+}
+function interruptibleDelay(ms, signal) {
+  let timer = null;
+  let onCancel = null;
+  const promise2 = new Promise((resolve12) => {
+    timer = setTimeout(() => resolve12("elapsed"), Math.max(1, ms));
+    timer.unref?.();
+    if (signal?.aborted) return resolve12("cancelled");
+    onCancel = () => {
+      clearTimeout(timer);
+      resolve12("cancelled");
+    };
+    signal?.addEventListener("abort", onCancel, { once: true });
+  });
+  return {
+    promise: promise2,
+    cancel: () => onCancel?.()
+  };
+}
+var RETRY_MAX_ATTEMPTS, BACKOFF_BASE_MS, TRANSIENT_PATTERNS, TERMINAL_PATTERNS, messageOf;
+var init_retry = __esm({
+  "server/drivers/retry.ts"() {
+    "use strict";
+    init_provider_safety();
+    RETRY_MAX_ATTEMPTS = 3;
+    BACKOFF_BASE_MS = [1e3, 3e3, 8e3];
+    TRANSIENT_PATTERNS = [
+      { pattern: /\b(?:429|rate.?limit|too many requests)\b/i, reason: "rate_limited" },
+      { pattern: /\boverloaded\b|\bcapacity\b/i, reason: "overloaded" },
+      { pattern: /\b5\d{2}\b|\binternal server error\b|\bbad gateway\b|\bservice unavailable\b/i, reason: "server_error" },
+      {
+        pattern: /\b(?:econnreset|econnrefused|epipe|etimedout|eai_again|connection reset|connection refused|socket hang up|network error|fetch failed)\b/i,
+        reason: "connection_reset"
+      },
+      { pattern: /\btimeout(ed)?\b|\btimed? out\b/i, reason: "timeout" }
+    ];
+    TERMINAL_PATTERNS = [
+      {
+        pattern: /\b(?:40[13]|unauthorized|forbidden|invalid api key|missing bearer|authentication required|not logged in|logged out)\b/i,
+        reason: "auth"
+      },
+      { pattern: /\b402\b|\bquota\b|\bbilling\b|\bsubscription\b/i, reason: "quota" },
+      { pattern: /\bmodel not found\b|\bunknown model\b|\bdoes not exist for model\b|\bunsupported model\b/i, reason: "unknown_model" },
+      { pattern: /\b400\b|\b422\b|\binvalid request\b|\bmalformed\b|\bunexpected status\b/i, reason: "invalid_request" },
+      { pattern: /\b404\b|\bno such thread\b|\bthread gone\b/i, reason: "not_found" },
+      // interrupt/cancel vocabulary from the drivers' own stop paths — a turn the
+      // user stopped must never come back as an auto-retry
+      { pattern: /\b(?:interrupted|cancelled by user)\b/i, reason: "interrupted" }
+    ];
+    messageOf = (err) => {
+      if (!err) return "";
+      if (err instanceof Error) return `${err.message}${err.cause ? ` ${String(err.cause)}` : ""}`;
+      if ("text" in err) return err.text;
+      return [err.stderr ?? "", ""].join(" ").trim();
+    };
+  }
+});
+
 // server/drivers/acp/core.ts
 import { homedir as homedir7 } from "node:os";
 import { lstat, mkdir as mkdir3, readFile, realpath, stat as stat2, writeFile } from "node:fs/promises";
@@ -21529,6 +21641,12 @@ function acpRpcError(value, method) {
     acpSessionFailure: value?.code === -32603
   });
 }
+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);
+}
 function acpVariantOption(result) {
   const option = (Array.isArray(result?.configOptions) ? result.configOptions : []).find(
     (entry) => entry?.type === "select" && typeof entry.id === "string" && (entry.id === "effort" || entry.category === "thought_level")
@@ -21676,6 +21794,18 @@ function createAcpDriver(support11) {
       const listeners = /* @__PURE__ */ new Set();
       const active = /* @__PURE__ */ new Map();
       const sessions = /* @__PURE__ */ new Map();
+      const retiring = /* @__PURE__ */ new Map();
+      const retireChild = async (threadId, child) => {
+        let children = retiring.get(threadId);
+        if (!children) retiring.set(threadId, children = /* @__PURE__ */ 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);
@@ -21689,10 +21819,13 @@ function createAcpDriver(support11) {
           session.child.stdin.end();
         } catch {
         }
-        const kill = setTimeout(() => {
-          void killCliTree(session.child);
-        }, 5e3);
-        kill.unref?.();
+        if (support11.restartOnMcpChange) void retireChild(threadId, session.child);
+        else {
+          const kill = setTimeout(() => {
+            void killCliTree(session.child);
+          }, 5e3);
+          kill.unref?.();
+        }
       };
       const armIdle = (threadId) => {
         const session = sessions.get(threadId);
@@ -21783,6 +21916,7 @@ function createAcpDriver(support11) {
         const current = session.current;
         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()) finish("cancel", "system");
         session.acp.failAll(new Error("turn settled"));
@@ -21842,7 +21976,7 @@ function createAcpDriver(support11) {
             if (!(idleMs && idleMs > 0)) return;
             if (idleTimer) clearTimeout(idleTimer);
             idleTimer = setTimeout(() => {
-              if (session.current?.asks.size) {
+              if (session.current?.asks.size || session.current?.runningTools.size) {
                 armIdle2();
                 return;
               }
@@ -21956,6 +22090,7 @@ function createAcpDriver(support11) {
           }
         };
         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;
@@ -22059,6 +22194,9 @@ function createAcpDriver(support11) {
             if (current && !current.state.settled && session.sessionId && p2.sessionId === session.sessionId) current.receiveModelVariants(p2.update);
             return;
           }
+          if (current && ["agent_message_chunk", "agent_thought_chunk", "tool_call", "tool_call_update"].includes(p2.update?.sessionUpdate)) {
+            current.state.startupActivity = true;
+          }
           if (!current || !current.state.promptSent) return;
           const u4 = p2.update ?? {};
           switch (u4.sessionUpdate) {
@@ -22090,6 +22228,7 @@ function createAcpDriver(support11) {
             }
             case "tool_call": {
               current.flushAssistantText();
+              trackRunningTool(current, u4, "pending");
               emit({
                 ...base2(threadId, current.turnId),
                 type: "item.started",
@@ -22102,6 +22241,7 @@ function createAcpDriver(support11) {
               break;
             }
             case "tool_call_update": {
+              trackRunningTool(current, u4);
               if (u4.status === "completed" || u4.status === "failed") {
                 current.state.producedItem = true;
                 emit({
@@ -22251,7 +22391,7 @@ function createAcpDriver(support11) {
         }
         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 && (!support11.restartOnMcpChange || pooled.sessionKey === sessionKey)) {
           if (pooled.idleTimer) clearTimeout(pooled.idleTimer);
           pooled.idleTimer = null;
           session = pooled;
@@ -22264,7 +22404,15 @@ function createAcpDriver(support11) {
           sessions.set(threadId, session);
         }
         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((resolve12, reject) => {
+          acknowledge = () => resolve12({ turnId });
+          rejectStartup = reject;
+        }) : null;
         const asks = /* @__PURE__ */ new Map();
         const modelOf = (result) => {
           const option = (Array.isArray(result?.configOptions) ? result.configOptions : []).find(
@@ -22309,12 +22457,15 @@ function createAcpDriver(support11) {
           turnConfig,
           controlsHost,
           state,
+          acknowledge,
           asks,
+          runningTools: /* @__PURE__ */ 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) clearTimeout(current.interruptTimer);
@@ -22327,12 +22478,24 @@ function createAcpDriver(support11) {
             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({ ...base2(threadId, turnId), type: "turn.started" });
         session.current = current;
         (async () => {
           try {
             const handshake = async () => {
+              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(`${support11.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",
@@ -22524,7 +22687,9 @@ ${promptInput.text}` : promptInput.text;
             if (turn.variant !== void 0 && requestedVariantOption().currentValue !== turn.variant) {
               throw new Error(`${support11.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",
@@ -22532,7 +22697,7 @@ ${promptInput.text}` : promptInput.text;
               void 0,
               void 0,
               promptIdleMs,
-              `${DRIVER_KIND8} went fully silent ${Math.round(promptIdleMs / 1e3)} s after the message and the turn was stopped. Raise OPENMAUS_ACP_PROMPT_IDLE_TIMEOUT_MS if this model legitimately takes longer to answer.`
+              `${DRIVER_KIND8} sent nothing for ${Math.round(promptIdleMs / 1e3)} 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) {
               writePromptSplitReceipt(DRIVER_KIND8, pendingSplitReceipt.key, pendingSplitReceipt.receipt);
@@ -22563,6 +22728,32 @@ ${promptInput.text}` : promptInput.text;
               const message2 = e instanceof Error ? e.message : String(e);
               const code = support11.classifyError?.(e);
               const needsAuth = code === "invalid_credentials" || code === "inactive_subscription" || message2 === support11.loginNote;
+              const failure = classifyError({ text: message2 });
+              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(message2);
+              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) {
+                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, message2));
+                  return;
+                }
+                acknowledge();
+                if (!state.stopped) emit({ ...base2(threadId, turnId), type: "runtime.error", message: message2 });
+                emit({
+                  ...base2(threadId, turnId),
+                  type: "turn.completed",
+                  ok: state.stopped,
+                  stopReason: state.stopped ? "cancelled" : "rpc_error",
+                  cost: null
+                });
+                return;
+              }
               emit({
                 ...base2(threadId, turnId),
                 type: "runtime.error",
@@ -22576,7 +22767,7 @@ ${promptInput.text}` : promptInput.text;
             }
           }
         })();
-        return { turnId };
+        return startupAck ?? { turnId };
       };
       const snapshot = async () => {
         const env = childEnv();
@@ -22632,6 +22823,9 @@ ${promptInput.text}` : promptInput.text;
           stopAll: async () => {
             for (const { stop } of active.values()) stop();
             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);
@@ -22641,6 +22835,9 @@ ${promptInput.text}` : promptInput.text;
         dispose: async () => {
           for (const { stop } of active.values()) 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();
         }
       };
@@ -22666,6 +22863,7 @@ var init_core3 = __esm({
     init_redact2();
     init_resume_recovery();
     init_session_idle();
+    init_retry();
     envOr = (key, fallback) => Number(process.env[key] ?? fallback);
     INIT_TIMEOUT = envOr("OPENMAUS_ACP_INIT_TIMEOUT_MS", 3e5);
     SESSION_CONFIG_TIMEOUT = envOr("OPENMAUS_ACP_SESSION_CONFIG_TIMEOUT_MS", 3e5);
@@ -24071,7 +24269,7 @@ var init_boxagent = __esm({
           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) => {
@@ -24524,101 +24722,6 @@ var init_mcp_gate_config = __esm({
   }
 });
 
-// shared/provider-safety.ts
-function isProviderSafetyBlock(message2) {
-  return /\bblocked by (?:our|the provider['’]s) safety systems\b|\bsafety monitoring\b.{0,100}\b(?:paused|ended|blocked)\b|\b(?:safety_check_failed|safety_policy_violation)\b/i.test(message2);
-}
-var init_provider_safety = __esm({
-  "shared/provider-safety.ts"() {
-    "use strict";
-  }
-});
-
-// server/drivers/retry.ts
-function classifyError(err) {
-  const text4 = messageOf(err);
-  if (isProviderSafetyBlock(text4)) return { transient: false, reason: "provider_safety" };
-  if (err && "exitCode" in err) {
-    const { exitCode: code } = err;
-    if (code !== null && code < 0) return { transient: false, reason: "interrupted" };
-    for (const { pattern, reason } of TRANSIENT_PATTERNS) {
-      if (pattern.test(text4)) return { transient: true, reason };
-    }
-    for (const { pattern, reason } of TERMINAL_PATTERNS) {
-      if (pattern.test(text4)) return { transient: false, reason };
-    }
-    return { transient: false, reason: "terminal_exit" };
-  }
-  for (const { pattern, reason } of TERMINAL_PATTERNS) {
-    if (pattern.test(text4)) return { transient: false, reason };
-  }
-  for (const { pattern, reason } of TRANSIENT_PATTERNS) {
-    if (pattern.test(text4)) return { transient: true, reason };
-  }
-  return { transient: false, reason: "unknown" };
-}
-function computeBackoff(attempt, random = Math.random) {
-  const base2 = BACKOFF_BASE_MS[Math.min(Math.max(attempt, 0), BACKOFF_BASE_MS.length - 1)];
-  const jitter = base2 * 0.25;
-  return Math.round(base2 - jitter + random() * jitter * 2);
-}
-function interruptibleDelay(ms, signal) {
-  let timer = null;
-  let onCancel = null;
-  const promise2 = new Promise((resolve12) => {
-    timer = setTimeout(() => resolve12("elapsed"), Math.max(1, ms));
-    timer.unref?.();
-    if (signal?.aborted) return resolve12("cancelled");
-    onCancel = () => {
-      clearTimeout(timer);
-      resolve12("cancelled");
-    };
-    signal?.addEventListener("abort", onCancel, { once: true });
-  });
-  return {
-    promise: promise2,
-    cancel: () => onCancel?.()
-  };
-}
-var RETRY_MAX_ATTEMPTS, BACKOFF_BASE_MS, TRANSIENT_PATTERNS, TERMINAL_PATTERNS, messageOf;
-var init_retry = __esm({
-  "server/drivers/retry.ts"() {
-    "use strict";
-    init_provider_safety();
-    RETRY_MAX_ATTEMPTS = 3;
-    BACKOFF_BASE_MS = [1e3, 3e3, 8e3];
-    TRANSIENT_PATTERNS = [
-      { pattern: /\b(?:429|rate.?limit|too many requests)\b/i, reason: "rate_limited" },
-      { pattern: /\boverloaded\b|\bcapacity\b/i, reason: "overloaded" },
-      { pattern: /\b5\d{2}\b|\binternal server error\b|\bbad gateway\b|\bservice unavailable\b/i, reason: "server_error" },
-      {
-        pattern: /\b(?:econnreset|econnrefused|epipe|etimedout|eai_again|connection reset|connection refused|socket hang up|network error|fetch failed)\b/i,
-        reason: "connection_reset"
-      },
-      { pattern: /\btimeout(ed)?\b|\btimed? out\b/i, reason: "timeout" }
-    ];
-    TERMINAL_PATTERNS = [
-      {
-        pattern: /\b(?:40[13]|unauthorized|forbidden|invalid api key|missing bearer|authentication required|not logged in|logged out)\b/i,
-        reason: "auth"
-      },
-      { pattern: /\b402\b|\bquota\b|\bbilling\b|\bsubscription\b/i, reason: "quota" },
-      { pattern: /\bmodel not found\b|\bunknown model\b|\bdoes not exist for model\b|\bunsupported model\b/i, reason: "unknown_model" },
-      { pattern: /\b400\b|\b422\b|\binvalid request\b|\bmalformed\b|\bunexpected status\b/i, reason: "invalid_request" },
-      { pattern: /\b404\b|\bno such thread\b|\bthread gone\b/i, reason: "not_found" },
-      // interrupt/cancel vocabulary from the drivers' own stop paths — a turn the
-      // user stopped must never come back as an auto-retry
-      { pattern: /\b(?:interrupted|cancelled by user)\b/i, reason: "interrupted" }
-    ];
-    messageOf = (err) => {
-      if (!err) return "";
-      if (err instanceof Error) return `${err.message}${err.cause ? ` ${String(err.cause)}` : ""}`;
-      if ("text" in err) return err.text;
-      return [err.stderr ?? "", ""].join(" ").trim();
-    };
-  }
-});
-
 // server/drivers/claude.ts
 import { createHash as createHash7, randomBytes as randomBytes2 } from "node:crypto";
 import { chmodSync as chmodSync4, mkdirSync as mkdirSync10, mkdtempSync as mkdtempSync2, readFileSync as readFileSync8, rmSync as rmSync6, unlinkSync as unlinkSync3, writeFileSync as writeFileSync5 } from "node:fs";
@@ -38100,6 +38203,10 @@ function createOpenAIChatRuntime(options) {
       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,
@@ -39989,6 +40096,9 @@ var init_qwen = __esm({
       // 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: (config2, turn) => ["--acp", ...qwenApprovalArgs(config2.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",
@@ -48599,8 +48709,7 @@ var init_cli_api_setup = __esm({
     API_ENDPOINTS = [
       { id: "openai", label: "OpenAI API", url: "https://api.openai.com/v1", keyUrl: "https://platform.openai.com/api-keys" },
       { id: "openrouter", label: "OpenRouter", url: "https://openrouter.ai/api/v1", keyUrl: "https://openrouter.ai/settings/keys" },
-      { id: "groq", label: "Groq", url: "https://api.groq.com/openai/v1", keyUrl: "https://console.groq.com/keys" },
-      { id: "requesty", label: "Requesty", url: "https://router.requesty.ai/v1", keyUrl: "https://app.requesty.ai/api-keys" }
+      { id: "groq", label: "Groq", url: "https://api.groq.com/openai/v1", keyUrl: "https://console.groq.com/keys" }
     ];
     SetupApiError = class extends Error {
     };

package/dist-server/server/automatic-recovery.js

@@ -0,0 +1,15 @@
+import { supportsWorkspaceFiles } from "./workspace.js";
+/** An automatic switch must not strand the task without its tools or move
+ * its filesystem to another machine. Approval and organisation policy are
+ * checked by the ordinary model-switch and turn-admission gates. */
+export function recoveryCapabilityError(from, to) {
+    if (from.capabilities.remoteAgent || to.capabilities.remoteAgent ||
+        supportsWorkspaceFiles(from.driverKind) !== supportsWorkspaceFiles(to.driverKind)) {
+        return "The backup cannot use the same workspace.";
+    }
+    const tools = ["agentsMcp", "computerMcp", "cloudComputerMcp", "composioMcp",
+        "phoneMcp", "browserMcp", "localComputerMcp", "customMcp", "images"];
+    if (tools.some(key => from.capabilities[key] === true && to.capabilities[key] !== true)) {
+        return "The backup does not support all of this engine's tools and attachments.";
+    }
+}

package/dist-server/server/cli-api-setup.js

@@ -4,7 +4,6 @@ export const API_ENDPOINTS = [
     { id: "openai", label: "OpenAI API", url: "https://api.openai.com/v1", keyUrl: "https://platform.openai.com/api-keys" },
     { id: "openrouter", label: "OpenRouter", url: "https://openrouter.ai/api/v1", keyUrl: "https://openrouter.ai/settings/keys" },
     { id: "groq", label: "Groq", url: "https://api.groq.com/openai/v1", keyUrl: "https://console.groq.com/keys" },
-    { id: "requesty", label: "Requesty", url: "https://router.requesty.ai/v1", keyUrl: "https://app.requesty.ai/api-keys" },
 ];
 export function normalizeApiUrl(value) {
     const input = value.trim();

package/dist-server/server/config.js

@@ -295,6 +295,10 @@ const defaultModelSelectionSchema = z.object({
     effort: z.enum(EFFORT_LEVELS).optional(),
     variant: z.string().refine(isModelVariant, "invalid model variant").optional(),
 }).refine((selection) => selection.variant === undefined || selection.effort === undefined, "choose either a model variant or an effort level");
+const automaticRecoverySchema = z.object({
+    enabled: z.boolean(),
+    backup: defaultModelSelectionSchema.optional(),
+}).strict().refine((recovery) => !recovery.enabled || recovery.backup !== undefined, { message: "Choose a backup model before enabling automatic recovery", path: ["backup"] });
 const threadsConfigSchema = z.object({
     maxConcurrentPerBot: z.number().int().min(1).max(MAX_CONCURRENT_BOT_THREADS),
     /** Cap each per-thread events/ and native/ NDJSON log at this many
@@ -327,6 +331,7 @@ const appConfigSchema = z.object({
      * addresses or `@domain` entries; admins get every scope, members chat only. */
     signIn: z.object({ admins: z.array(z.string().max(320)).max(500).optional(), members: z.array(z.string().max(320)).max(5000).optional() }).optional(),
     defaultModelSelection: defaultModelSelectionSchema.optional(),
+    automaticRecovery: automaticRecoverySchema.optional(),
     newBotDefaults: newBotDefaultsSchema.optional(),
     newBots: newBotsConfigSchema.optional(),
     /** CLI-only launch preferences. Never enable remote access implicitly. */
@@ -622,6 +627,7 @@ export const FLEET_NEUTRAL_KEYS = new Set([
     "vps",
     "rooms",
     "threads",
+    "automaticRecovery",
     "context",
     "localVm",
     "features",
@@ -953,6 +959,9 @@ export function saveConfig(patch, options = {}) {
         disk.customDomain = checkedPatch.customDomain;
     if (checkedPatch.signIn !== undefined)
         disk.signIn = checkedPatch.signIn;
+    // Replace the section so clearing a backup cannot revive the old selection.
+    if (checkedPatch.automaticRecovery !== undefined)
+        disk.automaticRecovery = checkedPatch.automaticRecovery;
     // A selection is replaced as one value, so changing engines also clears
     // an effort level omitted from the new selection.
     if (checkedPatch.defaultModelSelection !== undefined) {

package/dist-server/server/container-computer.js

@@ -7,6 +7,7 @@
 // typing, screenshots, accessibility, or window discovery.
 import { execFile } from "node:child_process";
 import { createHash, randomBytes } from "node:crypto";
+import { lstatSync } from "node:fs";
 import { chmod, mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join, resolve } from "node:path";
@@ -68,6 +69,15 @@ export function perBotLocalVmTarget(botId) {
         label: digest,
     };
 }
+/** Only provisioning creates this durable directory; idle removal keeps it. */
+export function localVmWorkspaceExists(target) {
+    try {
+        return lstatSync(target.workspaceDir, { throwIfNoEntry: false })?.isDirectory() === true;
+    }
+    catch {
+        return false;
+    }
+}
 const LINUX_WHEELS = {
     x86_64: {
         url: "https://files.pythonhosted.org/packages/fa/d7/a43008a328a40c85e7bc706fc20235b9abedc75e28b413817655153157ff/cua_driver-0.20.0-py3-none-manylinux_2_31_x86_64.whl",

package/dist-server/server/contracts.js

@@ -12,6 +12,16 @@ export class ProviderError extends Error {
         this.code = code;
     }
 }
+/** The driver proved this attempt never reached a prompt or client-side action,
+ * and its owned process has stopped. The harness may safely recover it. */
+export class TurnNotStartedError extends Error {
+    turnId;
+    constructor(turnId, message) {
+        super(message);
+        this.name = "TurnNotStartedError";
+        this.turnId = turnId;
+    }
+}
 /** Variants are opaque provider IDs, not the cross-engine effort enum. */
 export function isModelVariant(value) {
     return typeof value === "string" && value.length > 0 && value.length <= 256 &&