openmausbot 0.1.91 → 0.1.93

package/dist-server/server/drivers/antigravity-temp.js

@@ -0,0 +1,360 @@
+// Where Google's Windows Antigravity runtime unpacks itself, and how the
+// space it leaves behind is reclaimed.
+//
+// Adapted from pingdotgg/t3code@c18e5ea6ed, MIT License, Copyright (c) 2026
+// T3 Tools Inc. (full text in third_party/t3-code/LICENSE); modified:
+//   - apps/server/src/provider/antigravityAuthSupport.ts:187-212, 238-253
+//     (a short temp folder per instance, beside rather than inside the
+//     profile, and TEMP/TMP pointed at it for the runtime);
+//   - apps/server/src/provider/acp/AntigravitySessionFiles.ts:45-61 and
+//     apps/server/src/provider/Drivers/AntigravityDriver.ts:121-132
+//     (reclaim what earlier runs left behind when the driver starts).
+// What OMB does differently: the folder is stable per instance, never per
+// process, because the ACP pool's contractKey hashes the launch environment
+// and a new TEMP per process would respawn on every turn. t3code's per-process
+// run-* folders (AntigravityDriver.ts:202-227) are deliberately not copied.
+// Because the folder is shared, the sweep removes only unpack folders whose
+// process is gone instead of the whole folder. The user-started cleanup of the
+// system temp folder is OMB's own; t3code never touches system temp.
+//
+// Background: agy_acp_server.exe is a PyInstaller one-file build. Every launch
+// unpacks thousands of files (0.34-1.26 GB) into a new %TEMP%\_MEI... folder,
+// and a forced stop (taskkill /T /F) skips PyInstaller's own cleanup, so the
+// folder stays behind. PyInstaller names it `_MEI` + the unpacking process ID
+// + a counter from _wtempnam: the ID is `%08x` since 6.22.1 and `%d` before
+// (bootloader/src/pyi_utils_win32.c, pyi_create_temporary_application_directory).
+import { createHash, randomUUID } from "node:crypto";
+import { lstat, readdir, realpath, rename, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { basename, dirname, join, resolve } from "node:path";
+import { DATA_DIR } from "../config.js";
+const UNPACK_PREFIX = "_MEI";
+/** An unpack folder OMB has claimed by renaming it and is deleting. If the
+ * delete stops part way, the next sweep finishes it. */
+const CLAIM_PREFIX = ".omb-removing-";
+/** Files at the root of every Antigravity unpack folder. Other programs use
+ * PyInstaller too; without both of these a folder is not Antigravity's. */
+const ANTIGRAVITY_MARKERS = ["agy_acp_licenses.txt", "python310.dll"];
+/** A folder this recent may still be unpacking, even if its ID looks free. */
+export const SYSTEM_LEFTOVER_MIN_AGE_MS = 10 * 60_000;
+const INSTANCE_FOLDER = /^[0-9a-f]{12}$/u;
+/** The folder every instance's temp folder lives in. `tmp/` is already left
+ * out of workspace backups (workspace-backup.ts EXCLUDED). */
+export function antigravityTempRoot(dataDir = DATA_DIR) {
+    return join(dataDir, "tmp", "agy");
+}
+/** Used in place of an instance ID for the one temp folder every runtime
+ * verification shares. It has a space, which no instance ID has, so no
+ * instance shares the folder. Being one fixed folder, what a verification
+ * leaves behind (a runtime that would not stop) is swept like an instance's
+ * leftovers: after the next verification and when the driver starts. */
+export const VERIFICATION_TEMP_KEY = "runtime verification";
+/** One stable, short temp folder per instance. Short, because the runtime
+ * unpacks files up to 120 characters deep and Windows paths stop at 260.
+ * Hashed, so instance IDs that differ only in case stay apart on
+ * case-insensitive disks. */
+export function antigravityTempDir(dataDir, instanceId) {
+    const key = createHash("sha256").update(instanceId).digest("hex").slice(0, 12);
+    return join(antigravityTempRoot(dataDir), key);
+}
+/** Point the runtime's temp folder at `directory`. Windows only: that is
+ * where the runtime unpacks itself. Windows environment names ignore case,
+ * so an inherited `Temp` or `tmp` would otherwise sit beside ours and either
+ * could win. */
+export function setAntigravityTempEnvironment(environment, directory, platform = process.platform) {
+    if (platform !== "win32")
+        return;
+    for (const key of Object.keys(environment)) {
+        const upper = key.toUpperCase();
+        if (upper === "TEMP" || upper === "TMP")
+            delete environment[key];
+    }
+    environment.TEMP = directory;
+    environment.TMP = directory;
+}
+/** Process IDs that could own an unpack folder with this name, or null when
+ * the name is not a PyInstaller unpack folder at all.
+ *
+ * Since 6.22.1 the ID is 8 hex digits. Before that it is plain decimal and
+ * runs straight into _wtempnam's decimal counter, so the split is ambiguous:
+ * every split that leaves a 1-3 digit counter is a candidate. A folder counts
+ * as abandoned only when every candidate is gone, so the guess can keep a
+ * leftover a while longer but can never delete a live one. */
+export function unpackFolderOwnerPids(name) {
+    if (!name.startsWith(UNPACK_PREFIX))
+        return null;
+    const rest = name.slice(UNPACK_PREFIX.length);
+    const pids = new Set();
+    if (/^[0-9a-f]{8}\d+$/iu.test(rest))
+        pids.add(Number.parseInt(rest.slice(0, 8), 16));
+    if (/^[1-9]\d+$/u.test(rest)) {
+        for (let counter = 1; counter <= 3 && counter < rest.length; counter++) {
+            pids.add(Number.parseInt(rest.slice(0, rest.length - counter), 10));
+        }
+    }
+    const valid = [...pids].filter((pid) => Number.isSafeInteger(pid) && pid > 0);
+    return valid.length ? valid : null;
+}
+/** Whether a process with this ID exists. Only "no such process" (ESRCH)
+ * proves it is gone: EPERM means it exists but belongs to someone else. */
+export function processIsAlive(pid, kill = (target, signal) => process.kill(target, signal)) {
+    try {
+        kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error?.code !== "ESRCH";
+    }
+}
+function ownedByDeadProcess(name, isAlive) {
+    const pids = unpackFolderOwnerPids(name);
+    return pids !== null && !pids.some((pid) => isAlive(pid));
+}
+/** A real directory (not a link or junction to one), nothing there at all,
+ * or anything else. */
+async function entryKind(path) {
+    try {
+        const info = await lstat(path);
+        return info.isDirectory() && !info.isSymbolicLink() ? "directory" : "other";
+    }
+    catch (error) {
+        return error?.code === "ENOENT" ? "gone" : "other";
+    }
+}
+async function realDirectory(path) {
+    return (await entryKind(path)) === "directory";
+}
+async function listDirectory(path) {
+    try {
+        return await readdir(path, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+}
+/** The instance folders under OMB's temp root, each resolved through the
+ * disk. Returns nothing when any step of dataDir/tmp/agy/<id> is a link or
+ * junction, so a sweep can never be steered outside OMB's own folder. */
+async function ownedTempDirectories(dataDir, only) {
+    const root = resolve(antigravityTempRoot(dataDir));
+    let realRoot;
+    try {
+        const realData = await realpath(resolve(dataDir));
+        realRoot = await realpath(root);
+        if (realRoot !== join(realData, "tmp", "agy"))
+            return [];
+    }
+    catch {
+        return [];
+    }
+    const names = only === undefined
+        ? (await listDirectory(root)).filter((entry) => entry.isDirectory()).map((entry) => entry.name)
+        : [only];
+    const owned = [];
+    for (const name of names) {
+        if (!INSTANCE_FOLDER.test(name))
+            continue;
+        const directory = join(root, name);
+        try {
+            if (await realpath(directory) !== join(realRoot, name))
+                continue;
+        }
+        catch {
+            continue;
+        }
+        owned.push(directory);
+    }
+    return owned;
+}
+/** Unpack folders in one OMB-owned temp folder whose process is gone, and
+ * folders a previous sweep claimed but did not finish deleting. */
+async function abandonedIn(directory, isAlive) {
+    const found = [];
+    for (const entry of await listDirectory(directory)) {
+        // Dirent follows lstat: a link or junction is never a directory here.
+        if (!entry.isDirectory())
+            continue;
+        if (entry.name.startsWith(CLAIM_PREFIX) || ownedByDeadProcess(entry.name, isAlive)) {
+            found.push(join(directory, entry.name));
+        }
+    }
+    return found;
+}
+async function isAntigravityUnpack(directory) {
+    for (const marker of ANTIGRAVITY_MARKERS) {
+        try {
+            if (!(await lstat(join(directory, marker))).isFile())
+                return false;
+        }
+        catch {
+            return false;
+        }
+    }
+    return true;
+}
+/** Antigravity unpack folders in the system temp folder: both marker files,
+ * no live owner, and untouched for ten minutes. Other apps (Zed, t3code)
+ * start the same runtime, so this runs only when the person asks. */
+async function systemLeftovers(systemTemp, isAlive, now) {
+    const found = [];
+    for (const entry of await listDirectory(systemTemp)) {
+        if (!entry.isDirectory())
+            continue;
+        const directory = join(systemTemp, entry.name);
+        const claimed = entry.name.startsWith(CLAIM_PREFIX + UNPACK_PREFIX);
+        if (!claimed && !ownedByDeadProcess(entry.name, isAlive))
+            continue;
+        if (!claimed && !(await isAntigravityUnpack(directory)))
+            continue;
+        try {
+            if (now - (await lstat(directory)).mtimeMs < SYSTEM_LEFTOVER_MIN_AGE_MS)
+                continue;
+        }
+        catch {
+            continue;
+        }
+        found.push(directory);
+    }
+    return found;
+}
+/** Bytes under a folder, without following links. Stops at the deadline. */
+async function folderBytes(directory, deadline = Infinity) {
+    let bytes = 0;
+    const pending = [directory];
+    while (pending.length) {
+        if (Date.now() > deadline)
+            return { bytes, complete: false };
+        const current = pending.pop();
+        for (const entry of await listDirectory(current)) {
+            const path = join(current, entry.name);
+            if (entry.isDirectory())
+                pending.push(path);
+            else if (entry.isFile()) {
+                try {
+                    bytes += (await lstat(path)).size;
+                }
+                catch { /* already gone */ }
+            }
+        }
+    }
+    return { bytes, complete: true };
+}
+/** Claim a folder by renaming it, then delete it. On Windows the rename
+ * fails while any process still has a file inside open (every live runtime
+ * has its DLLs loaded), which is a second check after the process ID.
+ * Returns the bytes freed; "gone" when someone else (the automatic sweep and
+ * "Free up space" can pick the same folder) removed it first; or null when
+ * the folder was left alone. */
+async function claimAndRemove(directory, countBytes) {
+    const name = basename(directory);
+    // Checked again at the last moment: the listing may be stale.
+    const kind = await entryKind(directory);
+    if (kind !== "directory")
+        return kind === "gone" ? "gone" : null;
+    let claimed = directory;
+    if (!name.startsWith(CLAIM_PREFIX)) {
+        claimed = join(dirname(directory), `${CLAIM_PREFIX}${name}-${randomUUID().slice(0, 8)}`);
+        try {
+            await rename(directory, claimed);
+        }
+        catch (error) {
+            // Lost the race to another remover: the folder is gone, not in use.
+            if (error?.code === "ENOENT" && (await entryKind(directory)) === "gone")
+                return "gone";
+            return null;
+        }
+    }
+    const { bytes } = countBytes ? await folderBytes(claimed) : { bytes: 0 };
+    try {
+        await rm(claimed, { recursive: true, force: true, maxRetries: 3, retryDelay: 200 });
+        return bytes;
+    }
+    catch {
+        // The claimed name stays, and the next sweep finishes the job.
+        return null;
+    }
+}
+const sweeps = new Map();
+/** Delete this instance's abandoned unpack folders. Runs when the driver
+ * starts and before each launch (and, for VERIFICATION_TEMP_KEY, after each
+ * runtime verification). Touches nothing outside dataDir/tmp/agy/<instance>.
+ * Returns how many folders it removed. */
+export function sweepAntigravityTemp(instanceId, options = {}) {
+    const dataDir = options.dataDir ?? DATA_DIR;
+    const key = antigravityTempDir(dataDir, instanceId);
+    const running = sweeps.get(key);
+    if (running)
+        return running;
+    const sweep = (async () => {
+        const isAlive = options.isAlive ?? processIsAlive;
+        let removed = 0;
+        for (const directory of await ownedTempDirectories(dataDir, basename(key))) {
+            for (const folder of await abandonedIn(directory, isAlive)) {
+                if (typeof await claimAndRemove(folder, false) === "number")
+                    removed++;
+            }
+        }
+        return removed;
+    })().finally(() => sweeps.delete(key));
+    sweeps.set(key, sweep);
+    return sweep;
+}
+/** Fire-and-forget form for launch paths: never delays or fails a turn. */
+export function scheduleAntigravityTempSweep(instanceId, options = {}) {
+    void sweepAntigravityTemp(instanceId, options).catch((error) => {
+        console.warn(`antigravity: could not clear leftover runtime files: ${error instanceof Error ? error.message : String(error)}`);
+    });
+}
+async function leftoverCandidates(options) {
+    const isAlive = options.isAlive ?? processIsAlive;
+    const candidates = [];
+    for (const directory of await ownedTempDirectories(options.dataDir ?? DATA_DIR)) {
+        for (const path of await abandonedIn(directory, isAlive))
+            candidates.push({ path, where: "app" });
+    }
+    if ((options.platform ?? process.platform) === "win32") {
+        // TEMP itself may legitimately be a junction; what is inside it may not.
+        const systemTemp = await realpath(resolve(options.systemTemp ?? tmpdir())).catch(() => null);
+        if (systemTemp && await realDirectory(systemTemp)) {
+            for (const path of await systemLeftovers(systemTemp, isAlive, options.now ?? Date.now())) {
+                candidates.push({ path, where: "system" });
+            }
+        }
+    }
+    return candidates;
+}
+/** What "Free up space" would delete, and roughly how much it is. Deletes
+ * nothing. */
+export async function findAntigravityLeftovers(options = {}) {
+    const deadline = Date.now() + (options.budgetMs ?? 15_000);
+    const folders = [];
+    let complete = true;
+    for (const candidate of await leftoverCandidates(options)) {
+        const counted = await folderBytes(candidate.path, deadline);
+        complete &&= counted.complete;
+        folders.push({ ...candidate, bytes: counted.bytes });
+    }
+    return { folders, bytes: folders.reduce((total, folder) => total + folder.bytes, 0), complete };
+}
+/** "Free up space": looks again rather than trusting an earlier scan, so a
+ * folder that came back to life since is left alone. */
+export async function removeAntigravityLeftovers(options = {}) {
+    const deadline = Date.now() + (options.budgetMs ?? 120_000);
+    const candidates = await leftoverCandidates(options);
+    let removed = 0;
+    let alreadyGone = 0;
+    let freedBytes = 0;
+    for (const candidate of candidates) {
+        if (Date.now() > deadline)
+            break;
+        const bytes = await claimAndRemove(candidate.path, true);
+        if (bytes === "gone")
+            alreadyGone++;
+        if (typeof bytes !== "number")
+            continue;
+        removed++;
+        freedBytes += bytes;
+    }
+    // A folder another remover got to first is not "still in use".
+    return { removed, freedBytes, remaining: candidates.length - removed - alreadyGone };
+}

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

@@ -2,6 +2,7 @@ import { createAcpDriver } from "./acp/core.js";
 import { AntigravityAuthController, antigravityProfileAuthenticated, catalogFromAntigravityConfigOptions, prepareAntigravityProfile, probeAntigravityModels, validateAntigravityRuntime, } from "./antigravity-acp.js";
 import { antigravityManagedInstallAvailable, installAntigravityRuntime, resolveAntigravityRuntime, } from "./antigravity-runtime.js";
 import { resolveAntigravityReleaseAsset } from "./antigravity-release.js";
+import { VERIFICATION_TEMP_KEY, scheduleAntigravityTempSweep } from "./antigravity-temp.js";
 import { augmentedPath } from "../env-path.js";
 export const STATIC_ANTIGRAVITY_MODELS = {
     default: "gemini-3.8-flash-high",
@@ -39,6 +40,14 @@ const support = {
     images: true,
     spawnArgs: () => [],
     selectModel: { configId: "model" },
+    // Google's server reads its new-session default from this variable
+    // (model_selection.get_default_model_id in agy_acp_server 1.1.1). Starting
+    // on OMB's model skips a switch that re-fetches the account's model list
+    // from Google: 1.3-1.8 s on every new or cold-resumed conversation.
+    sessionModelEnv: "AGY_ACP_DEFAULT_MODEL",
+    // configureSession sets the permission mode on every turn and nothing in
+    // the launch depends on it, so an approval change keeps the process.
+    sessionScopedApproval: true,
     resumeMethod: "resume",
     clientFileSystem: true,
     redactStderr: true,
@@ -47,6 +56,11 @@ const support = {
     resolveCommand: async (env, config, instanceId) => {
         const runtime = await resolveAntigravityRuntime(config.cli, env);
         const profile = await prepareAntigravityProfile({ instanceId, runtime, baseEnv: env });
+        // A process stopped by force since the last launch (an idle close that
+        // outlived its grace, a crash) left its unpacked files behind. Reclaim
+        // them in the background; live folders are kept.
+        if (profile.tempDirectory)
+            scheduleAntigravityTempSweep(instanceId);
         return {
             command: runtime.executablePath,
             args: process.platform === "linux" ? ["--uid="] : [],
@@ -112,6 +126,13 @@ export const AntigravityDriver = {
     ...AcpAntigravityDriver,
     async create(input) {
         const base = await AcpAntigravityDriver.create(input);
+        // Reclaim what a previous run of this instance left behind when it was
+        // stopped by force (Windows keeps 0.34-1.26 GB per forced stop). Only
+        // this instance's folder under DATA_DIR/tmp/agy, only folders whose
+        // process is gone; the system temp folder is cleaned only on request.
+        scheduleAntigravityTempSweep(input.instanceId);
+        // The same for a runtime verification whose runtime would not stop.
+        scheduleAntigravityTempSweep(VERIFICATION_TEMP_KEY);
         const auth = new AntigravityAuthController();
         let installFailure;
         const runtimeAndProfile = async () => {

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

@@ -15,6 +15,7 @@ import { HermesAgentDriver } from "./acp/hermes.js";
 import { OpenAICompatDriver } from "./openai-compat.js";
 import { PiDriver } from "./pi.js";
 import { MistralDriver } from "./mistral.js";
+import { CerebrasDriver } from "./cerebras.js";
 import { MinimaxDriver } from "./minimax.js";
 export const BUILT_IN_DRIVERS = [
     GrokDriver,
@@ -35,4 +36,5 @@ export const BUILT_IN_DRIVERS = [
     BoatAgentDriver,
     MinimaxDriver,
     MistralDriver,
+    CerebrasDriver,
 ];

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

@@ -0,0 +1,108 @@
+import { z } from "zod";
+import { createOpenAIChatRuntime } from "./openai-chat.js";
+// Cerebras serves open models on wafer-scale chips: same OpenAI chat
+// contract, several times the tokens per second of a GPU cloud.
+const DEFAULT_URL = "https://api.cerebras.ai/v1";
+// The account tier is unknown: use the shared free-tier limit, not paid 128K.
+// https://inference-docs.cerebras.ai/models/overview
+const DEFAULT_MODELS = {
+    default: "gpt-oss-120b",
+    options: [
+        { id: "gpt-oss-120b", label: "GPT OSS 120B", contextWindow: 65536 },
+        { id: "qwen-3.8-27b", label: "Qwen3.8 27B", contextWindow: 65536 },
+    ],
+};
+const configSchema = z.object({
+    url: z.string().trim().url().default(DEFAULT_URL),
+    model: z.string().trim().min(1).optional(),
+    tools: z.boolean().optional(),
+});
+function decodeConfig(raw) {
+    const config = configSchema.parse(raw ?? {});
+    config.url = config.url.replace(/\/+$/, "");
+    const url = new URL(config.url);
+    if (url.protocol !== "https:" && !(url.protocol === "http:" &&
+        ["localhost", "127.0.0.1", "[::1]"].includes(url.hostname))) {
+        throw new Error("Cerebras requires HTTPS, except for a local test endpoint.");
+    }
+    return config;
+}
+const modelCard = z.object({ id: z.string().min(1) });
+/** Cerebras answers "Only 'text' content type can be used" for these. */
+const TEXT_ONLY_MODELS = /^(?:gpt-oss|llama3\.1-8b|llama-3\.3-70b)/i;
+export const CerebrasDriver = {
+    driverKind: "cerebras",
+    metadata: { displayName: "Cerebras (API)", supportsMultipleInstances: true, access: "api" },
+    models: DEFAULT_MODELS,
+    install: {
+        docsUrl: "https://cloud.cerebras.ai/",
+        settings: "connections",
+        signInCommand: "Save a Cerebras API key in Settings → Connections, or set CEREBRAS_API_KEY on the server.",
+    },
+    decodeConfig,
+    defaultConfig: () => decodeConfig({}),
+    async create(input) {
+        const { config } = input;
+        const apiKey = (input.environment.CEREBRAS_API_KEY ?? process.env.CEREBRAS_API_KEY ?? "").trim();
+        const known = new Map(DEFAULT_MODELS.options.map((option) => [option.id, option]));
+        const withConfiguredModel = (options) => {
+            const preferred = config.model ?? DEFAULT_MODELS.default;
+            if (config.model && !options.some((option) => option.id === config.model)) {
+                options = [{ id: config.model, label: config.model }, ...options];
+            }
+            return { default: options.some((option) => option.id === preferred) ? preferred : options[0].id, options };
+        };
+        let catalog = withConfiguredModel(DEFAULT_MODELS.options);
+        const refreshModels = async () => {
+            if (!apiKey)
+                return;
+            try {
+                const response = await fetch(`${config.url}/models`, {
+                    headers: { authorization: `Bearer ${apiKey}` },
+                    redirect: "error",
+                    signal: AbortSignal.timeout(8_000),
+                });
+                if (!response.ok)
+                    return;
+                const json = await response.json();
+                const rows = Array.isArray(json) ? json : z.object({ data: z.array(z.unknown()) }).parse(json).data;
+                const options = [];
+                const seen = new Set();
+                for (const row of rows) {
+                    const parsed = modelCard.safeParse(row);
+                    if (!parsed.success || !parsed.data.id.trim() || seen.has(parsed.data.id))
+                        continue;
+                    seen.add(parsed.data.id);
+                    options.push(known.get(parsed.data.id) ?? { id: parsed.data.id, label: parsed.data.id });
+                }
+                if (options.length)
+                    catalog = withConfiguredModel(options);
+            }
+            catch {
+                // A failed refresh keeps the last usable catalog, including custom models.
+            }
+        };
+        if (apiKey)
+            void refreshModels();
+        return createOpenAIChatRuntime({
+            input, driverKind: "cerebras", apiKey, apiUrl: config.url,
+            tools: config.tools, models: () => catalog, refreshModels, reasoning: true,
+            reasoningReplayField: "reasoning",
+            computerUse: true, imageInput: (model) => !TEXT_ONLY_MODELS.test(model),
+            nudgeAnnouncedAction: true,
+            requestBody: (model, messages, stream) => ({
+                model, messages, stream,
+                ...(stream ? { stream_options: { include_usage: true } } : {}),
+            }),
+            httpErrorLabel: "Cerebras",
+            missingKeyError: "Save a Cerebras API key in Settings → Connections, or set CEREBRAS_API_KEY.",
+            unavailableReason: "No Cerebras API key — open Settings → Connections.",
+            timeoutMs: 180_000, billing: "metered", includeUsageInCompleted: true,
+            nativeLog: {
+                source: "cerebras.chat.completions",
+                outgoing: (_turn, messages, model) => ({ model, messageCount: messages.length }),
+                incoming: ({ text, reasoning, usage }) => ({ textLength: text.length, reasoningLength: reasoning.length, usage }),
+            },
+        });
+    },
+};

package/dist-server/server/drivers/chat-mcp-tools.js

@@ -266,6 +266,22 @@ function boundedText(value) {
         end -= 1;
     return `${bytes.subarray(0, end).toString()}\n[MCP result truncated at 50KB; request less output.]`;
 }
+/** Optional fields a tool documents as "omit to use the default", where a
+ * blank string is an error instead. Smaller models fill optional fields with
+ * "" rather than leaving them out; dropping the blank restores the documented
+ * call. agent_browser_read: "Omit url to read the active tab." */
+const BUILT_IN_BROWSER_BLANK_MEANS_OMITTED = {
+    agent_browser_read: ["url"],
+};
+function omitBlankDefaults(builtInBrowser, tool, args) {
+    if (!builtInBrowser || !object(args))
+        return;
+    for (const field of BUILT_IN_BROWSER_BLANK_MEANS_OMITTED[tool] ?? []) {
+        const value = args[field];
+        if (typeof value === "string" && !value.trim())
+            delete args[field];
+    }
+}
 export async function mountChatTools(integrations, signal, computerUse = false) {
     const servers = [];
     if (computerUse && integrations?.computer)
@@ -316,12 +332,12 @@ export async function mountChatTools(integrations, signal, computerUse = false)
             // image delivery, including custom servers. Text stays bounded below.
             const client = "boxId" in descriptor ? new ChatBoatClient(descriptor) : new ChatMcpClient(descriptor, computerUse);
             clients.push(client);
-            return { name, client, tools: await client.tools(signal) };
+            return { name, client, builtInBrowser: descriptor === integrations?.browser, tools: await client.tools(signal) };
         }));
         for (const mount of mounts) {
             if (mount.status === "rejected")
                 throw mount.reason;
-            const { name: server, client, tools } = mount.value;
+            const { name: server, client, builtInBrowser, tools } = mount.value;
             const originalNames = new Set();
             for (const tool of tools) {
                 if (!object(tool) || typeof tool.name !== "string" || !tool.name.trim() || originalNames.has(tool.name))
@@ -352,7 +368,7 @@ export async function mountChatTools(integrations, signal, computerUse = false)
                     const suffix = `_${index}`;
                     name = base.slice(0, 64 - suffix.length) + suffix;
                 }
-                registered.set(name, { client, name: tool.name, schema });
+                registered.set(name, { client, builtInBrowser, name: tool.name, schema });
                 definitions.push({ type: "function", function: { name, description, parameters } });
                 if (Buffer.byteLength(JSON.stringify(definitions)) > CATALOG_BYTES)
                     throw new Error("MCP tool catalog exceeds the 1MB limit");
@@ -371,6 +387,7 @@ export async function mountChatTools(integrations, signal, computerUse = false)
         const tool = registered.get(name);
         if (!tool)
             throw new Error("The requested tool was not advertised for this turn");
+        omitBlankDefaults(tool.builtInBrowser, tool.name, args);
         if (!object(args) || !tool.schema(args))
             throw new Error("Tool arguments do not match the advertised input schema; use its required fields and types");
     };