toolroll 0.5.0

package/dist/onboard.d.ts

@@ -0,0 +1,108 @@
+/**
+ * Repo onboarding (four Codex rounds, findings 1–39): clone a GitHub
+ * repository into a configured projects root, as a ceremony.
+ *
+ * The boundaries, in one place: the clone is the ONLY network write and
+ * acts as the serve process's ambient GitHub credential; the target is
+ * confined to an explicitly configured --project-root; publication is
+ * CLAIM-FIRST (an exclusive mkdir of the final directory — a lost race
+ * fails before a byte is written); nothing is ever deleted that this
+ * request did not create; submodules and LFS smudge fetches are off; and
+ * a fresh clone enters with ZERO authority — no tasks, no scopes, no
+ * grants, exactly like an `up`-enrolled repository.
+ *
+ * POSIX only: tree death is proven by polling the process group to
+ * ESRCH. Windows cannot prove descendants died after the leader exited
+ * (finding 32), so onboarding refuses there instead of guessing.
+ */
+export declare function parseGithubRepo(raw: string): {
+    ok: true;
+    owner: string;
+    name: string;
+} | {
+    ok: false;
+    problem: string;
+};
+export type GhTreeResult = {
+    code: number;
+    stdout: string;
+    stderr: string;
+    timedOut: boolean;
+    notFound: boolean;
+    /** The whole process tree is PROVEN dead (finding 21) — cleanup and
+     * verification both gate on this; on doubt nothing is touched. */
+    treeGone: boolean;
+};
+/**
+ * Run gh with its own detached group and prove tree death on EVERY
+ * outcome. Deliberately NOT exec.ts's processGroup path: liveProviders is
+ * provider-owned (finding 12), and this contract — poll the group to
+ * ESRCH before anyone may clean up — is onboarding's own.
+ */
+export declare function runGhTree(args: readonly string[], options: {
+    cwd?: string;
+    timeoutMs: number;
+}): Promise<GhTreeResult>;
+/** Capped, control-stripped stderr for refusal text — never unbounded. */
+export declare function ghWords(stderr: string): string;
+export type RepoPreview = {
+    nameWithOwner: string;
+    visibility: string;
+    /** GitHub reports KiB (finding 18); null = unknown = treated LARGE. */
+    diskUsageKib: number | null;
+    description: string;
+};
+export declare const LARGE_REPO_KIB = 1048576;
+export declare function isLargeRepo(preview: RepoPreview): boolean;
+export type PreviewOutcome = {
+    ok: true;
+    preview: RepoPreview;
+} | {
+    ok: false;
+    reason: "gh-missing" | "gh-auth" | "gh-timeout" | "gh-said-no" | "malformed";
+    message: string;
+};
+/** `gh repo view` — nothing is written on ANY preview outcome. */
+export declare function previewGithubRepo(owner: string, name: string): Promise<PreviewOutcome>;
+export type RepoListing = {
+    nameWithOwner: string;
+    isPrivate: boolean;
+    /** ISO stamp of the last push, "" when GitHub omitted it. */
+    updatedAt: string;
+    description: string;
+};
+export type ListOutcome = {
+    ok: true;
+    repos: RepoListing[];
+} | {
+    ok: false;
+    reason: "gh-missing" | "gh-auth" | "gh-timeout" | "gh-said-no" | "malformed";
+    message: string;
+};
+/**
+ * `gh repo list` — the signed-in account's repositories, read-only, so the
+ * projects screen can OFFER them instead of making the operator type
+ * owner/name from memory. Same discipline as the preview: gh's answer is
+ * DATA — every identity is re-parsed through the strict parser and rows
+ * that fail it are dropped, never rendered. Nothing is written on any
+ * outcome.
+ */
+export declare function listGithubRepos(limit?: number): Promise<ListOutcome>;
+export type CloneOutcome = {
+    ok: true;
+    target: string;
+} | {
+    ok: false;
+    reason: "exists" | "gh-missing" | "gh-auth" | "gh-timeout" | "clone-failed" | "verify-failed" | "residual";
+    message: string;
+};
+/**
+ * The claim-first clone (findings 6/11/23): mkdir the FINAL target
+ * exclusively — EEXIST loses the race with NOTHING written — then clone
+ * into it. Cleanup removes the target only because THIS call created it,
+ * and only after the tree is proven dead; on doubt the residual is named.
+ */
+export declare function cloneGithubRepo(nameWithOwner: string, root: string, gitVerify: (cwd: string) => Promise<{
+    code: number;
+    stdout: string;
+}>): Promise<CloneOutcome>;

package/dist/onboard.js

@@ -0,0 +1,325 @@
+/**
+ * Repo onboarding (four Codex rounds, findings 1–39): clone a GitHub
+ * repository into a configured projects root, as a ceremony.
+ *
+ * The boundaries, in one place: the clone is the ONLY network write and
+ * acts as the serve process's ambient GitHub credential; the target is
+ * confined to an explicitly configured --project-root; publication is
+ * CLAIM-FIRST (an exclusive mkdir of the final directory — a lost race
+ * fails before a byte is written); nothing is ever deleted that this
+ * request did not create; submodules and LFS smudge fetches are off; and
+ * a fresh clone enters with ZERO authority — no tasks, no scopes, no
+ * grants, exactly like an `up`-enrolled repository.
+ *
+ * POSIX only: tree death is proven by polling the process group to
+ * ESRCH. Windows cannot prove descendants died after the leader exited
+ * (finding 32), so onboarding refuses there instead of guessing.
+ */
+import { mkdirSync, openSync, closeSync, writeSync, rmSync, constants as fsConstants } from "node:fs";
+import { basename, dirname, join } from "node:path";
+import { spawn } from "node:child_process";
+/** Strict, onboarding-only (finding 5/18): exactly owner/name, bounded
+ * ASCII, alnum-leading, no leading dash or dot, `.`/`..` refused. The two
+ * looser GITHUB_REPO_SHAPE call sites gate other, already-reviewed
+ * authority and are deliberately untouched. */
+const COMPONENT = /^[A-Za-z0-9][A-Za-z0-9._-]{0,99}$/;
+export function parseGithubRepo(raw) {
+    let text = raw.trim();
+    if (text.length === 0 || text.length > 512)
+        return { ok: false, problem: "name a repository as owner/name or a github.com link" };
+    if (text.startsWith("https://") || text.startsWith("http://")) {
+        let url;
+        try {
+            url = new URL(text);
+        }
+        catch {
+            return { ok: false, problem: "that link is not a URL" };
+        }
+        if (url.protocol !== "https:" || url.hostname !== "github.com" || url.port !== "" || url.username !== "" || url.password !== "" || url.search !== "" || url.hash !== "") {
+            return { ok: false, problem: "only plain https://github.com/owner/name links are accepted" };
+        }
+        const segments = url.pathname.split("/").filter(one => one !== "");
+        if (segments.length !== 2)
+            return { ok: false, problem: "a repository link has exactly two path segments: owner/name" };
+        text = `${segments[0]}/${segments[1]?.replace(/\.git$/, "")}`;
+    }
+    const parts = text.split("/");
+    if (parts.length !== 2)
+        return { ok: false, problem: "name a repository as owner/name" };
+    const [owner = "", name = ""] = parts;
+    for (const part of [owner, name]) {
+        if (!COMPONENT.test(part) || part === "." || part === ".." || part.startsWith("-") || part.startsWith(".")) {
+            return { ok: false, problem: "owner and name are letters, digits, dots, dashes, and underscores — nothing else" };
+        }
+    }
+    return { ok: true, owner, name };
+}
+const GH_ENV = {
+    GH_PROMPT_DISABLED: "1",
+    GH_NO_UPDATE_NOTIFIER: "1",
+    GIT_LFS_SKIP_SMUDGE: "1",
+    GIT_TERMINAL_PROMPT: "0",
+};
+/**
+ * Run gh with its own detached group and prove tree death on EVERY
+ * outcome. Deliberately NOT exec.ts's processGroup path: liveProviders is
+ * provider-owned (finding 12), and this contract — poll the group to
+ * ESRCH before anyone may clean up — is onboarding's own.
+ */
+export function runGhTree(args, options) {
+    return new Promise(resolve => {
+        if (process.platform === "win32") {
+            resolve({ code: 1, stdout: "", stderr: "onboarding is not supported on Windows yet", timedOut: false, notFound: true, treeGone: true });
+            return;
+        }
+        let child;
+        try {
+            child = spawn("gh", [...args], {
+                cwd: options.cwd,
+                shell: false,
+                windowsHide: true,
+                detached: true,
+                stdio: ["ignore", "pipe", "pipe"],
+                env: { ...process.env, ...GH_ENV },
+            });
+        }
+        catch (error) {
+            resolve({ code: 1, stdout: "", stderr: String(error), timedOut: false, notFound: false, treeGone: true });
+            return;
+        }
+        const pid = child.pid;
+        let stdout = "";
+        let stderr = "";
+        let timedOut = false;
+        let notFound = false;
+        const timer = setTimeout(() => {
+            timedOut = true;
+            if (pid !== undefined) {
+                try {
+                    process.kill(-pid, "SIGKILL");
+                }
+                catch {
+                    // group already gone
+                }
+            }
+        }, options.timeoutMs);
+        child.stdout?.setEncoding("utf8");
+        child.stdout?.on("data", (chunk) => {
+            if (stdout.length < 256 * 1024)
+                stdout += chunk;
+        });
+        child.stderr?.setEncoding("utf8");
+        child.stderr?.on("data", (chunk) => {
+            if (stderr.length < 64 * 1024)
+                stderr += chunk;
+        });
+        child.on("error", error => {
+            notFound = error.code === "ENOENT";
+            if (stderr === "")
+                stderr = String(error);
+        });
+        child.on("close", code => {
+            clearTimeout(timer);
+            // Tree death, proven by the group answering ESRCH — on every path.
+            const settle = (treeGone) => resolve({ code: notFound ? 127 : timedOut ? 124 : (code ?? 1), stdout, stderr, timedOut, notFound, treeGone });
+            if (pid === undefined) {
+                settle(true);
+                return;
+            }
+            const deadline = Date.now() + 5_000;
+            const poll = () => {
+                try {
+                    process.kill(-pid, 0);
+                }
+                catch {
+                    settle(true); // ESRCH: nobody left in the group
+                    return;
+                }
+                if (Date.now() > deadline) {
+                    settle(false);
+                    return;
+                }
+                setTimeout(poll, 100);
+            };
+            poll();
+        });
+    });
+}
+/** Capped, control-stripped stderr for refusal text — never unbounded. */
+export function ghWords(stderr) {
+    const line = stderr.split("\n").find(one => one.trim() !== "") ?? "";
+    return line.replace(/[\x00-\x1f\x7f]/g, " ").slice(0, 200).trim();
+}
+export const LARGE_REPO_KIB = 1_048_576; // 1 GiB in KiB
+export function isLargeRepo(preview) {
+    return preview.diskUsageKib === null || preview.diskUsageKib >= LARGE_REPO_KIB;
+}
+/** `gh repo view` — nothing is written on ANY preview outcome. */
+export async function previewGithubRepo(owner, name) {
+    const answer = await runGhTree(["repo", "view", `github.com/${owner}/${name}`, "--json", "nameWithOwner,visibility,diskUsage,description"], { timeoutMs: 30_000 });
+    if (answer.notFound)
+        return { ok: false, reason: "gh-missing", message: "the GitHub CLI is not installed on this machine — install gh where serve runs" };
+    if (answer.timedOut)
+        return { ok: false, reason: "gh-timeout", message: "GitHub did not answer in time — nothing was written" };
+    if (answer.code === 4)
+        return { ok: false, reason: "gh-auth", message: "gh is not signed in — run `gh auth login --hostname github.com` where serve runs" };
+    if (answer.code !== 0)
+        return { ok: false, reason: "gh-said-no", message: `GitHub said no — ${ghWords(answer.stderr) || "the repository may not exist, or this account cannot see it"}; nothing was written` };
+    let parsed;
+    try {
+        parsed = JSON.parse(answer.stdout);
+    }
+    catch {
+        return { ok: false, reason: "malformed", message: "GitHub's answer was not the JSON gh promises — nothing was written" };
+    }
+    const nameWithOwner = parsed["nameWithOwner"];
+    // The returned identity is RE-PARSED through the strict parser before
+    // anything derives from it (finding 18) — gh's answer is data too.
+    if (typeof nameWithOwner !== "string" || !parseGithubRepo(nameWithOwner).ok) {
+        return { ok: false, reason: "malformed", message: "GitHub named a repository shape this console refuses — nothing was written" };
+    }
+    const disk = parsed["diskUsage"];
+    const description = typeof parsed["description"] === "string" ? parsed["description"] : "";
+    return {
+        ok: true,
+        preview: {
+            nameWithOwner,
+            visibility: typeof parsed["visibility"] === "string" ? parsed["visibility"].toLowerCase() : "unknown",
+            diskUsageKib: typeof disk === "number" && disk >= 0 ? disk : null,
+            description: description.replace(/[\x00-\x1f\x7f]/g, " ").slice(0, 200),
+        },
+    };
+}
+/**
+ * `gh repo list` — the signed-in account's repositories, read-only, so the
+ * projects screen can OFFER them instead of making the operator type
+ * owner/name from memory. Same discipline as the preview: gh's answer is
+ * DATA — every identity is re-parsed through the strict parser and rows
+ * that fail it are dropped, never rendered. Nothing is written on any
+ * outcome.
+ */
+export async function listGithubRepos(limit = 100) {
+    const answer = await runGhTree(["repo", "list", "--json", "nameWithOwner,isPrivate,updatedAt,description", "--limit", String(Math.max(1, Math.min(200, limit)))], { timeoutMs: 30_000 });
+    if (answer.notFound)
+        return { ok: false, reason: "gh-missing", message: "the GitHub CLI is not installed on this machine — install gh where serve runs" };
+    if (answer.timedOut)
+        return { ok: false, reason: "gh-timeout", message: "GitHub did not answer in time" };
+    if (answer.code === 4)
+        return { ok: false, reason: "gh-auth", message: "gh is not signed in — run `gh auth login --hostname github.com` where serve runs" };
+    if (answer.code !== 0)
+        return { ok: false, reason: "gh-said-no", message: `GitHub said no — ${ghWords(answer.stderr) || "the account's repositories could not be listed"}` };
+    let parsed;
+    try {
+        parsed = JSON.parse(answer.stdout);
+    }
+    catch {
+        return { ok: false, reason: "malformed", message: "GitHub's answer was not the JSON gh promises" };
+    }
+    if (!Array.isArray(parsed))
+        return { ok: false, reason: "malformed", message: "GitHub's answer was not the JSON gh promises" };
+    const repos = [];
+    for (const raw of parsed) {
+        if (raw === null || typeof raw !== "object")
+            continue;
+        const row = raw;
+        const nameWithOwner = row["nameWithOwner"];
+        if (typeof nameWithOwner !== "string" || !parseGithubRepo(nameWithOwner).ok)
+            continue;
+        const description = typeof row["description"] === "string" ? row["description"] : "";
+        repos.push({
+            nameWithOwner,
+            isPrivate: row["isPrivate"] === true,
+            // The stamp is DATA too (ghlist review, finding 3): only an
+            // ISO-shaped value survives; anything else renders as nothing.
+            updatedAt: typeof row["updatedAt"] === "string" && /^\d{4}-\d{2}-\d{2}T[0-9:.]+Z?$/.test(row["updatedAt"])
+                ? row["updatedAt"]
+                : "",
+            description: description.replace(/[\x00-\x1f\x7f]/g, " ").slice(0, 120),
+        });
+    }
+    return { ok: true, repos };
+}
+/**
+ * The claim-first clone (findings 6/11/23): mkdir the FINAL target
+ * exclusively — EEXIST loses the race with NOTHING written — then clone
+ * into it. Cleanup removes the target only because THIS call created it,
+ * and only after the tree is proven dead; on doubt the residual is named.
+ */
+export async function cloneGithubRepo(nameWithOwner, root, gitVerify) {
+    const shape = parseGithubRepo(nameWithOwner);
+    if (!shape.ok)
+        return { ok: false, reason: "clone-failed", message: shape.problem };
+    const target = join(root, shape.name);
+    if (dirname(target) !== root || basename(target) !== shape.name) {
+        return { ok: false, reason: "clone-failed", message: "the target escaped its root — refused" };
+    }
+    try {
+        mkdirSync(target); // the CLAIM — exclusive by mkdir semantics
+    }
+    catch {
+        return {
+            ok: false,
+            reason: "exists",
+            message: `nothing was written by this request — a directory already exists at ${target}; if it is empty and nobody is cloning, it is an abandoned claim: inspect and remove it by hand`,
+        };
+    }
+    // The ownership marker (finding 11): written and removed before gh runs;
+    // its lifecycle is within this invocation only.
+    const marker = join(target, ".so-claim");
+    try {
+        const fd = openSync(marker, fsConstants.O_WRONLY | fsConstants.O_CREAT | fsConstants.O_EXCL, 0o600);
+        writeSync(fd, "claimed by standing-orders onboarding\n");
+        closeSync(fd);
+        rmSync(marker);
+    }
+    catch {
+        // The claim stands; a marker hiccup is not worth a wedged directory.
+    }
+    const answer = await runGhTree(["repo", "clone", `github.com/${nameWithOwner}`, target, "--", "--no-tags", "--no-recurse-submodules"], { timeoutMs: 10 * 60_000 });
+    const cleanOwn = () => {
+        if (!answer.treeGone)
+            return false; // doubt: touch nothing (finding 21)
+        try {
+            rmSync(target, { recursive: true, force: true });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    };
+    if (answer.notFound) {
+        cleanOwn();
+        return { ok: false, reason: "gh-missing", message: "the GitHub CLI is not installed on this machine — the claimed directory was removed" };
+    }
+    if (answer.code === 4) {
+        const removed = cleanOwn();
+        return { ok: false, reason: "gh-auth", message: `gh is not signed in — run \`gh auth login --hostname github.com\` where serve runs; ${removed ? "the claimed directory was removed" : `a residual remains at ${target}`}` };
+    }
+    if (answer.timedOut || answer.code !== 0) {
+        const removed = cleanOwn();
+        const said = answer.timedOut ? "the clone ran past ten minutes and was stopped" : `the clone failed — ${ghWords(answer.stderr) || "git said no"}`;
+        return {
+            ok: false,
+            reason: answer.timedOut ? "gh-timeout" : "clone-failed",
+            message: `${said}; ${removed ? "this request's partial copy was removed" : `a residual remains at ${target} — remove it by hand`}`,
+        };
+    }
+    if (!answer.treeGone) {
+        return { ok: false, reason: "residual", message: `the clone finished but its helpers could not be proven gone — inspect ${target} before using it` };
+    }
+    // Verify what landed IS the repository we asked for, where we asked.
+    const top = await gitVerify(target);
+    if (top.code !== 0 || top.stdout.trim() !== target) {
+        const removed = (() => {
+            try {
+                rmSync(target, { recursive: true, force: true });
+                return true;
+            }
+            catch {
+                return false;
+            }
+        })();
+        return { ok: false, reason: "verify-failed", message: `what landed did not verify as a repository at ${target}; ${removed ? "it was removed" : "a residual remains — remove it by hand"}` };
+    }
+    return { ok: true, target };
+}

package/dist/openrouter-models.d.ts

@@ -0,0 +1,30 @@
+export type OpenRouterModel = {
+    id: string;
+    name: string;
+    context: number | null;
+    tools: boolean;
+    input: number | null;
+    output: number | null;
+    cachedInput: number | null;
+    extraCharges: boolean;
+    conditionalPricing: boolean;
+    /** Unix seconds when OpenRouter listed it — the closest thing to a release date. */
+    created: number | null;
+};
+export type OpenRouterModels = {
+    ok: true;
+    models: OpenRouterModel[];
+    source: "public" | "account";
+    checkedAt: string;
+} | {
+    ok: false;
+    problem: string;
+};
+export declare function parseOpenRouterModels(data: unknown): OpenRouterModel[] | null;
+export declare function fetchOpenRouterModels(key: string | null, fetcher?: typeof fetch): Promise<OpenRouterModels>;
+/** One bounded cache per console. A changed/removed key cannot reuse another account's list. */
+export declare function openRouterModelsCache(fetcher?: typeof fetch): (key: string | null, refresh?: boolean) => Promise<OpenRouterModels>;
+export declare function modelDollars(amount: number | null): string;
+export declare function openRouterPicker(catalog: OpenRouterModels, selected: string | null, refreshUrl: string): string;
+/** Only filters already-rendered options; credentials never enter this script. */
+export declare function openRouterPickerScript(): string;

package/dist/openrouter-models.js

@@ -0,0 +1,120 @@
+/** Live discovery for the UI. Prices are USD, separate from rounded budget pins. */
+import { createHash } from "node:crypto";
+import { readCappedBody } from "./converse.js";
+import { validModelId } from "./provider.js";
+const record = (value) => value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
+function price(value, units = 1_000_000) {
+    if ((typeof value !== "string" || !/^\d+(?:\.\d+)?(?:e[+-]?\d+)?$/i.test(value)) && typeof value !== "number")
+        return null;
+    const amount = Number(value) * units;
+    return Number.isFinite(amount) && amount >= 0 ? amount : null;
+}
+export function parseOpenRouterModels(data) {
+    if (!Array.isArray(data) || data.length > 5_000)
+        return null;
+    const models = new Map();
+    for (const value of data) {
+        const row = record(value), pricing = record(row.pricing), architecture = record(row.architecture);
+        if (typeof row.id !== "string" || !validModelId(row.id) || row.id.length > 128)
+            continue;
+        if (Array.isArray(architecture.output_modalities) && !architecture.output_modalities.includes("text"))
+            continue;
+        models.set(row.id, {
+            id: row.id, name: typeof row.name === "string" ? row.name.slice(0, 150) : row.id,
+            context: typeof row.context_length === "number" && Number.isSafeInteger(row.context_length) && row.context_length > 0 ? row.context_length : null,
+            tools: Array.isArray(row.supported_parameters) && row.supported_parameters.includes("tools"),
+            input: price(pricing.prompt), output: price(pricing.completion), cachedInput: price(pricing.input_cache_read),
+            extraCharges: ["request", "image", "web_search", "internal_reasoning", "input_cache_write"].some(key => (price(pricing[key], 1) ?? 0) > 0),
+            conditionalPricing: Array.isArray(pricing.overrides) && pricing.overrides.length > 0,
+            created: typeof row.created === "number" && Number.isSafeInteger(row.created) && row.created > 0 ? row.created : null,
+        });
+    }
+    return [...models.values()].sort((a, b) => a.name.localeCompare(b.name));
+}
+export async function fetchOpenRouterModels(key, fetcher = fetch) {
+    try {
+        const response = await fetcher(`https://openrouter.ai/api/v1/models${key === null ? "" : "/user"}`, {
+            headers: key === null ? { accept: "application/json" } : { accept: "application/json", authorization: `Bearer ${key}` },
+            redirect: "error", signal: AbortSignal.timeout(8_000),
+        });
+        if (!response.ok) {
+            await response.body?.cancel();
+            return { ok: false, problem: response.status === 401 || response.status === 403
+                    ? "OpenRouter rejected this key. Update your connection and try again."
+                    : "OpenRouter’s model list is unavailable. Try again shortly." };
+        }
+        const body = await readCappedBody(response, 8_388_608);
+        if (body === null)
+            return { ok: false, problem: "OpenRouter’s model list was too large to load. Try again shortly." };
+        const models = parseOpenRouterModels(record(JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(body))).data);
+        if (models === null)
+            return { ok: false, problem: "OpenRouter returned an unreadable model list. Try again shortly." };
+        return { ok: true, models, source: key === null ? "public" : "account", checkedAt: new Date().toISOString() };
+    }
+    catch {
+        return { ok: false, problem: "Couldn’t load models from OpenRouter. Check your connection and try again." };
+    }
+}
+/** One bounded cache per console. A changed/removed key cannot reuse another account's list. */
+export function openRouterModelsCache(fetcher = fetch) {
+    let cache = null;
+    let pending = null;
+    return async (key, refresh = false) => {
+        const fingerprint = createHash("sha256").update(key ?? "public").digest("hex");
+        if (!refresh && cache?.fingerprint === fingerprint && cache.expires > Date.now())
+            return cache.result;
+        if (pending?.fingerprint === fingerprint)
+            return pending.result;
+        const result = fetchOpenRouterModels(key, fetcher);
+        pending = { fingerprint, result };
+        const value = await result;
+        // An older request finishing late must not overwrite a newer key's cache.
+        if (pending?.result === result) {
+            cache = { fingerprint, expires: Date.now() + (value.ok ? 600_000 : 30_000), result: value };
+            pending = null;
+        }
+        return value;
+    };
+}
+const escape = (s) => s.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&#39;");
+export function modelDollars(amount) {
+    if (amount === null)
+        return "Not reported";
+    if (amount === 0)
+        return "$0";
+    if (amount < 0.00000001)
+        return "<$0.00000001";
+    return "$" + amount.toLocaleString("en-US", { maximumFractionDigits: 8 });
+}
+function details(model) {
+    return `Input ${modelDollars(model.input)} · Output ${modelDollars(model.output)}${model.cachedInput === null ? "" : ` · Cached input ${modelDollars(model.cachedInput)}`} per 1M tokens. ` +
+        (model.context === null ? "" : `${model.context.toLocaleString("en-US")} token context. `) +
+        (model.tools ? "Tool calling supported. " : "Tool calling not listed. ") +
+        (model.conditionalPricing ? "Rates change with context length or other conditions. " : "") +
+        (model.extraCharges ? "Additional usage charges may apply. " : "") + "Actual charges depend on routing and usage.";
+}
+export function openRouterPicker(catalog, selected, refreshUrl) {
+    const rows = catalog.ok ? catalog.models : [];
+    const current = rows.find(row => row.id === selected);
+    const manual = selected && !current ? `<option selected value="${escape(selected)}" data-detail="This saved model is not in the loaded catalog. Availability and pricing are unverified.">${escape(selected)} · Saved choice</option>` : "";
+    return `<div data-openrouter-picker><p class="meta">${catalog.ok
+        ? `${rows.length} text models · ${catalog.source === "account" ? "Filtered for your OpenRouter account" : "Public catalog · Connect a key to check your account"} · Updated ${escape(catalog.checkedAt.slice(11, 16))} UTC`
+        : escape(catalog.problem)} <a href="${escape(refreshUrl)}">Refresh models</a></p>` +
+        `<label data-model-search hidden>Search models<input type="search" placeholder="Search by name or provider" autocomplete="off"></label>` +
+        `<label>Model<select name="model" aria-describedby="openrouter-price"><option value="__custom__"${selected === null ? " selected" : ""}>Choose a model</option>${manual}${rows.map(row => `<option value="${escape(row.id)}" data-detail="${escape(details(row))}"${row.id === selected ? " selected" : ""}>${escape(row.name)} · ${modelDollars(row.input)} in / ${modelDollars(row.output)} out per 1M</option>`).join("")}</select></label>` +
+        `<p id="openrouter-price" class="meta" aria-live="polite">${current ? escape(details(current)) : selected ? "This saved model is not in the loaded catalog. Availability and pricing are unverified." : "Choose a model to see its token prices and context size."}</p>` +
+        `<p data-model-count class="meta" aria-live="polite"></p><p class="meta"><a href="https://openrouter.ai/models" target="_blank" rel="noreferrer">Compare models on OpenRouter ↗</a> · Prices in USD; catalog browsing uses no model tokens.</p></div>`;
+}
+/** Only filters already-rendered options; credentials never enter this script. */
+export function openRouterPickerScript() {
+    return `(function(){document.querySelectorAll('[data-openrouter-picker]').forEach(function(root){
+    var search=root.querySelector('input[type=search]'),select=root.querySelector('select'),price=root.querySelector('#openrouter-price'),count=root.querySelector('[data-model-count]');
+    if(!search||!select)return;root.querySelector('[data-model-search]').hidden=false;
+    var options=Array.from(select.options),chosen=select.value;
+    function filter(){var q=search.value.trim().toLowerCase(),matches=options.filter(function(o){return o.value!=='__custom__'&&(o.textContent+' '+o.value).toLowerCase().includes(q)});
+      select.replaceChildren();options.forEach(function(o){if(o.value==='__custom__'||o.value===chosen||matches.includes(o))select.appendChild(o)});select.value=chosen;
+      count.textContent=q?matches.length+' matches'+(chosen!=='__custom__'&&!matches.some(function(o){return o.value===chosen})?' · your selection is kept':''):'';
+    }
+    select.addEventListener('change',function(){chosen=select.value;price.textContent=select.selectedOptions[0].dataset.detail||'Choose a model to see its token prices and context size.';filter()});search.addEventListener('input',filter);
+  })})();`;
+}