infinicode 2.3.5 → 2.3.6

package/dist/kernel/federation/federation.js

@@ -11,6 +11,7 @@ import { loadRole, saveRole, rolePreamble } from './role-context.js';
 import { discoverTailscalePeers } from './discovery.js';
 import { LanBeacon } from './lan-discovery.js';
 import { DEFAULT_MESH_PORT } from './types.js';
+import { createDefaultBackendRegistry } from '../agents/index.js';
 export class Federation {
     deps;
     server;
@@ -30,6 +31,8 @@ export class Federation {
     configSync;
     autoUpdate;
     compute = new ComputeRouter();
+    /** Executors available on this node (native kernel + installed CLIs). */
+    backends;
     /** Local subscribers to the merged mesh frame stream (for MCP stream_activity). */
     frameSubs = new Set();
     /** Recent frames for catch-up. */
@@ -41,6 +44,7 @@ export class Federation {
     constructor(deps) {
         this.deps = deps;
         this.client = new MeshClient({ token: deps.options.token });
+        this.backends = deps.backends ?? createDefaultBackendRegistry();
         this.configSync = new ConfigSync({ logger: deps.logger, apply: deps.options.applyConfig });
         this.autoUpdate = new AutoUpdate({
             version: deps.options.version,
@@ -59,7 +63,7 @@ export class Federation {
             host: options.host,
             token: options.token,
             logger,
-            getManifest: () => buildManifest(identity, this.deps.describe()),
+            getManifest: () => buildManifest(identity, this.describeWithBackends()),
             getNodes: () => this.nodeStatuses(),
             runCommand: (input) => this.deps.kernel.command(input),
             onRpc: (env, remote) => this.onRpc(env, remote),
@@ -107,7 +111,7 @@ export class Federation {
                 return reply(env, 'ack', self, { load: loadFromSnapshot(this.lastHw) });
             case 'hello':
                 this.learnInboundPeer(env, remote);
-                return reply(env, 'welcome', self, buildManifest(this.deps.identity, this.deps.describe()));
+                return reply(env, 'welcome', self, buildManifest(this.deps.identity, this.describeWithBackends()));
             case 'task.dispatch': {
                 // Non-blocking handoff: register the run, ack with a runId immediately,
                 // execute in the background, and let the caller follow it.
@@ -144,6 +148,29 @@ export class Federation {
                 const saved = saveRole(r);
                 return reply(env, 'ack', self, saved);
             }
+            case 'agents.list':
+                return reply(env, 'agents.offer', self, this.localAgents());
+            case 'message.send': {
+                // Wake / continue a CLI agent session on this node with a new message.
+                const d = env.data;
+                const runId = newId();
+                this.runs.set(runId, {
+                    runId,
+                    status: 'running',
+                    description: `msg→${(d.sessionId ?? '').slice(0, 8)}`,
+                    agent: d.agent,
+                    sessionId: d.sessionId,
+                    startedAt: Date.now(),
+                });
+                void this.runTaskAsync(runId, {
+                    description: 'message',
+                    capabilities: [],
+                    prompt: d.message,
+                    agent: d.agent,
+                    sessionId: d.sessionId,
+                });
+                return reply(env, 'message.accepted', self, { runId, sessionId: d.sessionId });
+            }
             default:
                 return reply(env, 'ack', self);
         }
@@ -207,12 +234,19 @@ export class Federation {
         if (!rec)
             return;
         const nodeId = this.deps.identity.nodeId;
-        this.server?.broadcast(frame('ev', nodeId, { k: 'RUN_STARTED', run: runId, desc: task.description }));
+        const backendId = task.agent && task.agent !== 'kernel' ? task.agent : null;
+        rec.agent = backendId ?? 'kernel';
+        this.server?.broadcast(frame('ev', nodeId, { k: 'RUN_STARTED', run: runId, desc: task.description, agent: rec.agent }));
         try {
-            const result = await this.runTask(task);
-            rec.status = result.status === 'COMPLETED' ? 'completed' : 'failed';
-            rec.missionId = result.missionId;
-            rec.outputs = result.outputs;
+            if (backendId) {
+                await this.runViaBackend(runId, backendId, task, rec);
+            }
+            else {
+                const result = await this.runTask(task);
+                rec.status = result.status === 'COMPLETED' ? 'completed' : 'failed';
+                rec.missionId = result.missionId;
+                rec.outputs = result.outputs;
+            }
             rec.completedAt = Date.now();
         }
         catch (err) {
@@ -222,6 +256,39 @@ export class Federation {
         }
         this.server?.broadcast(frame('ev', nodeId, { k: 'RUN_COMPLETED', run: runId, status: rec.status }));
     }
+    /**
+     * Execute a dispatched task with a third-party CLI backend (Claude Code /
+     * Codex / OpenCode) instead of the native kernel. The backend's activity
+     * streams up the same mesh SSE feed (log/ev frames), and its native session id
+     * is captured on the RunRecord so the run can be followed and later messaged.
+     */
+    async runViaBackend(runId, backendId, task, rec) {
+        const backend = this.backends.get(backendId);
+        if (!backend || !backend.available()) {
+            throw new Error(`backend not available on this node: ${backendId}`);
+        }
+        const nodeId = this.deps.identity.nodeId;
+        const localRole = loadRole();
+        const preamble = rolePreamble(localRole);
+        const res = await backend.run({ prompt: task.prompt, capabilities: task.capabilities, model: task.model, sessionId: task.sessionId }, {
+            runId,
+            rolePreamble: preamble,
+            onFrame: f => {
+                if (f.kind === 'log' && f.text) {
+                    this.server?.broadcast(frame('log', nodeId, { run: runId, agent: backendId, line: f.text }));
+                }
+                else {
+                    this.server?.broadcast(frame('ev', nodeId, { k: 'AGENT_OUTPUT', run: runId, agent: backendId, kind: f.kind, text: f.text }));
+                }
+            },
+        });
+        rec.status = res.status;
+        rec.sessionId = res.sessionId;
+        rec.missionId = res.sessionId ?? runId;
+        rec.outputs = [{ status: res.status, content: res.content, error: res.error }];
+        if (res.status === 'failed' && res.error)
+            rec.error = res.error;
+    }
     // ── Outbound operations ──────────────────────────────────────────────────
     /**
      * Hand a task to the best-fit connected peer (compute-routed) or a named one.
@@ -292,6 +359,96 @@ export class Federation {
         const res = await this.client.rpc(peer.url, envelope('command', this.deps.identity.nodeId, { input }, { to: nodeId }));
         return res.data;
     }
+    // ── Agent mailbox (CLI sessions message each other) ────────────────────────
+    /**
+     * CLI agent sessions on THIS node — any run that used a CLI backend and
+     * captured a session id. Live while running, dormant (still resumable) once
+     * complete. Deduped by session, newest kept, so a session that's been messaged
+     * several times shows once.
+     */
+    localAgents() {
+        const self = this.deps.identity.nodeId;
+        const bySession = new Map();
+        for (const rec of this.runs.values()) {
+            if (!rec.sessionId || !rec.agent || rec.agent === 'kernel')
+                continue;
+            const existing = bySession.get(rec.sessionId);
+            if (existing && existing.lastActiveAt >= (rec.completedAt ?? rec.startedAt))
+                continue;
+            bySession.set(rec.sessionId, {
+                agentId: rec.runId,
+                nodeId: self,
+                backend: rec.agent,
+                sessionId: rec.sessionId,
+                address: `${self}/${rec.sessionId}`,
+                status: rec.status,
+                description: rec.description,
+                lastActiveAt: rec.completedAt ?? rec.startedAt,
+            });
+        }
+        return [...bySession.values()];
+    }
+    /** All messageable CLI agent sessions across the mesh (local + peers). */
+    async agents() {
+        const self = this.deps.identity.nodeId;
+        const out = [...this.localAgents()];
+        for (const peer of this.mesh?.connected() ?? []) {
+            try {
+                const res = await this.client.rpc(peer.url, envelope('agents.list', self, {}, { to: peer.nodeId }));
+                if (Array.isArray(res.data))
+                    out.push(...res.data);
+            }
+            catch {
+                // peer unreachable — skip
+            }
+        }
+        return out;
+    }
+    /** Resolve an address (`nodeId/sessionId`, a sessionId, or a runId) to a handle. */
+    async resolveAgent(address) {
+        const dir = await this.agents();
+        if (address.includes('/')) {
+            const slash = address.indexOf('/');
+            const nodeId = address.slice(0, slash);
+            const sessionId = address.slice(slash + 1);
+            return dir.find(a => a.nodeId === nodeId && a.sessionId === sessionId) ?? null;
+        }
+        return dir.find(a => a.agentId === address) ?? dir.find(a => a.sessionId === address) ?? null;
+    }
+    /**
+     * Message a CLI agent session — wherever it lives on the mesh. Resumes that
+     * exact session with the text (so the agent keeps its context) and returns a
+     * runId to follow the reply. This is how one CLI agent talks to another.
+     */
+    async sendTo(address, text, opts) {
+        const target = await this.resolveAgent(address);
+        if (!target)
+            return null;
+        const self = this.deps.identity.nodeId;
+        if (target.nodeId === self) {
+            const runId = newId();
+            this.runs.set(runId, {
+                runId, status: 'running', description: `msg→${target.sessionId.slice(0, 8)}`,
+                agent: target.backend, sessionId: target.sessionId, startedAt: Date.now(),
+            });
+            void this.runTaskAsync(runId, {
+                description: 'message', capabilities: [], prompt: text,
+                agent: target.backend, sessionId: target.sessionId,
+            });
+            const record = opts?.wait ? await this.awaitRun(runId, opts.timeoutMs ?? 120_000) : undefined;
+            return { runId, nodeId: self, record };
+        }
+        const peer = this.mesh?.get(target.nodeId);
+        if (!peer)
+            return null;
+        const res = await this.client.rpc(peer.url, envelope('message.send', self, {
+            sessionId: target.sessionId, agent: target.backend, message: text, from: self,
+        }, { to: target.nodeId }));
+        const runId = res.data.runId;
+        this.dispatchedRuns.set(runId, target.nodeId);
+        const record = opts?.wait ? await this.awaitRun(runId, opts?.timeoutMs ?? 120_000) : undefined;
+        return { runId, nodeId: target.nodeId, record };
+    }
     /** Hub: publish shared config (providers/API keys/policy) to the fleet. */
     publishConfig(cfg) {
         return this.configSync.publish(cfg);
@@ -406,9 +563,24 @@ export class Federation {
         this.lan.start();
     }
     // ── Views ────────────────────────────────────────────────────────────────
+    /** Backend ids this node can execute tasks with ('kernel' + installed CLIs). */
+    availableBackends() {
+        return this.backends.availableIds();
+    }
+    /**
+     * The manifest inputs augmented with `backend:<id>` capability tags for each
+     * installed executor. This lets the compute-router match a task that asks for
+     * a specific agent (e.g. capabilities:['backend:claude']) to a node that
+     * actually has that CLI — without changing the caller's describe().
+     */
+    describeWithBackends() {
+        const d = this.deps.describe();
+        const tags = this.backends.availableIds().map(id => `backend:${id}`);
+        return { ...d, capabilities: [...d.capabilities, ...tags] };
+    }
     /** Neutral node-status list (self + peers) — feeds the mesh map. */
     nodeStatuses() {
-        const d = this.deps.describe();
+        const d = this.describeWithBackends();
         const self = selfNodeStatus(this.deps.identity, this.lastHw ?? this.telemetry.collect(), {
             version: d.version,
             capabilities: d.capabilities,

package/dist/kernel/federation/types.d.ts

@@ -126,7 +126,7 @@ export interface NodeStatus {
     load?: number;
     lastSeenAt: number;
 }
-export type MessageKind = 'hello' | 'welcome' | 'heartbeat' | 'manifest' | 'task.dispatch' | 'task.accepted' | 'task.status' | 'task.result' | 'task.cancel' | 'command' | 'command.result' | 'config.request' | 'config.offer' | 'update.announce' | 'update.request' | 'role.get' | 'role.set' | 'event' | 'telemetry' | 'ack' | 'error';
+export type MessageKind = 'hello' | 'welcome' | 'heartbeat' | 'manifest' | 'task.dispatch' | 'task.accepted' | 'task.status' | 'task.result' | 'task.cancel' | 'command' | 'command.result' | 'config.request' | 'config.offer' | 'update.announce' | 'update.request' | 'role.get' | 'role.set' | 'agents.list' | 'agents.offer' | 'message.send' | 'message.accepted' | 'event' | 'telemetry' | 'ack' | 'error';
 /** A dispatched/received task run — tracked for non-blocking handoff + monitoring. */
 export interface RunRecord {
     runId: string;
@@ -141,6 +141,31 @@ export interface RunRecord {
     error?: string;
     startedAt: number;
     completedAt?: number;
+    /** Which executor ran this — 'kernel' (native) or a CLI backend id. */
+    agent?: string;
+    /** The executor's native session id (CLI backends) — enables resume + messaging. */
+    sessionId?: string;
+}
+/**
+ * A messageable CLI agent session on the mesh. Any run that used a CLI backend
+ * and captured a native session id becomes an addressable agent — live while
+ * running, dormant (but still resumable) once complete. Its address is
+ * `nodeId/sessionId`; sending a message resumes that exact CLI session.
+ */
+export interface AgentHandle {
+    /** runId that created/owns the session (the follow handle). */
+    agentId: string;
+    /** node holding the session. */
+    nodeId: string;
+    /** which CLI backend runs it — 'claude' | 'codex' | 'opencode'. */
+    backend: string;
+    /** the CLI's native session id (what resume targets). */
+    sessionId: string;
+    /** routable address: `${nodeId}/${sessionId}`. */
+    address: string;
+    status: 'running' | 'completed' | 'failed';
+    description: string;
+    lastActiveAt: number;
 }
 /** Persistent per-device role + server-architecture context. */
 export interface RoleContext {

package/dist/kernel/free-providers.js

@@ -101,6 +101,89 @@ export const FREE_PROVIDERS = [
         ],
         notes: 'NVIDIA build.nvidia.com offers free NIM endpoints. 1000 req/month free tier.',
     },
+    {
+        id: 'cerebras',
+        name: 'Cerebras',
+        baseURL: 'https://api.cerebras.ai/v1',
+        keyUrl: 'https://cloud.cerebras.ai',
+        free: true,
+        recommended: {
+            coding: ['qwen-3-235b-a22b-instruct-2507', 'gpt-oss-120b'],
+            architecture: ['qwen-3-235b-a22b-instruct-2507'],
+            research: ['gpt-oss-120b'],
+            review: ['qwen-3-235b-a22b-instruct-2507'],
+            reasoning: ['qwen-3-235b-a22b-instruct-2507'],
+        },
+        knownModels: [
+            { id: 'qwen-3-235b-a22b-instruct-2507', name: 'Qwen3 235B', contextLength: 128_000, capabilities: ['coding', 'reasoning'], supportsFunctionCalling: true },
+            { id: 'gpt-oss-120b', name: 'GPT-OSS 120B', contextLength: 128_000, capabilities: ['coding', 'reasoning'], supportsFunctionCalling: true },
+            { id: 'qwen-3-32b', name: 'Qwen3 32B', contextLength: 128_000, capabilities: ['coding', 'reasoning'], supportsFunctionCalling: true },
+            { id: 'llama-3.3-70b', name: 'Llama 3.3 70B', contextLength: 128_000, capabilities: ['coding', 'reasoning'], supportsFunctionCalling: true },
+        ],
+        notes: 'Fastest inference (wafer-scale). Free: ~1M tokens/day, 30 RPM. Frontier open models.',
+    },
+    {
+        id: 'chutes',
+        name: 'Chutes',
+        baseURL: 'https://llm.chutes.ai/v1',
+        keyUrl: 'https://chutes.ai',
+        free: true,
+        recommended: {
+            coding: ['zai-org/GLM-4.6', 'deepseek-ai/DeepSeek-V3.1', 'moonshotai/Kimi-K2-Instruct'],
+            architecture: ['deepseek-ai/DeepSeek-V3.1', 'zai-org/GLM-4.6'],
+            research: ['deepseek-ai/DeepSeek-V3.1'],
+            reasoning: ['deepseek-ai/DeepSeek-R1'],
+            review: ['zai-org/GLM-4.6'],
+        },
+        knownModels: [
+            { id: 'zai-org/GLM-4.6', name: 'GLM-4.6', contextLength: 200_000, capabilities: ['coding', 'reasoning'], supportsFunctionCalling: true },
+            { id: 'moonshotai/Kimi-K2-Instruct', name: 'Kimi K2', contextLength: 128_000, capabilities: ['coding', 'reasoning'], supportsFunctionCalling: true },
+            { id: 'deepseek-ai/DeepSeek-V3.1', name: 'DeepSeek V3.1', contextLength: 128_000, capabilities: ['coding', 'reasoning'], supportsFunctionCalling: true },
+            { id: 'Qwen/Qwen3-235B-A22B', name: 'Qwen3 235B', contextLength: 256_000, capabilities: ['coding', 'reasoning'], supportsFunctionCalling: true },
+            { id: 'deepseek-ai/DeepSeek-R1', name: 'DeepSeek R1', contextLength: 128_000, capabilities: ['reasoning'] },
+        ],
+        notes: 'Huge decentralized catalog — GLM, Kimi, DeepSeek, Qwen frontier models. Generous free tier.',
+    },
+    {
+        id: 'sambanova',
+        name: 'SambaNova',
+        baseURL: 'https://api.sambanova.ai/v1',
+        keyUrl: 'https://cloud.sambanova.ai',
+        free: true,
+        recommended: {
+            coding: ['DeepSeek-V3.1', 'Meta-Llama-3.3-70B-Instruct'],
+            architecture: ['DeepSeek-V3.1'],
+            research: ['Meta-Llama-3.3-70B-Instruct'],
+            reasoning: ['DeepSeek-R1'],
+        },
+        knownModels: [
+            { id: 'DeepSeek-V3.1', name: 'DeepSeek V3.1', contextLength: 128_000, capabilities: ['coding', 'reasoning'], supportsFunctionCalling: true },
+            { id: 'Meta-Llama-3.3-70B-Instruct', name: 'Llama 3.3 70B', contextLength: 128_000, capabilities: ['coding', 'reasoning'], supportsFunctionCalling: true },
+            { id: 'gpt-oss-120b', name: 'GPT-OSS 120B', contextLength: 128_000, capabilities: ['coding', 'reasoning'], supportsFunctionCalling: true },
+            { id: 'Qwen3-32B', name: 'Qwen3 32B', contextLength: 128_000, capabilities: ['coding', 'reasoning'], supportsFunctionCalling: true },
+        ],
+        notes: 'Very fast (RDU). Permanent free tier (20 RPM) + $5 trial credits. No card.',
+    },
+    {
+        id: 'mistral',
+        name: 'Mistral',
+        baseURL: 'https://api.mistral.ai/v1',
+        keyUrl: 'https://console.mistral.ai/api-keys',
+        free: true,
+        recommended: {
+            coding: ['codestral-latest', 'mistral-large-latest'],
+            architecture: ['mistral-large-latest'],
+            research: ['mistral-large-latest'],
+            reasoning: ['magistral-medium-latest'],
+        },
+        knownModels: [
+            { id: 'mistral-large-latest', name: 'Mistral Large', contextLength: 128_000, capabilities: ['coding', 'reasoning'], supportsFunctionCalling: true },
+            { id: 'codestral-latest', name: 'Codestral', contextLength: 256_000, capabilities: ['coding', 'reasoning'], supportsFunctionCalling: true },
+            { id: 'magistral-medium-latest', name: 'Magistral Medium', contextLength: 128_000, capabilities: ['reasoning'], supportsFunctionCalling: true },
+            { id: 'mistral-small-latest', name: 'Mistral Small', contextLength: 128_000, capabilities: ['coding', 'reasoning'], supportsFunctionCalling: true },
+        ],
+        notes: 'La Plateforme free (Experiment) tier ≈ 1B tokens/month. Codestral is a strong coder.',
+    },
     {
         id: 'hf',
         name: 'Hugging Face Inference',

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

@@ -45,6 +45,16 @@ export interface KernelGatewayOptions {
     executor?: ProviderExecutor;
     /** Capabilities to route interactive chat under. */
     capabilities?: Capability[];
+    /**
+     * Soft benchmark floor for `auto` routing. Biases interactive coding toward
+     * capable models (weak ones become fallbacks, not first picks) so demanding
+     * work doesn't open on a lazy model — without hard-pinning anything.
+     */
+    minBenchmark?: number;
+    /** Stall guards (ms). Override the defaults (mainly for tests). */
+    headersTimeoutMs?: number;
+    firstChunkTimeoutMs?: number;
+    idleTimeoutMs?: number;
 }
 export declare class KernelGateway {
     private opts;
@@ -56,15 +66,55 @@ export declare class KernelGateway {
     constructor(opts: KernelGatewayOptions);
     get port(): number;
     get url(): string;
-    /** Start listening. Scans ports [port .. port+10] to avoid collisions. */
+    /**
+     * Start listening. Scans ports [port .. port+20] then falls back to an OS-chosen
+     * ephemeral port. Retries past BOTH EADDRINUSE (a lingering session holds it) and
+     * EACCES (a Windows excluded/reserved range) — never dies on a single bad port,
+     * since the whole point is that the gateway must come up so the TUI gets routing.
+     */
     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;
+    /**
+     * Build a continuation request: the original messages plus the partial answer as
+     * an assistant prefix so a fresh model resumes it instead of restarting. `prefix:
+     * true` is the continue-this-message convention (DeepSeek/Mistral/Zhipu/Qwen);
+     * providers that ignore it at worst restart — still better than a dead task.
+     */
+    private buildContinuation;
+    /** Close an already-open SSE stream with a synthetic clean finish so the client
+     *  gets a proper end-of-turn instead of hanging on a half-open connection. */
+    private endStream;
+    /**
+     * Run one model. Returns forwarded:true only after the response is validated
+     * and sent to the client; otherwise nothing is written to `res` and the caller
+     * swaps to the next model. Catches BOTH transport failures (non-2xx) AND bad
+     * tool calls the model streams back on a 200 (a weak model naming a tool that
+     * isn't in request.tools — e.g. `glob={...}` — which downstream would reject).
+     */
+    private attempt;
+    /**
+     * Relay an SSE stream, but with a small look-ahead: buffer frames until the
+     * first tool-call name or content delta. If that first tool call names a tool
+     * not in request.tools (or an error frame arrives), fail WITHOUT writing to the
+     * client so the caller can swap models. Once a valid start is seen, commit and
+     * stream the rest live (so large generations still stream token-by-token).
+     */
+    private streamValidated;
+    /**
+     * Classify one SSE frame: does it error, is it a safe commit point, is it a
+     * TERMINAL frame (finish_reason / `[DONE]` — held back so a truncation can be
+     * continued), and what visible content does it carry (accumulated so a fresh
+     * model can continue the answer from where a dead provider left off)?
+     */
+    private inspectFrame;
+    /** Validate a non-streamed response body for unknown tool calls / errors. */
+    private validateResponse;
+    /** The set of tool names the request declared (OpenAI tools[].function.name). */
+    private allowedTools;
     /** Resolve the initial target: honor an explicit provider/model, else route. */
     private resolveTarget;
     /** Ask the kernel router for the best untried, executable model. */
@@ -75,6 +125,8 @@ export declare class KernelGateway {
      * escalate to a stronger model via the kernel ladder, then fall back to rank.
      */
     private nextTarget;
+    /** First configured provider/model not in `tried` (optionally skipping a provider). */
+    private firstUntried;
     private toTarget;
     private rank;
     private routingRequest;