@aistupidlevel/mcp 0.0.0-stage → 0.1.0

package/dist/data-api.js

@@ -0,0 +1,216 @@
+/**
+ * Client for the ASL Data API (https://aistupidlevel.info/api/v1).
+ *
+ * A free key allows 10 requests a day and 1 a minute, so every response is cached in memory
+ * (default 15 minutes, keyed by URL), identical requests in flight are shared, refusals that will
+ * not change (403, 404) are cached too, and once the daily quota is spent no further request is
+ * sent until it resets. When a request cannot be made, an older cached answer is served with a
+ * note saying how old it is.
+ */
+import { LINKS, VERSION } from './config.js';
+import { ToolError } from './errors.js';
+/** How long an expired answer may still be served when the API cannot be reached. */
+const STALE_LIMIT_MS = 24 * 60 * 60 * 1000;
+const sleep = (ms) => new Promise(r => setTimeout(r, ms));
+const nextUtcMidnight = () => {
+    const d = new Date();
+    return Date.UTC(d.getUTCFullYear(), d.getUTCMonth(), d.getUTCDate() + 1);
+};
+const norm = (s) => s.trim().toLowerCase().replace(/[\s_]+/g, '-');
+export class DataApi {
+    cfg;
+    cache = new Map();
+    inflight = new Map();
+    models = new Map();
+    modelsSeenAt = 0;
+    /** The newest leaderboard (/models) answer, for showing a model's row without a request. */
+    lastBoard = null;
+    dailyBlockedUntil = 0;
+    dailyBlockedMessage = '';
+    lastQuota = null;
+    /** Network requests actually sent (for tests and diagnostics). */
+    requestsSent = 0;
+    constructor(cfg) {
+        this.cfg = cfg;
+    }
+    get hasKey() { return !!this.cfg.dataKey; }
+    /** The quota from the newest response, or null once its day is over. */
+    get quota() {
+        return this.lastQuota && (this.lastQuota.resetAt ?? Infinity) > Date.now() ? this.lastQuota : null;
+    }
+    /** The error a data tool returns when no Data API key is configured. */
+    missingKeyError() {
+        const why = this.cfg.warnings.data ? `${this.cfg.warnings.data} ` : '';
+        return new ToolError(`${why}This tool reads the AI Stupid Level Data API and needs a Data API key (asl_live_…). ` +
+            `Create one at ${LINKS.dataKeys} (a free key allows 10 requests a day and 1 a minute), then set ` +
+            `ASL_DATA_KEY in the "env" section of this MCP server's configuration and restart the client. ` +
+            `API documentation: ${LINKS.dataDocs}`);
+    }
+    /**
+     * GET a Data API path. `query` values that are undefined are left out, so "let the API choose"
+     * and an explicit value are cached separately, exactly as the API would answer them.
+     */
+    async get(path, query = {}) {
+        if (!this.cfg.dataKey)
+            throw this.missingKeyError();
+        const qs = Object.entries(query)
+            .filter(([, v]) => v !== undefined && v !== '')
+            .sort(([a], [b]) => a.localeCompare(b))
+            .map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(String(v))}`)
+            .join('&');
+        const url = `${this.cfg.dataBaseURL}${path}${qs ? `?${qs}` : ''}`;
+        const now = Date.now();
+        const hit = this.cache.get(url);
+        if (hit && hit.expires > now) {
+            if (hit.error)
+                throw new ToolError(hit.error);
+            return { body: hit.body, fetchedAt: hit.fetchedAt, cached: true };
+        }
+        if (this.dailyBlockedUntil > now)
+            return this.staleOr(url, this.dailyBlockedMessage);
+        let pending = this.inflight.get(url);
+        if (!pending) {
+            pending = this.fetchUrl(url).finally(() => this.inflight.delete(url));
+            this.inflight.set(url, pending);
+        }
+        return pending;
+    }
+    /** Resolve a model given as a numeric id, a model name (claude-opus-5-5) or a display name. */
+    async resolveModel(input) {
+        const raw = String(input).trim();
+        if (/^\d+$/.test(raw)) {
+            const id = Number(raw);
+            for (const m of this.models.values())
+                if (m.id === id)
+                    return m;
+            return { id, name: raw, displayName: null };
+        }
+        if (!this.models.size || Date.now() - this.modelsSeenAt > STALE_LIMIT_MS) {
+            // One request teaches us every id; later lookups are free.
+            await this.get('/models');
+        }
+        const want = norm(raw);
+        const exact = this.models.get(want);
+        if (exact)
+            return exact;
+        const unique = [...new Map([...this.models.values()].map(m => [m.id, m])).values()];
+        const partial = unique.filter(m => norm(m.name).includes(want) || (m.displayName && norm(m.displayName).includes(want)));
+        if (partial.length === 1)
+            return partial[0];
+        const list = (partial.length ? partial : unique).map(m => `${m.name} (id ${m.id})`).join(', ');
+        throw new ToolError(partial.length
+            ? `"${raw}" matches more than one model: ${list}. Pass the exact name or the numeric id.`
+            : `No tracked model matches "${raw}". Tracked models: ${list}.`);
+    }
+    /** Every model the last /models answer listed (no request is made). */
+    knownModel(id) {
+        for (const m of this.models.values())
+            if (m.id === id)
+                return m;
+        return undefined;
+    }
+    learnModels(body) {
+        if (!Array.isArray(body?.data))
+            return;
+        for (const m of body.data) {
+            const id = Number(m?.id);
+            if (!Number.isFinite(id) || typeof m?.name !== 'string')
+                continue;
+            const ref = { id, name: m.name, displayName: typeof m.displayName === 'string' ? m.displayName : null };
+            this.models.set(norm(m.name), ref);
+            if (ref.displayName)
+                this.models.set(norm(ref.displayName), ref);
+        }
+        this.modelsSeenAt = Date.now();
+        this.lastBoard = body;
+    }
+    staleOr(url, message) {
+        const old = this.cache.get(url);
+        if (old?.body && Date.now() - old.fetchedAt < STALE_LIMIT_MS) {
+            return { body: old.body, fetchedAt: old.fetchedAt, cached: true, staleReason: message };
+        }
+        throw new ToolError(message);
+    }
+    readQuota(h) {
+        const limit = Number(h.get('x-ratelimit-limit'));
+        const remaining = Number(h.get('x-ratelimit-remaining'));
+        const reset = Number(h.get('x-ratelimit-reset'));
+        // The daily quota's reset is an epoch timestamp. The per-minute limiter sends the same header
+        // names with its own values (limit 1, reset in seconds), which say nothing about the day.
+        if (h.get('x-ratelimit-limit') !== null && Number.isFinite(limit) && Number.isFinite(remaining) && reset > 1e9) {
+            this.lastQuota = { limit, remaining, resetAt: reset * 1000 };
+        }
+    }
+    async fetchUrl(url, attempt = 0) {
+        let res;
+        try {
+            this.requestsSent++;
+            res = await this.cfg.fetch(url, {
+                method: 'GET',
+                headers: { Authorization: `Bearer ${this.cfg.dataKey}`, Accept: 'application/json', 'User-Agent': `aistupidlevel-mcp/${VERSION}` },
+                signal: AbortSignal.timeout(30_000),
+            });
+        }
+        catch (err) {
+            return this.staleOr(url, `Could not reach the AI Stupid Level Data API (${err?.message ?? err}). Try again shortly.`);
+        }
+        this.readQuota(res.headers);
+        let body = null;
+        const text = await res.text().catch(() => '');
+        try {
+            body = text ? JSON.parse(text) : null;
+        }
+        catch { /* not JSON */ }
+        const now = Date.now();
+        if (res.ok && body && typeof body === 'object') {
+            const entry = { body, fetchedAt: now, expires: now + this.cfg.cacheTtlMs };
+            this.cache.set(url, entry);
+            if (/\/models(\?|$)/.test(url))
+                this.learnModels(body);
+            return { body, fetchedAt: now, cached: false };
+        }
+        const apiMessage = typeof body?.message === 'string' ? body.message : '';
+        const code = typeof body?.error === 'string' ? body.error : '';
+        if (res.status === 401) {
+            throw new ToolError(`The Data API rejected the key in ASL_DATA_KEY (${code || 'HTTP 401'}${apiMessage ? `: ${apiMessage}` : ''}). ` +
+                `Check it, or create a new one at ${LINKS.dataKeys}.`);
+        }
+        if (res.status === 429) {
+            const quota = this.lastQuota;
+            if (code === 'quota_exceeded') {
+                this.dailyBlockedUntil = quota?.resetAt && quota.resetAt > now ? quota.resetAt : nextUtcMidnight();
+                const mins = Math.max(1, Math.round((this.dailyBlockedUntil - now) / 60_000));
+                this.dailyBlockedMessage =
+                    `The Data API daily limit for this key is used up. ${apiMessage || 'The quota resets at 00:00 UTC.'} ` +
+                        `That is in about ${mins >= 60 ? `${Math.floor(mins / 60)} h ${mins % 60} min` : `${mins} min`}; until then this server sends no more requests. ` +
+                        `A free key allows 10 requests a day and 1 a minute; paid plans raise this to 10,000 a day or more: ${LINKS.pricing}`;
+                return this.staleOr(url, this.dailyBlockedMessage);
+            }
+            const ra = Number(res.headers.get('retry-after'));
+            const wait = Number.isFinite(ra) && ra > 0 ? ra * 1000 : 60_000;
+            if (attempt === 0 && wait <= this.cfg.maxWaitMs) {
+                await sleep(wait);
+                return this.fetchUrl(url, 1);
+            }
+            return this.staleOr(url, `The Data API per-minute limit was reached; try again in ${Math.ceil(wait / 1000)} s. ` +
+                `A free key allows 1 request a minute and 10 a day (answers are cached here for ${Math.round(this.cfg.cacheTtlMs / 60_000)} min, ` +
+                `so repeating a question costs nothing). Higher limits: ${LINKS.pricing}`);
+        }
+        if (res.status === 403 || res.status === 404 || res.status === 400) {
+            let msg;
+            if (code === 'latest_requires_plan') {
+                msg = `${apiMessage || 'The latest benchmark run is part of the paid plans.'} Plans: ${typeof body?.pricing === 'string' ? body.pricing : LINKS.pricing}`;
+            }
+            else if (code === 'model_not_found' || res.status === 404) {
+                msg = `AI Stupid Level does not track a model with that id${body?.model ? ` (${body.model})` : ''}. Use get_leaderboard to see the tracked models and their ids.`;
+            }
+            else {
+                msg = `The Data API refused the request (HTTP ${res.status}${code ? ` ${code}` : ''}${apiMessage ? `: ${apiMessage}` : ''}).`;
+            }
+            // The answer will not change within the cache period; asking again would only spend quota.
+            this.cache.set(url, { error: msg, fetchedAt: now, expires: now + this.cfg.cacheTtlMs });
+            throw new ToolError(msg);
+        }
+        return this.staleOr(url, `The AI Stupid Level Data API answered HTTP ${res.status}${apiMessage ? ` (${apiMessage})` : ''}. Try again shortly.`);
+    }
+}

package/dist/errors.d.ts

@@ -0,0 +1,4 @@
+/** A failure the tool reports to the client as a tool error (isError: true), in plain words. */
+export declare class ToolError extends Error {
+    constructor(message: string);
+}

package/dist/errors.js

@@ -0,0 +1,7 @@
+/** A failure the tool reports to the client as a tool error (isError: true), in plain words. */
+export class ToolError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'ToolError';
+    }
+}

package/dist/format.d.ts

@@ -0,0 +1,20 @@
+/** Plain-text rendering of API answers: compact, readable by people and models alike. */
+import type { DataResult, Quota } from './data-api.js';
+/** 2026-10-20T06:00:00.239Z → 2026-10-20 06:00 UTC */
+export declare function when(v: unknown): string;
+export declare function ago(ms: number): string;
+export declare const pct: (v: unknown) => string;
+export declare const num: (v: unknown, digits?: number) => string;
+/** "Claude Opus 5.5 (claude-opus-5-5, id 292)" */
+export declare function modelLabel(m: {
+    displayName?: unknown;
+    name?: unknown;
+    modelName?: unknown;
+    id?: unknown;
+    modelId?: unknown;
+}): string;
+/** Source line, cache age and quota left: appended to every Data API answer. */
+export declare function footer(r: DataResult, quota: Quota | null): string;
+/** $0.012, $0.00075, $1.25: two significant digits below a dollar. */
+export declare const usd: (v: number) => string;
+export declare function truncate(s: string, max: number): string;

package/dist/format.js

@@ -0,0 +1,47 @@
+/** 2026-10-20T06:00:00.239Z → 2026-10-20 06:00 UTC */
+export function when(v) {
+    if (v === null || v === undefined || v === '')
+        return 'unknown';
+    const d = new Date(typeof v === 'string' && /^\d{4}-\d\d-\d\d \d\d:\d\d:\d\d$/.test(v) ? `${v.replace(' ', 'T')}Z` : v);
+    if (Number.isNaN(d.getTime()))
+        return String(v);
+    return `${d.toISOString().slice(0, 16).replace('T', ' ')} UTC`;
+}
+export function ago(ms) {
+    const s = Math.max(0, Math.round(ms / 1000));
+    if (s < 90)
+        return `${s} s`;
+    const m = Math.round(s / 60);
+    if (m < 90)
+        return `${m} min`;
+    const h = Math.round(m / 60);
+    return h < 48 ? `${h} h` : `${Math.round(h / 24)} days`;
+}
+export const pct = (v) => (typeof v === 'number' && Number.isFinite(v) ? `${Math.round(v * 100)}%` : 'n/a');
+export const num = (v, digits = 0) => (typeof v === 'number' && Number.isFinite(v) ? (digits ? v.toFixed(digits) : String(Math.round(v))) : v === undefined || v === null ? 'n/a' : String(v));
+/** "Claude Opus 5.5 (claude-opus-5-5, id 292)" */
+export function modelLabel(m) {
+    const name = (m.name ?? m.modelName);
+    const id = m.id ?? m.modelId;
+    const display = typeof m.displayName === 'string' && m.displayName ? m.displayName : null;
+    const inner = [display && name && display !== name ? name : null, id !== undefined && id !== null ? `id ${id}` : null].filter(Boolean).join(', ');
+    return `${display ?? name ?? 'unknown model'}${inner ? ` (${inner})` : ''}`;
+}
+/** Source line, cache age and quota left: appended to every Data API answer. */
+export function footer(r, quota) {
+    const lines = [];
+    const gen = r.body?.generated_at ? `, generated ${when(r.body.generated_at)}` : '';
+    lines.push(`Source: AI Stupid Level Data API (aistupidlevel.info)${gen}. Attribution required: cite aistupidlevel.info as the source.`);
+    if (r.staleReason)
+        lines.push(`NOTE: this is an older cached answer, fetched ${ago(Date.now() - r.fetchedAt)} ago, because a fresh one could not be fetched: ${r.staleReason}`);
+    else if (r.cached)
+        lines.push(`Served from this server's cache (fetched ${ago(Date.now() - r.fetchedAt)} ago; no request was spent).`);
+    if (quota)
+        lines.push(`Data API requests left today for this key: ${quota.remaining} of ${quota.limit}.`);
+    return lines.join('\n');
+}
+/** $0.012, $0.00075, $1.25: two significant digits below a dollar. */
+export const usd = (v) => `$${v >= 1 ? v.toFixed(2) : Number(v.toPrecision(2))}`;
+export function truncate(s, max) {
+    return s.length <= max ? s : `${s.slice(0, max - 1)}…`;
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { createServer } from './server.js';
+export { VERSION, DEFAULT_DATA_BASE_URL, DEFAULT_ROUTER_BASE_URL, type ServerOptions } from './config.js';
+export { ROUTING_MODES } from './router-api.js';

package/dist/index.js

@@ -0,0 +1,3 @@
+export { createServer } from './server.js';
+export { VERSION, DEFAULT_DATA_BASE_URL, DEFAULT_ROUTER_BASE_URL } from './config.js';
+export { ROUTING_MODES } from './router-api.js';

package/dist/router-api.d.ts

@@ -0,0 +1,33 @@
+/**
+ * The few Smart Router calls the MCP tools make (https://aistupidlevel.info/v1): route preview,
+ * chat completion and usage. Same conventions as @aistupidlevel/router: Bearer aism_ key,
+ * X-ASL-Sandbox for mock answers, routing read from the X-AISM-* response headers, and an
+ * Idempotency-Key on chat so a retried request is never charged twice.
+ */
+import { type ResolvedConfig } from './config.js';
+import { ToolError } from './errors.js';
+export interface Routing {
+    provider: string | null;
+    model: string | null;
+    reasoning: string | null;
+    latencyMs: number | null;
+    requestId: string | null;
+    sandbox: boolean;
+    fallback: boolean;
+}
+export interface RouterResult<T = any> {
+    data: T;
+    routing: Routing;
+}
+export declare const ROUTING_MODES: readonly ["auto", "auto-best", "auto-coding", "auto-reasoning", "auto-tooling", "auto-task", "auto-value", "auto-value-coding", "auto-value-reasoning", "auto-value-tooling", "auto-fastest-quality", "auto-consistent", "auto-fastest", "auto-cheapest"];
+export declare class RouterApi {
+    private readonly cfg;
+    requestsSent: number;
+    constructor(cfg: ResolvedConfig);
+    get hasKey(): boolean;
+    missingKeyError(): ToolError;
+    request<T = any>(method: 'GET' | 'POST', path: string, body?: unknown, opts?: {
+        sandbox?: boolean;
+        idempotent?: boolean;
+    }): Promise<RouterResult<T>>;
+}

package/dist/router-api.js

@@ -0,0 +1,131 @@
+/**
+ * The few Smart Router calls the MCP tools make (https://aistupidlevel.info/v1): route preview,
+ * chat completion and usage. Same conventions as @aistupidlevel/router: Bearer aism_ key,
+ * X-ASL-Sandbox for mock answers, routing read from the X-AISM-* response headers, and an
+ * Idempotency-Key on chat so a retried request is never charged twice.
+ */
+import { LINKS, VERSION } from './config.js';
+import { ToolError } from './errors.js';
+export const ROUTING_MODES = [
+    'auto', 'auto-best', 'auto-coding', 'auto-reasoning', 'auto-tooling', 'auto-task',
+    'auto-value', 'auto-value-coding', 'auto-value-reasoning', 'auto-value-tooling',
+    'auto-fastest-quality', 'auto-consistent', 'auto-fastest', 'auto-cheapest',
+];
+function routingFrom(h) {
+    const reasoning = h.get('x-aism-reasoning');
+    const latency = h.get('x-aism-latency');
+    return {
+        provider: h.get('x-aism-provider'),
+        model: h.get('x-aism-model'),
+        reasoning,
+        latencyMs: latency !== null && latency !== '' && Number.isFinite(Number(latency)) ? Number(latency) : null,
+        requestId: h.get('x-aism-request-id'),
+        sandbox: h.get('x-aism-sandbox') === 'true',
+        fallback: !!reasoning && /fallback activated/i.test(reasoning),
+    };
+}
+const newIdempotencyKey = () => {
+    const c = globalThis.crypto;
+    if (c?.randomUUID)
+        return `asl-mcp-${c.randomUUID()}`;
+    return `asl-mcp-${Date.now().toString(16)}-${Math.random().toString(16).slice(2)}`;
+};
+/** A router error in words that say who has to act and where. */
+function explain(status, body) {
+    const err = body && typeof body === 'object' && body.error && typeof body.error === 'object' ? body.error : {};
+    const code = typeof err.code === 'string' ? err.code : '';
+    const msg = typeof err.message === 'string' && err.message ? err.message : `HTTP ${status}`;
+    switch (code) {
+        case 'allowance_exhausted':
+            return `The Smart Router plan's monthly allowance is used up and there are no prepaid credits (${msg}). Upgrade or buy credits: ${LINKS.billing}`;
+        case 'insufficient_quota':
+            return `This router key has reached its hard monthly budget (${msg}). Raise it at ${LINKS.routerKeys}`;
+        case 'no_provider_keys':
+            return `The Smart Router has no provider key to call a model with (${msg}). Add an OpenAI, Anthropic, Google, DeepSeek, Kimi or GLM key at ${LINKS.providerKeys}, or set sandbox: true to test the routing without one.`;
+        case 'provider_key_rejected':
+            return `A provider refused the provider key saved in your account (${msg}). Fix it at ${LINKS.providerKeys}`;
+        case 'provider_quota_exceeded':
+            return `Your provider account is out of credit or quota (${msg}).`;
+        case 'no_routable_model':
+            return `Your routing preferences exclude every model for this request (${msg}). Review them at ${LINKS.routerDocs}`;
+        case 'model_unavailable':
+            return `Every model in the fallback chain failed on the provider side (${msg}). Try again shortly.`;
+        case 'rate_limited':
+            return `The Smart Router is rate limiting this key (${msg}). Try again shortly.`;
+    }
+    if (status === 401)
+        return `The Smart Router rejected the key in ASL_ROUTER_KEY (${msg}). Check it, or create one at ${LINKS.routerKeys}`;
+    if (status === 403)
+        return `This router key may not do that (${msg}).`;
+    if (status === 404 && /model/i.test(msg))
+        return `${msg} Use one of the routing modes (auto, auto-coding, …) or a model id from the leaderboard.`;
+    return `The Smart Router answered HTTP ${status}${code ? ` ${code}` : ''}: ${msg}`;
+}
+export class RouterApi {
+    cfg;
+    requestsSent = 0;
+    constructor(cfg) {
+        this.cfg = cfg;
+    }
+    get hasKey() { return !!this.cfg.routerKey; }
+    missingKeyError() {
+        const why = this.cfg.warnings.router ? `${this.cfg.warnings.router} ` : '';
+        return new ToolError(`${why}This tool uses the AI Stupid Level Smart Router and needs a router key (aism_…). ` +
+            `Create one at ${LINKS.routerKeys} and add at least one provider key (OpenAI, Anthropic, Google, ` +
+            `DeepSeek, Kimi or GLM) in your account, then set ASL_ROUTER_KEY in the "env" section of this MCP ` +
+            `server's configuration and restart the client. Documentation: ${LINKS.routerDocs}`);
+    }
+    async request(method, path, body, opts = {}) {
+        if (!this.cfg.routerKey)
+            throw this.missingKeyError();
+        const headers = {
+            Authorization: `Bearer ${this.cfg.routerKey}`,
+            Accept: 'application/json',
+            'X-ASL-Client': `asl-mcp/${VERSION}`,
+            'User-Agent': `aistupidlevel-mcp/${VERSION}`,
+        };
+        if (body !== undefined)
+            headers['Content-Type'] = 'application/json';
+        if (opts.sandbox || this.cfg.forceSandbox)
+            headers['X-ASL-Sandbox'] = 'true';
+        if (opts.idempotent)
+            headers['Idempotency-Key'] = newIdempotencyKey();
+        const payload = body !== undefined ? JSON.stringify(body) : undefined;
+        const url = `${this.cfg.routerBaseURL}${path}`;
+        // One retry for a dropped connection or a 5xx; the idempotency key makes that safe for chat.
+        for (let attempt = 0;; attempt++) {
+            let res;
+            try {
+                this.requestsSent++;
+                res = await this.cfg.fetch(url, { method, headers, body: payload, signal: AbortSignal.timeout(this.cfg.routerTimeoutMs) });
+            }
+            catch (err) {
+                if (attempt === 0) {
+                    await new Promise(r => setTimeout(r, 500));
+                    continue;
+                }
+                const e = err;
+                throw new ToolError(e?.name === 'TimeoutError'
+                    ? `The Smart Router did not answer within ${Math.round(this.cfg.routerTimeoutMs / 1000)} s.`
+                    : `Could not reach the Smart Router (${e?.message ?? err}).`);
+            }
+            const text = await res.text().catch(() => '');
+            let data = null;
+            try {
+                data = text ? JSON.parse(text) : null;
+            }
+            catch { /* not JSON */ }
+            if (res.ok) {
+                if (data === null)
+                    throw new ToolError('The Smart Router returned a response that is not JSON.');
+                return { data, routing: routingFrom(res.headers) };
+            }
+            const retryable = res.status >= 500 && res.headers.get('x-should-retry') !== 'false';
+            if (attempt === 0 && retryable) {
+                await new Promise(r => setTimeout(r, 1000));
+                continue;
+            }
+            throw new ToolError(explain(res.status, data));
+        }
+    }
+}

package/dist/server.d.ts

@@ -0,0 +1,11 @@
+/**
+ * The MCP server: tools over the ASL Data API (rankings, history, drift, incidents, providers,
+ * recommendations) and the ASL Smart Router (route preview, routed prompts, usage).
+ *
+ * Every Data API tool makes at most one request, and usually none: answers are cached, and model
+ * names are resolved from the cached leaderboard. Tools that need a key that is not configured
+ * answer with a tool error saying which key and where to get it.
+ */
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { type ServerOptions } from './config.js';
+export declare function createServer(options?: ServerOptions): McpServer;