openmausbot 0.1.69 → 0.1.71

package/dist-server/local-computer-proxy.js

@@ -135,9 +135,11 @@ function windowsKnownDirs() {
 var cached = null;
 var probed = false;
 var loginShellPath = null;
+var registeredDirs = [];
 function augmentedPath() {
   if (cached === null) {
     cached = mergePaths([
+      ...registeredDirs.filter((d) => existsSync(d)),
       ...process.env.OMB_EXTRA_PATH ? process.env.OMB_EXTRA_PATH.split(delimiter) : [],
       ...process.env.PATH ? process.env.PATH.split(delimiter) : [],
       // Keep the last successful login-shell result while a rescan starts a

package/dist-server/local-computer.js

@@ -22,6 +22,7 @@ var SPAWNED_PROXIES = {
   agents: resolveProxy("drivers/agents-proxy"),
   dweb: resolveProxy("drivers/dweb-proxy"),
   connectors: resolveProxy("connector-proxy"),
+  mcpGate: resolveProxy("mcp-gate"),
   phone: resolveProxy("drivers/phone-proxy"),
   // Loaded by the external `pi` process via `-e`, not by this server — but
   // resolved through the same single source of truth so the packaged layout
@@ -216,7 +217,7 @@ function readCuaConnection({
       candidates.push(join2(home, "Library", "Application Support", directory, "cua-connection.json"));
     }
   }
-  for (const file of [...new Set(candidates)]) {
+  for (const file of new Set(candidates)) {
     try {
       const raw = JSON.parse(readFileSync(file, "utf8"));
       if (platform === "linux") {

package/dist-server/mcp-gate.js

@@ -0,0 +1,543 @@
+// server/mcp-gate.ts
+import { spawn as spawn2 } from "node:child_process";
+import { mkdirSync, readdirSync as readdirSync2, rmSync, statSync as statSync2, writeFileSync } from "node:fs";
+import { join as join2 } from "node:path";
+import { createInterface } from "node:readline";
+
+// server/env-path.ts
+import { execFile } from "node:child_process";
+import { closeSync, existsSync, openSync, readFileSync, readSync, statSync, readdirSync } from "node:fs";
+import { homedir } from "node:os";
+import { basename, delimiter, dirname, extname, join } from "node:path";
+function nvmBinDirs() {
+  try {
+    const base = join(homedir(), ".nvm", "versions", "node");
+    return readdirSync(base).filter((v) => v.startsWith("v")).sort((a, b) => b.localeCompare(a, void 0, { numeric: true })).map((v) => join(base, v, "bin"));
+  } catch {
+    return [];
+  }
+}
+function knownDirs() {
+  const home = homedir();
+  return [
+    join(home, ".local", "bin"),
+    // claude installer default
+    join(home, ".npm-global", "bin"),
+    // npm prefix ~/.npm-global (claude, opencode)
+    join(home, ".kimi-code", "bin"),
+    // kimi-code installer
+    join(home, ".grok", "bin"),
+    // x.ai installer
+    join(home, ".opencode", "bin"),
+    // opencode installer
+    join(home, ".claude", "local"),
+    // claude "local install"
+    "/opt/homebrew/bin",
+    // brew, Apple silicon
+    "/usr/local/bin",
+    // brew Intel / classic installs
+    join(home, ".volta", "bin"),
+    join(home, ".bun", "bin"),
+    join(home, ".asdf", "shims"),
+    join(home, ".deno", "bin"),
+    join(home, "bin"),
+    ...nvmBinDirs()
+  ];
+}
+function windowsKnownDirs() {
+  const home = homedir();
+  const appData = process.env.APPDATA ?? join(home, "AppData", "Roaming");
+  const localAppData = process.env.LOCALAPPDATA ?? join(home, "AppData", "Local");
+  return [
+    join(appData, "npm"),
+    // npm -g shims: claude, codex
+    join(home, ".grok", "bin"),
+    // x.ai installer
+    join(localAppData, "agy", "bin"),
+    // Antigravity installer
+    join(home, ".local", "bin"),
+    // claude native installer
+    join(home, ".claude", "local"),
+    join(home, "bin"),
+    // Factory droid installer (%USERPROFILE%\bin)
+    join(home, ".bun", "bin"),
+    join(home, ".deno", "bin"),
+    join(home, "go", "bin")
+  ];
+}
+var cached = null;
+var probed = false;
+var loginShellPath = null;
+var registeredDirs = [];
+function augmentedPath() {
+  if (cached === null) {
+    cached = mergePaths([
+      ...registeredDirs.filter((d) => existsSync(d)),
+      ...process.env.OMB_EXTRA_PATH ? process.env.OMB_EXTRA_PATH.split(delimiter) : [],
+      ...process.env.PATH ? process.env.PATH.split(delimiter) : [],
+      // Keep the last successful login-shell result while a rescan starts a
+      // fresh asynchronous probe. Otherwise resetPathCache() would make
+      // rc-only CLIs disappear again for the response that triggered it.
+      ...loginShellPath ? loginShellPath.split(delimiter) : [],
+      // Both platforms scan their standard install locations; only the
+      // login-shell probe below stays unix-only, since Windows has no
+      // equivalent rc file to source.
+      ...(process.platform === "win32" ? windowsKnownDirs() : knownDirs()).filter((d) => existsSync(d))
+    ]);
+  }
+  if (!probed && !process.env.VITEST && process.platform !== "win32") {
+    probed = true;
+    probeLoginShellPath();
+  }
+  return cached;
+}
+function mergePaths(parts) {
+  return [...new Set(parts.filter(Boolean))].join(delimiter);
+}
+function probeLoginShellPath() {
+  const shell = process.env.SHELL || "/bin/zsh";
+  execFile(
+    shell,
+    ["-l", "-i", "-c", 'printf "__OMB_PATH__%s" "$PATH"'],
+    { timeout: 5e3 },
+    (err, stdout) => {
+      if (err || !stdout) return;
+      const m = /__OMB_PATH__([^\n]*)/.exec(stdout);
+      if (!m || !m[1]) return;
+      loginShellPath = m[1];
+      cached = mergePaths([...(cached ?? "").split(delimiter), ...m[1].split(delimiter)]);
+    }
+  );
+}
+function splitCliString(cli) {
+  const out = [];
+  let cur = "";
+  let quote = null;
+  for (const ch of cli.trim()) {
+    if (quote) {
+      if (ch === quote) quote = null;
+      else cur += ch;
+    } else if (ch === '"' || ch === "'") {
+      quote = ch;
+    } else if (/\s/.test(ch)) {
+      if (cur) out.push(cur);
+      cur = "";
+    } else {
+      cur += ch;
+    }
+  }
+  if (cur) out.push(cur);
+  return out;
+}
+function isFile(p) {
+  try {
+    return statSync(p, { throwIfNoEntry: false })?.isFile() ?? false;
+  } catch {
+    return false;
+  }
+}
+function whichWin(cli) {
+  const exts = (process.env.PATHEXT ?? ".COM;.EXE;.BAT;.CMD").split(";").filter(Boolean);
+  const probe = (base) => {
+    const order = extname(base) ? [base, ...exts.map((e) => base + e)] : [...exts.map((e) => base + e), base];
+    return order.find(isFile) ?? null;
+  };
+  if (/[\\/]/.test(cli) || /^[a-zA-Z]:/.test(cli)) return probe(cli);
+  for (const dir of augmentedPath().split(delimiter)) {
+    if (!dir) continue;
+    const hit = probe(join(dir, cli));
+    if (hit) return hit;
+  }
+  return null;
+}
+function nodeExe(near) {
+  const local = join(near, "node.exe");
+  if (isFile(local)) return local;
+  const onPath = whichWin("node.exe");
+  if (onPath && extname(onPath).toLowerCase() === ".exe") return onPath;
+  return process.versions.electron ? null : process.execPath;
+}
+function parseCmdShim(shim) {
+  let text;
+  try {
+    text = readFileSync(shim, "utf8");
+  } catch {
+    return null;
+  }
+  const dir = dirname(shim);
+  const targets = [...text.matchAll(/"%~?dp0%?\\?([^"]+)"/g)].map((m) => join(dir, m[1])).filter((p) => isFile(p) && basename(p).toLowerCase() !== "node.exe");
+  const script = targets.find((p) => /\.[cm]?js$/i.test(p));
+  if (script) {
+    const node = nodeExe(dir);
+    if (node) return { command: node, args: [script] };
+  }
+  const exe = targets.find((p) => extname(p).toLowerCase() === ".exe");
+  return exe ? { command: exe, args: [] } : null;
+}
+function parseNodeShebang(file) {
+  let head = "";
+  let fd = null;
+  try {
+    fd = openSync(file, "r");
+    const buf = Buffer.alloc(128);
+    const n = readSync(fd, buf, 0, buf.length, 0);
+    head = buf.subarray(0, n).toString("utf8").split("\n", 1)[0];
+  } catch {
+    return null;
+  } finally {
+    if (fd !== null) {
+      try {
+        closeSync(fd);
+      } catch {
+      }
+    }
+  }
+  if (!/^#!.*\bnode(\.exe)?\b/.test(head)) return null;
+  const node = nodeExe(dirname(file));
+  return node ? { command: node, args: [file] } : null;
+}
+function resolveWord(cli, args) {
+  if (process.platform !== "win32") return { command: cli, args };
+  const file = whichWin(cli);
+  if (!file) return { command: cli, args };
+  const ext = extname(file).toLowerCase();
+  if (ext === ".cmd" || ext === ".bat") {
+    const direct = parseCmdShim(file);
+    return direct ? { command: direct.command, args: [...direct.args, ...args] } : { command: file, args };
+  }
+  if (ext === ".exe" || ext === ".com") return { command: file, args };
+  const viaNode = parseNodeShebang(file);
+  return viaNode ? { command: viaNode.command, args: [...viaNode.args, ...args] } : { command: file, args };
+}
+function resolveCliSpawn(cli, args) {
+  const trimmed = cli.trim();
+  if (trimmed.includes(" ") && existsSync(trimmed)) return resolveWord(trimmed, args);
+  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(cli, args);
+}
+
+// server/mcp-trim.ts
+var DEFAULT_RESULT_BUDGET = 8e3;
+var MIN_BUDGET = 512;
+var fmt = (n) => n.toLocaleString("en-US");
+function serialize(value) {
+  try {
+    const json = JSON.stringify(value);
+    return typeof json === "string" ? json : null;
+  } catch {
+    return null;
+  }
+}
+function fitArray(items, budget) {
+  const kept = [];
+  let used = 2;
+  for (const item of items) {
+    const json = serialize(item);
+    if (json === null) break;
+    const cost = json.length + (kept.length ? 1 : 0);
+    if (kept.length && used + cost > budget) break;
+    kept.push(item);
+    used += cost;
+  }
+  return kept;
+}
+function arrayFields(value) {
+  if (Array.isArray(value)) return [{ key: "", items: value }];
+  if (!value || typeof value !== "object") return [];
+  return Object.entries(value).filter((entry) => Array.isArray(entry[1])).map(([key, items]) => ({ key, items }));
+}
+function cutAt(text, chars) {
+  const cut = text.slice(0, Math.max(0, chars));
+  const last = cut.charCodeAt(cut.length - 1);
+  return last >= 55296 && last <= 56319 ? cut.slice(0, -1) : cut;
+}
+function marker(input) {
+  const counts = input.dropped.filter((d) => d.kept < d.total).map((d) => `${d.key || "items"} ${fmt(d.kept)} of ${fmt(d.total)}`).join(", ");
+  const what = input.structural ? counts ? ` Kept ${counts}.` : "" : " Cut mid-text, so what is above may be incomplete JSON.";
+  const where = input.spillHint && input.spillPath ? ` The whole result is at ${JSON.stringify(input.spillPath)}; reading it costs as much as not trimming, so narrow the call first.` : " If you need more, call the tool again with a narrower query, a filter, or the next page.";
+  return `
+
+[OpenMausBot trimmed this tool result to fit the conversation: ${fmt(input.originalChars)} \u2192 ${fmt(input.keptChars)} characters.${what}${where}]`;
+}
+function trimStructured(parsed, budget) {
+  const room = Math.max(MIN_BUDGET, budget);
+  const current = serialize(parsed);
+  if (current !== null && current.length <= room) return null;
+  const fields = arrayFields(parsed);
+  if (!fields.length) return null;
+  const skeleton = Array.isArray(parsed) ? 2 : serialize({ ...parsed, ...Object.fromEntries(fields.map((f) => [f.key, []])) })?.length ?? Infinity;
+  const share = Math.floor((room - skeleton) / fields.length);
+  if (!Number.isFinite(skeleton) || share <= 0) return null;
+  const dropped = [];
+  let value;
+  if (Array.isArray(parsed)) {
+    const kept = fitArray(parsed, share);
+    dropped.push({ key: "", kept: kept.length, total: parsed.length });
+    value = kept;
+  } else {
+    const next = { ...parsed };
+    for (const field of fields) {
+      const kept = fitArray(field.items, share);
+      dropped.push({ key: field.key, kept: kept.length, total: field.items.length });
+      next[field.key] = kept;
+    }
+    value = next;
+  }
+  if (!dropped.some((d) => d.kept < d.total)) return null;
+  const json = serialize(value);
+  return json !== null && json.length <= room ? { value, dropped } : null;
+}
+function trimResultText(input) {
+  const { text } = input;
+  const budget = Math.max(MIN_BUDGET, input.budget ?? DEFAULT_RESULT_BUDGET);
+  if (text.length <= budget) return { text, trimmed: false, originalChars: text.length };
+  const room = Math.max(MIN_BUDGET, budget - 400);
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    parsed = void 0;
+  }
+  const fields = parsed === void 0 ? [] : arrayFields(parsed);
+  if (fields.length) {
+    const skeleton = Array.isArray(parsed) ? 2 : serialize({ ...parsed, ...Object.fromEntries(fields.map((f) => [f.key, []])) })?.length ?? Infinity;
+    const share = Math.floor((room - skeleton) / fields.length);
+    if (Number.isFinite(skeleton) && share > 0) {
+      const dropped = [];
+      let value;
+      if (Array.isArray(parsed)) {
+        const kept = fitArray(parsed, share);
+        dropped.push({ key: "", kept: kept.length, total: parsed.length });
+        value = kept;
+      } else {
+        const next = { ...parsed };
+        for (const field of fields) {
+          const kept = fitArray(field.items, share);
+          dropped.push({ key: field.key, kept: kept.length, total: field.items.length });
+          next[field.key] = kept;
+        }
+        value = next;
+      }
+      const json = serialize(value);
+      if (json !== null && json.length <= room) {
+        return {
+          text: json + marker({ originalChars: text.length, keptChars: json.length, dropped, spillPath: input.spillPath, spillHint: input.spillHint, structural: true }),
+          trimmed: true,
+          originalChars: text.length
+        };
+      }
+    }
+  }
+  const cut = cutAt(text, room);
+  return {
+    text: cut + marker({ originalChars: text.length, keptChars: cut.length, dropped: [], spillPath: input.spillPath, spillHint: input.spillHint, structural: false }),
+    trimmed: true,
+    originalChars: text.length
+  };
+}
+
+// server/procs.ts
+import {
+  spawn,
+  execFile as execFile2
+} from "node:child_process";
+function killCliTree(child2, timeoutMs = 5e3) {
+  const pid = child2.pid;
+  if (!pid || child2.exitCode !== null || child2.signalCode !== null) return Promise.resolve(true);
+  return new Promise((resolve) => {
+    let timer;
+    const done = (stopped) => {
+      clearTimeout(timer);
+      child2.off("close", closed);
+      resolve(stopped);
+    };
+    const closed = () => done(true);
+    child2.once("close", closed);
+    timer = setTimeout(() => done(false), timeoutMs);
+    timer.unref?.();
+    if (process.platform === "win32") {
+      execFile2("taskkill", ["/PID", String(pid), "/T", "/F"], { windowsHide: true }, (err) => {
+        if (!err) return;
+        try {
+          child2.kill();
+        } catch {
+        }
+      });
+      return;
+    }
+    try {
+      process.kill(-pid, "SIGTERM");
+    } catch {
+      try {
+        child2.kill("SIGTERM");
+      } catch {
+      }
+    }
+  });
+}
+
+// server/mcp-gate.ts
+var NAME = process.env.OMB_GATE_NAME || "mcp";
+var SPILL_DIR = process.env.OMB_GATE_SPILL_DIR || "";
+var BUDGET = Number(process.env.OMB_GATE_BUDGET) > 0 ? Number(process.env.OMB_GATE_BUDGET) : DEFAULT_RESULT_BUDGET;
+var SPILL_MAX_AGE_MS = 24 * 60 * 6e4;
+var SPILL_HINT = process.env.OMB_GATE_SPILL_HINT === "1";
+var GATE_ENV_KEYS = ["OMB_GATE_NAME", "OMB_GATE_SPILL_DIR", "OMB_GATE_BUDGET", "OMB_GATE_UPSTREAM", "OMB_GATE_SPILL_HINT"];
+function fail(message) {
+  process.stderr.write(`mcp-gate(${NAME}): ${message}
+`);
+  process.exit(1);
+}
+function upstreamSpec() {
+  let parsed;
+  try {
+    parsed = JSON.parse(process.env.OMB_GATE_UPSTREAM ?? "");
+  } catch {
+    fail("OMB_GATE_UPSTREAM is not valid JSON");
+  }
+  const spec2 = parsed;
+  if (!spec2 || typeof spec2 !== "object" || typeof spec2.command !== "string" || !spec2.command) {
+    fail("OMB_GATE_UPSTREAM needs a command");
+  }
+  return spec2;
+}
+function sweepSpill(dir) {
+  let entries;
+  try {
+    entries = readdirSync2(dir);
+  } catch {
+    return;
+  }
+  const cutoff = Date.now() - SPILL_MAX_AGE_MS;
+  for (const entry of entries) {
+    try {
+      const path = join2(dir, entry);
+      if (statSync2(path).mtimeMs < cutoff) rmSync(path, { force: true });
+    } catch {
+    }
+  }
+}
+var spilled = 0;
+function spill(tool, text) {
+  if (!SPILL_DIR) return void 0;
+  const safeTool = tool.replace(/[^A-Za-z0-9_.-]/g, "-").slice(0, 60) || "tool";
+  const path = join2(SPILL_DIR, `${Date.now()}-${process.pid}-${spilled++}-${safeTool}.json`);
+  try {
+    mkdirSync(SPILL_DIR, { recursive: true, mode: 448 });
+    writeFileSync(path, text, { mode: 384 });
+    return path;
+  } catch (error) {
+    process.stderr.write(`mcp-gate(${NAME}): could not save the full result: ${String(error)}
+`);
+    return void 0;
+  }
+}
+function trimCallResult(result, tool) {
+  const content = result.content;
+  if (!Array.isArray(content)) return false;
+  const textBlocks = content.filter(
+    (block) => Boolean(block) && typeof block === "object" && block.type === "text" && typeof block.text === "string"
+  );
+  const total = textBlocks.reduce((sum, block) => sum + block.text.length, 0);
+  if (!textBlocks.length || total <= BUDGET) return false;
+  const share = Math.floor(BUDGET / textBlocks.length);
+  const path = spill(tool, textBlocks.map((block) => block.text).join("\n"));
+  let trimmed = false;
+  for (const block of textBlocks) {
+    const outcome = trimResultText({ text: block.text, budget: share, spillPath: path, spillHint: SPILL_HINT, toolName: tool });
+    if (!outcome.trimmed) continue;
+    block.text = outcome.text;
+    trimmed = true;
+  }
+  if (trimmed && result.structuredContent && typeof result.structuredContent === "object") {
+    const structured = trimStructured(result.structuredContent, BUDGET);
+    if (structured) result.structuredContent = structured.value;
+  }
+  return trimmed;
+}
+var spec = upstreamSpec();
+if (SPILL_DIR) sweepSpill(SPILL_DIR);
+var childEnv = { ...process.env, ...spec.env };
+for (const key of GATE_ENV_KEYS) delete childEnv[key];
+var resolved = resolveCliSpawn(spec.command, spec.args ?? []);
+var child = spawn2(resolved.command, resolved.args, {
+  stdio: ["pipe", "pipe", "pipe"],
+  env: childEnv,
+  shell: false,
+  // a console app spawned from the desktop shell flashes a window otherwise
+  ...process.platform === "win32" ? { windowsHide: true } : {}
+});
+var reaping = false;
+var reapChild = () => {
+  if (reaping) return;
+  reaping = true;
+  void killCliTree(child);
+};
+process.on("SIGTERM", () => {
+  reapChild();
+  process.exit(0);
+});
+process.on("SIGINT", () => {
+  reapChild();
+  process.exit(0);
+});
+process.on("exit", reapChild);
+child.on("error", (error) => {
+  process.stderr.write(`mcp-gate(${NAME}): could not start ${resolved.command}: ${String(error)}
+`);
+  process.exit(1);
+});
+child.stderr.pipe(process.stderr);
+var pending = /* @__PURE__ */ new Map();
+createInterface({ input: process.stdin }).on("line", (line) => {
+  if (line.trim()) {
+    try {
+      const message = JSON.parse(line);
+      if (message.method === "tools/call" && message.id !== void 0 && message.id !== null) {
+        const params = message.params;
+        pending.set(String(message.id), typeof params?.name === "string" ? params.name : "tool");
+      }
+    } catch {
+    }
+  }
+  child.stdin.write(`${line}
+`);
+});
+process.stdin.on("end", () => child.stdin.end());
+createInterface({ input: child.stdout }).on("line", (line) => {
+  if (!line.trim()) return;
+  let message;
+  try {
+    message = JSON.parse(line);
+  } catch {
+    process.stdout.write(`${line}
+`);
+    return;
+  }
+  const id = message.id === void 0 || message.id === null ? void 0 : String(message.id);
+  const tool = id === void 0 ? void 0 : pending.get(id);
+  if (id !== void 0) pending.delete(id);
+  const result = message.result;
+  if (tool && result && typeof result === "object" && !Array.isArray(result)) {
+    try {
+      if (trimCallResult(result, tool)) {
+        process.stderr.write(`mcp-gate(${NAME}): trimmed ${tool} to ${BUDGET} chars
+`);
+      }
+    } catch (error) {
+      process.stderr.write(`mcp-gate(${NAME}): could not trim ${tool}: ${String(error)}
+`);
+      process.stdout.write(`${line}
+`);
+      return;
+    }
+  }
+  process.stdout.write(`${JSON.stringify(message)}
+`);
+});
+child.on("exit", (code, signal) => process.exit(code ?? (signal ? 1 : 0)));

package/dist-server/mcp-server.js

@@ -375,6 +375,22 @@ var TOOLS = [
     },
     annotations: MUTATING
   },
+  {
+    name: "edit_bot_message",
+    description: "Edit an earlier user message, which forks the conversation from that point and answers again. This is the rewind a person performs in the composer, and the only mapped way to make the harness rebuild a thread's context instead of resuming the provider's own session. Refused while the thread is working.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        bot_id: { type: "string", description: "The ID of the bot." },
+        message_id: { type: "string", description: "The user message to replace." },
+        text: { type: "string", description: "What that message should say instead." },
+        task_id: { type: "string", description: "Optional owned task/thread ID. Defaults to the bot's selected task." }
+      },
+      required: ["bot_id", "message_id", "text"],
+      additionalProperties: false
+    },
+    annotations: MUTATING
+  },
   {
     name: "list_available_models",
     description: "List configured model instances and capabilities without exposing local executable paths.",
@@ -1014,6 +1030,28 @@ async function handleToolCall(name, args, baseFetcher = request, signal) {
       });
       return { success: true, bot: projectBot(res.bot) };
     }
+    case "edit_bot_message": {
+      const botId = idArg(args, "bot_id");
+      const messageId = idArg(args, "message_id");
+      const text = String(args.text ?? "").trim();
+      if (!text) throw new Error("text is required");
+      const current = await fleet(fetcher);
+      const bot = records(current.bots).find((candidate) => candidate.id === botId);
+      if (!bot) throw new Error(`Bot not found: ${botId}`);
+      let threadId;
+      if (args.task_id !== void 0) {
+        threadId = idArg(args, "task_id");
+        if (!taskBelongsTo(bot, threadId)) throw new Error(`Task '${threadId}' does not belong to bot '${botId}'`);
+        if (botTaskState(bot, threadId).busy) throw new Error("Interrupt the task or let it finish before editing a message");
+      } else if (bot.busy) {
+        throw new Error("Interrupt the bot or let it finish before editing a message");
+      }
+      const res = await fetcher(
+        `/api/bots/${encodeURIComponent(botId)}/messages/${encodeURIComponent(messageId)}/edit`,
+        { method: "POST", body: JSON.stringify({ text, ...threadId ? { threadId } : {} }) }
+      );
+      return { success: true, botId, message: res?.message ?? null };
+    }
     case "list_available_models": {
       const res = await fetcher("/api/instances");
       return {