rebellm-bridge 0.1.0

package/dist/http.d.ts

@@ -0,0 +1,14 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+/** Long conversations are large, but not this large. */
+export declare const MAX_BODY: number;
+export declare class HttpError extends Error {
+    readonly status: number;
+    constructor(status: number, message: string);
+}
+export declare function sendJson(res: ServerResponse, status: number, body: unknown): void;
+/** The request body as JSON; rejects with an HttpError (413 or 400). */
+export declare function readJson(req: IncomingMessage): Promise<unknown>;
+/** The path of a request URL, without the query (Claude Code adds `?beta=true`). */
+export declare const pathOf: (req: IncomingMessage) => string;
+/** Aborts when the client goes away before the response is finished. */
+export declare function clientGone(res: ServerResponse): AbortSignal;

package/dist/http.js

@@ -0,0 +1,46 @@
+/** Long conversations are large, but not this large. */
+export const MAX_BODY = 8 << 20;
+export class HttpError extends Error {
+    status;
+    constructor(status, message) {
+        super(message);
+        this.status = status;
+    }
+}
+export function sendJson(res, status, body) {
+    res.writeHead(status, { 'Content-Type': 'application/json; charset=utf-8', 'Cache-Control': 'no-store' });
+    res.end(JSON.stringify(body));
+}
+/** The request body as JSON; rejects with an HttpError (413 or 400). */
+export function readJson(req) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        let size = 0;
+        req.on('data', (c) => {
+            size += c.length;
+            if (size > MAX_BODY) {
+                reject(new HttpError(413, 'the request body is too large'));
+                req.destroy();
+            }
+            else
+                chunks.push(c);
+        });
+        req.on('end', () => {
+            try {
+                resolve(JSON.parse(Buffer.concat(chunks).toString('utf8')));
+            }
+            catch {
+                reject(new HttpError(400, 'the body is not JSON'));
+            }
+        });
+        req.on('error', reject);
+    });
+}
+/** The path of a request URL, without the query (Claude Code adds `?beta=true`). */
+export const pathOf = (req) => (req.url ?? '/').split('?')[0] ?? '/';
+/** Aborts when the client goes away before the response is finished. */
+export function clientGone(res) {
+    const gone = new AbortController();
+    res.on('close', () => !res.writableFinished && gone.abort());
+    return gone.signal;
+}

package/dist/launcher.d.ts

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+import type { Writable } from 'node:stream';
+export declare const USAGE = "Usage: rebellm-claude [--claude <path>] [--shared-config] [--port <n>] [claude arguments]\n\nRuns Claude Code on the model in your RebeLLM tab, through rebellm-bridge.\n\n  --claude <path>   the claude executable (default: claude on PATH)\n  --shared-config   use your normal Claude Code config instead of ~/.rebellm-bridge/claude\n  --port <n>        the bridge's port (default 7343); a bridge already there is reused\n\nEverything else, and everything after --, goes to claude.";
+export declare const MISSING = "claude was not found on PATH. Install Claude Code (https://claude.com/claude-code), or pass --claude <path>.";
+/** The name Claude Code shows; the bridge answers every model name with the tab's model. */
+export declare const MODEL = "rebellm";
+export interface LauncherOptions {
+    claude?: string;
+    sharedConfig: boolean;
+    port: number;
+    /** For claude, in order. */
+    args: string[];
+}
+/** Takes the launcher's own flags out of `argv`; everything else passes to claude. */
+export declare function parseLauncher(argv: string[]): LauncherOptions | {
+    error: string;
+};
+/** A command as the shell would find it: a path as given, else on PATH (with PATHEXT on Windows). */
+export declare function findCommand(name: string, env: NodeJS.ProcessEnv, platform?: NodeJS.Platform): string | null;
+/** What sends every model request of claude to the bridge. */
+export declare function bridgeEnv(base: string, contextTokens?: number): Record<string, string>;
+/** The parent's environment with the bridge's on top; a real API key is removed, never sent to the bridge. */
+export declare function childEnv(parent: NodeJS.ProcessEnv, ours: Record<string, string>, platform?: NodeJS.Platform): NodeJS.ProcessEnv;
+export declare const configDir: (home: string) => string;
+export declare const logFile: (home: string) => string;
+/** Puts `env` into the config dir's `settings.json`, keeping the rest; a warning when it cannot. */
+export declare function writeSettings(dir: string, env: Record<string, string>): string | null;
+export interface LaunchIo {
+    stderr: Writable;
+    env: NodeJS.ProcessEnv;
+    home?: string;
+    /** How often to ask the bridge whether the tab is there. */
+    pollMs?: number;
+    platform?: NodeJS.Platform;
+}
+/** The launcher; resolves with claude's exit code once claude and any bridge it started have stopped. */
+export declare function launch(argv: string[], io: LaunchIo): Promise<number>;

package/dist/launcher.js

@@ -0,0 +1,253 @@
+#!/usr/bin/env node
+import { accessSync, constants, createWriteStream, mkdirSync, readFileSync, realpathSync, statSync, writeFileSync, } from 'node:fs';
+import { homedir, constants as os } from 'node:os';
+import { delimiter, dirname, extname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import spawn from 'cross-spawn';
+import { TOKEN_ENV, VERSION, bridgeHealth, resolveToken, tokenFile } from './cli.js';
+import { DEFAULT_PORT, startServer } from './server.js';
+export const USAGE = `Usage: rebellm-claude [--claude <path>] [--shared-config] [--port <n>] [claude arguments]
+
+Runs Claude Code on the model in your RebeLLM tab, through rebellm-bridge.
+
+  --claude <path>   the claude executable (default: claude on PATH)
+  --shared-config   use your normal Claude Code config instead of ~/.rebellm-bridge/claude
+  --port <n>        the bridge's port (default ${DEFAULT_PORT}); a bridge already there is reused
+
+Everything else, and everything after --, goes to claude.`;
+export const MISSING = 'claude was not found on PATH. Install Claude Code (https://claude.com/claude-code), or pass --claude <path>.';
+/** The name Claude Code shows; the bridge answers every model name with the tab's model. */
+export const MODEL = 'rebellm';
+/** How long a request waits for the tab's model, as the bridge's `--wait` default. */
+const WAIT_MS = 120_000;
+/** Takes the launcher's own flags out of `argv`; everything else passes to claude. */
+export function parseLauncher(argv) {
+    const o = { sharedConfig: false, port: DEFAULT_PORT, args: [] };
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        if (arg === '--') {
+            o.args.push(...argv.slice(i + 1));
+            break;
+        }
+        const eq = arg.startsWith('--') ? arg.indexOf('=') : -1;
+        const flag = eq > 0 ? arg.slice(0, eq) : arg;
+        if (flag === '--shared-config' && eq < 0) {
+            o.sharedConfig = true;
+        }
+        else if (flag === '--claude' || flag === '--port') {
+            const value = eq > 0 ? arg.slice(eq + 1) : argv[++i];
+            if (!value)
+                return { error: `${flag} needs a value` };
+            if (flag === '--claude')
+                o.claude = value;
+            else {
+                const port = Number(value);
+                if (!Number.isInteger(port) || port < 0 || port > 65535)
+                    return { error: `--port ${value} is not a port number` };
+                o.port = port;
+            }
+        }
+        else
+            o.args.push(arg);
+    }
+    return o;
+}
+/** The key of `name` in `env`; Windows treats `Path` and `PATH` as one. */
+const envKey = (env, name, win) => (win ? Object.keys(env).find((k) => k.toUpperCase() === name) : undefined) ?? name;
+function runnable(file, win) {
+    try {
+        if (!statSync(file).isFile())
+            return false;
+        if (!win)
+            accessSync(file, constants.X_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** A command as the shell would find it: a path as given, else on PATH (with PATHEXT on Windows). */
+export function findCommand(name, env, platform = process.platform) {
+    const win = platform === 'win32';
+    // Windows runs only files with an executable extension; npm installs claude as claude.cmd.
+    const exts = win && !extname(name)
+        ? (env[envKey(env, 'PATHEXT', win)] ?? '.COM;.EXE;.BAT;.CMD')
+            .split(';')
+            .filter(Boolean)
+            .map((e) => e.toLowerCase())
+        : [''];
+    const withExts = (base) => exts.map((e) => base + e);
+    if (/[\\/]/.test(name))
+        return withExts(name).find((f) => runnable(f, win)) ?? null;
+    const dirs = (env[envKey(env, 'PATH', win)] ?? '').split(win ? ';' : delimiter).filter(Boolean);
+    for (const dir of dirs) {
+        const hit = withExts(join(dir, name)).find((f) => runnable(f, win));
+        if (hit)
+            return hit;
+    }
+    return null;
+}
+/** What sends every model request of claude to the bridge. */
+export function bridgeEnv(base, contextTokens) {
+    return {
+        ANTHROPIC_BASE_URL: base,
+        // The bridge checks no key; a Bearer token needs no approval prompt in Claude Code.
+        ANTHROPIC_AUTH_TOKEN: 'rebellm-bridge-needs-no-key',
+        ANTHROPIC_MODEL: MODEL,
+        ANTHROPIC_SMALL_FAST_MODEL: MODEL,
+        ANTHROPIC_DEFAULT_HAIKU_MODEL: MODEL,
+        // A local model can take minutes before its first token.
+        API_TIMEOUT_MS: '600000',
+        CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC: '1',
+        // Claude Code assumes 200k for a model it does not know; it should compact within the tab's.
+        ...(contextTokens ? { CLAUDE_CODE_MAX_CONTEXT_TOKENS: String(contextTokens) } : {}),
+    };
+}
+/** The parent's environment with the bridge's on top; a real API key is removed, never sent to the bridge. */
+export function childEnv(parent, ours, platform = process.platform) {
+    const win = platform === 'win32';
+    const drop = new Set(['ANTHROPIC_API_KEY', ...Object.keys(ours)]);
+    const env = {};
+    for (const [k, v] of Object.entries(parent))
+        if (!drop.has(win ? k.toUpperCase() : k))
+            env[k] = v;
+    return { ...env, ...ours };
+}
+export const configDir = (home) => join(home, '.rebellm-bridge', 'claude');
+export const logFile = (home) => join(home, '.rebellm-bridge', 'bridge.log');
+const isObj = (v) => !!v && typeof v === 'object' && !Array.isArray(v);
+/** Puts `env` into the config dir's `settings.json`, keeping the rest; a warning when it cannot. */
+export function writeSettings(dir, env) {
+    const file = join(dir, 'settings.json');
+    mkdirSync(dir, { recursive: true, mode: 0o700 });
+    let settings = {};
+    try {
+        const parsed = JSON.parse(readFileSync(file, 'utf8'));
+        if (!isObj(parsed))
+            return `${file} is not a JSON object; left it as it is`;
+        settings = parsed;
+    }
+    catch (e) {
+        if (e.code !== 'ENOENT')
+            return `could not read ${file}; left it as it is`;
+    }
+    settings.env = { ...(isObj(settings.env) ? settings.env : {}), ...env };
+    writeFileSync(file, `${JSON.stringify(settings, null, 2)}\n`);
+    return null;
+}
+const sleep = (ms, signal) => new Promise((resolve) => {
+    const t = setTimeout(resolve, ms);
+    signal.addEventListener('abort', () => (clearTimeout(t), resolve()), { once: true });
+});
+/** The launcher; resolves with claude's exit code once claude and any bridge it started have stopped. */
+export async function launch(argv, io) {
+    const say = (line) => void io.stderr.write(`rebellm-claude: ${line}\n`);
+    const o = parseLauncher(argv);
+    if ('error' in o) {
+        say(o.error);
+        io.stderr.write(`\n${USAGE}\n`);
+        return 2;
+    }
+    const platform = io.platform ?? process.platform;
+    const home = io.home ?? homedir();
+    const claude = findCommand(o.claude ?? 'claude', io.env, platform);
+    if (!claude) {
+        say(o.claude ? `${o.claude} was not found` : MISSING);
+        return 1;
+    }
+    // Ctrl+C quits the wait; while claude runs, claude handles it.
+    const quit = new AbortController();
+    const onSigint = () => quit.abort();
+    process.on('SIGINT', onSigint);
+    let server = null;
+    let log = null;
+    try {
+        let base = `http://127.0.0.1:${o.port}`;
+        let token = `the token in ${tokenFile(home)}`;
+        let health = await bridgeHealth(base);
+        if (health)
+            say(`using the bridge already running on ${base}`);
+        else {
+            const tok = resolveToken({ ...(io.env[TOKEN_ENV] ? { env: io.env[TOKEN_ENV] } : {}), home });
+            const file = logFile(home);
+            mkdirSync(dirname(file), { recursive: true, mode: 0o700 });
+            const stream = createWriteStream(file, { flags: 'a', mode: 0o600 });
+            log = stream;
+            const write = (line) => void stream.write(`${new Date().toISOString()} ${line}\n`);
+            try {
+                server = await startServer({ host: '127.0.0.1', port: o.port, token: tok.token, waitMs: WAIT_MS, log: write });
+            }
+            catch (e) {
+                if (e.code !== 'EADDRINUSE')
+                    throw e;
+                // Another launcher may have started one meanwhile.
+                health = await bridgeHealth(base);
+                if (!health)
+                    throw new Error(`port ${o.port} on 127.0.0.1 is in use by something that is not a rebellm-bridge`, {
+                        cause: e,
+                    });
+            }
+            if (server) {
+                base = `http://127.0.0.1:${server.port}`;
+                write(`${VERSION} listening on 127.0.0.1:${server.port} for rebellm-claude`);
+                say(`started the bridge on ${base} (log: ${file})`);
+                if (tok.created)
+                    token = `this new token (stored in ${tok.file}):\n\n  ${tok.token}\n`;
+                else if (tok.source === 'env')
+                    token = `the token in ${TOKEN_ENV}`;
+                health = await bridgeHealth(base);
+            }
+        }
+        if (!health?.tab) {
+            say(`waiting for the RebeLLM tab. In RebeLLM → Settings → Local bridge, connect to ` +
+                `${base.replace('http:', 'ws:')} with ${token}\nCtrl+C quits.`);
+            while (!health?.tab) {
+                if (quit.signal.aborted)
+                    return 130;
+                await sleep(io.pollMs ?? 1000, quit.signal);
+                health = await bridgeHealth(base);
+            }
+        }
+        const model = health.model ? ` (model ${health.model}, ${health.state})` : '';
+        say(`the RebeLLM tab is connected${model}`);
+        const dir = o.sharedConfig ? null : configDir(home);
+        const ours = bridgeEnv(base, health.contextTokens);
+        if (dir) {
+            const warning = writeSettings(dir, ours);
+            if (warning)
+                say(warning);
+        }
+        say(`starting ${claude} with ${dir ? `the config in ${dir}` : 'your own Claude Code config'}`);
+        const env = childEnv(io.env, { ...ours, ...(dir ? { CLAUDE_CONFIG_DIR: dir } : {}) }, platform);
+        const child = spawn(claude, o.args, { stdio: 'inherit', env });
+        return await new Promise((resolve) => {
+            child.on('error', (e) => {
+                say(`could not start ${claude}: ${e.message}`);
+                resolve(1);
+            });
+            child.on('exit', (code, signal) => resolve(code ?? 128 + ((signal && os.signals[signal]) || 0)));
+        });
+    }
+    catch (e) {
+        say(e.message);
+        return 1;
+    }
+    finally {
+        process.off('SIGINT', onSigint);
+        await server?.close();
+        const stream = log;
+        if (stream)
+            await new Promise((resolve) => stream.end(resolve));
+    }
+}
+function invokedDirectly() {
+    try {
+        return !!process.argv[1] && realpathSync(process.argv[1]) === realpathSync(fileURLToPath(import.meta.url));
+    }
+    catch {
+        return false;
+    }
+}
+if (invokedDirectly()) {
+    void launch(process.argv.slice(2), { stderr: process.stderr, env: process.env }).then((code) => process.exit(code));
+}

package/dist/mcp.d.ts

@@ -0,0 +1,17 @@
+import type { Readable, Writable } from 'node:stream';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { ChatInput, ChatOptions, ChatResult, Health, TabLink } from './tab.js';
+/** How the MCP face reaches a tab: in this process, or through a bridge already running. */
+export interface ChatBackend {
+    health(): Promise<Health>;
+    /** Waits for a ready model like the HTTP face does; rejects with the reason when there is none. */
+    chat(input: ChatInput, opts: ChatOptions): Promise<ChatResult>;
+}
+export declare function tabBackend(tab: TabLink, waitMs: number): ChatBackend;
+/** A bridge already serving the port, used through its OpenAI endpoint. */
+export declare function httpBackend(base: string): ChatBackend;
+/** The `status` tool's text; never the token, which would end up in the client's context. */
+export declare function describeHealth(h: Health): string;
+export declare function createMcpServer(backend: ChatBackend, version: string): McpServer;
+/** Serves MCP over stdio until the client closes its end. */
+export declare function serveStdio(server: McpServer, stdin: Readable, stdout: Writable): Promise<void>;

package/dist/mcp.js

@@ -0,0 +1,169 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import * as z from 'zod';
+export function tabBackend(tab, waitMs) {
+    return {
+        health: async () => tab.health(),
+        async chat(input, opts) {
+            const missing = await tab.waitReady(waitMs, opts.signal);
+            if (missing)
+                throw new Error(missing.message);
+            return tab.chat(input, opts);
+        },
+    };
+}
+const isObj = (v) => !!v && typeof v === 'object' && !Array.isArray(v);
+async function errorMessage(r) {
+    const body = await r.json().catch(() => null);
+    const err = isObj(body) ? body.error : undefined;
+    return isObj(err) && typeof err.message === 'string' ? err.message : `the bridge answered ${r.status}`;
+}
+/** The `data:` payloads of a server-sent event stream. */
+async function* sseData(body) {
+    const decoder = new TextDecoder();
+    let buf = '';
+    for await (const bytes of body) {
+        buf += decoder.decode(bytes, { stream: true });
+        let end;
+        while ((end = buf.indexOf('\n\n')) >= 0) {
+            const event = buf.slice(0, end);
+            buf = buf.slice(end + 2);
+            const data = event
+                .split('\n')
+                .filter((l) => l.startsWith('data:'))
+                .map((l) => l.slice(5).trimStart());
+            if (data.length)
+                yield data.join('\n');
+        }
+    }
+}
+/** A bridge already serving the port, used through its OpenAI endpoint. */
+export function httpBackend(base) {
+    return {
+        async health() {
+            const r = await fetch(`${base}/health`);
+            if (!r.ok)
+                throw new Error(await errorMessage(r));
+            return (await r.json());
+        },
+        async chat(input, opts) {
+            const r = await fetch(`${base}/v1/chat/completions`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    messages: input.messages,
+                    ...(input.maxTokens !== undefined ? { max_tokens: input.maxTokens } : {}),
+                    ...(input.temperature !== undefined ? { temperature: input.temperature } : {}),
+                    stream: true,
+                    stream_options: { include_usage: true },
+                }),
+                ...(opts.signal ? { signal: opts.signal } : {}),
+            });
+            if (!r.ok || !r.body)
+                throw new Error(await errorMessage(r));
+            let text = '';
+            let stop = 'eos';
+            let usage = { prompt: 0, completion: 0, tokensPerSec: 0 };
+            for await (const data of sseData(r.body)) {
+                if (data === '[DONE]')
+                    break;
+                const o = JSON.parse(data);
+                if (isObj(o.error))
+                    throw new Error(String(o.error.message ?? 'the bridge failed'));
+                const choice = Array.isArray(o.choices) && isObj(o.choices[0]) ? o.choices[0] : undefined;
+                const piece = isObj(choice?.delta) ? choice.delta.content : undefined;
+                if (typeof piece === 'string' && piece) {
+                    text += piece;
+                    opts.onEvent?.({ t: 'token', text: piece });
+                }
+                if (choice?.finish_reason === 'length')
+                    stop = 'length';
+                if (isObj(o.usage))
+                    usage = {
+                        prompt: Number(o.usage.prompt_tokens),
+                        completion: Number(o.usage.completion_tokens),
+                        tokensPerSec: 0,
+                    };
+            }
+            return { id: '', text, calls: [], stop, usage };
+        },
+    };
+}
+/** The `status` tool's text; never the token, which would end up in the client's context. */
+export function describeHealth(h) {
+    if (!h.tab)
+        return ('No RebeLLM tab is connected. In RebeLLM → Settings → Local bridge, paste the bridge token ' +
+            '(printed at its first start, stored in ~/.rebellm-bridge/token) and turn the switch on.');
+    const tab = `A RebeLLM tab is connected${h.app ? ` (app ${h.app})` : ''}.`;
+    const model = h.model ? `The model ${h.model}` : 'The model';
+    if (h.state === 'ready')
+        return `${tab} ${model} is ready${h.contextTokens ? `, with a context of ${h.contextTokens} tokens` : ''}.`;
+    if (h.state === 'loading')
+        return `${tab} ${model} is loading${h.detail ? ` (${h.detail})` : ''}.`;
+    return `${tab} ${model} is not available${h.detail ? `: ${h.detail}` : ''}.`;
+}
+const message = z.object({ role: z.enum(['system', 'user', 'assistant']), content: z.string() });
+export function createMcpServer(backend, version) {
+    const server = new McpServer({ name: 'rebellm-bridge', version });
+    server.registerTool('chat', {
+        title: 'Ask the RebeLLM model',
+        description: "Sends a conversation to the model running in the user's RebeLLM browser tab (a local model on this " +
+            "machine's GPU) and returns its answer. Waits for the tab when it is not connected or its model is loading.",
+        inputSchema: {
+            messages: z.array(message).min(1).describe('The conversation; the last message is usually from the user'),
+            max_tokens: z.number().int().positive().optional().describe('Most tokens in the answer'),
+            temperature: z.number().min(0).optional(),
+        },
+    }, async ({ messages, max_tokens, temperature }, extra) => {
+        const token = extra._meta?.progressToken;
+        let n = 0;
+        const progress = (message) => token !== undefined &&
+            void extra
+                .sendNotification({
+                method: 'notifications/progress',
+                params: { progressToken: token, progress: ++n, message },
+            })
+                .catch(() => undefined);
+        try {
+            const r = await backend.chat({
+                messages,
+                ...(max_tokens !== undefined ? { maxTokens: max_tokens } : {}),
+                ...(temperature !== undefined ? { temperature } : {}),
+            }, {
+                signal: extra.signal,
+                onEvent: (e) => {
+                    if (e.t === 'token')
+                        progress(e.text);
+                    else if (e.t === 'queued')
+                        progress(`waiting in the tab's queue, position ${e.position}`);
+                },
+            });
+            return { content: [{ type: 'text', text: r.text }] };
+        }
+        catch (e) {
+            return { isError: true, content: [{ type: 'text', text: `RebeLLM: ${e.message}` }] };
+        }
+    });
+    server.registerTool('status', {
+        title: 'RebeLLM tab status',
+        description: 'Tells whether a RebeLLM tab is connected to the bridge and whether its model is ready.',
+    }, async () => {
+        try {
+            return { content: [{ type: 'text', text: describeHealth(await backend.health()) }] };
+        }
+        catch (e) {
+            return { isError: true, content: [{ type: 'text', text: `RebeLLM: ${e.message}` }] };
+        }
+    });
+    return server;
+}
+/** Serves MCP over stdio until the client closes its end. */
+export async function serveStdio(server, stdin, stdout) {
+    const closed = new Promise((resolve) => {
+        stdin.once('end', resolve);
+        stdin.once('close', resolve);
+    });
+    await server.connect(new StdioServerTransport(stdin, stdout));
+    await closed;
+    await server.close();
+}

package/dist/openai.d.ts

@@ -0,0 +1,54 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import { type ChatInput, type ChatResult, type TabLink } from './tab.js';
+/** Well inside the read timeouts of common clients (Node's fetch: 300 s). */
+export declare const KEEPALIVE_MS = 15000;
+export interface RouteOptions {
+    /** How long a request waits for a tab with a ready model. */
+    waitMs: number;
+    keepAliveMs?: number;
+}
+/** OpenAI's error shape, which its SDKs turn into readable messages. */
+export declare function sendError(res: ServerResponse, status: number, message: string, type: string, code?: string): void;
+export type ParsedRequest = {
+    input: ChatInput;
+    stream: boolean;
+    includeUsage: boolean;
+} | {
+    error: string;
+};
+/** An OpenAI chat completion request as the tab's `chat`; the error says what is wrong with it. */
+export declare function toChatInput(body: unknown): ParsedRequest;
+/** A non-streamed answer in OpenAI's shape. */
+export declare function completion(r: ChatResult, meta: {
+    id: string;
+    created: number;
+    model: string;
+}): {
+    object: string;
+    choices: {
+        index: number;
+        message: {
+            tool_calls?: {
+                id: string;
+                type: "function";
+                function: {
+                    name: string;
+                    arguments: string;
+                };
+            }[] | undefined;
+            role: string;
+            content: string | null;
+        };
+        finish_reason: string;
+    }[];
+    usage: {
+        prompt_tokens: number;
+        completion_tokens: number;
+        total_tokens: number;
+    };
+    id: string;
+    created: number;
+    model: string;
+};
+/** The HTTP routes for OpenAI-style clients: completions, models and health. */
+export declare function openaiRoutes(tab: TabLink, o: RouteOptions): (req: IncomingMessage, res: ServerResponse) => void;