openmausbot 0.1.75 → 0.1.76

package/dist-server/pair-cli.js

@@ -1113,6 +1113,21 @@ var require_main = __commonJS({
 // server/atomic.ts
 import { randomUUID as randomUUID3 } from "node:crypto";
 import { closeSync, fsyncSync, openSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
+function sleepSync(ms) {
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+function renameWithRetry(tmp, path3, rename2 = renameSync) {
+  for (let attempt = 0; ; attempt += 1) {
+    try {
+      rename2(tmp, path3);
+      return;
+    } catch (e) {
+      const code = e.code;
+      if (!code || !RETRYABLE_RENAME_CODES.has(code) || attempt >= RENAME_RETRY_DELAYS_MS.length) throw e;
+      sleepSync(RENAME_RETRY_DELAYS_MS[attempt]);
+    }
+  }
+}
 function writeFileAtomic(path3, data, options = {}) {
   const tmp = `${path3}.${process.pid}.${randomUUID3()}.tmp`;
   let fd = null;
@@ -1122,7 +1137,7 @@ function writeFileAtomic(path3, data, options = {}) {
     fsyncSync(fd);
     closeSync(fd);
     fd = null;
-    renameSync(tmp, path3);
+    renameWithRetry(tmp, path3);
   } catch (e) {
     if (fd !== null) {
       try {
@@ -1137,9 +1152,12 @@ function writeFileAtomic(path3, data, options = {}) {
     throw e;
   }
 }
+var RENAME_RETRY_DELAYS_MS, RETRYABLE_RENAME_CODES;
 var init_atomic = __esm({
   "server/atomic.ts"() {
     "use strict";
+    RENAME_RETRY_DELAYS_MS = [5, 10, 20, 40, 80];
+    RETRYABLE_RENAME_CODES = /* @__PURE__ */ new Set(["EPERM", "EACCES", "EBUSY"]);
   }
 });
 
@@ -18609,28 +18627,29 @@ function isFile(p) {
     return false;
   }
 }
-function whichWin(cli) {
-  const exts = (process.env.PATHEXT ?? ".COM;.EXE;.BAT;.CMD").split(";").filter(Boolean);
+function whichWin(cli, env) {
+  const exts = ((env ?? process.env).PATHEXT ?? ".COM;.EXE;.BAT;.CMD").split(";").filter(Boolean);
   const probe = (base2) => {
     const order = extname(base2) ? [base2, ...exts.map((e) => base2 + e)] : [...exts.map((e) => base2 + e), base2];
     return order.find(isFile) ?? null;
   };
   if (/[\\/]/.test(cli) || /^[a-zA-Z]:/.test(cli)) return probe(cli);
-  for (const dir of augmentedPath().split(delimiter3)) {
+  const path3 = env ? env.PATH ?? env.Path ?? "" : augmentedPath();
+  for (const dir of path3.split(delimiter3)) {
     if (!dir) continue;
     const hit = probe(join9(dir, cli));
     if (hit) return hit;
   }
   return null;
 }
-function nodeExe(near) {
+function nodeExe(near, env) {
   const local = join9(near, "node.exe");
   if (isFile(local)) return local;
-  const onPath2 = whichWin("node.exe");
+  const onPath2 = whichWin("node.exe", env);
   if (onPath2 && extname(onPath2).toLowerCase() === ".exe") return onPath2;
   return process.versions.electron ? null : process.execPath;
 }
-function parseCmdShim(shim) {
+function parseCmdShim(shim, env) {
   let text4;
   try {
     text4 = readFileSync6(shim, "utf8");
@@ -18641,13 +18660,13 @@ function parseCmdShim(shim) {
   const targets = [...text4.matchAll(/"%~?dp0%?\\?([^"]+)"/g)].map((m) => join9(dir, m[1])).filter((p) => isFile(p) && basename2(p).toLowerCase() !== "node.exe");
   const script = targets.find((p) => /\.[cm]?js$/i.test(p));
   if (script) {
-    const node = nodeExe(dir);
+    const node = nodeExe(dir, env);
     if (node) return { command: node, args: [script] };
   }
   const exe = targets.find((p) => extname(p).toLowerCase() === ".exe");
   return exe ? { command: exe, args: [] } : null;
 }
-function parseNodeShebang(file2) {
+function parseNodeShebang(file2, env) {
   let head = "";
   let fd = null;
   try {
@@ -18666,32 +18685,32 @@ function parseNodeShebang(file2) {
     }
   }
   if (!/^#!.*\bnode(\.exe)?\b/.test(head)) return null;
-  const node = nodeExe(dirname4(file2));
+  const node = nodeExe(dirname4(file2), env);
   return node ? { command: node, args: [file2] } : null;
 }
-function resolveWord(cli, args) {
+function resolveWord(cli, args, env) {
   if (process.platform !== "win32") return { command: cli, args };
-  const file2 = whichWin(cli);
+  const file2 = whichWin(cli, env);
   if (!file2) return { command: cli, args };
   const ext = extname(file2).toLowerCase();
   if (ext === ".cmd" || ext === ".bat") {
-    const direct = parseCmdShim(file2);
+    const direct = parseCmdShim(file2, env);
     return direct ? { command: direct.command, args: [...direct.args, ...args] } : { command: file2, args };
   }
   if (ext === ".exe" || ext === ".com") return { command: file2, args };
-  const viaNode = parseNodeShebang(file2);
+  const viaNode = parseNodeShebang(file2, env);
   return viaNode ? { command: viaNode.command, args: [...viaNode.args, ...args] } : { command: file2, args };
 }
-function resolveCliSpawn(cli, args) {
+function resolveCliSpawn(cli, args, env) {
   const trimmed = cli.trim();
-  if (trimmed.includes(" ") && existsSync7(trimmed)) return resolveWord(trimmed, args);
+  if (trimmed.includes(" ") && existsSync7(trimmed)) return resolveWord(trimmed, args, env);
   const split = splitCliString(cli);
   if (split.length > 1 || split[0] !== trimmed) {
     const [head, ...fixed] = split;
     if (!head) return { command: cli, args };
-    return resolveWord(head, [...fixed, ...args]);
+    return resolveWord(head, [...fixed, ...args], env);
   }
-  return resolveWord(cli, args);
+  return resolveWord(cli, args, env);
 }
 var cached2, probed, loginShellPath, registeredDirs;
 var init_env_path = __esm({
@@ -18710,8 +18729,8 @@ import {
   execFile as execFile3
 } from "node:child_process";
 import { join as join10 } from "node:path";
-function resolveCli(cli, args = []) {
-  return resolveCliSpawn(cli, args);
+function resolveCli(cli, args = [], env) {
+  return resolveCliSpawn(cli, args, env);
 }
 function estimatedWindowsCommandLineChars(resolved) {
   return [resolved.command, ...resolved.args].reduce(
@@ -18825,9 +18844,13 @@ async function stopCliTree(child, pid, timeoutMs) {
   if (exited()) return true;
   return new Promise((resolve13) => {
     let timer;
+    let finished = false;
     const done = (stopped) => {
+      if (finished) return;
+      finished = true;
       clearTimeout(timer);
       child.off("close", closed);
+      child.off("exit", closed);
       resolve13(stopped);
     };
     const closed = () => done(true);
@@ -18835,7 +18858,12 @@ async function stopCliTree(child, pid, timeoutMs) {
     timer = setTimeout(() => done(false), timeoutMs);
     timer.unref?.();
     execFile3("taskkill", ["/PID", String(pid), "/T", "/F"], { windowsHide: true }, (err) => {
-      if (!err) return;
+      if (finished) return;
+      if (!err) {
+        if (exited()) done(true);
+        else child.once("exit", closed);
+        return;
+      }
       try {
         child.kill();
       } catch {
@@ -22639,15 +22667,16 @@ function askSummary(ask) {
   if (questions) return askQuestionSummary(questions).slice(0, 300);
   return askInputSummary(ask.input) ?? ask.tool ?? "tool";
 }
-function permissionSocketPath(threadId) {
+function permissionSocketPath(threadId, botId) {
+  const key = botId ? `${botId}\0${threadId}` : threadId;
   const prefix = threadId.replace(/[^\w-]/g, "").slice(0, 4);
-  const digest2 = createHash5("sha256").update(threadId).digest("hex").slice(0, 4);
+  const digest2 = createHash5("sha256").update(key).digest("hex").slice(0, 4);
   return brokerSocketPath(DATA_DIR, `${prefix}${digest2}`);
 }
-function brokerSocketCandidates(threadId) {
-  const base2 = permissionSocketPath(threadId);
+function brokerSocketCandidates(threadId, botId) {
+  const base2 = permissionSocketPath(threadId, botId);
   if (process.platform !== "win32") {
-    const scope = createHash5("sha256").update(`${DATA_DIR}\0${process.pid}\0${threadId}`).digest("hex").slice(0, 16);
+    const scope = createHash5("sha256").update(`${DATA_DIR}\0${process.pid}\0${botId ?? ""}\0${threadId}`).digest("hex").slice(0, 16);
     return [base2, join20(tmpdir3(), `omb-perm-${scope}.sock`)];
   }
   return [
@@ -23045,8 +23074,8 @@ var init_claude = __esm({
           createdAt: (/* @__PURE__ */ new Date()).toISOString()
         });
         const retryState = /* @__PURE__ */ new Map();
-        const sendTurn = async (turn) => {
-          const { threadId } = turn;
+        const sendTurn = async (turn, logicalTurnId) => {
+          const { threadId, botId } = turn;
           if (active.has(threadId)) throw new Error("a turn is already running on this thread");
           const permissionMode = turn.approvalMode === void 0 ? config2.permissionMode : turn.approvalMode === "full" ? "bypassPermissions" : turn.approvalMode === "auto" ? "auto" : turn.approvalMode === "edits" ? "acceptEdits" : "default";
           const controlsHost = turn.integrations?.localComputer?.scope === "local-computer";
@@ -23054,7 +23083,7 @@ var init_claude = __esm({
             throw new Error("local computer control requires the interactive approval broker");
           }
           const promptMsg = claudeUserMessage(turn.text, turn.images);
-          const turnId = newId();
+          const turnId = logicalTurnId ?? newId();
           const retryAbort = new AbortController();
           const retry = retryState.get(threadId) ?? { attempt: 0, cancelled: false };
           retry.cancelled = false;
@@ -23159,7 +23188,7 @@ var init_claude = __esm({
             if (gated) mcpServers[name] = gated;
           }
           let broker;
-          const socketPath = permissionSocketPath(threadId);
+          const socketPath = permissionSocketPath(threadId, botId);
           if (permissionMode !== "bypassPermissions") {
             args.push("--permission-prompt-tool", "mcp__ogb__approve");
           }
@@ -23198,9 +23227,11 @@ var init_claude = __esm({
           const live = sessions.get(threadId);
           if (live && !live.turn && !live.closing && live.child.exitCode === null && live.argsKey === argsKey && (!sessionId || sessionId === live.sessionId)) {
             if (live.idleTimer) clearTimeout(live.idleTimer);
-            live.turn = { turnId, settled: false, sawStreamDelta: false };
+            live.turn = { turnId, input: turn, retryAbort, settled: false, sawStreamDelta: false };
             active.set(threadId, { stop: () => {
               closeSession(threadId, "interrupted");
+              retry.cancelled = true;
+              retryAbort.abort();
               stopSession(live);
             }, turnId, broker: live.broker });
             emit({ ...base2(threadId, turnId), type: "turn.started" });
@@ -23255,7 +23286,7 @@ var init_claude = __esm({
             if (socketPath) {
               const askTools = /* @__PURE__ */ new Map();
               broker = await createPermissionBroker({
-                socketPaths: brokerSocketCandidates(threadId),
+                socketPaths: brokerSocketCandidates(threadId, botId),
                 isActive: () => Boolean(sessions.get(threadId)?.turn),
                 onAsk: (ask) => {
                   const eventTurnId = sessions.get(threadId)?.turn?.turnId ?? turnId;
@@ -23331,7 +23362,7 @@ var init_claude = __esm({
             sessionId: sessionId ?? newSessionId,
             sawInit: false,
             nativePermissionMode: null,
-            turn: { turnId, settled: false, sawStreamDelta: false },
+            turn: { turnId, input: turn, retryAbort, settled: false, sawStreamDelta: false },
             idleTimer: null,
             closing: false,
             stderr: ""
@@ -23483,9 +23514,11 @@ var init_claude = __esm({
             if (closeFinalized) return;
             closeFinalized = true;
             if (session.turn && !session.turn.settled) {
+              const { turnId: turnId2, input: turn2, retryAbort: retryAbort2 } = session.turn;
+              const retry2 = retryState.get(threadId) ?? { attempt: 0, cancelled: false };
               const message2 = `claude exited ${code} before result${session.stderr ? `: ${session.stderr.trim().slice(-300)}` : ""}`;
               const verdict = classifyError({ exitCode: code, stderr: message2 });
-              if (!retry.cancelled && code !== 0 && verdict.transient && !session.turn.sawStreamDelta && retry.attempt < RETRY_MAX_ATTEMPTS - 1) {
+              if (!retry2.cancelled && code !== 0 && verdict.transient && !session.turn.sawStreamDelta && retry2.attempt < RETRY_MAX_ATTEMPTS - 1) {
                 const failedBroker = session.broker;
                 session.broker = void 0;
                 failedBroker?.pause();
@@ -23503,23 +23536,23 @@ var init_claude = __esm({
                 }
                 sessions.delete(threadId);
                 session.turn = null;
-                retry.attempt++;
-                const delayMs = computeBackoff(retry.attempt - 1);
+                retry2.attempt++;
+                const delayMs = computeBackoff(retry2.attempt - 1);
                 emit({
-                  ...base2(threadId, turnId),
+                  ...base2(threadId, turnId2),
                   type: "turn.retrying",
-                  attempt: retry.attempt,
+                  attempt: retry2.attempt,
                   delayMs,
                   reason: verdict.reason
                 });
                 void (async () => {
-                  const wait2 = interruptibleDelay(delayMs * retryScale, retryAbort.signal);
+                  const wait2 = interruptibleDelay(delayMs * retryScale, retryAbort2.signal);
                   await wait2.promise;
-                  if (retry.cancelled) {
+                  if (retry2.cancelled) {
                     active.delete(threadId);
                     retryState.delete(threadId);
                     emit({
-                      ...base2(threadId, turnId),
+                      ...base2(threadId, turnId2),
                       type: "turn.completed",
                       ok: false,
                       stopReason: "interrupted",
@@ -23530,16 +23563,16 @@ var init_claude = __esm({
                   active.delete(threadId);
                   try {
                     const cursor3 = session.sessionId ?? sessionId ?? void 0;
-                    await sendTurn({ ...turn, resumeCursor: cursor3 });
+                    await sendTurn({ ...turn2, resumeCursor: cursor3 }, turnId2);
                   } catch (e) {
                     retryState.delete(threadId);
                     emit({
-                      ...base2(threadId, turnId),
+                      ...base2(threadId, turnId2),
                       type: "runtime.error",
                       message: e instanceof Error ? e.message : String(e)
                     });
                     emit({
-                      ...base2(threadId, turnId),
+                      ...base2(threadId, turnId2),
                       type: "turn.completed",
                       ok: false,
                       stopReason: "exit_before_result",
@@ -23555,10 +23588,10 @@ var init_claude = __esm({
                 promptSubmitted: session.sawInit,
                 producedOutput: session.turn.sawStreamDelta
               });
-              if (mayReplay(resumeFailure) && !retry.cancelled) {
+              if (mayReplay(resumeFailure) && !retry2.cancelled) {
                 const recovery = recoveryPromptFor({
-                  recoveryText: turn.recoveryText,
-                  currentText: turn.text,
+                  recoveryText: turn2.recoveryText,
+                  currentText: turn2.text,
                   failure: resumeFailure
                 });
                 session.broker?.close();
@@ -23578,23 +23611,23 @@ var init_claude = __esm({
                 session.turn = null;
                 active.delete(threadId);
                 emit({
-                  ...base2(threadId, turnId),
+                  ...base2(threadId, turnId2),
                   type: "turn.retrying",
-                  attempt: retry.attempt + 1,
+                  attempt: retry2.attempt + 1,
                   delayMs: 0,
                   reason: "resume_rejected"
                 });
                 void (async () => {
                   try {
-                    await sendTurn({ ...turn, resumeCursor: void 0, recoveryText: void 0, text: recovery.text });
+                    await sendTurn({ ...turn2, resumeCursor: void 0, recoveryText: void 0, text: recovery.text }, turnId2);
                   } catch (e) {
                     retryState.delete(threadId);
                     emit({
-                      ...base2(threadId, turnId),
+                      ...base2(threadId, turnId2),
                       type: "runtime.error",
                       message: e instanceof Error ? e.message : String(e)
                     });
-                    emit({ ...base2(threadId, turnId), type: "turn.completed", ok: false, stopReason: "exit_before_result", cost: null });
+                    emit({ ...base2(threadId, turnId2), type: "turn.completed", ok: false, stopReason: "exit_before_result", cost: null });
                   }
                 })();
                 return;
@@ -25615,72 +25648,89 @@ function createOpenAIChatRuntime(options) {
     createdAt: (/* @__PURE__ */ new Date()).toISOString()
   });
   const complete = async (messages, model, stream, signal, onDelta) => {
-    const timeout = AbortSignal.timeout(options.timeoutMs);
-    const response = await fetch(`${options.apiUrl}/chat/completions`, {
-      method: "POST",
-      headers: { authorization: `Bearer ${options.apiKey}`, "content-type": "application/json" },
-      body: JSON.stringify(options.requestBody(model, messages, stream)),
-      signal: signal ? AbortSignal.any([signal, timeout]) : timeout
-    });
-    if (!response.ok) {
-      const body = await response.text().catch(() => "");
-      throw new Error(`${options.httpErrorLabel} HTTP ${response.status}${body ? `: ${body.slice(0, 200)}` : ""}`);
-    }
-    if (!stream) {
-      const json2 = await response.json();
-      const message2 = json2.choices?.[0]?.message;
-      return {
-        text: typeof message2?.content === "string" ? message2.content : "",
-        reasoning: options.reasoning && typeof message2?.reasoning_content === "string" ? message2.reasoning_content : "",
-        usage: usageFrom(json2.usage)
-      };
-    }
-    if (!response.body) {
-      throw new Error(options.noBodyError ?? `${options.httpErrorLabel} returned no response body`);
-    }
-    let text4 = "";
-    let reasoning = "";
-    let usage = null;
-    const reader = response.body.getReader();
-    const decoder = new TextDecoder();
-    let buffer = "";
+    const timeoutController = new AbortController();
+    let idleTimer = null;
+    const resetIdleTimer = () => {
+      if (idleTimer) clearTimeout(idleTimer);
+      idleTimer = setTimeout(() => {
+        timeoutController.abort(new DOMException("Streaming idle timeout elapsed", "AbortError"));
+      }, options.timeoutMs);
+    };
+    resetIdleTimer();
     try {
-      readLoop: for (; ; ) {
-        const { done, value } = await reader.read();
-        if (done) break;
-        buffer += decoder.decode(value, { stream: true });
-        let newline;
-        while ((newline = buffer.indexOf("\n")) !== -1) {
-          const line = buffer.slice(0, newline).trim();
-          buffer = buffer.slice(newline + 1);
-          if (!line.startsWith("data:")) continue;
-          const data = line.slice(5).trim();
-          if (data === "[DONE]") break readLoop;
-          let chunk;
-          try {
-            chunk = JSON.parse(data);
-          } catch {
-            continue;
-          }
-          const delta = chunk.choices?.[0]?.delta;
-          const reasoningDelta = options.reasoning && typeof delta?.reasoning_content === "string" ? delta.reasoning_content : "";
-          const contentDelta = typeof delta?.content === "string" ? delta.content : "";
-          if (reasoningDelta) {
-            reasoning += reasoningDelta;
-            onDelta?.(reasoningDelta, "reasoning_text");
-          }
-          if (contentDelta) {
-            text4 += contentDelta;
-            onDelta?.(contentDelta, "assistant_text");
+      const activeSignal = signal ? AbortSignal.any([signal, timeoutController.signal]) : timeoutController.signal;
+      const response = await fetch(`${options.apiUrl}/chat/completions`, {
+        method: "POST",
+        headers: { authorization: `Bearer ${options.apiKey}`, "content-type": "application/json" },
+        body: JSON.stringify(options.requestBody(model, messages, stream)),
+        signal: activeSignal
+      });
+      if (!response.ok) {
+        const body = await response.text().catch(() => "");
+        throw new Error(`${options.httpErrorLabel} HTTP ${response.status}${body ? `: ${body.slice(0, 200)}` : ""}`);
+      }
+      if (!stream) {
+        const json2 = await response.json();
+        const message2 = json2.choices?.[0]?.message;
+        return {
+          text: typeof message2?.content === "string" ? message2.content : "",
+          reasoning: options.reasoning && typeof message2?.reasoning_content === "string" ? message2.reasoning_content : "",
+          usage: usageFrom(json2.usage)
+        };
+      }
+      if (!response.body) {
+        throw new Error(options.noBodyError ?? `${options.httpErrorLabel} returned no response body`);
+      }
+      let text4 = "";
+      let reasoning = "";
+      let usage = null;
+      const reader = response.body.getReader();
+      const decoder = new TextDecoder();
+      let buffer = "";
+      try {
+        readLoop: for (; ; ) {
+          const { done, value } = await reader.read();
+          if (done) {
+            if (buffer.trim() === "data: [DONE]") break;
+            throw new DOMException("Stream ended before completion", "AbortError");
+          }
+          resetIdleTimer();
+          buffer += decoder.decode(value, { stream: true });
+          let newline;
+          while ((newline = buffer.indexOf("\n")) !== -1) {
+            const line = buffer.slice(0, newline).trim();
+            buffer = buffer.slice(newline + 1);
+            if (!line.startsWith("data:")) continue;
+            const data = line.slice(5).trim();
+            if (data === "[DONE]") break readLoop;
+            let chunk;
+            try {
+              chunk = JSON.parse(data);
+            } catch {
+              continue;
+            }
+            const delta = chunk.choices?.[0]?.delta;
+            const reasoningDelta = options.reasoning && typeof delta?.reasoning_content === "string" ? delta.reasoning_content : "";
+            const contentDelta = typeof delta?.content === "string" ? delta.content : "";
+            if (reasoningDelta) {
+              reasoning += reasoningDelta;
+              onDelta?.(reasoningDelta, "reasoning_text");
+            }
+            if (contentDelta) {
+              text4 += contentDelta;
+              onDelta?.(contentDelta, "assistant_text");
+            }
+            if (chunk.usage) usage = usageFrom(chunk.usage);
           }
-          if (chunk.usage) usage = usageFrom(chunk.usage);
         }
+      } finally {
+        await reader.cancel().catch(() => {
+        });
       }
+      return { text: text4, reasoning, usage };
     } finally {
-      await reader.cancel().catch(() => {
-      });
+      if (idleTimer) clearTimeout(idleTimer);
     }
-    return { text: text4, reasoning, usage };
   };
   const messagesFor = (turn) => [
     ...turn.system ? [{ role: "system", content: turn.system }] : [],
@@ -34647,11 +34697,18 @@ function hermesConfiguredModel(env = process.env) {
     custom: true
   };
 }
+function hermesAcpModelsTimeoutMs(env) {
+  const raw = env[HERMES_ACP_MODELS_TIMEOUT_ENV];
+  if (raw === void 0) return HERMES_ACP_MODELS_DEFAULT_TIMEOUT_MS;
+  const parsed = Number(raw);
+  return Number.isInteger(parsed) && parsed > 0 && parsed <= 2147483647 ? parsed : HERMES_ACP_MODELS_DEFAULT_TIMEOUT_MS;
+}
 async function fetchHermesAcpModels(cli, env) {
   return await new Promise((resolve13) => {
     let child;
     try {
-      child = spawn6(cli, ["acp"], { stdio: ["pipe", "pipe", "ignore"], env });
+      const resolved = resolveCli(cli, ["acp"], env);
+      child = spawn6(resolved.command, resolved.args, { stdio: ["pipe", "pipe", "ignore"], env, windowsHide: true });
     } catch {
       return resolve13([]);
     }
@@ -34676,7 +34733,7 @@ async function fetchHermesAcpModels(cli, env) {
       }
       resolve13(out);
     };
-    timer = setTimeout(() => done([]), 5e3);
+    timer = setTimeout(() => done([]), hermesAcpModelsTimeoutMs(env));
     child.once("error", () => done([]));
     child.once("close", () => {
       if (hardKillTimer) clearTimeout(hardKillTimer);
@@ -34756,11 +34813,12 @@ async function applySetting2(request, method, params, what) {
     throw new Error(`Hermes rejected ${what} via ${method}: ${e.message}`);
   }
 }
-var EMPTY2, HERMES_OPENMAUS_SCREENSHOT_COMPAT, HERMES_OPENMAUS_SCREENSHOT_COMPAT_MODEL, HERMES_CONFIG_MODEL_ID, HERMES_HOSTED_PROVIDER_KEYS, HERMES_LOCAL_CONFIG_PROVIDERS, support10, HermesAgentDriver;
+var EMPTY2, HERMES_OPENMAUS_SCREENSHOT_COMPAT, HERMES_OPENMAUS_SCREENSHOT_COMPAT_MODEL, HERMES_CONFIG_MODEL_ID, HERMES_HOSTED_PROVIDER_KEYS, HERMES_LOCAL_CONFIG_PROVIDERS, HERMES_ACP_MODELS_TIMEOUT_ENV, HERMES_ACP_MODELS_DEFAULT_TIMEOUT_MS, support10, HermesAgentDriver;
 var init_hermes = __esm({
   "server/drivers/acp/hermes.ts"() {
     "use strict";
     init_browser();
+    init_procs();
     init_local_inject();
     init_core3();
     EMPTY2 = { default: "", options: [] };
@@ -34774,6 +34832,8 @@ var init_hermes = __esm({
       "Z_AI_API_KEY"
     ];
     HERMES_LOCAL_CONFIG_PROVIDERS = /* @__PURE__ */ new Set(["custom", "lmstudio", "ollama", "vllm", "llamacpp"]);
+    HERMES_ACP_MODELS_TIMEOUT_ENV = "HERMES_ACP_MODELS_TIMEOUT_MS";
+    HERMES_ACP_MODELS_DEFAULT_TIMEOUT_MS = 15e3;
     support10 = {
       driverKind: "hermesAgent",
       displayName: "Hermes",
@@ -34846,12 +34906,19 @@ function decodeConfig5(raw) {
     provider: typeof config2.provider === "string" ? config2.provider || void 0 : process.env.OPENAI_COMPAT_PROVIDER || void 0
   };
 }
-var DRIVER_KIND5, DEFAULT_MODELS, OpenAICompatDriver;
+var DRIVER_KIND5, DEFAULT_IDLE_TIMEOUT_MS, idleTimeoutMs, DEFAULT_MODELS, OpenAICompatDriver;
 var init_openai_compat = __esm({
   "server/drivers/openai-compat.ts"() {
     "use strict";
     init_openai_chat();
     DRIVER_KIND5 = "openai-compat";
+    DEFAULT_IDLE_TIMEOUT_MS = 18e4;
+    idleTimeoutMs = () => {
+      const raw = process.env.OPENMAUS_OPENAI_COMPAT_IDLE_TIMEOUT_MS;
+      if (!raw) return DEFAULT_IDLE_TIMEOUT_MS;
+      const value = Number(raw);
+      return Number.isSafeInteger(value) && value >= 1e3 && value <= 2147483647 ? value : DEFAULT_IDLE_TIMEOUT_MS;
+    };
     DEFAULT_MODELS = {
       default: "meta-llama/llama-3.3-70b-instruct",
       options: [
@@ -34932,7 +34999,7 @@ var init_openai_compat = __esm({
           httpErrorLabel: "upstream",
           missingKeyError: `no API key \u2014 set ${config2.apiKeyEnv} or add it to the instance config`,
           unavailableReason: `no API key \u2014 set ${config2.apiKeyEnv} or add it to the instance config`,
-          timeoutMs: 12e4,
+          timeoutMs: idleTimeoutMs(),
           reasoning: true,
           billing: "metered",
           includeUsageInCompleted: true,
@@ -35176,6 +35243,16 @@ async function fetchPiModels(cli, env) {
     }
   });
 }
+async function updatePiModelCatalog(cli, env) {
+  return new Promise((resolve13) => {
+    execCli(
+      cli,
+      PI_MODEL_UPDATE_ARGS,
+      { env, timeout: 6e4, maxBuffer: 1024 * 1024 },
+      (error51) => resolve13(!error51)
+    );
+  });
+}
 function decodeConfig6(raw) {
   if (raw === null || raw === void 0) return { cli: "pi", fullAuto: false };
   if (typeof raw !== "object") throw new Error("pi config must be an object");
@@ -35193,7 +35270,7 @@ function piEnvironment(source) {
   for (const key of PROVIDER_CREDENTIAL_ENV) delete env[key];
   return env;
 }
-var DRIVER_KIND6, PI_ARGS, NODE_ENV_FLAG2, EMPTY3, PiDriver;
+var DRIVER_KIND6, PI_ARGS, PI_MODEL_UPDATE_ARGS, NODE_ENV_FLAG2, EMPTY3, PiDriver;
 var init_pi = __esm({
   "server/drivers/pi.ts"() {
     "use strict";
@@ -35207,6 +35284,7 @@ var init_pi = __esm({
     init_native();
     DRIVER_KIND6 = "piAgent";
     PI_ARGS = ["--mode", "rpc", "--no-session"];
+    PI_MODEL_UPDATE_ARGS = ["update", "--models", "--no-approve"];
     NODE_ENV_FLAG2 = { ELECTRON_RUN_AS_NODE: "1" };
     EMPTY3 = { default: "", options: [] };
     PiDriver = {
@@ -35228,7 +35306,7 @@ var init_pi = __esm({
         const { instanceId, config: config2 } = input;
         const catalogEnv = piEnvironment({ ...process.env, ...input.environment });
         let models = EMPTY3;
-        const refreshModels = async () => {
+        const readModels = async () => {
           let base3 = models;
           try {
             const resolved = await fetchPiModels(config2.cli, catalogEnv);
@@ -35242,7 +35320,11 @@ var init_pi = __esm({
             if (base3.options.length) models = base3;
           }
         };
-        await refreshModels();
+        const refreshModels = async () => {
+          await updatePiModelCatalog(config2.cli, catalogEnv);
+          await readModels();
+        };
+        await readModels();
         const listeners = /* @__PURE__ */ new Set();
         const active = /* @__PURE__ */ new Map();
         const emit = (event) => {

package/dist-server/server/agent-tool-policy.js

@@ -6,6 +6,7 @@
  */
 export const READ_ONLY_AGENT_TOOL_NAMES = new Set([
     "list_bots",
+    "list_team_setup",
     "list_rooms",
     "list_threads",
     "check_delegation",