@repo-os/repoos 0.5.45

package/dist/core/logger.js

@@ -0,0 +1,138 @@
+/**
+ * Centralized logging for RepoOS system, tasks, and agents.
+ * Logs are stored as newline-delimited JSON (NDJSON) in .repoos/logs/
+ * Structure:
+ *   .repoos/logs/system.log       - System-wide errors and critical events
+ *   .repoos/logs/tasks/<id>.log   - Per-task lifecycle and state changes
+ *   .repoos/logs/agents/<id>.log  - Per-agent activity and errors
+ */
+import { appendFileSync, mkdirSync, existsSync, readFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+/**
+ * Central logger for RepoOS. Creates and manages log files in .repoos/logs/
+ */
+export class Logger {
+    root;
+    logsDir;
+    constructor(opts) {
+        this.root = opts.root;
+        this.logsDir = join(opts.root, ".repoos", "logs");
+    }
+    /**
+     * Log a system-wide event or error. Includes fatal crashes and critical failures.
+     */
+    system(level, message, context) {
+        this.write("system.log", {
+            timestamp: new Date().toISOString(),
+            level,
+            component: "system",
+            message,
+            context,
+        });
+    }
+    /**
+     * Log a task lifecycle event: state changes, errors, transitions through pipeline.
+     */
+    task(taskId, level, message, context) {
+        this.write(`tasks/${taskId}.log`, {
+            timestamp: new Date().toISOString(),
+            level,
+            component: "task",
+            message,
+            context,
+        });
+    }
+    /**
+     * Log agent activity: startup, completion, errors, output streams.
+     */
+    agent(agentId, level, message, context) {
+        this.write(`agents/${agentId}.log`, {
+            timestamp: new Date().toISOString(),
+            level,
+            component: "agent",
+            message,
+            context,
+        });
+    }
+    /**
+     * Log integration/merge job activity (phase transitions, errors).
+     */
+    integration(taskId, level, message, context) {
+        this.write(`tasks/${taskId}.log`, {
+            timestamp: new Date().toISOString(),
+            level,
+            component: "integration",
+            message,
+            context,
+        });
+    }
+    /**
+     * Read up to `limit` log entries for a specific task or agent, in
+     * chronological order (oldest first). Callers that want most-recent-first
+     * (`getTaskLogs`, `getAgentLogs`, `getSystemLogs`) reverse the result.
+     */
+    readLogs(logPath, limit = 1000) {
+        const fullPath = join(this.logsDir, logPath);
+        if (!existsSync(fullPath))
+            return [];
+        try {
+            const content = readFileSync(fullPath, "utf8");
+            const lines = content.split("\n").filter((line) => line.trim());
+            const entries = [];
+            for (const line of lines) {
+                try {
+                    entries.push(JSON.parse(line));
+                }
+                catch {
+                    // Skip malformed lines
+                }
+            }
+            return entries.slice(Math.max(0, entries.length - limit));
+        }
+        catch {
+            return [];
+        }
+    }
+    /**
+     * Get task logs in reverse order (most recent first).
+     */
+    getTaskLogs(taskId, limit = 1000) {
+        const entries = this.readLogs(`tasks/${taskId}.log`, limit);
+        return entries.reverse();
+    }
+    /**
+     * Get agent logs in reverse order (most recent first).
+     */
+    getAgentLogs(agentId, limit = 1000) {
+        const entries = this.readLogs(`agents/${agentId}.log`, limit);
+        return entries.reverse();
+    }
+    /**
+     * Get system logs in reverse order (most recent first).
+     */
+    getSystemLogs(limit = 1000) {
+        const entries = this.readLogs("system.log", limit);
+        return entries.reverse();
+    }
+    /**
+     * Write a log entry as NDJSON to the appropriate log file.
+     */
+    write(logPath, entry) {
+        try {
+            const fullPath = join(this.logsDir, logPath);
+            const dir = dirname(fullPath);
+            mkdirSync(dir, { recursive: true });
+            appendFileSync(fullPath, JSON.stringify(entry) + "\n", "utf8");
+        }
+        catch (err) {
+            // Logging should never crash the system. Silent failure.
+            console.error(`Failed to write log: ${err}`);
+        }
+    }
+}
+/**
+ * Create a logger for a repository root.
+ */
+export function createLogger(root) {
+    return new Logger({ root });
+}

package/dist/core/models.d.ts

@@ -0,0 +1,45 @@
+/** Default ceiling on the `opencode models` probe, ms. A hung CLI is SIGKILLed. */
+export declare const MODELS_TIMEOUT_MS = 5000;
+/** Codex app-server has a heavier cold start than a one-shot CLI command. */
+export declare const CODEX_MODELS_TIMEOUT_MS = 15000;
+/** Hard cap on collected stdout so a runaway provider list can't balloon memory. */
+export declare const MODELS_MAX_BYTES: number;
+/** Outcome of probing one model source. `models` is never null. */
+export interface ModelSourceResult {
+    supported: boolean;
+    models: string[];
+    /** True when the source supports a cache-refreshing re-probe. */
+    refreshable: boolean;
+}
+/** Options handed to an adapter's `list`. */
+export interface ListModelsOptions {
+    /** Re-probe with the source's refresh flag (e.g. `--refresh`). */
+    refresh?: boolean;
+    /** Working directory the probe runs in (repo root). */
+    cwd?: string;
+    /** Optional Agent.cli allowlist; avoids probing unrelated installed CLIs. */
+    clis?: string[];
+}
+/** A per-CLI model source. `list` never throws — failures resolve empty. */
+export interface ModelSourceAdapter {
+    /** Stable id, e.g. "opencode". */
+    id: string;
+    /** The `Agent.cli` value this adapter serves, e.g. "claude code". */
+    cli: string;
+    supported: boolean;
+    list(opts: ListModelsOptions): Promise<ModelSourceResult>;
+}
+/**
+ * Parse `opencode models` stdout into a sorted, unique list of model ids. The
+ * command emits one `provider/model` id per line; anything else (headers, help
+ * text, ANSI noise) is dropped.
+ */
+export declare function parseLiveModels(text: string): string[];
+/** Registry keyed by `Agent.cli`. Only opencode lists models; the rest are stubs. */
+export declare const MODEL_SOURCES: Record<string, ModelSourceAdapter>;
+/**
+ * Probe every registered model source, fail-soft. Never throws and never
+ * hangs: a bad PATH, missing binary, or timeout resolves an empty result.
+ * Returns results keyed by `Agent.cli` for `GET /api/models`.
+ */
+export declare function listModelSources(opts?: ListModelsOptions): Promise<Record<string, ModelSourceResult>>;

package/dist/core/models.js

@@ -0,0 +1,291 @@
+/**
+ * Per-CLI model-source adapters — feeds the Agents page model dropdown from
+ * what each coding agent can actually run. Today only opencode has a
+ * machine-readable model list (`opencode models`); the other known CLIs are
+ * registered as `{ supported: false }` placeholders so a future adapter is a
+ * one-file change.
+ *
+ * Zero runtime deps: `node:child_process` only (binary resolution reuses
+ * src/core/detect.ts). Everything is fail-soft: a missing binary, a hung
+ * probe, or unparseable output must never throw — callers get
+ * `{ models: [] }` and degrade to the static model list.
+ */
+import { spawn } from "node:child_process";
+import { resolveBinary, KNOWN_AGENTS } from "./detect.js";
+/** Default ceiling on the `opencode models` probe, ms. A hung CLI is SIGKILLed. */
+export const MODELS_TIMEOUT_MS = 5000;
+/** Codex app-server has a heavier cold start than a one-shot CLI command. */
+export const CODEX_MODELS_TIMEOUT_MS = 15_000;
+/** Hard cap on collected stdout so a runaway provider list can't balloon memory. */
+export const MODELS_MAX_BYTES = 64 * 1024;
+/** Longest accepted model id — keeps the dropdown readable. */
+const MODEL_ID_MAX_LEN = 120;
+/**
+ * Parse `opencode models` stdout into a sorted, unique list of model ids. The
+ * command emits one `provider/model` id per line; anything else (headers, help
+ * text, ANSI noise) is dropped.
+ */
+export function parseLiveModels(text) {
+    const seen = new Set();
+    for (const raw of text.split("\n")) {
+        const id = raw.trim();
+        if (!id || id.length > MODEL_ID_MAX_LEN)
+            continue;
+        if (!id.includes("/"))
+            continue;
+        seen.add(id);
+    }
+    return [...seen].sort();
+}
+/** Spawn `<bin> <args>` and collect stdout up to MODELS_MAX_BYTES. */
+function spawnModels(bin, args, opts) {
+    return new Promise((resolve) => {
+        let proc;
+        try {
+            proc = spawn(bin, args, {
+                cwd: opts.cwd ?? process.cwd(),
+                stdio: ["ignore", "pipe", "pipe"],
+            });
+        }
+        catch {
+            resolve("");
+            return;
+        }
+        let out = "";
+        let settled = false;
+        const done = (text) => {
+            if (settled)
+                return;
+            settled = true;
+            resolve(text);
+        };
+        const timer = setTimeout(() => {
+            try {
+                proc.kill("SIGKILL");
+            }
+            catch {
+                /* already gone */
+            }
+            done("");
+        }, opts.timeoutMs);
+        proc.stdout?.on("data", (c) => {
+            if (out.length < MODELS_MAX_BYTES)
+                out += c.toString("utf8");
+        });
+        proc.on("error", () => {
+            clearTimeout(timer);
+            done("");
+        });
+        proc.on("exit", () => {
+            clearTimeout(timer);
+            done(out);
+        });
+    });
+}
+/** Query Codex's account-aware picker catalog through its stdio app-server. */
+function listCodexModels(bin, opts) {
+    return new Promise((resolve) => {
+        let proc;
+        try {
+            proc = spawn(bin, ["app-server", "--listen", "stdio://"], {
+                cwd: opts.cwd ?? process.cwd(),
+                stdio: ["pipe", "pipe", "pipe"],
+            });
+        }
+        catch {
+            resolve([]);
+            return;
+        }
+        let pending = "";
+        let settled = false;
+        const done = (models) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            try {
+                proc.kill("SIGTERM");
+            }
+            catch {
+                /* already exited */
+            }
+            resolve(models);
+        };
+        const timer = setTimeout(() => {
+            try {
+                proc.kill("SIGKILL");
+            }
+            catch {
+                /* already exited */
+            }
+            done([]);
+        }, CODEX_MODELS_TIMEOUT_MS);
+        proc.stdout?.on("data", (chunk) => {
+            pending += chunk.toString("utf8");
+            const lines = pending.split("\n");
+            pending = lines.pop() ?? "";
+            for (const line of lines) {
+                try {
+                    const message = JSON.parse(line);
+                    if (message.id !== 2 || !Array.isArray(message.result?.data))
+                        continue;
+                    done(message.result.data
+                        .map((entry) => entry.model)
+                        .filter((model) => typeof model === "string" && model.length > 0));
+                }
+                catch {
+                    /* notifications and malformed lines are irrelevant */
+                }
+            }
+        });
+        proc.on("error", () => done([]));
+        proc.on("close", () => done([]));
+        proc.stdin?.write([
+            JSON.stringify({
+                id: 1,
+                method: "initialize",
+                params: { clientInfo: { name: "repoos", version: "0.3.0" }, capabilities: {} },
+            }),
+            JSON.stringify({
+                id: 2,
+                method: "model/list",
+                params: { limit: 100, includeHidden: false },
+            }),
+            "",
+        ].join("\n"));
+    });
+}
+/** The opencode adapter: spawns `opencode models` and parses `provider/model`. */
+const opencodeAdapter = {
+    id: "opencode",
+    cli: "opencode",
+    supported: true,
+    async list(opts = {}) {
+        // "default" (the coding agent's own default) is always offered first.
+        const bin = resolveBinary("opencode", process.env.PATH ?? "");
+        if (!bin)
+            return { supported: true, models: ["default"], refreshable: true };
+        const args = opts.refresh ? ["models", "--refresh"] : ["models"];
+        const out = await spawnModels(bin, args, {
+            timeoutMs: MODELS_TIMEOUT_MS,
+            cwd: opts.cwd,
+        });
+        return { supported: true, models: ["default", ...parseLiveModels(out)], refreshable: true };
+    },
+};
+const codexAdapter = {
+    id: "codex",
+    cli: "codex",
+    supported: true,
+    async list(opts = {}) {
+        const bin = resolveBinary("codex", process.env.PATH ?? "");
+        if (!bin)
+            return { supported: true, models: ["default"], refreshable: true };
+        const models = await listCodexModels(bin, opts);
+        return { supported: true, models: ["default", ...new Set(models)], refreshable: true };
+    },
+};
+/**
+ * Copilot accepts a model with every prompt, but its CLI does not expose a
+ * stable machine-readable model catalog. Offer the CLI default and let the
+ * existing per-model compatibility probe validate any manually configured id.
+ */
+const copilotAdapter = {
+    id: "copilot",
+    cli: "github copilot",
+    supported: true,
+    async list() {
+        return { supported: true, models: ["default"], refreshable: false };
+    },
+};
+/**
+ * Kiro adapter: parses `kiro-cli chat --list-models` plain-text output.
+ * The CLI emits a human-readable table; we strip ANSI codes and take the
+ * first whitespace-delimited token from each model row (e.g. "auto",
+ * "claude-sonnet-4.5"). A leading "*" marks the default model and is
+ * stripped before taking the token. Token counts are not reported by the
+ * CLI; cost tracking uses the credits footer parsed by extractUsage.
+ */
+function parseKiroModels(text) {
+    const seen = new Set();
+    // Strip ANSI escape sequences
+    const clean = text.replace(/\x1b\[[^m]*m/g, "").replace(/\x1b\[[?][0-9]*[a-zA-Z]/g, "");
+    for (const raw of clean.split("\n")) {
+        const line = raw.trim().replace(/^\*\s*/, ""); // strip leading "*"
+        if (!line)
+            continue;
+        const token = line.split(/\s+/)[0];
+        // Must look like a model id: alphanumeric, hyphens, dots — no spaces
+        if (!token || token.length > MODEL_ID_MAX_LEN)
+            continue;
+        if (!/^[a-zA-Z0-9][a-zA-Z0-9._-]*$/.test(token))
+            continue;
+        // Skip header lines like "Available" or "models"
+        if (/^available$/i.test(token) || /^models$/i.test(token))
+            continue;
+        seen.add(token);
+    }
+    return [...seen];
+}
+const kiroAdapter = {
+    id: "kiro",
+    cli: "kiro",
+    supported: true,
+    async list(opts = {}) {
+        const bin = resolveBinary("kiro-cli", process.env.PATH ?? "");
+        if (!bin)
+            return { supported: true, models: ["default"], refreshable: true };
+        const out = await spawnModels(bin, ["chat", "--list-models"], {
+            timeoutMs: MODELS_TIMEOUT_MS,
+            cwd: opts.cwd,
+        });
+        const models = parseKiroModels(out);
+        return { supported: true, models: ["default", ...models], refreshable: true };
+    },
+};
+/** Placeholder adapter for CLIs with no machine-readable model list. */
+function unsupported(id, cli) {
+    return {
+        id,
+        cli,
+        supported: false,
+        async list() {
+            return { supported: false, models: [], refreshable: false };
+        },
+    };
+}
+/** Registry keyed by `Agent.cli`. Only opencode lists models; the rest are stubs. */
+export const MODEL_SOURCES = {
+    opencode: opencodeAdapter,
+    codex: codexAdapter,
+    "github copilot": copilotAdapter,
+    kiro: kiroAdapter,
+};
+for (const known of KNOWN_AGENTS) {
+    if (known.id === "opencode" ||
+        known.id === "codex" ||
+        known.id === "copilot" ||
+        known.id === "kiro")
+        continue;
+    MODEL_SOURCES[known.name] = unsupported(known.id, known.name);
+}
+/**
+ * Probe every registered model source, fail-soft. Never throws and never
+ * hangs: a bad PATH, missing binary, or timeout resolves an empty result.
+ * Returns results keyed by `Agent.cli` for `GET /api/models`.
+ */
+export async function listModelSources(opts = {}) {
+    const out = {};
+    const selected = opts.clis?.length
+        ? Object.values(MODEL_SOURCES).filter((source) => opts.clis.includes(source.cli))
+        : Object.values(MODEL_SOURCES);
+    await Promise.all(selected.map(async (src) => {
+        try {
+            out[src.cli] = await src.list(opts);
+        }
+        catch {
+            out[src.cli] = { supported: src.supported, models: [], refreshable: src.supported };
+        }
+    }));
+    return out;
+}

package/dist/core/net-probe.d.ts

@@ -0,0 +1,4 @@
+/** True if a TCP connection to `127.0.0.1:port` succeeds within `timeoutMs`. */
+export declare function portListening(port: number, timeoutMs?: number): Promise<boolean>;
+/** Extract the port from a `http://localhost:PORT` style origin, or null if unparseable. */
+export declare function originPort(service: string): number | null;

package/dist/core/net-probe.js

@@ -0,0 +1,20 @@
+/** Tiny TCP reachability probe — used to answer "is anything listening on this local port?" */
+import { connect } from "node:net";
+/** True if a TCP connection to `127.0.0.1:port` succeeds within `timeoutMs`. */
+export function portListening(port, timeoutMs = 800) {
+    return new Promise((resolve) => {
+        const socket = connect({ host: "127.0.0.1", port });
+        const finish = (value) => {
+            socket.destroy();
+            resolve(value);
+        };
+        socket.once("connect", () => finish(true));
+        socket.once("error", () => finish(false));
+        socket.setTimeout(timeoutMs, () => finish(false));
+    });
+}
+/** Extract the port from a `http://localhost:PORT` style origin, or null if unparseable. */
+export function originPort(service) {
+    const m = service.match(/:(\d+)(?:\/|$)/);
+    return m ? Number(m[1]) : null;
+}

package/dist/core/providers/deepinfra.d.ts

@@ -0,0 +1,23 @@
+/**
+ * DeepInfra provider adapter (0313). DeepInfra's "featured" endpoint is a
+ * public, unauthenticated JSON list that already curates a small set of
+ * attractive models with a human-written `description` — exactly the "worth
+ * trying" + "one-line reason" shape the playground sidebar needs, with no
+ * curation logic of our own required.
+ */
+import type { PlaygroundModel, PlaygroundProviderAdapter } from "./types.js";
+interface DeepInfraModel {
+    model_name: string;
+    type: string;
+    description?: string;
+    pricing?: {
+        type?: string;
+        cents_per_input_token?: number;
+        cents_per_output_token?: number;
+    };
+    max_tokens?: number;
+}
+/** Parse DeepInfra's featured-models response into playground models. Exported for tests. */
+export declare function parseDeepInfraFeatured(models: DeepInfraModel[]): PlaygroundModel[];
+export declare const deepinfraProvider: PlaygroundProviderAdapter;
+export {};

package/dist/core/providers/deepinfra.js

@@ -0,0 +1,44 @@
+import { oneLineReason, parseJsonResponse } from "./types.js";
+const FEATURED_URL = "https://api.deepinfra.com/models/featured";
+const FETCH_TIMEOUT_MS = 8000;
+const MAX_MODELS = 12;
+/** DeepInfra prices in cents-per-token; $/1M tokens = cents-per-token * 10,000. */
+function dollarsPerMillion(centsPerToken) {
+    return typeof centsPerToken === "number" && Number.isFinite(centsPerToken) && centsPerToken >= 0
+        ? centsPerToken * 10_000
+        : null;
+}
+/** A malformed/negative `max_tokens` isn't a usable context window. */
+function positiveContextWindow(maxTokens) {
+    return typeof maxTokens === "number" && Number.isFinite(maxTokens) && maxTokens > 0
+        ? maxTokens
+        : null;
+}
+/** Parse DeepInfra's featured-models response into playground models. Exported for tests. */
+export function parseDeepInfraFeatured(models) {
+    return models
+        .filter((m) => m.type === "text-generation" && m.pricing?.type === "tokens")
+        .slice(0, MAX_MODELS)
+        .map((m) => ({
+        id: m.model_name,
+        runId: `deepinfra/${m.model_name}`,
+        name: m.model_name,
+        reason: oneLineReason(m.description, "Featured on DeepInfra."),
+        inputPricePerM: dollarsPerMillion(m.pricing?.cents_per_input_token),
+        outputPricePerM: dollarsPerMillion(m.pricing?.cents_per_output_token),
+        contextWindow: positiveContextWindow(m.max_tokens),
+    }));
+}
+export const deepinfraProvider = {
+    id: "deepinfra",
+    label: "DeepInfra",
+    async fetchModels() {
+        const res = await fetch(FEATURED_URL, { signal: AbortSignal.timeout(FETCH_TIMEOUT_MS) });
+        if (!res.ok)
+            throw new Error(`DeepInfra API returned ${res.status}`);
+        const data = await parseJsonResponse(res, "DeepInfra");
+        if (!Array.isArray(data))
+            throw new Error("DeepInfra API returned an unexpected shape");
+        return parseDeepInfraFeatured(data);
+    },
+};

package/dist/core/providers/index.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Registry + cache for the Model Playground's provider adapters (0313).
+ *
+ * Cache/rate-limit-aware fetching: each provider's live result is cached for
+ * CACHE_TTL_MS so a busy Agents page doesn't hammer DeepInfra/OpenRouter on
+ * every load; concurrent callers during a cold/expired cache share one
+ * in-flight fetch instead of firing duplicate requests. A transient fetch
+ * failure falls back to the last good snapshot when one exists, so a single
+ * provider outage never blanks the whole sidebar — only a cold-cache failure
+ * surfaces as an error to the client, and it never takes the other provider
+ * down with it (each adapter is isolated in its own try/catch).
+ */
+import type { PlaygroundProviderAdapter, PlaygroundProviderGroup } from "./types.js";
+export * from "./types.js";
+export { parseDeepInfraFeatured } from "./deepinfra.js";
+export { curateOpenRouterModels } from "./openrouter.js";
+export declare const PLAYGROUND_PROVIDERS: PlaygroundProviderAdapter[];
+export declare const CACHE_TTL_MS: number;
+/** Test-only hook to reset module-level cache state between test cases. */
+export declare function resetPlaygroundProviderCache(): void;
+/** Fetch (or serve cached) model catalogs from every registered provider. Never throws. */
+export declare function listPlaygroundModels(opts?: {
+    refresh?: boolean;
+}): Promise<PlaygroundProviderGroup[]>;

package/dist/core/providers/index.js

@@ -0,0 +1,59 @@
+import { deepinfraProvider } from "./deepinfra.js";
+import { openrouterProvider } from "./openrouter.js";
+export * from "./types.js";
+export { parseDeepInfraFeatured } from "./deepinfra.js";
+export { curateOpenRouterModels } from "./openrouter.js";
+export const PLAYGROUND_PROVIDERS = [
+    deepinfraProvider,
+    openrouterProvider,
+];
+export const CACHE_TTL_MS = 15 * 60 * 1000;
+const cache = new Map();
+const inFlight = new Map();
+/** Test-only hook to reset module-level cache state between test cases. */
+export function resetPlaygroundProviderCache() {
+    cache.clear();
+    inFlight.clear();
+}
+async function loadProvider(adapter, refresh) {
+    const cached = cache.get(adapter.id);
+    if (!refresh && cached && Date.now() - cached.at < CACHE_TTL_MS)
+        return cached.group;
+    const existing = inFlight.get(adapter.id);
+    if (existing)
+        return existing;
+    const promise = (async () => {
+        try {
+            const models = await adapter.fetchModels();
+            const group = {
+                id: adapter.id,
+                label: adapter.label,
+                models,
+                fetchedAt: new Date().toISOString(),
+            };
+            cache.set(adapter.id, { at: Date.now(), group });
+            return group;
+        }
+        catch (err) {
+            if (cached)
+                return cached.group;
+            const reason = err instanceof Error ? err.message : String(err);
+            return {
+                id: adapter.id,
+                label: adapter.label,
+                models: [],
+                error: reason,
+                fetchedAt: new Date().toISOString(),
+            };
+        }
+        finally {
+            inFlight.delete(adapter.id);
+        }
+    })();
+    inFlight.set(adapter.id, promise);
+    return promise;
+}
+/** Fetch (or serve cached) model catalogs from every registered provider. Never throws. */
+export async function listPlaygroundModels(opts = {}) {
+    return Promise.all(PLAYGROUND_PROVIDERS.map((p) => loadProvider(p, opts.refresh ?? false)));
+}

package/dist/core/providers/openrouter.d.ts

@@ -0,0 +1,28 @@
+/**
+ * OpenRouter provider adapter (0313). Unlike DeepInfra, the public
+ * `GET /api/v1/models` endpoint lists hundreds of models with no "featured"
+ * signal, so curation happens here: drop free/non-text/low-context entries,
+ * then keep the single best (largest context) model per top-level namespace
+ * (e.g. "qwen/…", "deepseek/…") so the sidebar shows variety instead of a
+ * wall of one vendor's SKUs. Never hardcode specific model ids — the live
+ * catalog changes constantly and a stale id would just silently vanish.
+ */
+import type { PlaygroundModel, PlaygroundProviderAdapter } from "./types.js";
+interface OpenRouterModel {
+    id: string;
+    name?: string;
+    description?: string;
+    context_length?: number;
+    architecture?: {
+        input_modalities?: string[];
+        output_modalities?: string[];
+    };
+    pricing?: {
+        prompt?: string;
+        completion?: string;
+    };
+}
+/** Curate + parse OpenRouter's models response into playground models. Exported for tests. */
+export declare function curateOpenRouterModels(models: OpenRouterModel[]): PlaygroundModel[];
+export declare const openrouterProvider: PlaygroundProviderAdapter;
+export {};