infinicode 2.3.3 → 2.3.5

package/.opencode/plugins/mesh-commands.tsx

@@ -0,0 +1,139 @@
+/** @jsxImportSource @opentui/solid */
+/**
+ * infinicode — mesh command palette
+ *
+ * Adds the OpenKernel mesh/kernel slash-commands natively to the TUI's `/`
+ * command palette. Each command is dispatched to a LOCAL mesh node over HTTP
+ * (POST /fed/command → kernel.command()), so the same command surface exposed by
+ * `infinicode serve`'s console and the CLI is available right inside the TUI.
+ *
+ * The local node is started (or reused) by `infinicode run`, which injects:
+ *   INFINICODE_MESH_URL   e.g. http://127.0.0.1:47913
+ *   INFINICODE_MESH_TOKEN optional bearer token
+ *
+ * Argless commands (/nodes, /running, /activity, /whoami, /mesh-help) run
+ * immediately and show output in an alert. Arg-taking commands (/node, /build,
+ * /follow, /dispatch, /goal, /mission, /role) open a prompt first.
+ */
+import type { TuiPlugin, TuiPluginApi, TuiPluginModule } from "@opencode-ai/plugin/tui"
+import { createBindingLookup } from "@opentui/keymap/extras"
+
+type CommandResult = { ok?: boolean; text?: string; data?: unknown }
+
+const meshUrl = () => (process.env.INFINICODE_MESH_URL ?? "http://127.0.0.1:47913").replace(/\/+$/, "")
+const meshToken = () => process.env.INFINICODE_MESH_TOKEN
+
+/** POST a slash-command to the local mesh node and return its CommandResult. */
+async function send(input: string): Promise<CommandResult> {
+  const token = meshToken()
+  try {
+    const res = await fetch(`${meshUrl()}/fed/command`, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        ...(token ? { authorization: `Bearer ${token}` } : {}),
+      },
+      body: JSON.stringify({ input }),
+      signal: AbortSignal.timeout(30_000),
+    })
+    if (!res.ok) return { ok: false, text: `mesh error ${res.status} — is a node running? (infinicode serve)` }
+    return (await res.json()) as CommandResult
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e)
+    return { ok: false, text: `no local mesh node reachable at ${meshUrl()} (${msg})` }
+  }
+}
+
+/** Render a CommandResult in a scrollable alert dialog. */
+function show(api: TuiPluginApi, title: string, res: CommandResult): void {
+  const DialogAlert = api.ui.DialogAlert
+  const message = (res.text && res.text.trim()) || (res.ok ? "(no output)" : "command failed")
+  api.ui.dialog.setSize("large")
+  api.ui.dialog.replace(() => (
+    <DialogAlert title={title} message={message} onConfirm={() => api.ui.dialog.clear()} />
+  ))
+}
+
+/** Run a fixed slash-command now and show the result. */
+function runNow(api: TuiPluginApi, title: string, input: string): void {
+  api.ui.toast({ variant: "info", title: "mesh", message: `${input} …`, duration: 1200 })
+  void send(input).then((res) => show(api, title, res))
+}
+
+/** Open a prompt, then dispatch `<slash> <entered args>`. */
+function runWithArgs(
+  api: TuiPluginApi,
+  title: string,
+  slash: string,
+  placeholder: string,
+): void {
+  const DialogPrompt = api.ui.DialogPrompt
+  api.ui.dialog.setSize("medium")
+  api.ui.dialog.replace(() => (
+    <DialogPrompt
+      title={title}
+      value=""
+      placeholder={placeholder}
+      onConfirm={(args: string) => {
+        api.ui.dialog.clear()
+        const input = args && args.trim() ? `${slash} ${args.trim()}` : slash
+        api.ui.toast({ variant: "info", title: "mesh", message: `${input} …`, duration: 1200 })
+        void send(input).then((res) => show(api, title, res))
+      }}
+      onCancel={() => api.ui.dialog.clear()}
+    />
+  ))
+}
+
+interface Spec {
+  name: string
+  slashName: string
+  title: string
+  /** if set, prompt for args first with this placeholder; else run immediately */
+  arg?: string
+  /** the underlying kernel slash-command (defaults to `/${slashName}`) */
+  cmd?: string
+}
+
+const SPECS: Spec[] = [
+  { name: "mesh_nodes", slashName: "nodes", title: "Mesh nodes" },
+  { name: "mesh_running", slashName: "running", title: "Running tasks" },
+  { name: "mesh_activity", slashName: "activity", title: "Mesh activity" },
+  { name: "mesh_whoami", slashName: "whoami", title: "This node" },
+  { name: "mesh_help", slashName: "mesh-help", title: "Mesh commands", cmd: "/help" },
+  { name: "mesh_node", slashName: "node", title: "Node control", arg: "<node> <message>", cmd: "/node" },
+  { name: "mesh_build", slashName: "build", title: "Phased build", arg: "<node> <goal>", cmd: "/build" },
+  { name: "mesh_dispatch", slashName: "dispatch", title: "Dispatch task", arg: "<node> <task>", cmd: "/dispatch" },
+  { name: "mesh_follow", slashName: "follow", title: "Follow run", arg: "<run-id>", cmd: "/follow" },
+  { name: "mesh_goal", slashName: "goal", title: "New goal", arg: "<goal description>", cmd: "/goal" },
+  { name: "mesh_mission", slashName: "mission", title: "Mission", arg: "<mission description>", cmd: "/mission" },
+  { name: "mesh_role", slashName: "role", title: "Set role", arg: "<role>", cmd: "/role" },
+]
+
+const tui: TuiPlugin = async (api, options) => {
+  if (options?.enabled === false) return
+  const keys = createBindingLookup({})
+
+  api.keymap.registerLayer({
+    commands: SPECS.map((s) => ({
+      name: s.name,
+      title: s.title,
+      category: "Mesh",
+      namespace: "palette" as const,
+      slashName: s.slashName,
+      run() {
+        const cmd = s.cmd ?? `/${s.slashName}`
+        if (s.arg) runWithArgs(api, s.title, cmd, s.arg)
+        else runNow(api, s.title, cmd)
+      },
+    })),
+    bindings: keys.gather("mesh.global", SPECS.map((s) => s.name)),
+  })
+}
+
+const plugin: TuiPluginModule & { id: string } = {
+  id: "infinicode-mesh-commands",
+  tui,
+}
+
+export default plugin

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.3';
+const VERSION = '2.3.5';
 const config = new Conf({
     projectName: 'infinicode',
     defaults: DEFAULT_CONFIG,

package/dist/commands/run.js

@@ -16,14 +16,14 @@
  */
 import chalk from 'chalk';
 import ora from 'ora';
-import { existsSync } from 'node:fs';
+import { existsSync, readFileSync } from 'node:fs';
 import { dirname, join, resolve } from 'node:path';
-import { fileURLToPath } from 'node:url';
+import { fileURLToPath, pathToFileURL } from 'node:url';
 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 } 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. */
@@ -309,6 +313,135 @@ function ensureModelInjected(providers, providerId, modelId) {
     if (!p.models[modelId])
         p.models[modelId] = { name: modelId };
 }
+function runPkgVersion() {
+    try {
+        return JSON.parse(readFileSync(join(resolve(__dirname, '..', '..'), 'package.json'), 'utf8')).version ?? '0.0.0';
+    }
+    catch {
+        return '0.0.0';
+    }
+}
+/** Is a mesh node already listening at this URL? (e.g. a separate `infinicode serve`). */
+async function meshAlive(url, token) {
+    try {
+        const res = await fetch(`${url}/fed/manifest`, {
+            headers: token ? { authorization: `Bearer ${token}` } : undefined,
+            signal: AbortSignal.timeout(1500),
+        });
+        return res.ok;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Make the TUI a mesh participant so the in-TUI slash commands (/nodes, /build,
+ * /activity …) have a local node to talk to. If a node is already running on the
+ * configured port (a separate `infinicode serve`), point the TUI at THAT one;
+ * 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, kernel) {
+    if (process.env.INFINICODE_NO_MESH)
+        return null;
+    const fed = config.get('federation') ?? {};
+    const port = fed.port ?? 47913;
+    const token = fed.token;
+    const url = `http://127.0.0.1:${port}`;
+    try {
+        // Reuse an already-running node (don't double-bind the port).
+        if (await meshAlive(url, token))
+            return { url, token, stop: async () => { } };
+        const role = (fed.role ?? 'peer');
+        const identity = loadOrCreateIdentity({ role, displayName: fed.displayName });
+        const version = runPkgVersion();
+        const describe = () => {
+            const defs = kernel.workerRuntime.listRegisteredDefinitions();
+            return {
+                version,
+                capabilities: [...new Set(defs.flatMap(d => d.capabilities))],
+                workers: defs.map(d => d.type),
+                commands: kernel.commands.list().map(c => c.name),
+                providers: kernel.providerManager.listInfos().map(p => p.id),
+            };
+        };
+        const federation = new Federation({
+            kernel, identity, describe, logger: new SilentLogger(),
+            options: {
+                version, port, host: fed.host, token, seeds: fed.seeds,
+                autoPullConfig: role === 'satellite',
+            },
+        });
+        kernel.attachFederation(federation);
+        await federation.start();
+        if (fed.lan)
+            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(); },
+        };
+    }
+    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);
@@ -316,36 +449,85 @@ 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, sessionKernel);
+    if (mesh) {
+        process.env.INFINICODE_MESH_URL = mesh.url;
+        if (mesh.token)
+            process.env.INFINICODE_MESH_TOKEN = mesh.token;
+    }
     // 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
+    // a local mesh node is available (else the commands would have nothing to hit).
+    const pluginPaths = [];
+    if (mesh) {
+        const pluginFile = join(resolve(__dirname, '..', '..'), '.opencode', 'plugins', 'mesh-commands.tsx');
+        if (existsSync(pluginFile))
+            pluginPaths.push(pathToFileURL(pluginFile).href);
+    }
     process.env.OPENCODE_CONFIG_CONTENT = JSON.stringify({
         $schema: 'https://opencode.ai/config.json',
         provider: providers,
         model: modelRef,
         small_model: modelRef,
         enabled_providers: Object.keys(providers),
+        ...(pluginPaths.length > 0 ? { plugin: pluginPaths } : {}),
         agent: {
             build: {
                 model: modelRef,
@@ -360,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) {
@@ -384,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, [], {
@@ -392,10 +582,12 @@ export async function runAgent(_masterUrl, _model, _useTui, config) {
         });
     }
     catch (e) {
+        await cleanup();
         const err = e;
         if (err.exitCode) {
             process.exit(err.exitCode);
         }
         throw e;
     }
+    await cleanup();
 }

package/dist/kernel/federation/federation.js

@@ -61,6 +61,7 @@ export class Federation {
             logger,
             getManifest: () => buildManifest(identity, this.deps.describe()),
             getNodes: () => this.nodeStatuses(),
+            runCommand: (input) => this.deps.kernel.command(input),
             onRpc: (env, remote) => this.onRpc(env, remote),
         });
         await this.server.start();

package/dist/kernel/federation/transport-http.d.ts

@@ -9,6 +9,9 @@ export interface MeshServerOptions {
     getManifest: () => NodeManifest;
     /** Optional: full mesh view (self + peers) for the GET /fed/nodes probe. */
     getNodes?: () => unknown;
+    /** Optional: run a kernel slash-command on this node (POST /fed/command).
+     *  Powers the in-TUI mesh command palette. */
+    runCommand?: (input: string) => Promise<unknown>;
     onRpc: RpcHandler;
     logger: Logger;
 }

package/dist/kernel/federation/transport-http.js

@@ -78,6 +78,31 @@ export class MeshServer {
             this.openStream(req, res);
             return;
         }
+        if (req.method === 'POST' && url.startsWith('/fed/command')) {
+            if (!this.opts.runCommand) {
+                res.writeHead(404).end('no command handler');
+                return;
+            }
+            this.readBody(req)
+                .then(async (body) => {
+                let input = '';
+                try {
+                    input = JSON.parse(body).input ?? '';
+                }
+                catch {
+                    res.writeHead(400).end('bad json');
+                    return;
+                }
+                const result = await this.opts.runCommand(input);
+                res.writeHead(200, { 'content-type': 'application/json' });
+                res.end(JSON.stringify(result ?? { ok: false, text: 'no result' }));
+            })
+                .catch(err => {
+                this.opts.logger.warn(`[federation] command error: ${err instanceof Error ? err.message : String(err)}`);
+                res.writeHead(500).end('command failed');
+            });
+            return;
+        }
         if (req.method === 'POST' && url.startsWith('/fed/rpc')) {
             this.readBody(req)
                 .then(async (body) => {

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.3",
+  "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",