konsul-ai 0.2.4

package/dist/router.js

@@ -0,0 +1,268 @@
+import { combineSignals, isAbortError, normalizeAbortReason } from "./abort.js";
+const OPENROUTER_BASE = process.env.OPENROUTER_BASE_URL || "https://openrouter.ai/api/v1";
+export class Router {
+    apiKey;
+    timeoutMs;
+    constructor(apiKey, timeoutMs = 60_000) {
+        this.apiKey = apiKey;
+        this.timeoutMs = timeoutMs;
+    }
+    buildHeaders() {
+        return {
+            Authorization: `Bearer ${this.apiKey}`,
+            "Content-Type": "application/json",
+            "HTTP-Referer": "https://github.com/model-council",
+            "X-Title": "model-council",
+        };
+    }
+    handleFetchError(model, err, signal) {
+        if (err instanceof DOMException && err.name === "TimeoutError") {
+            throw new Error(`${model}: timed out after ${this.timeoutMs / 1000}s`);
+        }
+        if (isAbortError(err)) {
+            throw normalizeAbortReason(err);
+        }
+        if (signal?.aborted) {
+            throw normalizeAbortReason(signal.reason, `${model}: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        throw new Error(`${model}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    buildSignal(timeoutMs, signal) {
+        return signal ? AbortSignal.any([AbortSignal.timeout(timeoutMs), signal]) : AbortSignal.timeout(timeoutMs);
+    }
+    async checkResponse(model, res) {
+        if (!res.ok) {
+            const body = await res.text();
+            const hint = res.status === 401 ? " (check your OPENROUTER_API_KEY)" :
+                res.status === 402 ? " (insufficient credits — top up at openrouter.ai/credits)" :
+                    res.status === 429 ? " (rate limited — wait a moment and retry)" :
+                        res.status === 503 ? " (model temporarily unavailable)" :
+                            "";
+            throw new Error(`${model}: ${res.status}${hint} — ${body}`);
+        }
+    }
+    async complete(model, messages, opts = {}) {
+        let res;
+        try {
+            res = await fetch(`${OPENROUTER_BASE}/chat/completions`, {
+                method: "POST",
+                headers: this.buildHeaders(),
+                body: JSON.stringify({
+                    model,
+                    messages,
+                    temperature: opts.temperature ?? 0.7,
+                    max_tokens: opts.maxTokens ?? 8192,
+                    ...(opts.plugins?.length ? { plugins: opts.plugins } : {}),
+                }),
+                signal: this.buildSignal(this.timeoutMs, opts.signal),
+            });
+        }
+        catch (err) {
+            this.handleFetchError(model, err, opts.signal);
+        }
+        await this.checkResponse(model, res);
+        const data = (await res.json());
+        const content = data.choices?.[0]?.message?.content ?? "";
+        const usage = data.usage ?? { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 };
+        return {
+            content,
+            usage: { prompt: usage.prompt_tokens, completion: usage.completion_tokens },
+        };
+    }
+    /** Streaming completion — calls onChunk for each token as it arrives. */
+    async completeStream(model, messages, opts, onChunk) {
+        let res;
+        try {
+            res = await fetch(`${OPENROUTER_BASE}/chat/completions`, {
+                method: "POST",
+                headers: this.buildHeaders(),
+                body: JSON.stringify({
+                    model,
+                    messages,
+                    temperature: opts.temperature ?? 0.7,
+                    max_tokens: opts.maxTokens ?? 8192,
+                    stream: true,
+                    ...(opts.plugins?.length ? { plugins: opts.plugins } : {}),
+                }),
+                signal: this.buildSignal(this.timeoutMs * 2, opts.signal),
+            });
+        }
+        catch (err) {
+            this.handleFetchError(model, err, opts.signal);
+        }
+        await this.checkResponse(model, res);
+        if (!res.body) {
+            throw new Error(`${model}: response body is empty`);
+        }
+        const reader = res.body.getReader();
+        const decoder = new TextDecoder();
+        let full = "";
+        let buffer = "";
+        let usage = { prompt: 0, completion: 0 };
+        const handleSseLine = (line) => {
+            const normalized = line.trim();
+            if (!normalized.startsWith("data: "))
+                return;
+            const data = normalized.slice(6).trim();
+            if (data === "[DONE]")
+                return;
+            try {
+                const parsed = JSON.parse(data);
+                const delta = parsed.choices?.[0]?.delta?.content ?? "";
+                if (delta) {
+                    full += delta;
+                    onChunk(delta);
+                }
+                if (parsed.usage) {
+                    usage = {
+                        prompt: parsed.usage.prompt_tokens ?? 0,
+                        completion: parsed.usage.completion_tokens ?? 0,
+                    };
+                }
+            }
+            catch { /* skip malformed SSE chunks */ }
+        };
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                buffer += decoder.decode(value, { stream: true });
+                const lines = buffer.split("\n");
+                buffer = lines.pop();
+                for (const line of lines) {
+                    handleSseLine(line);
+                }
+            }
+            if (buffer.trim()) {
+                handleSseLine(buffer);
+            }
+        }
+        finally {
+            reader.releaseLock();
+        }
+        return { content: full, usage };
+    }
+    /** Fetch available models from OpenRouter. */
+    async listModels() {
+        let res;
+        try {
+            res = await fetch(`${OPENROUTER_BASE}/models`, {
+                headers: this.buildHeaders(),
+                signal: AbortSignal.timeout(15_000),
+            });
+        }
+        catch (err) {
+            throw new Error(`Failed to fetch models: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        if (!res.ok) {
+            throw new Error(`Failed to fetch models: HTTP ${res.status}`);
+        }
+        const body = (await res.json());
+        return body.data
+            .filter((m) => {
+            const pp = parseFloat(m.pricing?.prompt ?? "");
+            const cp = parseFloat(m.pricing?.completion ?? "");
+            return !isNaN(pp) && !isNaN(cp) && (m.context_length ?? 0) > 0;
+        })
+            .map((m) => ({
+            id: m.id,
+            name: m.name,
+            promptPrice: parseFloat(m.pricing.prompt) * 1_000_000,
+            completionPrice: parseFloat(m.pricing.completion) * 1_000_000,
+            contextLength: m.context_length,
+            modality: m.architecture?.modality ?? null,
+        }))
+            .sort((a, b) => a.promptPrice - b.promptPrice || a.name.localeCompare(b.name));
+    }
+    /** Fire completions in parallel, settle all (don't fail-fast). */
+    async parallel(tasks, staggerMs = 0) {
+        if (staggerMs <= 0) {
+            return Promise.allSettled(tasks.map((fn) => fn()));
+        }
+        const delay_ = (ms) => new Promise((r) => setTimeout(r, ms));
+        return Promise.allSettled(tasks.map(async (fn, i) => {
+            if (i > 0)
+                await delay_(i * staggerMs);
+            return fn();
+        }));
+    }
+    /**
+     * Like parallel(), but proceeds early once minResults have fulfilled,
+     * giving remaining tasks a short grace period before skipping them.
+     */
+    async parallelRace(tasks, opts = {}) {
+        if (tasks.length === 0)
+            return [];
+        const { staggerMs = 0, minResults = tasks.length, graceMs = 5000, signal } = opts;
+        const target = Math.min(minResults, tasks.length);
+        const controllers = tasks.map(() => new AbortController());
+        const promises = tasks.map(async (fn, i) => {
+            const taskSignal = combineSignals(controllers[i].signal, signal);
+            try {
+                if (staggerMs > 0 && i > 0)
+                    await delay(i * staggerMs, taskSignal);
+                return await fn(taskSignal);
+            }
+            catch (err) {
+                if (taskSignal?.aborted)
+                    throw normalizeAbortReason(taskSignal.reason);
+                throw err;
+            }
+        });
+        const results = new Array(tasks.length).fill(null);
+        let fulfilled = 0;
+        const tracked = promises.map((p, i) => p.then((value) => {
+            if (results[i] !== null)
+                return;
+            results[i] = { status: "fulfilled", value };
+            fulfilled++;
+        }, (reason) => {
+            if (results[i] !== null)
+                return;
+            results[i] = { status: "rejected", reason };
+        }));
+        const allDone = Promise.allSettled(tracked);
+        const ready = new Promise((resolve) => {
+            let graceStarted = false;
+            const check = () => {
+                if (!graceStarted && fulfilled >= target) {
+                    graceStarted = true;
+                    if (graceMs <= 0) {
+                        resolve();
+                        return;
+                    }
+                    setTimeout(resolve, graceMs);
+                }
+            };
+            tracked.forEach((t) => t.then(check));
+        });
+        await Promise.race([allDone, ready]);
+        for (let i = 0; i < results.length; i++) {
+            if (results[i] !== null)
+                continue;
+            const reason = new Error("Skipped (cancelled after grace period)");
+            results[i] = { status: "rejected", reason };
+            controllers[i].abort(new DOMException(reason.message, "AbortError"));
+        }
+        return results;
+    }
+}
+function delay(ms, signal) {
+    return new Promise((resolve, reject) => {
+        if (signal?.aborted) {
+            reject(normalizeAbortReason(signal.reason));
+            return;
+        }
+        const onAbort = () => {
+            clearTimeout(timer);
+            signal?.removeEventListener("abort", onAbort);
+            reject(normalizeAbortReason(signal?.reason));
+        };
+        const timer = setTimeout(() => {
+            signal?.removeEventListener("abort", onAbort);
+            resolve();
+        }, ms);
+        signal?.addEventListener("abort", onAbort, { once: true });
+    });
+}

package/dist/server.d.ts

@@ -0,0 +1,6 @@
+import { type Server } from "node:http";
+export declare function startServer(opts: {
+    apiKey: string;
+    port?: number;
+    host?: string;
+}): Server;

package/dist/server.js

@@ -0,0 +1,233 @@
+import { createServer } from "node:http";
+import { readFileSync } from "node:fs";
+import { Council, aggregateScores } from "./council.js";
+import { Router } from "./router.js";
+import { PRESETS, DEFAULT_PRESET, MODELS } from "./config.js";
+const MIME = {
+    ".html": "text/html; charset=utf-8",
+    ".css": "text/css; charset=utf-8",
+    ".js": "text/javascript; charset=utf-8",
+};
+const MAX_BODY_BYTES = 1024 * 1024;
+class PayloadTooLargeError extends Error {
+    constructor(message = "Request body too large") {
+        super(message);
+        this.name = "PayloadTooLargeError";
+    }
+}
+function resolveWebDir() {
+    return new URL("web/", import.meta.url);
+}
+function serveStatic(res, file) {
+    const ext = file.slice(file.lastIndexOf("."));
+    const mime = MIME[ext];
+    if (!mime) {
+        res.writeHead(404).end("Not found");
+        return;
+    }
+    try {
+        const content = readFileSync(new URL(file, resolveWebDir()), "utf-8");
+        res.writeHead(200, { "Content-Type": mime }).end(content);
+    }
+    catch {
+        res.writeHead(404).end("Not found");
+    }
+}
+function json(res, status, data) {
+    res.writeHead(status, { "Content-Type": "application/json" }).end(JSON.stringify(data));
+}
+function discardBody(req) {
+    req.on("error", () => { });
+    req.resume();
+}
+function firstHeader(value) {
+    return Array.isArray(value) ? value[0] : value;
+}
+function hasJsonContentType(req) {
+    const contentType = firstHeader(req.headers["content-type"]);
+    if (!contentType)
+        return false;
+    return contentType.split(";", 1)[0].trim().toLowerCase() === "application/json";
+}
+function isAllowedBrowserOrigin(req) {
+    const origin = firstHeader(req.headers.origin);
+    if (!origin)
+        return true;
+    try {
+        const url = new URL(origin);
+        return (url.protocol === "http:" &&
+            (url.hostname === "localhost" || url.hostname === "127.0.0.1" || url.hostname === "[::1]"));
+    }
+    catch {
+        return false;
+    }
+}
+function getContentLength(req) {
+    const contentLength = firstHeader(req.headers["content-length"]);
+    if (!contentLength || !/^\d+$/.test(contentLength))
+        return undefined;
+    return Number.parseInt(contentLength, 10);
+}
+function sendSSE(res, event, data) {
+    if (res.destroyed || res.writableEnded)
+        return;
+    try {
+        res.write(`event: ${event}\ndata: ${JSON.stringify(data)}\n\n`);
+    }
+    catch {
+        // Ignore writes after the client has already gone away.
+    }
+}
+async function readBody(req) {
+    const chunks = [];
+    let totalBytes = 0;
+    for await (const chunk of req) {
+        const buffer = chunk;
+        totalBytes += buffer.length;
+        if (totalBytes > MAX_BODY_BYTES) {
+            throw new PayloadTooLargeError(`Request body exceeds ${MAX_BODY_BYTES} bytes`);
+        }
+        chunks.push(buffer);
+    }
+    return Buffer.concat(chunks).toString("utf-8");
+}
+function buildConfig(preset, web) {
+    const base = PRESETS[preset] ?? PRESETS[DEFAULT_PRESET];
+    return {
+        members: [...base.members],
+        chair: { ...base.chair },
+        rounds: base.rounds,
+        temperature: base.temperature,
+        web,
+    };
+}
+function presetsInfo() {
+    const info = {};
+    for (const [name, cfg] of Object.entries(PRESETS)) {
+        info[name] = {
+            members: cfg.members.map((m) => m.label),
+            chair: cfg.chair.label,
+            rounds: cfg.rounds,
+        };
+    }
+    return info;
+}
+function modelsInfo() {
+    return Object.values(MODELS).map((m) => ({ id: m.id, label: m.label, role: m.role }));
+}
+async function handleCouncil(req, res, apiKey) {
+    if (!hasJsonContentType(req)) {
+        discardBody(req);
+        json(res, 415, { error: "Content-Type must be application/json" });
+        return;
+    }
+    if (!isAllowedBrowserOrigin(req)) {
+        discardBody(req);
+        json(res, 403, { error: "Origin not allowed" });
+        return;
+    }
+    const contentLength = getContentLength(req);
+    if (contentLength !== undefined && contentLength > MAX_BODY_BYTES) {
+        discardBody(req);
+        json(res, 413, { error: `Request body must be <= ${MAX_BODY_BYTES} bytes` });
+        return;
+    }
+    let body;
+    try {
+        body = JSON.parse(await readBody(req));
+    }
+    catch (err) {
+        if (err instanceof PayloadTooLargeError) {
+            json(res, 413, { error: `Request body must be <= ${MAX_BODY_BYTES} bytes` });
+            return;
+        }
+        json(res, 400, { error: "Invalid JSON" });
+        return;
+    }
+    const query = body.query?.trim();
+    if (!query) {
+        json(res, 400, { error: "Missing query" });
+        return;
+    }
+    const presetName = body.preset && body.preset in PRESETS ? body.preset : DEFAULT_PRESET;
+    const config = buildConfig(presetName, body.web);
+    const router = new Router(apiKey);
+    const disconnect = new AbortController();
+    const abortForDisconnect = () => {
+        if (disconnect.signal.aborted || res.writableEnded)
+            return;
+        disconnect.abort(new DOMException("Client disconnected", "AbortError"));
+    };
+    const cleanupDisconnect = () => {
+        req.off("aborted", abortForDisconnect);
+        res.off("close", abortForDisconnect);
+    };
+    req.once("aborted", abortForDisconnect);
+    res.once("close", abortForDisconnect);
+    res.writeHead(200, {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        "Connection": "keep-alive",
+    });
+    const council = new Council(router, config, (msg) => sendSSE(res, "log", { message: msg }), (chunk) => sendSSE(res, "stream", { text: chunk }));
+    if (body.history?.length) {
+        council.setHistory(body.history);
+    }
+    try {
+        const result = await council.run(query, disconnect.signal);
+        if (disconnect.signal.aborted)
+            return;
+        const scores = aggregateScores(result.opinions, result.reviews);
+        sendSSE(res, "result", { ...result, scores });
+    }
+    catch (err) {
+        if (disconnect.signal.aborted)
+            return;
+        const message = err instanceof Error ? err.message : String(err);
+        sendSSE(res, "error", { message });
+    }
+    finally {
+        cleanupDisconnect();
+    }
+    res.end();
+}
+export function startServer(opts) {
+    const { apiKey, port = 3000, host = "127.0.0.1" } = opts;
+    const server = createServer(async (req, res) => {
+        const url = new URL(req.url ?? "/", "http://127.0.0.1");
+        const method = req.method ?? "GET";
+        // Static files
+        if (method === "GET" && (url.pathname === "/" || url.pathname === "/index.html")) {
+            serveStatic(res, "index.html");
+            return;
+        }
+        if (method === "GET" && url.pathname === "/style.css") {
+            serveStatic(res, "style.css");
+            return;
+        }
+        if (method === "GET" && url.pathname === "/app.js") {
+            serveStatic(res, "app.js");
+            return;
+        }
+        // API routes
+        if (method === "GET" && url.pathname === "/api/presets") {
+            json(res, 200, presetsInfo());
+            return;
+        }
+        if (method === "GET" && url.pathname === "/api/models") {
+            json(res, 200, modelsInfo());
+            return;
+        }
+        if (method === "POST" && url.pathname === "/api/council") {
+            await handleCouncil(req, res, apiKey);
+            return;
+        }
+        json(res, 404, { error: "Not found" });
+    });
+    server.listen(port, host, () => {
+        const address = server.address();
+        const resolvedPort = typeof address === "object" && address ? address.port : port;
+        console.log(`\n⚖  Konsul web UI running at http://localhost:${resolvedPort}\n`);
+    });
+    return server;
+}

package/dist/types.d.ts

@@ -0,0 +1,52 @@
+export interface ModelConfig {
+    id: string;
+    label: string;
+    role: "member" | "chair";
+}
+export interface CouncilConfig {
+    members: ModelConfig[];
+    chair: ModelConfig;
+    rounds: number;
+    temperature: number;
+    web?: boolean;
+}
+export interface Opinion {
+    model: ModelConfig;
+    content: string;
+    latencyMs: number;
+}
+export interface Review {
+    reviewer: ModelConfig;
+    rankings: {
+        modelId: string;
+        label: string;
+        rank: number;
+        reasoning: string;
+    }[];
+    latencyMs: number;
+}
+export interface CouncilResult {
+    query: string;
+    opinions: Opinion[];
+    reviews: Review[];
+    synthesis: string;
+    totalLatencyMs: number;
+    tokenEstimate: number;
+}
+export interface RouterMessage {
+    role: "system" | "user" | "assistant";
+    content: string;
+}
+export interface RouterResponse {
+    id: string;
+    choices: {
+        message: {
+            content: string;
+        };
+    }[];
+    usage?: {
+        prompt_tokens: number;
+        completion_tokens: number;
+        total_tokens: number;
+    };
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};