openmausbot 0.1.55

package/dist-server/server/drivers/acp/cursor.js

@@ -0,0 +1,365 @@
+import { execCli } from "../../procs.js";
+import { createAcpDriver } from "./core.js";
+/** Translate an argv `--model` slug into the id this ACP session will accept.
+ *
+ * Cursor keeps two model namespaces and they do not match. `cursor-agent
+ * models` and the `--model` flag speak flat slugs (`auto`, `gpt-5.3-codex`).
+ * The ACP session advertises parameterised ids instead
+ * (`default[]`, `gpt-5.3-codex[reasoning=medium,fast=false]`), and
+ * `session/set_model` accepts *only* those. Sending the argv slug earns
+ * `-32602 Invalid params` for every model, not merely unknown ones — which
+ * read as "this account cannot use that model" and sent people to check their
+ * subscription over a pure id-format mismatch.
+ *
+ * Matching walks from most to least specific, and `auto` is special-cased
+ * because Cursor calls that entry `default[]` while naming it "Auto".
+ *
+ * Returns null when nothing matches, including when the agent advertised no
+ * models at all. The caller then falls back to sending the slug unchanged,
+ * which is what older CLIs that ignore the model list still expect.
+ */
+export function resolveCursorAcpModelId(available, wanted) {
+    const want = wanted.trim().toLowerCase();
+    if (!want)
+        return null;
+    const ids = available.filter((m) => typeof m?.modelId === "string" && m.modelId);
+    if (!ids.length)
+        return null;
+    const base = (id) => id.split("[")[0].trim().toLowerCase();
+    const exact = ids.find((m) => m.modelId.toLowerCase() === want);
+    if (exact)
+        return exact.modelId;
+    const byBase = ids.find((m) => base(m.modelId) === want);
+    if (byBase)
+        return byBase.modelId;
+    const byName = ids.find((m) => (m.name ?? "").trim().toLowerCase() === want);
+    if (byName)
+        return byName.modelId;
+    if (want === "auto" || want === "default") {
+        const dflt = ids.find((m) => base(m.modelId) === "default");
+        if (dflt)
+            return dflt.modelId;
+    }
+    return null;
+}
+export const STATIC_CURSOR_MODELS = {
+    default: "auto",
+    options: [
+        { id: "auto", label: "Auto" },
+        { id: "composer-2.5", label: "Composer 2.5" },
+        { id: "composer-2.5-fast", label: "Composer 2.5 Fast" },
+        { id: "gpt-5.3-codex", label: "Codex 5.3" },
+        { id: "claude-sonnet-5-thinking-high", label: "Claude Sonnet 5 1M Thinking" },
+    ],
+};
+const SLUG = /^[a-z0-9][a-z0-9._:+-]*$/i;
+const EXEC_TIMEOUT_MS = 8_000;
+const nonBlank = (value) => Boolean(value?.trim());
+function firstJsonValue(text) {
+    const trimmed = text.trim();
+    if (!trimmed)
+        return null;
+    try {
+        return JSON.parse(trimmed);
+    }
+    catch {
+        // CLIs sometimes print a banner before the payload. Take the first
+        // {...} or [...] span that parses, rather than requiring a clean stdout.
+    }
+    const start = trimmed.search(/[{[]/);
+    if (start < 0)
+        return null;
+    for (let end = trimmed.length; end > start + 1; end--) {
+        const slice = trimmed.slice(start, end).trim();
+        if (!slice.endsWith("}") && !slice.endsWith("]"))
+            continue;
+        try {
+            return JSON.parse(slice);
+        }
+        catch {
+            // keep shrinking
+        }
+    }
+    return null;
+}
+function asRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function labelFor(id, explicit) {
+    if (explicit?.trim())
+        return explicit.trim();
+    return id
+        .split(/[-_./]+/g)
+        .filter(Boolean)
+        .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+        .join(" ");
+}
+function pushModel(options, seen, id, label, custom = false) {
+    if (!SLUG.test(id) || seen.has(id))
+        return;
+    seen.add(id);
+    options.push({ id, label: labelFor(id, label), ...(custom ? { custom: true } : {}) });
+}
+/** Turn `cursor-agent models` JSON (or a close cousin) into a picker catalog.
+ *  Unknown shapes return null so the caller can try text / keep the fallback. */
+export function decodeCursorModelCatalog(payload) {
+    const records = Array.isArray(payload)
+        ? payload
+        : Array.isArray(asRecord(payload)?.models)
+            ? asRecord(payload).models
+            : Array.isArray(asRecord(payload)?.data)
+                ? asRecord(payload).data
+                : Array.isArray(asRecord(payload)?.modelIds)
+                    ? asRecord(payload).modelIds
+                    : [];
+    if (!records.length)
+        return null;
+    const options = [];
+    const seen = new Set();
+    for (const row of records) {
+        if (typeof row === "string") {
+            pushModel(options, seen, row);
+            continue;
+        }
+        const rec = asRecord(row);
+        if (!rec)
+            continue;
+        const id = rec.id ?? rec.modelId ?? rec.slug ?? rec.name;
+        if (typeof id !== "string")
+            continue;
+        const label = (typeof rec.label === "string" && rec.label) ||
+            (typeof rec.displayName === "string" && rec.displayName) ||
+            (typeof rec.name === "string" && rec.name !== id ? rec.name : undefined);
+        pushModel(options, seen, id, label || undefined);
+    }
+    if (!options.length)
+        return null;
+    const defaultId = (typeof asRecord(payload)?.default === "string" && seen.has(asRecord(payload).default)
+        ? asRecord(payload).default
+        : undefined) ??
+        (seen.has(STATIC_CURSOR_MODELS.default) ? STATIC_CURSOR_MODELS.default : options[0].id);
+    // Keep the static cloud set at the front (stable picker rail) and append
+    // live ids the static list does not already name.
+    const merged = STATIC_CURSOR_MODELS.options.map((option) => ({ ...option }));
+    const mergedSeen = new Set(merged.map((option) => option.id));
+    for (const option of options) {
+        if (mergedSeen.has(option.id))
+            continue;
+        mergedSeen.add(option.id);
+        merged.push(option);
+    }
+    return { default: defaultId, options: merged };
+}
+function stripModelMarkers(label) {
+    let cleaned = label.trim();
+    let isDefault = false;
+    let isCurrent = false;
+    const defaultMatch = cleaned.match(/\s*\(default\)\s*$/i);
+    if (defaultMatch) {
+        isDefault = true;
+        cleaned = cleaned.slice(0, defaultMatch.index).trim();
+    }
+    const currentMatch = cleaned.match(/\s*\(current\)\s*$/i);
+    if (currentMatch) {
+        isCurrent = true;
+        cleaned = cleaned.slice(0, currentMatch.index).trim();
+    }
+    return { label: cleaned, isDefault, isCurrent };
+}
+/** Parse plain `cursor-agent models` text: one slug per line, optional `id - label`
+ *  columns, and `(default)` / `(current)` markers on the label. */
+export function decodeCursorModelText(text) {
+    const options = [];
+    const seen = new Set();
+    let markedDefault;
+    let markedCurrent;
+    for (const raw of text.split(/\r?\n/)) {
+        const line = raw.trim();
+        if (!line || line.startsWith("#") || /^available\s+models?\b/i.test(line) || /^models?\b/i.test(line))
+            continue;
+        const stripped = line.replace(/^[\s*•\-]+\s*/, "");
+        const parts = stripped.split(/\s+[—–|:]\s+|\s+-\s+|\s{2,}/);
+        const id = (parts[0] ?? "").trim();
+        const rawLabel = parts.slice(1).join(" ").trim();
+        const { label, isDefault, isCurrent } = stripModelMarkers(rawLabel);
+        pushModel(options, seen, id, label || undefined);
+        if (isDefault)
+            markedDefault = id;
+        if (isCurrent)
+            markedCurrent = id;
+    }
+    if (!options.length)
+        return null;
+    const merged = STATIC_CURSOR_MODELS.options.map((option) => ({ ...option }));
+    const mergedSeen = new Set(merged.map((option) => option.id));
+    for (const option of options) {
+        if (mergedSeen.has(option.id))
+            continue;
+        mergedSeen.add(option.id);
+        merged.push(option);
+    }
+    const defaultId = (markedDefault && seen.has(markedDefault) ? markedDefault : undefined) ??
+        (markedCurrent && seen.has(markedCurrent) ? markedCurrent : undefined) ??
+        (seen.has(STATIC_CURSOR_MODELS.default) ? STATIC_CURSOR_MODELS.default : options[0].id);
+    return { default: defaultId, options: merged };
+}
+function truthyAuthFlag(value) {
+    if (value === true)
+        return true;
+    if (value === false)
+        return false;
+    if (typeof value === "string") {
+        const normalized = value.trim().toLowerCase();
+        if (["true", "authenticated", "logged_in", "logged-in", "yes"].includes(normalized))
+            return true;
+        if (["false", "unauthenticated", "logged_out", "logged-out", "no"].includes(normalized))
+            return false;
+    }
+    return null;
+}
+/** Read `cursor-agent status --format json`.
+ *  Returns null when the payload does not actually answer the question. */
+export function decodeCursorAuthStatus(payload) {
+    const rec = asRecord(payload);
+    if (!rec)
+        return null;
+    const auth = asRecord(rec.auth);
+    const candidates = [
+        rec.isAuthenticated,
+        rec.authenticated,
+        rec.loggedIn,
+        rec.logged_in,
+        auth?.isAuthenticated,
+        auth?.authenticated,
+        rec.status,
+        auth?.status,
+    ];
+    for (const candidate of candidates) {
+        const flag = truthyAuthFlag(candidate);
+        if (flag !== null)
+            return flag;
+    }
+    return null;
+}
+/** Parse the documented human-readable `cursor-agent status` fallback. */
+export function decodeCursorAuthText(text) {
+    const normalized = text.trim().toLowerCase();
+    if (!normalized)
+        return null;
+    if (/not (?:logged|signed) in|not authenticated|unauthenticated|logged out/.test(normalized))
+        return false;
+    if (/login successful|logged in|signed in|authenticated/.test(normalized))
+        return true;
+    return null;
+}
+function execText(run, cli, args, env) {
+    return new Promise((resolve) => {
+        run(cli, args, { timeout: EXEC_TIMEOUT_MS, env: env }, (err, stdout) => {
+            if (err)
+                return resolve(null);
+            resolve(String(stdout ?? ""));
+        });
+    });
+}
+export async function probeCursorAuth(cli, env, run = execCli) {
+    if (nonBlank(env.CURSOR_API_KEY) || nonBlank(env.CURSOR_AUTH_TOKEN))
+        return true;
+    for (const args of [["status", "--format", "json"], ["status"]]) {
+        const stdout = await execText(run, cli, [...args], env);
+        if (stdout == null)
+            continue;
+        const decoded = decodeCursorAuthStatus(firstJsonValue(stdout)) ?? decodeCursorAuthText(stdout);
+        if (decoded !== null)
+            return decoded;
+    }
+    return false;
+}
+export async function fetchCursorModels(cli, env, run = execCli) {
+    // Live CLI prints plain text (`slug - Label`); `--format json` is not supported yet.
+    for (const args of [["models"], ["--list-models"]]) {
+        const stdout = await execText(run, cli, [...args], env);
+        if (stdout == null)
+            continue;
+        const fromText = decodeCursorModelText(stdout);
+        if (fromText)
+            return fromText;
+        const fromJson = decodeCursorModelCatalog(firstJsonValue(stdout));
+        if (fromJson)
+            return fromJson;
+    }
+    return STATIC_CURSOR_MODELS;
+}
+export function classifyCursorError(error) {
+    const message = error instanceof Error ? error.message : String(error ?? "");
+    const code = error && typeof error === "object" ? error.code : undefined;
+    const blob = `${code ?? ""} ${message}`.toLowerCase();
+    if (code === -32000 ||
+        /unauthoriz|unauthenticated|not signed in|not logged in|invalid api key|invalid_credentials|authentication required/.test(blob)) {
+        return "invalid_credentials";
+    }
+    if (/inactive subscription|subscription.*(expired|inactive)|upgrade your (plan|subscription)/.test(blob)) {
+        return "inactive_subscription";
+    }
+    return undefined;
+}
+const support = (run) => ({
+    driverKind: "cursorAgent",
+    displayName: "Cursor",
+    models: STATIC_CURSOR_MODELS,
+    // Cursor and other coding agents can both install a generic `agent` shim.
+    // Cursor's compatibility alias is unambiguous and ships with the same CLI.
+    defaultCli: "cursor-agent",
+    nativeSource: "cursor.acp",
+    loginNote: "Cursor CLI is not signed in — run `cursor-agent login` in a terminal, or set CURSOR_API_KEY",
+    install: {
+        command: {
+            darwin: "curl https://cursor.com/install -fsS | bash",
+            linux: "curl https://cursor.com/install -fsS | bash",
+            win32: "irm 'https://cursor.com/install?win32=true' | iex",
+        },
+        docsUrl: "https://cursor.com/docs/cli/installation",
+        signInCommand: "cursor-agent login",
+    },
+    // Global flags must precede `acp` (cursor.com/docs/cli/reference/parameters).
+    // `--force` is the documented auto-approve switch (`--yolo` is an alias);
+    // `--model` is the reliable pin — ACP session/set_model is best-effort below.
+    spawnArgs: (config, turn) => [
+        ...(config.fullAuto ? ["--force"] : turn.approvalMode === "auto" ? ["--auto-review"] : []),
+        ...(turn.model ? ["--model", turn.model] : []),
+        "acp",
+    ],
+    credentialEnv: ["CURSOR_API_KEY", "CURSOR_AUTH_TOKEN"],
+    resolveModels: (environment, config) => fetchCursorModels(config.cli || "cursor-agent", environment, run),
+    // Prefer the advertised ACP method. An already-signed-in CLI should accept
+    // cursor_login without a browser; a missing method rides the ambient login
+    // (CURSOR_API_KEY / `cursor-agent login`) instead of failing the turn.
+    pickAuthMethod: (methods) => (methods.some((m) => m.id === "cursor_login") ? "cursor_login" : null),
+    authFailure: "continue",
+    isAuthenticated: (env, config) => probeCursorAuth(config.cli || "cursor-agent", env, run),
+    classifyError: classifyCursorError,
+    async configureSession({ request, sessionId, turn, sessionModels }) {
+        if (!turn.model)
+            return;
+        // Prefer the id this session actually advertised; fall back to the argv
+        // slug so a CLI that advertises nothing behaves exactly as before.
+        const modelId = resolveCursorAcpModelId(sessionModels ?? [], turn.model) ?? turn.model;
+        try {
+            await request("session/set_model", { sessionId, modelId });
+        }
+        catch (e) {
+            const err = e;
+            // -32601 method missing, -32602 id not in this session's namespace. In
+            // both cases spawnArgs already pinned `--model`, so the turn runs the
+            // right model anyway; failing it here would refuse a working request.
+            if (err.code === -32601 || err.code === -32602)
+                return;
+            throw new Error(`Cursor rejected model "${turn.model}" (sent as "${modelId}") via session/set_model: ${err.message}. ` +
+                `Check that \`cursor-agent\` is current and that this account can use that model.`);
+        }
+    },
+    buildPromptText: (turn) => (turn.system ? `${turn.system}\n\n${turn.text}` : turn.text),
+});
+export function createCursorAgentDriver(run = execCli) {
+    return createAcpDriver(support(run));
+}
+export const CursorAgentDriver = createCursorAgentDriver();

package/dist-server/server/drivers/acp/custom.js

@@ -0,0 +1,51 @@
+// Bring-your-own engine: any agent CLI that speaks ACP over stdio plugs in
+// as an instance of this driver — no code, one config entry:
+//
+//   { "instances": { "my-agent": {
+//       "driver": "customAcp",
+//       "displayName": "My Agent",
+//       "config": { "cli": "my-agent acp" } } } }
+//
+// The `cli` string carries the whole command (wrapper strings resolve via
+// splitCliString, so "npx -y some-agent acp" works too). There is no auth
+// story on purpose: the user's CLI is expected to be signed in from a
+// terminal already, exactly like the qwen harness. Model choice stays
+// inside the agent — we advertise a single passthrough id and never pass
+// a model on argv, because -m conventions differ per CLI.
+import { createAcpDriver } from "./core.js";
+const CONFIGURE_HINT = 'a custom ACP engine needs its command — add "config": { "cli": "<your-agent> acp" } to this instance in config.json, or use Settings → Engines → Set CLI…';
+const support = {
+    driverKind: "customAcp",
+    displayName: "Custom (ACP)",
+    access: "custom",
+    // One passthrough id: the agent runs whatever it is configured for.
+    // Advertising a made-up catalog would promise switching we cannot do.
+    models: { default: "agent-default", options: [{ id: "agent-default", label: "Agent default" }] },
+    defaultCli: "",
+    nativeSource: "custom.acp",
+    loginNote: CONFIGURE_HINT,
+    // Mode-entering args ride the cli string itself ("fx acp"), so nothing
+    // extra here.
+    spawnArgs: () => [],
+    pickAuthMethod: () => null,
+    authFailure: "continue",
+    isAuthenticated: () => true,
+};
+const base = createAcpDriver(support);
+export const CustomAcpDriver = {
+    ...base,
+    // decodeAcpConfig never throws (a missing cli falls back to defaultCli,
+    // which is empty here). Turn every blank-command path into the same
+    // teaching shadow row instead of a bare spawn ENOENT at first send.
+    decodeConfig(raw) {
+        const decoded = base.decodeConfig(raw);
+        if (!decoded.cli.trim())
+            throw new Error(CONFIGURE_HINT);
+        return decoded;
+    },
+    async create(input) {
+        if (!input.config.cli.trim())
+            throw new Error(CONFIGURE_HINT);
+        return base.create(input);
+    },
+};

package/dist-server/server/drivers/acp/droid.js

@@ -0,0 +1,225 @@
+// Factory Droid harness support — the `droid` CLI over ACP stdio
+// (`droid exec -o acp`), on the Factory login (~/.factory/auth.v2.file) or a
+// FACTORY_API_KEY. The generic protocol runtime lives in acp/core.ts; this
+// file is only the per-harness quirks. Verified against droid 0.196.0:
+// initialize reports protocolVersion 1, loadSession:true (session/load resume
+// works), promptCapabilities image+embeddedContext, and authMethods
+// device-pairing + factory-api-key.
+//
+// UNLIKE every other ACP harness here, droid ignores argv for session
+// settings. `droid exec --help` says so under "Stream JSON-RPC Mode": "CLI
+// flags do not configure JSON-RPC sessions: -m/--model, --auto,
+// -r/--reasoning-effort, and --disable-builtin-skills are still validated,
+// but session settings come from JSON-RPC requests." So a `-m` that only
+// reaches argv is accepted and then ignored, and the session runs whatever
+// ~/.factory/settings.json selected. Model and autonomy are session config
+// options set over the wire (session/set_model, session/set_mode), which is
+// why both live in configureSession() below and NOT in spawnArgs.
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { decodeInjectId, hostApiKey, localHost, mergeLocalInject } from "../local-inject.js";
+import { createAcpDriver } from "./core.js";
+// FACTORY_HOME_OVERRIDE replaces the HOME the CLI resolves, NOT the data root:
+// droid builds every path as <home>/.factory/… (verified against 0.196.0 —
+// `FACTORY_HOME_OVERRIDE=/tmp/x droid exec -o acp` created /tmp/x/.factory/).
+// Kimi's KIMI_CODE_HOME is a data root; this one is not, so the `.factory`
+// segment stays on both branches.
+//
+// Which credential file exists depends on the `secure_auth_storage` feature
+// flag droid fetches for the account: with secure storage on it writes
+// auth.v2.loginkeychain (macOS) or auth.v2.keyring (keytar), and only falls
+// back to auth.v2.file when that write fails. droid's own check tries all of
+// them, so checking one name alone reports a fresh signed-in login as logged
+// out. Names read from the 0.196.0 binary.
+const AUTH_FILES = ["auth.v2.file", "auth.v2.loginkeychain", "auth.v2.keyring"];
+function authFilePaths(env) {
+    const home = env.FACTORY_HOME_OVERRIDE || env.HOME || homedir();
+    return AUTH_FILES.map((name) => join(home, ".factory", name));
+}
+const INJECT_ID_PREFIX = "custom:openmausbot-";
+export function droidInjectId(host, model) {
+    const safe = `${host}-${model}`.replace(/[^a-zA-Z0-9._+-]+/g, "-").replace(/-+/g, "-");
+    return `${INJECT_ID_PREFIX}${safe}`;
+}
+function factoryHome(env) {
+    return env.FACTORY_HOME_OVERRIDE || env.HOME || env.USERPROFILE || homedir();
+}
+/** Upsert a BYOK custom model so session/set_model can reach the local host. */
+export function ensureDroidInjectModel(modelId, env = process.env) {
+    const inject = decodeInjectId(modelId);
+    if (!inject)
+        return modelId;
+    const host = localHost(inject.host);
+    if (!host)
+        return modelId;
+    const id = droidInjectId(inject.host, inject.model);
+    const dir = join(factoryHome(env), ".factory");
+    mkdirSync(dir, { recursive: true });
+    const path = join(dir, "settings.json");
+    let settings = {};
+    try {
+        settings = JSON.parse(readFileSync(path, "utf8"));
+    }
+    catch (error) {
+        if (existsSync(path))
+            throw error;
+    }
+    const custom = Array.isArray(settings.customModels) ? [...settings.customModels] : [];
+    const match = custom.find((row) => row.id === id || (row.model === inject.model && row.baseUrl === host.baseUrl));
+    if (match) {
+        if (!match.id) {
+            match.id = id;
+            settings.customModels = custom;
+            writeFileSync(path, `${JSON.stringify(settings, null, 2)}\n`);
+        }
+        return match.id;
+    }
+    custom.push({
+        id,
+        model: inject.model,
+        displayName: `${inject.model} (${host.label})`,
+        baseUrl: host.baseUrl,
+        apiKey: hostApiKey(host, env),
+        provider: "generic-chat-completion-api",
+    });
+    settings.customModels = custom;
+    writeFileSync(path, `${JSON.stringify(settings, null, 2)}\n`);
+    return id;
+}
+/** ACP `session/new` throws "Authentication required" unless a Factory
+ *  login or FACTORY_API_KEY is present — even for a BYOK custom model.
+ *  Droid 0.198 only checks that the env var is set, then uses the
+ *  custom row's own key for the local host. Do not invent a key for
+ *  subscription models, and do not overwrite a real Factory key. */
+export function applyDroidLocalAuthEnv(env, modelId) {
+    if (!decodeInjectId(modelId))
+        return;
+    if (env.FACTORY_API_KEY?.trim())
+        return;
+    // session/new already succeeds on a Factory login file. A placeholder
+    // FACTORY_API_KEY can take precedence over that login, so leave env
+    // alone when one of the auth files is present.
+    if (authFilePaths(env).some(existsSync))
+        return;
+    env.FACTORY_API_KEY = "openmausbot-local";
+}
+function readSettings(env) {
+    return JSON.parse(readFileSync(join(factoryHome(env), ".factory", "settings.json"), "utf8"));
+}
+async function resolveModels(env) {
+    let catalog = MODELS;
+    try {
+        const settings = readSettings(env);
+        const custom = (settings.customModels ?? []).flatMap((m) => {
+            // Live inject rows come from mergeLocalInject as host::model. Skip the
+            // BYOK copies we wrote so the picker does not list the same model twice.
+            if (m.id?.startsWith(INJECT_ID_PREFIX))
+                return [];
+            const id = m.id || (m.model ? `custom:${m.model}` : "");
+            if (!id)
+                return [];
+            return [{ id, label: m.displayName || m.model || id, custom: true }];
+        });
+        const merged = [...custom, ...MODELS.options.filter((o) => !custom.some((c) => c.id === o.id))];
+        // Favourites first, in the user's own order; everything else keeps its
+        // existing order (Array.prototype.sort is stable).
+        const rank = new Map((settings.modelFavorites ?? []).map((id, i) => [id, i]));
+        const options = merged.sort((a, b) => (rank.get(a.id) ?? Infinity) - (rank.get(b.id) ?? Infinity));
+        const configured = settings.sessionDefaultSettings?.model;
+        const fallback = options[0]?.id ?? MODELS.default;
+        catalog = {
+            default: configured && options.some((o) => o.id === configured) ? configured : fallback,
+            options,
+        };
+    }
+    catch {
+        // no settings file yet, or unreadable: ship the built-ins
+    }
+    return mergeLocalInject(catalog, env);
+}
+// droid answers a rejected setting with a bare JSON-RPC message ("Model not
+// recognized", "Method not found") that reaches the error card verbatim,
+// naming neither the engine nor the setting that failed. Say what we asked for.
+async function applySetting(request, method, params, what) {
+    try {
+        await request(method, params);
+    }
+    catch (e) {
+        throw new Error(`Droid rejected ${what} via ${method}: ${e.message}. ` +
+            `Check that \`droid\` is current (0.196.0+ supports it) and that this account can use that value.`);
+    }
+}
+// Autonomy maps onto droid's session modes (session/new advertises
+// normal | spec | auto-low | auto-medium | auto-high). Always set it
+// explicitly: ~/.factory/settings.json can pin a mode, and inheriting it
+// would either make every session yolo or make fullAuto silently ask.
+const MODE_DEFAULT = "normal"; // auto-approves reads only; everything else asks
+const MODE_FULL_AUTO = "auto-high";
+// A curated slice of `droid exec -m <bogus>`'s built-in catalog (0.196.0 lists
+// 43). Custom models from ~/.factory/settings.json are per-machine and carry a
+// `custom:` prefix, so they can't be enumerated statically; a bot can still be
+// switched onto one through the model picker (PATCH /api/bots/:id).
+const MODELS = {
+    default: "claude-opus-5",
+    options: [
+        { id: "auto", label: "Auto (Factory picks)" },
+        { id: "claude-opus-5", label: "Claude Opus 5" },
+        { id: "claude-sonnet-5", label: "Claude Sonnet 5" },
+        { id: "claude-haiku-4-5-20251001", label: "Claude Haiku 4.5" },
+        { id: "gpt-5.6-sol", label: "GPT-5.6 Sol" },
+        { id: "gpt-5.6-terra", label: "GPT-5.6 Terra" },
+        { id: "gemini-3.1-pro-preview", label: "Gemini 3.1 Pro" },
+        { id: "glm-5.2", label: "GLM 5.2" },
+        { id: "kimi-k3", label: "Kimi K3" },
+        { id: "grok-4.6", label: "Grok 4.6" },
+    ],
+};
+const support = {
+    driverKind: "droidAgent",
+    displayName: "Droid",
+    models: MODELS,
+    defaultCli: "droid",
+    nativeSource: "droid.acp",
+    loginNote: "Droid CLI is not signed in — run `droid` once and log in, or set FACTORY_API_KEY",
+    install: {
+        command: {
+            darwin: "curl -fsSL https://app.factory.ai/cli | sh",
+            linux: "curl -fsSL https://app.factory.ai/cli | sh",
+            win32: "irm https://app.factory.ai/cli/windows | iex",
+        },
+        docsUrl: "https://docs.factory.ai/droid-cli/quickstart",
+        signInCommand: "droid",
+    },
+    // No model/mode flags here on purpose: see the header note. `-o acp` is the
+    // ACP entry point; everything else is negotiated over the protocol.
+    spawnArgs: () => ["exec", "-o", "acp"],
+    credentialEnv: ["FACTORY_API_KEY"],
+    // The advertised methods are device-pairing (a browser flow that cannot be
+    // driven over ACP) and factory-api-key (read from the child env, no
+    // authenticate call needed). Ride the ambient login instead, like Kimi.
+    pickAuthMethod: () => null,
+    authFailure: "continue",
+    // The signed-in CLI is the primary source; FACTORY_API_KEY is the fallback
+    // droid itself advertises, and it is checked last so an ambient key can
+    // never be what makes an otherwise logged-out instance look ready.
+    isAuthenticated: (env) => authFilePaths(env).some(existsSync) || Boolean(env.FACTORY_API_KEY),
+    resolveModels,
+    resolveTurnModel: (model, env) => (model ? ensureDroidInjectModel(model, env) : model),
+    applyTurnEnv: (env, { requestedModel }) => {
+        applyDroidLocalAuthEnv(env, requestedModel);
+    },
+    async configureSession({ request, sessionId, config, turn }) {
+        const modeId = config.fullAuto ? MODE_FULL_AUTO : MODE_DEFAULT;
+        await applySetting(request, "session/set_mode", { sessionId, modeId }, `autonomy mode "${modeId}"`);
+        // Pin the model for the same reason as the mode: with no set_model the
+        // session runs whatever ~/.factory/settings.json selected, which can be a
+        // `custom:` provider pointing at its own endpoint and key.
+        const modelId = turn.model ?? MODELS.default;
+        await applySetting(request, "session/set_model", { sessionId, modelId }, `model "${modelId}"`);
+    },
+    // House convention for ACP harnesses (grok, gemini, kimi all do this): the
+    // persona rides in the prompt text rather than a CLI system-prompt flag.
+    buildPromptText: (turn) => (turn.system ? `${turn.system}\n\n${turn.text}` : turn.text),
+};
+export const DroidAgentDriver = createAcpDriver(support);