openmausbot 0.1.55

package/dist-server/server/drivers/dweb-proxy.js

@@ -0,0 +1,193 @@
+// dweb MCP proxy — spawned as an MCP server inside a bot's agent process.
+// Exposes dweb's HTTP API (the local OpenMaus network daemon) as tools an
+// agent can call to inspect the network and run model requests:
+//
+//   dweb_status          → ping dweb, summarize server + peer state
+//   dweb_repo_status     → the OpenMausBot repo the daemon is tracking
+//   dweb_opencode_models → models available on the opencode integration
+//   dweb_opencode_run    → run a model command, wait up to 5 min for output
+//
+// Speaks raw JSON-RPC 2.0 over stdio (no MCP SDK — house style, matches
+// agents-proxy / computer-proxy / permission-proxy). Config comes from env:
+//   DWEB_URL  base URL of the local dweb daemon (http://127.0.0.1:49737)
+import readline from "node:readline";
+const DWEB = (process.env.DWEB_URL ?? "http://127.0.0.1:49737").replace(/\/+$/, "");
+const DWEB_DISPLAY = (() => {
+    try {
+        const url = new URL(DWEB);
+        url.username = "";
+        url.password = "";
+        return url.toString().replace(/\/+$/, "");
+    }
+    catch {
+        return "(invalid DWEB_URL)";
+    }
+})();
+const TOOLS = [
+    {
+        name: "dweb_status",
+        description: "Ping the local dweb daemon and report its status: server id, hostname, platform, version, uptime, peer count, and the services it runs. Call this first to confirm the network is reachable and see what's available.",
+        inputSchema: { type: "object", properties: {} },
+    },
+    {
+        name: "dweb_repo_status",
+        description: "Report the state of the OpenMausBot repository the dweb daemon is tracking: repo name, checked-out branch, last commit, file count, and checkout path.",
+        inputSchema: { type: "object", properties: {} },
+    },
+    {
+        name: "dweb_opencode_models",
+        description: "List the models available on dweb's opencode integration. Each has an id you can pass to dweb_opencode_run. Returns a note if no models are available.",
+        inputSchema: { type: "object", properties: {} },
+    },
+    {
+        name: "dweb_opencode_run",
+        description: "Run a model on dweb's opencode integration and wait for the result. Give a command for the model to process; optionally pick a model with the 'model' arg (defaults to dweb's choice). Can take several minutes — use this for long-running model work and report the output back verbatim.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                command: { type: "string", description: "The command/prompt to run on the model." },
+                model: { type: "string", description: "Optional model id (from dweb_opencode_models)." },
+            },
+            required: ["command"],
+        },
+    },
+];
+const send = (msg) => process.stdout.write(JSON.stringify(msg) + "\n");
+const ok = (id, result) => send({ jsonrpc: "2.0", id, result });
+const rpcErr = (id, code, message) => send({ jsonrpc: "2.0", id, error: { code, message } });
+const textResult = (id, text, isError = false) => ok(id, { content: [{ type: "text", text }], isError });
+async function api(path, init) {
+    const res = await fetch(DWEB + path, {
+        signal: AbortSignal.timeout(30_000),
+        ...init,
+        headers: { "content-type": "application/json", ...init?.headers },
+    });
+    const body = (await res.json().catch(() => ({})));
+    if (!res.ok)
+        throw new Error(String(body.error ?? `HTTP ${res.status}`));
+    return body;
+}
+async function callTool(name, args) {
+    if (name === "dweb_status") {
+        const r = await api("/ping");
+        const lines = [
+            `status: ${String(r.status ?? "unknown")}`,
+            `server: ${String(r.server ?? "unknown")}`,
+            `id: ${String(r.id ?? "unknown")}`,
+            `hostname: ${String(r.hostname ?? "unknown")}`,
+            `platform: ${String(r.platform ?? "unknown")}`,
+            `version: ${String(r.version ?? "unknown")}`,
+            `uptime: ${String(r.uptime ?? "unknown")}`,
+            `peers: ${String(r.peers ?? "unknown")}`,
+            `services: ${String(r.services ?? "unknown")}`,
+        ];
+        return { text: `dweb status:\n${lines.join("\n")}` };
+    }
+    if (name === "dweb_repo_status") {
+        const r = await api("/api/repo/status");
+        const lines = [
+            `repo: ${String(r.repo ?? "unknown")}`,
+            `branch: ${String(r.branch ?? "unknown")}`,
+            `commit: ${String(r.commit ?? "unknown")}`,
+            `files: ${String(r.files ?? "unknown")}`,
+            `path: ${String(r.path ?? "unknown")}`,
+        ];
+        return { text: `dweb repo status:\n${lines.join("\n")}` };
+    }
+    if (name === "dweb_opencode_models") {
+        const r = await api("/api/opencode/models");
+        const models = Array.isArray(r.models) ? r.models : [];
+        if (!models.length)
+            return { text: "No models available on dweb's opencode integration." };
+        const lines = models.map((model) => {
+            const id = typeof model === "object" && model !== null && "id" in model ? model.id : model;
+            return `- ${String(id)}`;
+        });
+        return { text: `Models available on dweb's opencode integration:\n${lines.join("\n")}` };
+    }
+    if (name === "dweb_opencode_run") {
+        if (typeof args.command !== "string" || !args.command.trim()) {
+            return { text: "dweb_opencode_run needs a string command.", isError: true };
+        }
+        if (args.model !== undefined && typeof args.model !== "string") {
+            return { text: "dweb_opencode_run model must be a string.", isError: true };
+        }
+        const command = args.command.trim();
+        const model = args.model?.trim() || undefined;
+        const r = await api("/api/opencode/run", {
+            method: "POST",
+            body: JSON.stringify({ command, ...(model !== undefined ? { model } : {}) }),
+            signal: AbortSignal.timeout(300000),
+        });
+        if (r.status === "error") {
+            return {
+                text: `dweb request failed at ${DWEB_DISPLAY}: ${String(r.error ?? r.output ?? "opencode run failed")}`,
+                isError: true,
+            };
+        }
+        return { text: String(r.output ?? "(no output)") };
+    }
+    return { text: `Unknown tool: ${name}`, isError: true };
+}
+async function handle(msg) {
+    const id = msg.id;
+    const method = msg.method;
+    if (!method)
+        return;
+    const params = (msg.params ?? {});
+    switch (method) {
+        case "initialize":
+            ok(id, {
+                protocolVersion: params.protocolVersion ?? "2024-11-05",
+                capabilities: { tools: {} },
+                serverInfo: { name: "dweb-proxy", version: "0.1.0" },
+            });
+            return;
+        case "notifications/initialized":
+        case "notifications/cancelled":
+            return;
+        case "ping":
+            ok(id, {});
+            return;
+        case "tools/list":
+            ok(id, { tools: TOOLS });
+            return;
+        case "tools/call": {
+            const name = params.name;
+            if (!TOOLS.some((t) => t.name === name))
+                return rpcErr(id, -32602, `Unknown tool: ${name}`);
+            try {
+                const rawArgs = params.arguments;
+                const args = typeof rawArgs === "object" && rawArgs !== null && !Array.isArray(rawArgs) ? rawArgs : {};
+                const { text, isError } = await callTool(name, args);
+                textResult(id, text, isError);
+            }
+            catch (e) {
+                const message = e instanceof Error ? e.message : String(e);
+                textResult(id, `dweb request failed at ${DWEB_DISPLAY}: ${message}`, true);
+            }
+            return;
+        }
+        default:
+            if (id !== undefined)
+                rpcErr(id, -32601, `Method not found: ${method}`);
+    }
+}
+const rl = readline.createInterface({ input: process.stdin, terminal: false });
+rl.on("line", (line) => {
+    const t = line.trim();
+    if (!t)
+        return;
+    let msg;
+    try {
+        msg = JSON.parse(t);
+    }
+    catch {
+        return;
+    }
+    void handle(msg).catch((e) => {
+        if (msg.id !== undefined)
+            rpcErr(msg.id, -32603, e.message);
+    });
+});
+rl.on("close", () => process.exit(0));

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

@@ -0,0 +1,48 @@
+import { createOpenAIChatRuntime } from "./openai-chat.js";
+const DRIVER_KIND = "grok";
+const DEFAULT_URL = "https://api.x.ai/v1";
+const MODELS = {
+    default: "grok-4",
+    options: [
+        { id: "grok-4", label: "Grok 4" },
+        { id: "grok-4-fast", label: "Grok 4 Fast" },
+        { id: "grok-3-mini", label: "Grok 3 Mini" },
+    ],
+};
+function decodeConfig(raw) {
+    const config = (raw ?? {});
+    return {
+        url: typeof config.url === "string" ? config.url : DEFAULT_URL,
+        apiKeyEnv: typeof config.apiKeyEnv === "string" ? config.apiKeyEnv : "XAI_API_KEY",
+    };
+}
+export const GrokDriver = {
+    driverKind: DRIVER_KIND,
+    metadata: { displayName: "Grok (API)", supportsMultipleInstances: true },
+    models: MODELS,
+    decodeConfig,
+    defaultConfig: () => decodeConfig({}),
+    async create(input) {
+        const { config } = input;
+        const apiKey = input.environment[config.apiKeyEnv] ?? process.env[config.apiKeyEnv] ?? "";
+        return createOpenAIChatRuntime({
+            input,
+            driverKind: DRIVER_KIND,
+            apiKey,
+            apiUrl: config.url,
+            models: () => MODELS,
+            requestBody: (model, messages, stream) => ({ model, messages, stream }),
+            httpErrorLabel: "xAI",
+            missingKeyError: `no xAI key — set ${config.apiKeyEnv} or config.json xai.key`,
+            unavailableReason: `no xAI API key — add {"xai":{"key":"xai-…"}} to ~/.openmausbot/config.json or set ${config.apiKeyEnv}`,
+            timeoutMs: 120_000,
+            retryScale: Number(process.env.FAKE_GROK_RETRY_SCALE ?? "1"),
+            generateModel: () => "grok-3-mini",
+            nativeLog: {
+                source: "xai.chat.completions",
+                outgoing: (_turn, messages, model) => ({ model, messages }),
+                incoming: ({ text, usage }) => ({ text, usage }),
+            },
+        });
+    },
+};

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

@@ -0,0 +1,4 @@
+// Back-compat re-export: the Grok Build ACP driver moved to acp/grok.ts,
+// riding the shared acp/core.ts runtime. Kept here so existing imports and
+// dist-server references keep resolving.
+export { GrokAgentDriver } from "./acp/grok.js";

package/dist-server/server/drivers/local-inject.js

@@ -0,0 +1,388 @@
+// Shared local-host inject — the sidecar workflow, inside the picker.
+// Probe oMLX / Ollama / EXO / LM Studio / Unsloth, list whatever they
+// serve under Custom on every agent, and decode a pick back into a host
+// + API id the selected driver can inject.
+import { readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+export const LOCAL_HOSTS = [
+    { id: "omlx", label: "oMLX", baseUrl: "http://127.0.0.1:8080/v1", apiKey: "omlx" },
+    { id: "ollama", label: "Ollama", baseUrl: "http://127.0.0.1:11434/v1", apiKey: "ollama" },
+    { id: "local_ollama", label: "Ollama", baseUrl: "http://127.0.0.1:11434/v1", apiKey: "ollama" },
+    { id: "exo", label: "EXO", baseUrl: "http://127.0.0.1:52415/v1", apiKey: "exo" },
+    { id: "lmstudio", label: "LM Studio", baseUrl: "http://127.0.0.1:1234/v1", apiKey: "lm-studio" },
+    { id: "unsloth", label: "Unsloth", baseUrl: "http://127.0.0.1:8888/v1", apiKeyEnv: "UNSLOTH_STUDIO_AUTH_TOKEN" },
+    { id: "unsloth_api", label: "Unsloth", baseUrl: "http://127.0.0.1:8888/v1", apiKeyEnv: "UNSLOTH_STUDIO_AUTH_TOKEN" },
+];
+export const INJECT_SEP = "::";
+const HOST_BY_ID = new Map(LOCAL_HOSTS.map((host) => [host.id, host]));
+const MODEL_ID = /^[\w][\w./:+-]*$/;
+/** Ollama's /api/ps lists running models with their context_length; a
+ * small model's real window matters more than a big one's — an 8k model
+ * guessed at 32k gets a rebuild it cannot hold. */
+export function contextWindowsFromPs(extra) {
+    const out = new Map();
+    const rec = extra && typeof extra === "object" ? extra : null;
+    if (!rec || !Array.isArray(rec.models))
+        return out;
+    for (const m of rec.models) {
+        if (!m || typeof m !== "object")
+            continue;
+        const row = m;
+        const id = typeof row.model === "string" ? row.model : typeof row.name === "string" ? row.name : null;
+        const ctx = typeof row.context_length === "number" && Number.isFinite(row.context_length) && row.context_length > 0 ? row.context_length : null;
+        if (id && ctx) {
+            out.set(id, ctx);
+            const baseId = id.split(":")[0];
+            const current = out.get(baseId);
+            out.set(baseId, current === undefined ? ctx : Math.min(current, ctx));
+        }
+    }
+    return out;
+}
+export function encodeInjectId(host, model) {
+    return `${host}${INJECT_SEP}${model}`;
+}
+export function decodeInjectId(id) {
+    if (!id)
+        return null;
+    const sep = id.indexOf(INJECT_SEP);
+    if (sep <= 0)
+        return null;
+    const host = id.slice(0, sep);
+    const model = id.slice(sep + INJECT_SEP.length);
+    if (!HOST_BY_ID.has(host) || !MODEL_ID.test(model))
+        return null;
+    return { host, model };
+}
+export function localHost(id) {
+    return HOST_BY_ID.get(id);
+}
+export function injectedApiModel(id) {
+    return decodeInjectId(id)?.model ?? null;
+}
+/**
+ * Map a picker / leftover API id onto a live `host::model` inject id.
+ * Claude Code's settings.model is the last slug it used (e.g.
+ * `orcarouter/Qwen3.8-27B-Uncensored-GGUF`) and is not host-encoded, so a
+ * Custom pick of that leftover would otherwise skip inject and demand /login.
+ */
+export function resolveInjectId(modelId, extras) {
+    if (!modelId)
+        return modelId;
+    if (decodeInjectId(modelId))
+        return modelId;
+    const matches = extras.filter((row) => row.id === modelId || row.model === modelId);
+    const match = matches.find((row) => row.loaded) ?? matches[0];
+    return match?.id ?? modelId;
+}
+/** Anthropic-compatible base (Claude Code wants this without a trailing /v1). */
+export function anthropicBaseUrl(host) {
+    return host.baseUrl.replace(/\/v1\/?$/, "");
+}
+export function hostApiKey(host, env = process.env) {
+    if (host.apiKeyEnv && env[host.apiKeyEnv])
+        return env[host.apiKeyEnv];
+    if (host.apiKey)
+        return host.apiKey;
+    if (host.id === "unsloth" || host.id === "unsloth_api") {
+        const fromFile = readUnslothKey(env);
+        if (fromFile)
+            return fromFile;
+    }
+    return "local";
+}
+const CODEX_RESERVED_PROVIDERS = new Set(["openai", "ollama", "lmstudio"]);
+/**
+ * Configure the custom local providers on the Codex app-server without
+ * rewriting the user's config.toml. Provider secrets ride in the child
+ * environment; argv only contains the corresponding environment key name.
+ */
+export function codexLocalProviderArgs(env, modelId) {
+    const inject = decodeInjectId(modelId);
+    if (!inject || CODEX_RESERVED_PROVIDERS.has(inject.host))
+        return [];
+    const host = localHost(inject.host);
+    if (!host)
+        return [];
+    const envKey = `OPENMAUSBOT_LOCAL_${host.id.toUpperCase().replace(/[^A-Z0-9]+/g, "_")}_API_KEY`;
+    env[envKey] = hostApiKey(host, env);
+    return [
+        "-c",
+        `model_providers.${host.id}.name=${JSON.stringify(host.label)}`,
+        "-c",
+        `model_providers.${host.id}.base_url=${JSON.stringify(host.baseUrl)}`,
+        "-c",
+        `model_providers.${host.id}.env_key=${JSON.stringify(envKey)}`,
+    ];
+}
+function firstUnslothToken(row) {
+    if (!row || typeof row !== "object")
+        return null;
+    const rec = row;
+    for (const bucket of [rec.minted, rec.saved]) {
+        if (typeof bucket === "string" && bucket)
+            return bucket;
+        if (Array.isArray(bucket)) {
+            const token = bucket.find((value) => typeof value === "string" && value);
+            if (typeof token === "string")
+                return token;
+        }
+    }
+    if (typeof rec.api_key === "string" && rec.api_key)
+        return rec.api_key;
+    return null;
+}
+function readUnslothKey(env) {
+    const home = env.HOME || env.USERPROFILE || homedir();
+    try {
+        const raw = JSON.parse(readFileSync(join(home, ".unsloth", "studio", "auth", "agent_api_key.json"), "utf8"));
+        // Older Studio wrote `{ api_key }`. Current Studio writes
+        // `{ servers: { "http://127.0.0.1:8888": { minted: ["sk-unsloth-…"] } } }`.
+        // Prefer the localhost minted token so a stale mixed-format file cannot
+        // win; keep the top-level key as fallback.
+        if (raw.servers && typeof raw.servers === "object") {
+            const servers = raw.servers;
+            for (const url of ["http://127.0.0.1:8888", "http://localhost:8888"]) {
+                const token = firstUnslothToken(servers[url]);
+                if (token)
+                    return token;
+            }
+            for (const row of Object.values(servers)) {
+                const token = firstUnslothToken(row);
+                if (token)
+                    return token;
+            }
+        }
+        if (typeof raw.api_key === "string" && raw.api_key)
+            return raw.api_key;
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+function idsFromModelsPayload(payload) {
+    const records = Array.isArray(payload)
+        ? payload
+        : payload && typeof payload === "object" && Array.isArray(payload.data)
+            ? payload.data
+            : payload && typeof payload === "object" && Array.isArray(payload.models)
+                ? payload.models
+                : [];
+    return records.flatMap((record) => {
+        if (typeof record === "string")
+            return MODEL_ID.test(record) ? [record] : [];
+        if (!record || typeof record !== "object")
+            return [];
+        const id = record.id ?? record.name;
+        if (typeof id !== "string" || !MODEL_ID.test(id))
+            return [];
+        const low = id.toLowerCase();
+        if (low.includes("embed") || low.includes("bge-") || low.includes("nomic"))
+            return [];
+        return [id];
+    });
+}
+async function timedJson(url, env, host, fetchImpl) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), 1200);
+    timer.unref?.();
+    try {
+        const response = await fetchImpl(url, {
+            signal: controller.signal,
+            headers: { Authorization: `Bearer ${hostApiKey(host, env)}` },
+        });
+        if (!response.ok)
+            return null;
+        return await response.json();
+    }
+    catch {
+        return null;
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+/** Which of this host's models are actually in memory / running. */
+export function loadedIdsFromPayloads(_host, catalog, extra) {
+    const loaded = new Set();
+    const catalogIds = new Set(idsFromModelsPayload(catalog));
+    const add = (id) => {
+        const base = id.split(":")[0];
+        if (catalogIds.size && !catalogIds.has(id) && !catalogIds.has(base))
+            return;
+        if (!MODEL_ID.test(id))
+            return;
+        loaded.add(id);
+        if (catalogIds.has(base))
+            loaded.add(base);
+    };
+    if (extra && typeof extra === "object") {
+        const rec = extra;
+        const running = Array.isArray(rec.models)
+            ? rec.models
+            : Array.isArray(rec.data)
+                ? rec.data
+                : [];
+        // oMLX /v1/models/status lists every model with loaded:true/false.
+        // /health only has default_model, which is the configured default — not
+        // necessarily what is in memory. Prefer explicit flags when present.
+        const hasLoadedFlags = running.some((row) => row && typeof row === "object" && ("loaded" in row || "state" in row));
+        if (!hasLoadedFlags && typeof rec.default_model === "string")
+            add(rec.default_model);
+        for (const row of running) {
+            if (typeof row === "string") {
+                if (!hasLoadedFlags)
+                    add(row);
+                continue;
+            }
+            if (!row || typeof row !== "object")
+                continue;
+            const item = row;
+            const id = (typeof item.name === "string" && item.name) ||
+                (typeof item.model === "string" && item.model) ||
+                (typeof item.id === "string" && item.id) ||
+                "";
+            if (!id)
+                continue;
+            const state = typeof item.state === "string" ? item.state.toLowerCase() : "";
+            if (item.loaded === false || state === "not-loaded" || state === "unloaded")
+                continue;
+            if (item.loaded === true || state === "loaded" || state === "idle" || !hasLoadedFlags) {
+                add(id);
+            }
+        }
+    }
+    if (!loaded.size && catalog && typeof catalog === "object") {
+        const rec = catalog;
+        if (typeof rec.default_model === "string")
+            add(rec.default_model);
+        const records = Array.isArray(rec.data) ? rec.data : [];
+        for (const row of records) {
+            if (!row || typeof row !== "object")
+                continue;
+            const item = row;
+            if (typeof item.id !== "string")
+                continue;
+            const state = typeof item.state === "string" ? item.state.toLowerCase() : "";
+            if (item.loaded === true || state === "loaded")
+                add(item.id);
+        }
+    }
+    return loaded;
+}
+function loadedProbeUrl(host) {
+    const origin = anthropicBaseUrl(host);
+    if (host.id === "omlx")
+        return `${origin}/v1/models/status`;
+    if (host.id === "ollama" || host.id === "local_ollama")
+        return `${origin}/api/ps`;
+    if (host.id === "lmstudio")
+        return `${origin}/api/v0/models`;
+    return null;
+}
+/** Live models from the same local hosts the sidecar probed. */
+export async function probeLocalInjects(env = process.env, fetchImpl = fetch) {
+    const seenHosts = new Set();
+    const hosts = LOCAL_HOSTS.filter((host) => {
+        const key = host.baseUrl.replace(/\/$/, "");
+        if (seenHosts.has(key))
+            return false;
+        seenHosts.add(key);
+        return true;
+    });
+    const found = [];
+    const pages = await Promise.all(hosts.map(async (host) => {
+        const catalogUrl = `${host.baseUrl.replace(/\/$/, "")}/models`;
+        const extraUrl = loadedProbeUrl(host);
+        const [catalog, extra] = await Promise.all([
+            timedJson(catalogUrl, env, host, fetchImpl),
+            extraUrl ? timedJson(extraUrl, env, host, fetchImpl) : Promise.resolve(null),
+        ]);
+        const catalogIds = catalog ? idsFromModelsPayload(catalog) : [];
+        const extraIds = extra ? idsFromModelsPayload(extra) : [];
+        const loaded = loadedIdsFromPayloads(host, catalog ?? extra, extra);
+        const ids = [...new Set([...catalogIds, ...extraIds, ...loaded])];
+        const windows = contextWindowsFromPs(extra);
+        return { host, ids, loaded, windows };
+    }));
+    for (const { host, ids, loaded, windows } of pages) {
+        for (const model of ids) {
+            const contextWindow = windows.get(model);
+            found.push({
+                id: encodeInjectId(host.id, model),
+                host: host.id,
+                model,
+                label: `${model} (${host.label})`,
+                loaded: loaded.has(model),
+                ...(contextWindow ? { contextWindow } : {}),
+            });
+        }
+    }
+    return found;
+}
+/** Append live local models as custom rows. Official rows stay first. */
+export async function mergeLocalInject(catalog, env = process.env, fetchImpl = fetch) {
+    const vitest = env.VITEST ?? process.env.VITEST;
+    const probe = env.OPENMAUSBOT_PROBE_LOCAL_INJECT ?? process.env.OPENMAUSBOT_PROBE_LOCAL_INJECT;
+    if (vitest === "true" && probe !== "1")
+        return catalog;
+    const extras = await probeLocalInjects(env, fetchImpl);
+    if (!extras.length)
+        return catalog;
+    const liveApiIds = new Set(extras.map((extra) => extra.model));
+    // A settings leftover that is just the API id of a live inject is not a
+    // second model — Custom should only offer the host:: row.
+    const options = catalog.options
+        .filter((option) => decodeInjectId(option.id) || !option.custom || !liveApiIds.has(option.id))
+        .map((option) => ({ ...option }));
+    const seen = new Set(options.map((option) => option.id));
+    for (const extra of extras) {
+        const existing = options.find((option) => option.id === extra.id);
+        if (existing) {
+            if (extra.loaded)
+                existing.loaded = true;
+            if (extra.contextWindow)
+                existing.contextWindow = extra.contextWindow;
+            continue;
+        }
+        seen.add(extra.id);
+        options.push({
+            id: extra.id,
+            label: extra.label,
+            custom: true,
+            ...(extra.loaded ? { loaded: true } : {}),
+            ...(extra.contextWindow ? { contextWindow: extra.contextWindow } : {}),
+        });
+    }
+    return { default: catalog.default, options };
+}
+/** Point an OpenAI-compatible CLI at the injected host. */
+export function applyOpenAIInject(env, modelId) {
+    const inject = decodeInjectId(modelId);
+    if (!inject)
+        return { model: modelId ?? null, injected: false };
+    const host = localHost(inject.host);
+    if (!host)
+        return { model: modelId ?? null, injected: false };
+    const key = hostApiKey(host, env);
+    env.OPENAI_BASE_URL = host.baseUrl;
+    env.OPENAI_API_KEY = key;
+    return { model: inject.model, injected: true };
+}
+/** Point Claude Code at the injected host instead of Anthropic cloud. */
+export function applyClaudeInject(env, modelId) {
+    const inject = decodeInjectId(modelId);
+    if (!inject)
+        return { model: modelId ?? null, injected: false };
+    const host = localHost(inject.host);
+    if (!host)
+        return { model: modelId ?? null, injected: false };
+    const key = hostApiKey(host, env);
+    env.ANTHROPIC_BASE_URL = anthropicBaseUrl(host);
+    env.ANTHROPIC_AUTH_TOKEN = key;
+    env.ANTHROPIC_API_KEY = key;
+    env.ANTHROPIC_MODEL = inject.model;
+    return { model: inject.model, injected: true };
+}