infinicode 2.3.4 → 2.3.5

package/dist/cli.js

@@ -16,7 +16,7 @@ import { serve } from './commands/serve.js';
 import { mcpCommand } from './commands/mcp.js';
 import { installTui } from './commands/install-tui.js';
 import { DEFAULT_CONFIG } from './kernel/config-schema.js';
-const VERSION = '2.3.4';
+const VERSION = '2.3.5';
 const config = new Conf({
     projectName: 'infinicode',
     defaults: DEFAULT_CONFIG,

package/dist/commands/run.js

@@ -23,7 +23,7 @@ import { createRequire } from 'node:module';
 import { ASCII_VIDEO_FPS, ASCII_VIDEO_FRAMES } from '../ascii-video-animation.js';
 import { getProviderPreset } from '../kernel/free-providers.js';
 import { buildKernelFromConfig } from '../kernel/setup.js';
-import { SilentLogger, Federation, loadOrCreateIdentity } from '../kernel/index.js';
+import { SilentLogger, Federation, loadOrCreateIdentity, KernelGateway } from '../kernel/index.js';
 import { openAICompatBaseURL } from '../kernel/provider-url.js';
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const PROMPT_ANIMATION_MAX_FRAMES = Math.min(ASCII_VIDEO_FRAMES.length, ASCII_VIDEO_FPS * 3);
@@ -257,8 +257,11 @@ async function pickDefaultModel(config, masterReachable) {
  * in parallel (so all models are exposed, incl. large ones like GLM-5.2 on HF
  * and Nemotron-Ultra on NVIDIA), then route the default model under the policy.
  */
-async function prepareRouting(config, policyName) {
-    const kernel = buildKernelFromConfig(config, { logger: new SilentLogger() });
+async function prepareRouting(config, policyName, sharedKernel) {
+    // Reuse the caller's session kernel when provided (so the gateway routes
+    // against the same warmed-up provider pool) — only destroy a kernel we own.
+    const kernel = sharedKernel ?? buildKernelFromConfig(config, { logger: new SilentLogger() });
+    const ownsKernel = !sharedKernel;
     const modelsByProvider = {};
     try {
         // Let background token-verified health checks run first.
@@ -297,7 +300,8 @@ async function prepareRouting(config, policyName) {
         return { routed: null, modelsByProvider };
     }
     finally {
-        kernel.destroy();
+        if (ownsKernel)
+            kernel.destroy();
     }
 }
 /** Ensure the routed model exists in the TUI's injected provider config. */
@@ -337,7 +341,7 @@ async function meshAlive(url, token) {
  * otherwise start an in-process node for the session. Best-effort: on any
  * failure the TUI still launches, just without the live mesh palette.
  */
-async function startLocalMeshNode(config) {
+async function startLocalMeshNode(config, kernel) {
     if (process.env.INFINICODE_NO_MESH)
         return null;
     const fed = config.get('federation') ?? {};
@@ -348,7 +352,6 @@ async function startLocalMeshNode(config) {
         // Reuse an already-running node (don't double-bind the port).
         if (await meshAlive(url, token))
             return { url, token, stop: async () => { } };
-        const kernel = buildKernelFromConfig(config, { logger: new SilentLogger() });
         const role = (fed.role ?? 'peer');
         const identity = loadOrCreateIdentity({ role, displayName: fed.displayName });
         const version = runPkgVersion();
@@ -375,15 +378,70 @@ async function startLocalMeshNode(config) {
             federation.startLanDiscovery(undefined, fed.lanPort);
         for (const s of fed.seeds ?? [])
             await federation.connect(s).catch(() => undefined);
+        // The kernel is owned by runAgent — the mesh only stops the federation.
         return {
             url, token,
-            stop: async () => { await federation.stop(); kernel.destroy(); },
+            stop: async () => { await federation.stop(); },
         };
     }
     catch {
         return null;
     }
 }
+/** Build the gateway's provider table (baseURL/apiKey/models) from config. */
+function buildGatewayProviders(config, masterUrl, masterReachable, defaultModel, modelsByProvider) {
+    const out = [];
+    const catalog = (id, fallback) => {
+        const fetched = modelsByProvider[id];
+        return fetched && fetched.length ? fetched : fallback;
+    };
+    const shape = (models) => models.map(m => ({ id: m.id, name: m.name, contextLength: m.contextLength }));
+    if (masterReachable) {
+        out.push({
+            id: 'ollama',
+            baseURL: `${masterUrl}/v1`,
+            models: shape(catalog('ollama', [{ id: defaultModel, name: defaultModel, contextLength: 8192 }])),
+        });
+    }
+    for (const cfg of config.get('cloudProviders') ?? []) {
+        if (!cfg.enabled || !cfg.apiKey)
+            continue;
+        const preset = getProviderPreset(cfg.id);
+        const fallback = (preset?.knownModels ?? []).map(m => ({ id: m.id, name: m.name, contextLength: m.contextLength }));
+        const models = shape(catalog(cfg.id, fallback));
+        if (cfg.id === 'gemini') {
+            // Google's OpenAI-compatibility endpoint keeps the relay uniform.
+            out.push({ id: 'gemini', baseURL: 'https://generativelanguage.googleapis.com/v1beta/openai', apiKey: cfg.apiKey, models });
+        }
+        else {
+            const headers = cfg.headerName && cfg.headerName !== 'Authorization' ? { [cfg.headerName]: cfg.apiKey } : undefined;
+            out.push({ id: cfg.id, baseURL: openAICompatBaseURL(cfg.baseURL), apiKey: cfg.apiKey, headers, models });
+        }
+    }
+    return out;
+}
+/**
+ * Build the TUI's provider config as a SINGLE `infinicode` provider pointing at
+ * the local kernel gateway. Real API keys stay server-side (the TUI only gets a
+ * dummy token); every model in the pool is exposed as `providerId/modelId`, plus
+ * an `auto` entry that lets the kernel router pick per request.
+ */
+function buildGatewayTuiConfig(gatewayUrl, providers) {
+    const models = { auto: { name: 'AUTO — kernel routes best model' } };
+    for (const p of providers) {
+        for (const m of p.models) {
+            models[`${p.id}/${m.id}`] = modelEntry({ id: `${p.id}/${m.id}`, name: m.name ?? m.id, contextLength: m.contextLength });
+        }
+    }
+    return {
+        infinicode: {
+            npm: '@ai-sdk/openai-compatible',
+            name: 'infinicode (kernel)',
+            options: { baseURL: gatewayUrl, apiKey: 'infinicode-gateway' },
+            models,
+        },
+    };
+}
 export async function runAgent(_masterUrl, _model, _useTui, config) {
     const masterUrl = await resolveConfiguredMasterUrl(config);
     const masterReachable = await isOllamaReachable(masterUrl);
@@ -391,10 +449,14 @@ export async function runAgent(_masterUrl, _model, _useTui, config) {
     const cloudProviders = config.get('cloudProviders') ?? [];
     const enabledCloud = cloudProviders.filter(p => p.enabled);
     const policyName = config.get('policy') ?? 'balanced';
+    // Session kernel — lives for the whole TUI session. It is the routing/recovery
+    // brain the gateway and the mesh node both share, so every chat turn the TUI
+    // makes flows through the same warmed-up provider pool + event bus.
+    const sessionKernel = buildKernelFromConfig(config, { logger: new SilentLogger() });
     // Make this TUI session a mesh participant so the in-TUI slash commands
     // (/nodes, /build, /activity, …) have a local node to talk to. Reuses a
     // running `infinicode serve` if one is up, else starts an in-process node.
-    const mesh = await startLocalMeshNode(config);
+    const mesh = await startLocalMeshNode(config, sessionKernel);
     if (mesh) {
         process.env.INFINICODE_MESH_URL = mesh.url;
         if (mesh.token)
@@ -403,27 +465,52 @@ export async function runAgent(_masterUrl, _model, _useTui, config) {
     // One kernel pass: load every provider's full model catalog (in parallel) and
     // route the default model under the policy.
     const routeSpinner = ora('loading model catalog & routing...').start();
-    const { routed, modelsByProvider } = await prepareRouting(config, policyName);
+    const { routed, modelsByProvider } = await prepareRouting(config, policyName, sessionKernel);
     routeSpinner.stop();
-    const providers = buildProviderConfig(masterUrl, defaultModel, cloudProviders, masterReachable, modelsByProvider);
-    let defaultProvider;
-    let pickedModel;
-    if (routed && providers[routed.providerId]) {
-        defaultProvider = routed.providerId;
-        pickedModel = routed.modelId;
-        ensureModelInjected(providers, routed.providerId, routed.modelId);
+    // Stand up the OpenAI-compatible kernel gateway. The TUI points at THIS as its
+    // single provider, so interactive chat gains full kernel parity: auto-routing,
+    // escalate-on-error, provider rotation, health/quota, live telemetry.
+    const gwProviders = buildGatewayProviders(config, masterUrl, masterReachable, defaultModel, modelsByProvider);
+    let gateway;
+    if (!process.env.INFINICODE_NO_GATEWAY && gwProviders.length > 0) {
+        try {
+            gateway = new KernelGateway({ kernel: sessionKernel, providers: gwProviders, policyName, logger: new SilentLogger() });
+            await gateway.start();
+        }
+        catch {
+            gateway = undefined; // fall back to direct-provider config below
+        }
+    }
+    let providers;
+    let modelRef;
+    if (gateway) {
+        providers = buildGatewayTuiConfig(gateway.url, gwProviders);
+        modelRef = 'infinicode/auto'; // default to kernel auto-routing
     }
     else {
-        const fb = await pickDefaultModel(config, masterReachable);
-        defaultProvider = fb.provider;
-        pickedModel = fb.model;
+        // Fallback: talk to providers directly (no kernel in the loop).
+        providers = buildProviderConfig(masterUrl, defaultModel, cloudProviders, masterReachable, modelsByProvider);
+        let defaultProvider;
+        let pickedModel;
+        if (routed && providers[routed.providerId]) {
+            defaultProvider = routed.providerId;
+            pickedModel = routed.modelId;
+            ensureModelInjected(providers, routed.providerId, routed.modelId);
+        }
+        else {
+            const fb = await pickDefaultModel(config, masterReachable);
+            defaultProvider = fb.provider;
+            pickedModel = fb.model;
+        }
+        modelRef = `${defaultProvider}/${pickedModel}`;
     }
-    const modelRef = `${defaultProvider}/${pickedModel}`;
-    const providerCount = Object.keys(providers).length;
+    const providerCount = gateway ? gwProviders.length : Object.keys(providers).length;
     const modelCount = Object.values(providers).reduce((n, p) => n + Object.keys(p.models ?? {}).length, 0);
     const policy = config.get('policy') ?? 'local-first';
     const pinnedCount = Object.keys(config.get('workerModels') ?? {}).length;
-    const routingInfo = `AUTO ${policy} ${providerCount}P ${pinnedCount}pins`;
+    const routingInfo = gateway
+        ? `KERNEL ${policy} ${providerCount}P ${pinnedCount}pins`
+        : `AUTO ${policy} ${providerCount}P ${pinnedCount}pins`;
     // Runtime TUI plugin that adds the mesh slash-commands (/nodes, /build, …)
     // to the `/` palette. Shipped in the package at .opencode/plugins; loaded via
     // a file:// URL so it resolves regardless of the TUI's cwd. Only injected when
@@ -455,6 +542,9 @@ export async function runAgent(_masterUrl, _model, _useTui, config) {
         },
     });
     console.log(chalk.dim(`\ninfinicode — launching TUI with ${chalk.cyan(String(providerCount))} provider(s), ${chalk.cyan(String(modelCount))} model(s)`));
+    if (gateway) {
+        console.log(chalk.dim(`  kernel gateway: ${chalk.green(gateway.url)} ${chalk.dim('(auto-routing + escalate-on-error)')}`));
+    }
     console.log(chalk.dim(`  default model: ${chalk.cyan(modelRef)}`));
     console.log(chalk.dim(`  policy: ${chalk.cyan(config.get('policy') ?? 'local-first')}`));
     if (enabledCloud.length > 0) {
@@ -479,6 +569,11 @@ export async function runAgent(_masterUrl, _model, _useTui, config) {
         console.log(chalk.cyan('  infinicode install-tui --url <url>') + chalk.dim(' # or download from a hosted binary'));
         process.exit(1);
     }
+    const cleanup = async () => {
+        await gateway?.stop().catch(() => undefined);
+        await mesh?.stop().catch(() => undefined);
+        sessionKernel.destroy();
+    };
     const { execa } = await import('execa');
     try {
         await execa(tuiBinary, [], {
@@ -487,12 +582,12 @@ export async function runAgent(_masterUrl, _model, _useTui, config) {
         });
     }
     catch (e) {
-        await mesh?.stop().catch(() => undefined);
+        await cleanup();
         const err = e;
         if (err.exitCode) {
             process.exit(err.exitCode);
         }
         throw e;
     }
-    await mesh?.stop().catch(() => undefined);
+    await cleanup();
 }

package/dist/kernel/gateway/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * OpenKernel — Gateway module.
+ *
+ * A local OpenAI-compatible endpoint backed by the kernel's routing + recovery,
+ * so the interactive TUI path gains 1:1 parity with the headless mission path.
+ */
+export { KernelGateway, FetchExecutor, type KernelGatewayOptions, type GatewayProvider, type GatewayTarget, type ProviderExecutor, } from './openai-gateway.js';

package/dist/kernel/gateway/index.js

@@ -0,0 +1,7 @@
+/**
+ * OpenKernel — Gateway module.
+ *
+ * A local OpenAI-compatible endpoint backed by the kernel's routing + recovery,
+ * so the interactive TUI path gains 1:1 parity with the headless mission path.
+ */
+export { KernelGateway, FetchExecutor, } from './openai-gateway.js';

package/dist/kernel/gateway/openai-gateway.d.ts

@@ -0,0 +1,85 @@
+import type { Kernel } from '../kernel.js';
+import type { Logger, Capability } from '../types.js';
+/** A provider the gateway can execute against (resolved from config). */
+export interface GatewayProvider {
+    id: string;
+    /** OpenAI-compatible base URL ending in the version segment (…/v1). */
+    baseURL: string;
+    apiKey?: string;
+    /** Extra headers (e.g. a custom auth header name for providers that need it). */
+    headers?: Record<string, string>;
+    models: Array<{
+        id: string;
+        name?: string;
+        contextLength?: number;
+    }>;
+}
+/** A fully-resolved call target (provider + chosen model). */
+export interface GatewayTarget {
+    providerId: string;
+    baseURL: string;
+    apiKey?: string;
+    headers?: Record<string, string>;
+    model: string;
+}
+/**
+ * The execution plane. Swap this to route calls through Bifrost / a remote
+ * gateway / a mock without changing any kernel routing/recovery logic.
+ */
+export interface ProviderExecutor {
+    execute(target: GatewayTarget, body: Record<string, unknown>, signal: AbortSignal): Promise<Response>;
+}
+/** Default executor: call the upstream OpenAI-compatible endpoint directly. */
+export declare class FetchExecutor implements ProviderExecutor {
+    execute(target: GatewayTarget, body: Record<string, unknown>, signal: AbortSignal): Promise<Response>;
+}
+export interface KernelGatewayOptions {
+    kernel: Kernel;
+    providers: GatewayProvider[];
+    /** Policy name to route under (e.g. 'balanced'). */
+    policyName: string;
+    host?: string;
+    /** Preferred port; the gateway scans upward if it is taken. */
+    port?: number;
+    logger: Logger;
+    executor?: ProviderExecutor;
+    /** Capabilities to route interactive chat under. */
+    capabilities?: Capability[];
+}
+export declare class KernelGateway {
+    private opts;
+    private server?;
+    private table;
+    private executor;
+    private boundPort;
+    private modelsCache?;
+    constructor(opts: KernelGatewayOptions);
+    get port(): number;
+    get url(): string;
+    /** Start listening. Scans ports [port .. port+10] to avoid collisions. */
+    start(): Promise<void>;
+    private listen;
+    stop(): Promise<void>;
+    private handle;
+    private listModels;
+    private handleChat;
+    /** Stream bytes through untouched, or relay the JSON body for non-streaming. */
+    private relay;
+    /** Resolve the initial target: honor an explicit provider/model, else route. */
+    private resolveTarget;
+    /** Ask the kernel router for the best untried, executable model. */
+    private routerPick;
+    /**
+     * Choose the next target after a failure. 429 / provider-down → rotate to a
+     * different provider; everything else (incl. Groq's tool_use_failed) →
+     * escalate to a stronger model via the kernel ladder, then fall back to rank.
+     */
+    private nextTarget;
+    private toTarget;
+    private rank;
+    private routingRequest;
+    private recordError;
+    private emitSwitch;
+    private sendJson;
+    private readBody;
+}

package/dist/kernel/gateway/openai-gateway.js

@@ -0,0 +1,344 @@
+/**
+ * OpenKernel — OpenAI-compatible Gateway
+ *
+ * A local HTTP endpoint (`/v1/chat/completions`, `/v1/models`) that sits between
+ * the opencode TUI (the Harness) and the real LLM providers. Every chat turn the
+ * TUI makes flows THROUGH the kernel, so the interactive path gains full 1:1
+ * parity with the headless mission path:
+ *
+ *   • routing        — CapabilityRouter.rank() picks the best model per request
+ *                      (model "auto"), honoring the active policy + benchmarks.
+ *   • escalation     — on a provider error (e.g. Groq 400 "tool_use_failed"),
+ *                      RecoveryManager.classify() + router.escalate() swap to a
+ *                      stronger model (or rotate provider) and retry, transparently.
+ *   • health/quota   — recordSuccess/recordFailure/record429 feed the pool.
+ *   • telemetry      — MODEL_CHANGED / PROVIDER_CHANGED / RECOVERY events fire on
+ *                      the kernel bus, so /activity + the mesh see TUI traffic.
+ *
+ * Because the TUI *and* every upstream speak the OpenAI wire format, the gateway
+ * is a TRANSPARENT RELAY: it forwards messages/tools/tool_choice verbatim and
+ * streams the response back byte-for-byte, only choosing WHICH provider+model to
+ * hit. The kernel is purely the routing/recovery brain — no lossy re-encoding.
+ *
+ * The provider CALL is isolated behind the ProviderExecutor interface. The default
+ * FetchExecutor calls the upstream directly; a BifrostExecutor (or any other
+ * execution plane) can be dropped in later without touching the routing logic.
+ */
+import { createServer } from 'node:http';
+/** Default executor: call the upstream OpenAI-compatible endpoint directly. */
+export class FetchExecutor {
+    async execute(target, body, signal) {
+        const headers = { 'content-type': 'application/json' };
+        if (target.apiKey)
+            headers['authorization'] = `Bearer ${target.apiKey}`;
+        Object.assign(headers, target.headers ?? {}); // custom headers win (e.g. non-Authorization key header)
+        const url = `${target.baseURL.replace(/\/+$/, '')}/chat/completions`;
+        return fetch(url, { method: 'POST', headers, body: JSON.stringify(body), signal });
+    }
+}
+const MAX_ATTEMPTS = 4;
+const MODELS_TTL_MS = 30_000;
+export class KernelGateway {
+    opts;
+    server;
+    table = new Map();
+    executor;
+    boundPort = 0;
+    modelsCache;
+    constructor(opts) {
+        this.opts = opts;
+        for (const p of opts.providers)
+            this.table.set(p.id, p);
+        this.executor = opts.executor ?? new FetchExecutor();
+    }
+    get port() {
+        return this.boundPort;
+    }
+    get url() {
+        return `http://${this.opts.host ?? '127.0.0.1'}:${this.boundPort}/v1`;
+    }
+    /** Start listening. Scans ports [port .. port+10] to avoid collisions. */
+    async start() {
+        const host = this.opts.host ?? '127.0.0.1';
+        const first = this.opts.port ?? 47915;
+        let lastErr;
+        for (let candidate = first; candidate <= first + 10; candidate++) {
+            try {
+                await this.listen(host, candidate);
+                this.boundPort = candidate;
+                this.opts.logger.info(`[gateway] OpenAI-compatible endpoint on ${host}:${candidate} (${this.table.size} providers)`);
+                return;
+            }
+            catch (err) {
+                lastErr = err;
+                if (err.code !== 'EADDRINUSE')
+                    throw err;
+            }
+        }
+        throw lastErr ?? new Error('gateway: no free port');
+    }
+    listen(host, port) {
+        return new Promise((resolve, reject) => {
+            const server = createServer((req, res) => void this.handle(req, res));
+            server.once('error', reject);
+            server.listen(port, host, () => {
+                server.off('error', reject);
+                this.server = server;
+                resolve();
+            });
+        });
+    }
+    async stop() {
+        if (this.server) {
+            await new Promise(resolve => this.server.close(() => resolve()));
+            this.server = undefined;
+        }
+    }
+    // ── HTTP ────────────────────────────────────────────────────────────────────
+    async handle(req, res) {
+        const url = req.url ?? '/';
+        try {
+            if (req.method === 'GET' && (url.startsWith('/v1/models') || url === '/v1' || url === '/')) {
+                this.sendJson(res, 200, this.listModels());
+                return;
+            }
+            if (req.method === 'POST' && url.startsWith('/v1/chat/completions')) {
+                const body = JSON.parse(await this.readBody(req));
+                await this.handleChat(body, res);
+                return;
+            }
+            this.sendJson(res, 404, { error: { message: 'not found', type: 'invalid_request_error' } });
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            this.opts.logger.warn(`[gateway] ${message}`);
+            if (!res.headersSent)
+                this.sendJson(res, 500, { error: { message, type: 'gateway_error' } });
+            else
+                try {
+                    res.end();
+                }
+                catch { /* ignore */ }
+        }
+    }
+    listModels() {
+        const data = [
+            { id: 'auto', object: 'model', created: 0, owned_by: 'infinicode' },
+        ];
+        for (const p of this.table.values()) {
+            for (const m of p.models)
+                data.push({ id: `${p.id}/${m.id}`, object: 'model', created: 0, owned_by: p.id });
+        }
+        return { object: 'list', data };
+    }
+    // ── Chat: route → execute → escalate-on-error → relay ────────────────────────
+    async handleChat(body, res) {
+        const stream = body['stream'] === true;
+        const messages = Array.isArray(body['messages']) ? body['messages'] : [];
+        const estTokens = Math.ceil(JSON.stringify(messages).length / 4);
+        const requested = typeof body['model'] === 'string' ? body['model'] : '';
+        const tried = new Set();
+        let target = await this.resolveTarget(requested, estTokens, tried);
+        if (!target) {
+            this.sendJson(res, 503, { error: { message: 'no providers available', type: 'gateway_error' } });
+            return;
+        }
+        const controller = new AbortController();
+        res.on('close', () => controller.abort());
+        let lastStatus = 502;
+        let lastErr = 'no attempt made';
+        for (let attempt = 1; attempt <= MAX_ATTEMPTS && target; attempt++) {
+            tried.add(`${target.providerId}/${target.model}`);
+            const upstream = { ...body, model: target.model, stream };
+            try {
+                const resp = await this.executor.execute(target, upstream, controller.signal);
+                if (resp.ok) {
+                    this.opts.kernel.providerManager.recordSuccess(target.providerId);
+                    await this.relay(resp, res, stream);
+                    return;
+                }
+                lastStatus = resp.status;
+                lastErr = await resp.text().catch(() => `${resp.status}`);
+                this.recordError(target.providerId, resp.status, lastErr);
+            }
+            catch (err) {
+                lastStatus = 502;
+                lastErr = err instanceof Error ? err.message : String(err);
+                if (controller.signal.aborted)
+                    return; // client hung up
+                this.recordError(target.providerId, 0, lastErr);
+            }
+            const next = await this.nextTarget(target, `${lastStatus} ${lastErr}`, estTokens, tried);
+            if (!next)
+                break;
+            this.emitSwitch(target, next, `${lastStatus} ${lastErr}`);
+            target = next;
+        }
+        if (!res.headersSent) {
+            this.sendJson(res, lastStatus >= 400 ? lastStatus : 502, {
+                error: { message: `all routes failed: ${lastErr}`, type: 'gateway_error' },
+            });
+        }
+    }
+    /** Stream bytes through untouched, or relay the JSON body for non-streaming. */
+    async relay(resp, res, stream) {
+        if (stream && resp.body) {
+            res.writeHead(200, {
+                'content-type': resp.headers.get('content-type') ?? 'text/event-stream',
+                'cache-control': 'no-cache',
+                connection: 'keep-alive',
+            });
+            const reader = resp.body.getReader();
+            for (;;) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                res.write(Buffer.from(value));
+            }
+            res.end();
+            return;
+        }
+        const text = await resp.text();
+        res.writeHead(resp.status, { 'content-type': resp.headers.get('content-type') ?? 'application/json' });
+        res.end(text);
+    }
+    // ── Routing helpers ──────────────────────────────────────────────────────────
+    /** Resolve the initial target: honor an explicit provider/model, else route. */
+    async resolveTarget(requested, estTokens, tried) {
+        const raw = requested.trim();
+        const isAuto = raw === '' || raw === 'auto' || raw === 'infinicode/auto' || raw.endsWith('/auto');
+        if (!isAuto) {
+            const slash = raw.indexOf('/');
+            if (slash > 0) {
+                const providerId = raw.slice(0, slash);
+                const modelId = raw.slice(slash + 1);
+                const gp = this.table.get(providerId);
+                if (gp)
+                    return this.toTarget(gp, modelId);
+            }
+            // bare model id — find its owner
+            for (const gp of this.table.values()) {
+                if (gp.models.some(m => m.id === raw))
+                    return this.toTarget(gp, raw);
+            }
+        }
+        return this.routerPick(estTokens, tried);
+    }
+    /** Ask the kernel router for the best untried, executable model. */
+    async routerPick(estTokens, tried) {
+        const ranked = await this.rank(estTokens);
+        for (const d of ranked) {
+            const gp = this.table.get(d.providerId);
+            if (gp && !tried.has(`${d.providerId}/${d.modelId}`))
+                return this.toTarget(gp, d.modelId);
+        }
+        // last resort: first configured model not yet tried
+        for (const gp of this.table.values()) {
+            for (const m of gp.models) {
+                if (!tried.has(`${gp.id}/${m.id}`))
+                    return this.toTarget(gp, m.id);
+            }
+        }
+        return null;
+    }
+    /**
+     * Choose the next target after a failure. 429 / provider-down → rotate to a
+     * different provider; everything else (incl. Groq's tool_use_failed) →
+     * escalate to a stronger model via the kernel ladder, then fall back to rank.
+     */
+    async nextTarget(current, errText, estTokens, tried) {
+        const kind = this.opts.kernel.recovery.classify(errText);
+        const ranked = await this.rank(estTokens);
+        const usable = ranked.filter(d => this.table.has(d.providerId) && !tried.has(`${d.providerId}/${d.modelId}`));
+        if (kind === '429' || kind === 'provider-down') {
+            const diffProvider = usable.find(d => d.providerId !== current.providerId);
+            if (diffProvider)
+                return this.toTarget(this.table.get(diffProvider.providerId), diffProvider.modelId);
+            return usable[0] ? this.toTarget(this.table.get(usable[0].providerId), usable[0].modelId) : null;
+        }
+        // escalate: strictly stronger model than the current one
+        const esc = this.opts.kernel.router.escalate(await this.routingRequest(estTokens), current.providerId, current.model);
+        if (esc && this.table.has(esc.providerId) && !tried.has(`${esc.providerId}/${esc.modelId}`)) {
+            return this.toTarget(this.table.get(esc.providerId), esc.modelId);
+        }
+        return usable[0] ? this.toTarget(this.table.get(usable[0].providerId), usable[0].modelId) : null;
+    }
+    toTarget(gp, model) {
+        return { providerId: gp.id, baseURL: gp.baseURL, apiKey: gp.apiKey, headers: gp.headers, model };
+    }
+    async rank(estTokens) {
+        try {
+            return this.opts.kernel.router.rank(await this.routingRequest(estTokens));
+        }
+        catch {
+            return [];
+        }
+    }
+    async routingRequest(estTokens) {
+        const kernel = this.opts.kernel;
+        const now = Date.now();
+        if (!this.modelsCache || now - this.modelsCache.at > MODELS_TTL_MS) {
+            this.modelsCache = { at: now, models: await kernel.providerManager.getAvailableModels() };
+        }
+        const policy = kernel.policies.get(this.opts.policyName);
+        return {
+            capabilities: this.opts.capabilities ?? ['coding', 'reasoning'],
+            preferences: { reasoning: 88, speed: 70, cost: 'medium', contextLength: Math.max(16_000, estTokens * 2) },
+            policy,
+            availableProviders: kernel.providerManager.listInfos(),
+            availableModels: this.modelsCache.models,
+            estimatedRequestTokens: estTokens,
+        };
+    }
+    // ── Telemetry / health ───────────────────────────────────────────────────────
+    recordError(providerId, status, error) {
+        if (status === 429)
+            this.opts.kernel.providerManager.record429(providerId);
+        else
+            this.opts.kernel.providerManager.recordFailure(providerId);
+        this.opts.kernel.eventBus.emit({
+            type: 'RECOVERY',
+            timestamp: Date.now(),
+            data: { source: 'gateway', providerId, status, error: error.slice(0, 300) },
+        });
+    }
+    emitSwitch(from, to, reason) {
+        const bus = this.opts.kernel.eventBus;
+        if (from.providerId !== to.providerId) {
+            bus.emit({
+                type: 'PROVIDER_CHANGED',
+                timestamp: Date.now(),
+                data: { source: 'gateway', previousProviderId: from.providerId, providerId: to.providerId, reason: reason.slice(0, 200) },
+            });
+        }
+        bus.emit({
+            type: 'MODEL_CHANGED',
+            timestamp: Date.now(),
+            data: {
+                source: 'gateway',
+                previousModelId: `${from.providerId}/${from.model}`,
+                modelId: `${to.providerId}/${to.model}`,
+                providerId: to.providerId,
+                reason: reason.slice(0, 200),
+            },
+        });
+        this.opts.logger.info(`[gateway] ${from.providerId}/${from.model} → ${to.providerId}/${to.model}`);
+    }
+    // ── IO ────────────────────────────────────────────────────────────────────────
+    sendJson(res, status, body) {
+        res.writeHead(status, { 'content-type': 'application/json' });
+        res.end(JSON.stringify(body));
+    }
+    readBody(req) {
+        return new Promise((resolve, reject) => {
+            let data = '';
+            req.on('data', chunk => {
+                data += chunk;
+                if (data.length > 32_000_000)
+                    reject(new Error('body too large'));
+            });
+            req.on('end', () => resolve(data));
+            req.on('error', reject);
+        });
+    }
+}

package/dist/kernel/index.d.ts

@@ -37,6 +37,7 @@ export type { MissionPlannerDeps, PlanOptions } from './planner.js';
 export { normalizeCapabilities, CANONICAL_CAPABILITIES } from './capability-map.js';
 export { phaseBenchmarkFloor, phaseLabel } from './scheduler.js';
 export * from './federation/index.js';
+export * from './gateway/index.js';
 export { createMcpServer, serveMcpStdio } from './mcp/index.js';
 export type { McpServerDeps } from './mcp/index.js';
 export { GoalLoop } from './autonomy/index.js';

package/dist/kernel/index.js

@@ -29,6 +29,8 @@ export { normalizeCapabilities, CANONICAL_CAPABILITIES } from './capability-map.
 export { phaseBenchmarkFloor, phaseLabel } from './scheduler.js';
 // Federation — neutral device mesh (peers, telemetry, config sync, MOLTFED interop)
 export * from './federation/index.js';
+// Gateway — local OpenAI-compatible endpoint backed by kernel routing/recovery
+export * from './gateway/index.js';
 // MCP — north-facing control surface (spawn/dispatch/role/voice/map over the mesh)
 export { createMcpServer, serveMcpStdio } from './mcp/index.js';
 // Autonomy — proactive unattended goal loop (interval/idle/once triggers)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "infinicode",
-  "version": "2.3.4",
+  "version": "2.3.5",
   "description": "OpenKernel — provider-agnostic AI execution kernel. Native coding agent + mission-driven execution runtime.",
   "type": "module",
   "main": "./dist/kernel/index.js",