konsul-ai 0.2.4

package/dist/index.js

@@ -0,0 +1,616 @@
+#!/usr/bin/env node
+import { readFileSync, writeFileSync } from "node:fs";
+import * as path from "node:path";
+import * as readline from "node:readline";
+import { Council, aggregateScores } from "./council.js";
+import { Router } from "./router.js";
+import { PRESETS, DEFAULT_PRESET, MODELS } from "./config.js";
+const c = {
+    dim: (s) => `\x1b[2m${s}\x1b[0m`,
+    bold: (s) => `\x1b[1m${s}\x1b[0m`,
+    green: (s) => `\x1b[32m${s}\x1b[0m`,
+    yellow: (s) => `\x1b[33m${s}\x1b[0m`,
+    cyan: (s) => `\x1b[36m${s}\x1b[0m`,
+    red: (s) => `\x1b[31m${s}\x1b[0m`,
+    blue: (s) => `\x1b[34m${s}\x1b[0m`,
+};
+function fmtMs(ms) {
+    return ms < 1000 ? `${ms}ms` : `${(ms / 1000).toFixed(1)}s`;
+}
+/** Strip ANSI escape sequences from untrusted model output before printing. */
+function stripAnsi(s) {
+    return s
+        .replace(/\x1b\[[0-9;]*[a-zA-Z]/g, "") // CSI sequences
+        .replace(/\x1b\][^\x07]*\x07/g, "") // OSC sequences (title, hyperlinks)
+        .replace(/\x1b[()][A-Z0-9]/g, "") // charset sequences
+        .replace(/\x1b[^[\]()][A-Za-z]?/g, ""); // remaining single-char escapes
+}
+function loadEnv() {
+    const candidates = [
+        path.join(process.cwd(), ".env"),
+        new URL("../.env", import.meta.url),
+    ];
+    for (const envPath of candidates) {
+        try {
+            const contents = readFileSync(envPath, "utf-8");
+            for (const line of contents.split("\n")) {
+                const match = line.match(/^\s*([^#=]+?)\s*=\s*(.*?)\s*$/);
+                if (match && !process.env[match[1]]) {
+                    process.env[match[1]] = match[2];
+                }
+            }
+            return; // loaded successfully, stop trying
+        }
+        catch { /* try next candidate */ }
+    }
+}
+// ── Arg parsing ─────────────────────────────────────────────────
+const BOOLEAN_FLAGS = new Set([
+    "verbose", "help", "models", "web", "serve",
+    "free", "budget", "balanced", "premium",
+]);
+function parseArgs(argv) {
+    const args = argv.slice(2);
+    const flags = {};
+    const positional = [];
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === "--") {
+            positional.push(...args.slice(i + 1));
+            break;
+        }
+        if (args[i].startsWith("--")) {
+            const [key, ...rest] = args[i].slice(2).split("=");
+            if (rest.length) {
+                flags[key] = rest.join("=");
+            }
+            else if (BOOLEAN_FLAGS.has(key)) {
+                flags[key] = "true";
+            }
+            else if (i + 1 < args.length) {
+                flags[key] = args[++i];
+            }
+            else {
+                flags[key] = "true";
+            }
+        }
+        else {
+            positional.push(args[i]);
+        }
+    }
+    return { flags, positional };
+}
+function parsePort(value) {
+    if (value === undefined)
+        return 3000;
+    if (!/^\d+$/.test(value)) {
+        throw new Error(/^-/.test(value) || value === "true"
+            ? "Missing value for --port. Expected an integer between 0 and 65535."
+            : `Invalid --port value "${value}". Expected an integer between 0 and 65535.`);
+    }
+    const port = Number(value);
+    if (!Number.isInteger(port) || port < 0 || port > 65535) {
+        throw new Error("Invalid --port value. Expected an integer between 0 and 65535.");
+    }
+    return port;
+}
+async function main() {
+    loadEnv();
+    const { flags, positional } = parseArgs(process.argv);
+    if (flags.help !== undefined) {
+        printHelp();
+        process.exit(0);
+    }
+    if (flags.models !== undefined) {
+        printModels();
+        process.exit(0);
+    }
+    // API key
+    if (flags.key) {
+        console.error(c.yellow("Warning: --key exposes your API key in shell history and `ps`. Use OPENROUTER_API_KEY env var or .env file instead."));
+    }
+    const apiKey = flags.key ?? process.env.OPENROUTER_API_KEY;
+    if (!apiKey) {
+        console.error(c.red("Missing API key. Set OPENROUTER_API_KEY in your .env file or environment."));
+        process.exit(1);
+    }
+    // Web UI server mode
+    if (flags.serve !== undefined) {
+        let port;
+        try {
+            port = parsePort(flags.port);
+        }
+        catch (err) {
+            console.error(c.red(err instanceof Error ? err.message : String(err)));
+            process.exit(1);
+        }
+        const { startServer } = await import("./server.js");
+        startServer({ apiKey, port });
+        return;
+    }
+    const config = buildConfig(flags);
+    const verbose = flags.verbose !== undefined;
+    const outputPath = flags.output;
+    const presetName = flags.free !== undefined ? "free" :
+        flags.budget !== undefined ? "budget" :
+            flags.premium !== undefined ? "premium" :
+                flags.balanced !== undefined ? "balanced" :
+                    (flags.members !== undefined || flags.chair !== undefined) ? "custom" :
+                        DEFAULT_PRESET;
+    console.log(c.bold("\n⚖  Konsul\n"));
+    const webTag = config.web ? " · 🌐 web" : "";
+    console.log(c.dim(`${presetName} · ${config.members.map((m) => m.label).join(", ")} · chair: ${config.chair.label} · ${config.rounds} round${config.rounds > 1 ? "s" : ""}${webTag}`));
+    const router = new Router(apiKey);
+    // One-shot or interactive mode
+    const query = positional.join(" ").trim();
+    if (query) {
+        const council = createCouncil(router, config);
+        const ok = await runQuery(council, query, verbose, outputPath);
+        if (!ok)
+            process.exitCode = 1;
+    }
+    else {
+        await interactive(router, config, verbose, outputPath);
+    }
+}
+async function runQuery(council, query, verbose, outputPath) {
+    console.log(c.dim(`\n> ${query}\n`));
+    try {
+        const result = await council.run(query);
+        console.log("\n" + "═".repeat(60));
+        if (!council.streaming) {
+            console.log(c.bold(c.green("\nSynthesis\n")));
+            console.log(stripAnsi(result.synthesis));
+            console.log("\n" + "═".repeat(60));
+        }
+        const scores = aggregateScores(result.opinions, result.reviews);
+        console.log(c.dim("\nRankings: ") + scores.map((s, i) => `${i + 1}. ${s.label} (${s.avgRank.toFixed(1)})`).join("  "));
+        console.log(c.dim(`${fmtMs(result.totalLatencyMs)} · ~${result.tokenEstimate} tokens`));
+        if (verbose) {
+            console.log(c.bold("\n── Individual Opinions ──\n"));
+            for (const op of result.opinions) {
+                console.log(c.cyan(`▸ ${op.model.label}`) + c.dim(` (${fmtMs(op.latencyMs)})`));
+                console.log(stripAnsi(op.content));
+                console.log();
+            }
+        }
+        // Save to file
+        if (outputPath) {
+            const output = {
+                query: result.query,
+                synthesis: result.synthesis,
+                opinions: result.opinions.map((op) => ({
+                    model: op.model.label,
+                    modelId: op.model.id,
+                    content: op.content,
+                    latencyMs: op.latencyMs,
+                })),
+                reviews: result.reviews.map((rev) => ({
+                    reviewer: rev.reviewer.label,
+                    rankings: rev.rankings,
+                    latencyMs: rev.latencyMs,
+                })),
+                scores: scores.map((s) => ({ model: s.label, modelId: s.modelId, avgRank: s.avgRank })),
+                totalLatencyMs: result.totalLatencyMs,
+                tokenEstimate: result.tokenEstimate,
+            };
+            writeFileSync(outputPath, JSON.stringify(output, null, 2) + "\n");
+            console.log(c.dim(`Saved to ${outputPath}`));
+        }
+        return true;
+    }
+    catch (err) {
+        console.error(c.red(`\nError: ${err instanceof Error ? err.message : String(err)}`));
+        return false;
+    }
+}
+function createCouncil(router, config) {
+    return new Council(router, config, (msg) => console.log(msg), (chunk) => process.stdout.write(stripAnsi(chunk)));
+}
+function printConfig(config, presetName) {
+    const webTag = config.web ? " · 🌐 web" : "";
+    console.log(c.dim(`${presetName} · ${config.members.map((m) => m.label).join(", ")} · chair: ${config.chair.label}${webTag}\n`));
+}
+async function interactive(router, initialConfig, verbose, outputPath) {
+    let config = initialConfig;
+    let council = createCouncil(router, config);
+    let currentVerbose = verbose;
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    console.log(c.dim("\nCommands: /tier <free|budget|balanced|premium>  /new-team  /web  /verbose  /clear  /quit|/exit\n"));
+    const prompt = () => {
+        rl.question(c.blue("→ "), async (input) => {
+            const q = input.trim();
+            if (q === "/quit" || q === "/exit") {
+                console.log(c.dim("Bye."));
+                rl.close();
+                return;
+            }
+            if (q === "/clear") {
+                council.clearHistory();
+                console.log(c.dim("History cleared.\n"));
+                prompt();
+                return;
+            }
+            if (q.startsWith("/tier")) {
+                const tier = q.split(/\s+/)[1];
+                if (tier && PRESETS[tier]) {
+                    const savedHistory = council.getHistory();
+                    config = { ...PRESETS[tier], web: config.web };
+                    council = createCouncil(router, config);
+                    council.setHistory(savedHistory);
+                    printConfig(config, tier);
+                }
+                else {
+                    console.log(c.dim(`Usage: /tier <${Object.keys(PRESETS).join("|")}>\n`));
+                }
+                prompt();
+                return;
+            }
+            if (q === "/new-team") {
+                const result = await selectTeam(router, rl);
+                if (result) {
+                    const savedHistory = council.getHistory();
+                    config = {
+                        chair: result.chair,
+                        members: result.members,
+                        rounds: config.rounds,
+                        temperature: config.temperature,
+                        web: config.web,
+                    };
+                    council = createCouncil(router, config);
+                    council.setHistory(savedHistory);
+                    printConfig(config, "custom");
+                }
+                prompt();
+                return;
+            }
+            if (q === "/web") {
+                const enabled = council.toggleWeb();
+                console.log(c.dim(`Web search ${enabled ? "enabled 🌐" : "disabled"}\n`));
+                prompt();
+                return;
+            }
+            if (q === "/verbose") {
+                currentVerbose = !currentVerbose;
+                console.log(c.dim(`Verbose ${currentVerbose ? "on" : "off"}\n`));
+                prompt();
+                return;
+            }
+            if (!q) {
+                prompt();
+                return;
+            }
+            await runQuery(council, q, currentVerbose, outputPath);
+            console.log();
+            prompt();
+        });
+    };
+    prompt();
+}
+function buildConfig(flags) {
+    const presetName = flags.free !== undefined ? "free" :
+        flags.budget !== undefined ? "budget" :
+            flags.premium !== undefined ? "premium" :
+                flags.balanced !== undefined ? "balanced" :
+                    DEFAULT_PRESET;
+    const preset = PRESETS[presetName];
+    const config = { ...preset };
+    if (flags.chair) {
+        config.chair = resolveModel(flags.chair, "chair");
+    }
+    if (flags.members) {
+        const names = flags.members.split(",").map((s) => s.trim());
+        config.members = names.map((n) => resolveModel(n, "member"));
+    }
+    if (flags.rounds) {
+        config.rounds = Math.max(1, parseInt(flags.rounds, 10) || 1);
+    }
+    if (flags.web !== undefined) {
+        config.web = true;
+    }
+    return config;
+}
+function resolveModel(name, role = "member") {
+    if (name.includes("/")) {
+        const parts = name.split("/");
+        const label = parts[parts.length - 1]
+            .replace(/-/g, " ")
+            .replace(/\b\w/g, (ch) => ch.toUpperCase());
+        return { id: name, label, role };
+    }
+    const lower = name.toLowerCase();
+    const entry = Object.entries(MODELS).find(([key]) => key.toLowerCase() === lower);
+    if (entry)
+        return entry[1];
+    const byLabel = Object.values(MODELS).find((m) => m.label.toLowerCase().includes(lower));
+    if (byLabel)
+        return byLabel;
+    const byId = Object.values(MODELS).find((m) => m.id.includes(lower));
+    if (byId)
+        return byId;
+    console.error(c.yellow(`Warning: "${name}" not in catalog, passing as-is to OpenRouter`));
+    return { id: name, label: name, role };
+}
+function printModels() {
+    console.log(c.bold("\n⚖  Konsul — Available Models\n"));
+    for (const [key, model] of Object.entries(MODELS)) {
+        const tag = model.role === "chair" ? c.yellow(" (strong)") : "";
+        console.log(`  ${c.cyan(key.padEnd(16))} ${model.label.padEnd(20)} ${c.dim(model.id)}${tag}`);
+    }
+    console.log(c.dim("\nOr use any OpenRouter model ID directly: --chair=xiaomi/mimo-v2-pro\n"));
+}
+function printHelp() {
+    console.log(`
+${c.bold("⚖  Konsul")} — Multi-LLM debate and synthesis
+
+${c.bold("USAGE")}
+  konsul [options] "your question"
+  konsul                              ${c.dim("interactive mode")}
+
+${c.bold("PRESETS")}
+  --free         4 free models, Trinity Large chair    ${c.dim("$0/run")}
+  --budget       4 cheap models, DeepSeek chair       ${c.dim("~$0.002/run")}
+  --balanced     cheap + mid mix, Gemini Pro chair     ${c.dim("~$0.05/run  (default)")}
+  --premium      mid + strong, Opus chair              ${c.dim("~$0.30+/run")}
+
+${c.bold("OPTIONS")}
+  --chair MODEL        Override the chair (name or provider/model-id)
+  --members A,B,C      Override members (names or provider/model-id)
+  --rounds N           Number of review rounds (default: 1)
+  --output FILE        Save full results as JSON
+  --web                Enable web search for opinions & synthesis
+  --verbose            Show all individual opinions
+  --models             List available models
+  --serve              Start web UI server on localhost (default port 3000)
+  --port N             Set web UI port (use with --serve)
+  --help               Show this help
+
+${c.bold("EXAMPLES")}
+  konsul --budget "What causes inflation?"
+  konsul --chair opus "Proofread this paragraph: ..."
+  konsul --members deepseekV3,sonnet,gpt4o --chair opus "Compare Rust vs Go"
+  konsul --chair xiaomi/mimo-v2-pro "Best neuroscience books?"
+  konsul --web "Latest findings on CRISPR gene therapy 2026"
+  konsul --premium --output result.json "Explain quantum entanglement"
+`);
+}
+const TIER_ORDER = { free: 0, budget: 1, balanced: 2, premium: 3 };
+function tierColor(tier) {
+    switch (tier) {
+        case "free": return c.green;
+        case "budget": return c.cyan;
+        case "balanced": return c.yellow;
+        case "premium": return c.red;
+    }
+}
+function estimateRunCost(m) {
+    // Per-call cost in $ assuming ~2000 input + ~1000 output tokens
+    return (m.promptPrice * 2000 + m.completionPrice * 1000) / 1_000_000;
+}
+function classifyTier(m) {
+    if (m.promptPrice === 0 && m.completionPrice === 0)
+        return "free";
+    const cost = estimateRunCost(m);
+    if (cost < 0.005)
+        return "budget";
+    if (cost <= 0.025)
+        return "balanced";
+    return "premium";
+}
+const EXCLUDE_PATTERNS = /\b(embed|moderat|tts|whisper|dall-e|stable-diffusion|image-gen|audio|speech)\b/i;
+function filterForAcademic(models) {
+    return models.filter((m) => {
+        if (m.modality && !m.modality.includes("->text"))
+            return false;
+        if (m.contextLength < 16_384)
+            return false;
+        if (EXCLUDE_PATTERNS.test(m.name) || EXCLUDE_PATTERNS.test(m.id))
+            return false;
+        return true;
+    });
+}
+function sortByTierThenCost(models) {
+    return [...models].sort((a, b) => {
+        const ta = classifyTier(a);
+        const tb = classifyTier(b);
+        if (ta !== tb)
+            return TIER_ORDER[ta] - TIER_ORDER[tb];
+        return estimateRunCost(a) - estimateRunCost(b);
+    });
+}
+function clearScreen() {
+    process.stdout.write("\x1b[2J\x1b[H");
+}
+function computePageSize() {
+    const rows = process.stdout.rows || 24;
+    return Math.max(5, rows - 13);
+}
+function fmtContext(n) {
+    if (n >= 1_000_000)
+        return `${(n / 1_000_000).toFixed(n % 1_000_000 === 0 ? 0 : 1)}M`;
+    return `${Math.round(n / 1000)}K`;
+}
+function fmtPrice(p) {
+    if (p === 0)
+        return c.green("free".padStart(7));
+    return `$${p.toFixed(2)}`.padStart(7);
+}
+async function selectTeam(router, rl) {
+    const ask = (q) => new Promise((resolve) => rl.question(q, resolve));
+    console.log(c.dim("\n  Fetching models from OpenRouter…"));
+    let allModels;
+    try {
+        allModels = await router.listModels();
+    }
+    catch (err) {
+        console.log(c.red(`  ${err instanceof Error ? err.message : String(err)}\n`));
+        return null;
+    }
+    const academicModels = sortByTierThenCost(filterForAcademic(allModels));
+    if (academicModels.length === 0) {
+        console.log(c.red("  No suitable models available.\n"));
+        return null;
+    }
+    let filtered = academicModels;
+    let searchTerm = null;
+    let page = 0;
+    const picked = [];
+    const pickedIds = new Set();
+    const pageSize = () => computePageSize();
+    const pages = () => Math.ceil(filtered.length / pageSize());
+    const showPage = (hint) => {
+        clearScreen();
+        const ps = pageSize();
+        const start = page * ps;
+        const slice = filtered.slice(start, start + ps);
+        // Header
+        const pageInfo = `Page ${page + 1}/${pages()}`;
+        console.log(c.bold(`\n  ⚖  Select Council Team`) + c.dim(`  ${" ".repeat(Math.max(0, 40 - pageInfo.length))}${pageInfo}`));
+        if (searchTerm) {
+            console.log(c.dim(`  Filtered: "${searchTerm}" (${filtered.length} matches) · /all to reset`));
+        }
+        console.log();
+        // Table with tier section headers
+        let lastTier = null;
+        for (let i = 0; i < slice.length; i++) {
+            const m = slice[i];
+            const globalIdx = start + i + 1;
+            const tier = classifyTier(m);
+            if (tier !== lastTier) {
+                if (lastTier !== null)
+                    console.log();
+                console.log(`  ${tierColor(tier)(tier.toUpperCase())}`);
+                lastTier = tier;
+            }
+            const pickIdx = picked.findIndex((p) => p.id === m.id);
+            const marker = pickIdx === 0 ? c.yellow("★") : pickIdx > 0 ? c.dim(`${pickIdx + 1}`) : " ";
+            const num = String(globalIdx).padStart(4);
+            const name = m.name.length > 34 ? m.name.slice(0, 33) + "…" : m.name.padEnd(34);
+            console.log(`  ${marker}${num}  ${name} ${fmtPrice(m.promptPrice)}  ${fmtPrice(m.completionPrice)}  ${fmtContext(m.contextLength).padStart(5)}`);
+        }
+        // Selection status
+        if (picked.length > 0) {
+            console.log();
+            const parts = picked.map((m, i) => {
+                const tag = i === 0 ? c.yellow("chair") : "member";
+                return `${c.cyan(m.name)} ${c.dim(`(${tag})`)}`;
+            });
+            console.log(`  ${c.bold("Selected:")} ${parts.join(c.dim(", "))}`);
+        }
+        // Footer
+        console.log(c.dim(`\n  Enter: next · /prev · /search <term> · /all · /undo · /done · /quit`));
+        if (hint)
+            console.log(c.dim(`  ${hint}`));
+    };
+    showPage();
+    while (true) {
+        const promptText = picked.length === 0
+            ? "  Add # (1st = chair, rest = members): "
+            : picked.length === 1
+                ? "  Add members (or /done): "
+                : "  Add more (or /done): ";
+        const input = (await ask(c.blue(promptText))).trim();
+        // Enter = next page
+        if (!input) {
+            page = page < pages() - 1 ? page + 1 : 0;
+            showPage();
+            continue;
+        }
+        // Slash commands
+        if (input === "/quit") {
+            clearScreen();
+            return null;
+        }
+        if (input === "/prev") {
+            if (page > 0)
+                page--;
+            showPage();
+            continue;
+        }
+        if (input === "/all") {
+            filtered = academicModels;
+            searchTerm = null;
+            page = 0;
+            showPage();
+            continue;
+        }
+        if (input === "/undo") {
+            const removed = picked.pop();
+            if (removed)
+                pickedIds.delete(removed.id);
+            showPage();
+            continue;
+        }
+        if (input === "/done") {
+            if (picked.length < 2) {
+                showPage("Need at least 2 models (1 chair + 1 member).");
+                continue;
+            }
+            // Confirmation screen
+            clearScreen();
+            console.log(c.bold("\n  ⚖  Confirm Team\n"));
+            const chairTier = classifyTier(picked[0]);
+            console.log(c.bold("  Chair:   ") + c.cyan(picked[0].name) + c.dim(` · ${tierColor(chairTier)(chairTier)} · ${fmtPrice(picked[0].promptPrice).trim()}/${fmtPrice(picked[0].completionPrice).trim()}`));
+            console.log(c.bold("  Members:"));
+            for (let i = 1; i < picked.length; i++) {
+                const m = picked[i];
+                const t = classifyTier(m);
+                console.log(`    • ${c.cyan(m.name)}` + c.dim(` · ${tierColor(t)(t)} · ${fmtPrice(m.promptPrice).trim()}/${fmtPrice(m.completionPrice).trim()}`));
+            }
+            const confirm = (await ask(c.blue("\n  Confirm? [Y/n] "))).trim().toLowerCase();
+            if (confirm && confirm !== "y" && confirm !== "yes") {
+                showPage();
+                continue;
+            }
+            clearScreen();
+            return {
+                chair: { id: picked[0].id, label: picked[0].name, role: "chair" },
+                members: picked.slice(1).map((m) => ({ id: m.id, label: m.name, role: "member" })),
+            };
+        }
+        if (input.startsWith("/search")) {
+            const term = input.slice(7).trim().toLowerCase();
+            if (!term) {
+                showPage();
+                continue;
+            }
+            const matches = academicModels.filter((m) => m.name.toLowerCase().includes(term) || m.id.toLowerCase().includes(term));
+            if (matches.length === 0) {
+                showPage(`No models match "${term}".`);
+                continue;
+            }
+            filtered = matches;
+            searchTerm = term;
+            page = 0;
+            showPage();
+            continue;
+        }
+        if (input.startsWith("/")) {
+            showPage("Commands: /prev /search <term> /all /undo /done /quit");
+            continue;
+        }
+        // Number input — accumulate picks
+        const nums = input.split(/[\s,]+/).map(Number).filter((n) => n > 0 && n <= filtered.length);
+        if (nums.length === 0) {
+            showPage("Enter model numbers to add. e.g. 80 or 3, 7, 12");
+            continue;
+        }
+        let added = 0;
+        for (const n of nums) {
+            const m = filtered[n - 1];
+            if (!pickedIds.has(m.id)) {
+                picked.push(m);
+                pickedIds.add(m.id);
+                added++;
+            }
+        }
+        showPage(added === 0 ? "Already selected." : undefined);
+        continue;
+    }
+}
+main().catch((err) => {
+    console.error(c.red(err.message));
+    process.exit(1);
+});

package/dist/router.d.ts

@@ -0,0 +1,61 @@
+import type { RouterMessage } from "./types.js";
+export interface RemoteModel {
+    id: string;
+    name: string;
+    promptPrice: number;
+    completionPrice: number;
+    contextLength: number;
+    modality: string | null;
+}
+export declare class Router {
+    private apiKey;
+    private timeoutMs;
+    constructor(apiKey: string, timeoutMs?: number);
+    private buildHeaders;
+    private handleFetchError;
+    private buildSignal;
+    private checkResponse;
+    complete(model: string, messages: RouterMessage[], opts?: {
+        temperature?: number;
+        maxTokens?: number;
+        plugins?: {
+            id: string;
+        }[];
+        signal?: AbortSignal;
+    }): Promise<{
+        content: string;
+        usage: {
+            prompt: number;
+            completion: number;
+        };
+    }>;
+    /** Streaming completion — calls onChunk for each token as it arrives. */
+    completeStream(model: string, messages: RouterMessage[], opts: {
+        temperature?: number;
+        maxTokens?: number;
+        plugins?: {
+            id: string;
+        }[];
+        signal?: AbortSignal;
+    }, onChunk: (text: string) => void): Promise<{
+        content: string;
+        usage: {
+            prompt: number;
+            completion: number;
+        };
+    }>;
+    /** Fetch available models from OpenRouter. */
+    listModels(): Promise<RemoteModel[]>;
+    /** Fire completions in parallel, settle all (don't fail-fast). */
+    parallel<T>(tasks: (() => Promise<T>)[], staggerMs?: number): Promise<PromiseSettledResult<T>[]>;
+    /**
+     * Like parallel(), but proceeds early once minResults have fulfilled,
+     * giving remaining tasks a short grace period before skipping them.
+     */
+    parallelRace<T>(tasks: ((signal?: AbortSignal) => Promise<T>)[], opts?: {
+        staggerMs?: number;
+        minResults?: number;
+        graceMs?: number;
+        signal?: AbortSignal;
+    }): Promise<PromiseSettledResult<T>[]>;
+}