infinicode 1.0.0 → 2.0.0

package/dist/kernel/providers/openai-compatible-provider.js

@@ -0,0 +1,233 @@
+import { openAICompatBaseURL } from '../provider-url.js';
+export class OpenAICompatibleProvider {
+    info;
+    baseURL;
+    apiKey;
+    headerName;
+    timeoutMs;
+    knownModels;
+    constructor(options) {
+        // Normalize to the canonical OpenAI-compatible base (exactly one version
+        // segment where the provider expects it) so chat/models URLs are correct
+        // regardless of how the base URL was stored.
+        this.baseURL = openAICompatBaseURL(options.baseURL);
+        this.apiKey = options.apiKey;
+        this.headerName = options.headerName ?? 'Authorization';
+        this.timeoutMs = options.timeoutMs ?? 30_000;
+        this.knownModels = options.knownModels ?? [];
+        this.info = {
+            id: options.id,
+            name: options.name,
+            type: options.type ?? 'cloud',
+            healthy: false,
+            available: !!this.apiKey || options.type === 'local',
+            baseURL: this.baseURL,
+        };
+    }
+    async capabilities() {
+        const models = await this.fetchModels();
+        return {
+            streaming: true,
+            functionCalling: true,
+            vision: models.some(m => m.supportsVision),
+            maxContextLength: Math.max(8192, ...models.map(m => m.contextLength)),
+            models,
+        };
+    }
+    async complete(request) {
+        const start = Date.now();
+        const response = await fetch(`${this.baseURL}/chat/completions`, {
+            method: 'POST',
+            headers: this.headers(),
+            body: JSON.stringify({
+                model: request.model,
+                messages: this.buildMessages(request),
+                temperature: request.temperature ?? 0.3,
+                max_tokens: request.maxTokens ?? 4096,
+                stream: false,
+            }),
+            signal: AbortSignal.timeout(this.timeoutMs),
+        });
+        if (!response.ok) {
+            throw new Error(`${this.info.name} completion failed: HTTP ${response.status}`);
+        }
+        const data = (await response.json());
+        return {
+            content: data.choices?.[0]?.message?.content ?? '',
+            providerId: this.info.id,
+            modelId: request.model,
+            tokensIn: data.usage?.prompt_tokens ?? 0,
+            tokensOut: data.usage?.completion_tokens ?? 0,
+            durationMs: Date.now() - start,
+        };
+    }
+    async *completeStream(request) {
+        const response = await fetch(`${this.baseURL}/chat/completions`, {
+            method: 'POST',
+            headers: this.headers(),
+            body: JSON.stringify({
+                model: request.model,
+                messages: this.buildMessages(request),
+                temperature: request.temperature ?? 0.3,
+                max_tokens: request.maxTokens ?? 4096,
+                stream: true,
+            }),
+            signal: AbortSignal.timeout(this.timeoutMs * 2),
+        });
+        if (!response.ok || !response.body) {
+            throw new Error(`${this.info.name} stream failed: HTTP ${response.status}`);
+        }
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = '';
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            buffer += decoder.decode(value, { stream: true });
+            const lines = buffer.split('\n');
+            buffer = lines.pop() ?? '';
+            for (const line of lines) {
+                const trimmed = line.trim();
+                if (!trimmed.startsWith('data: '))
+                    continue;
+                const payload = trimmed.slice(6);
+                if (payload === '[DONE]') {
+                    yield { delta: '', done: true, providerId: this.info.id, modelId: request.model };
+                    return;
+                }
+                try {
+                    const chunk = JSON.parse(payload);
+                    const delta = chunk.choices?.[0]?.delta?.content ?? '';
+                    if (delta) {
+                        yield { delta, done: false, providerId: this.info.id, modelId: request.model };
+                    }
+                }
+                catch {
+                    // skip
+                }
+            }
+        }
+    }
+    async refresh() {
+        await this.fetchModels();
+    }
+    async verify() {
+        const start = Date.now();
+        try {
+            // Prefer a curated chat model — an arbitrary first /models entry may be a
+            // non-chat model (audio/guard) that rejects chat completions.
+            let model = this.knownModels[0]?.id;
+            if (!model) {
+                try {
+                    model = (await this.fetchModels())[0]?.id;
+                }
+                catch {
+                    // network failure — no model; fail below
+                }
+            }
+            if (!model)
+                return { ok: false, latencyMs: Date.now() - start, error: 'no model available to verify' };
+            // Raw fetch (not complete()) so we can read the tier's rate-limit headers.
+            const res = await fetch(`${this.baseURL}/chat/completions`, {
+                method: 'POST',
+                headers: this.headers(),
+                body: JSON.stringify({ model, messages: [{ role: 'user', content: 'ping' }], max_tokens: 1, temperature: 0 }),
+                signal: AbortSignal.timeout(this.timeoutMs),
+            });
+            const latencyMs = Date.now() - start;
+            const rateLimitTokens = this.parseTokenLimit(res);
+            if (!res.ok) {
+                const body = await res.text().catch(() => '');
+                return { ok: false, latencyMs, error: `HTTP ${res.status} ${body.slice(0, 120)}`, rateLimitTokens };
+            }
+            return { ok: true, latencyMs, rateLimitTokens };
+        }
+        catch (err) {
+            return { ok: false, latencyMs: Date.now() - start, error: err instanceof Error ? err.message : String(err) };
+        }
+    }
+    parseTokenLimit(res) {
+        const raw = res.headers.get('x-ratelimit-limit-tokens') ??
+            res.headers.get('x-ratelimit-limit-tokens-minute') ??
+            res.headers.get('ratelimit-limit-tokens');
+        if (!raw)
+            return undefined;
+        const n = parseInt(raw, 10);
+        return Number.isFinite(n) && n > 0 ? n : undefined;
+    }
+    async fetchModels() {
+        let response;
+        try {
+            response = await fetch(`${this.baseURL}/models`, {
+                headers: this.headers(),
+                signal: AbortSignal.timeout(this.timeoutMs),
+            });
+        }
+        catch (err) {
+            // Network-level failure (DNS/connection/TLS): the provider is genuinely
+            // unreachable. Surface it so the health check marks the provider
+            // unhealthy and the router won't route the app to a dead endpoint.
+            throw err;
+        }
+        if (!response.ok) {
+            // Endpoint is reachable but /models is unsupported or errored — fall back
+            // to the known catalog (many providers serve chat without a models list).
+            return this.knownModels.map(m => this.toProviderModel(m.id, m.contextLength));
+        }
+        try {
+            const data = (await response.json());
+            return (data.data ?? []).map(m => this.toProviderModel(m.id, m.context_length ?? m.context_window));
+        }
+        catch {
+            return this.knownModels.map(m => this.toProviderModel(m.id, m.contextLength));
+        }
+    }
+    toProviderModel(id, contextLength) {
+        const known = this.knownModels.find(m => m.id === id);
+        const lower = id.toLowerCase();
+        const capabilities = known?.capabilities ?? ['reasoning'];
+        if (!capabilities.includes('reasoning'))
+            capabilities.push('reasoning');
+        if (lower.includes('code') || lower.includes('coder'))
+            capabilities.push('coding');
+        if (lower.includes('vision') || lower.includes('vl'))
+            capabilities.push('vision');
+        return {
+            id,
+            name: known?.name ?? id,
+            providerId: this.info.id,
+            contextLength: contextLength ?? known?.contextLength ?? 8192,
+            capabilities,
+            supportsStreaming: known?.supportsStreaming ?? true,
+            supportsFunctionCalling: known?.supportsFunctionCalling ?? true,
+            supportsVision: known?.supportsVision ?? false,
+            benchmarkScore: known?.benchmarkScore,
+            maxRequestTokens: known?.maxRequestTokens,
+            costPer1kTokens: known?.costPer1kTokens,
+        };
+    }
+    headers() {
+        const headers = { 'Content-Type': 'application/json' };
+        if (this.apiKey) {
+            headers[this.headerName] = this.headerName === 'Authorization'
+                ? `Bearer ${this.apiKey}`
+                : this.apiKey;
+        }
+        return headers;
+    }
+    buildMessages(request) {
+        const messages = [];
+        if (request.systemPrompt) {
+            messages.push({ role: 'system', content: request.systemPrompt });
+        }
+        if (request.context) {
+            const ctxStr = Object.entries(request.context)
+                .map(([k, v]) => `${k}: ${typeof v === 'string' ? v : JSON.stringify(v)}`)
+                .join('\n');
+            messages.push({ role: 'system', content: ctxStr });
+        }
+        messages.push({ role: 'user', content: request.prompt });
+        return messages;
+    }
+}

package/dist/kernel/recovery-manager.d.ts

@@ -0,0 +1,38 @@
+/**
+ * OpenKernel — Recovery Manager
+ *
+ * Classifies failures: 429, timeout, provider-down, hallucination,
+ *   tool-failure, verification-failure, planning-failure, browser-failure.
+ *
+ * Recovery actions: retry → rotate provider → spawn different worker →
+ *   replan → checkpoint → continue.
+ */
+import type { FailureType, Logger, Mission, Policy, RecoveryDecision, Task } from './types.js';
+import type { EventBus } from './event-bus.js';
+import type { ProviderManager } from './provider-manager.js';
+import type { WorkerRuntime } from './worker-runtime.js';
+import type { CapabilityRouter } from './router.js';
+export interface RecoveryManagerDeps {
+    eventBus: EventBus;
+    providerManager: ProviderManager;
+    workerRuntime: WorkerRuntime;
+    router: CapabilityRouter;
+    logger: Logger;
+}
+export interface RecoveryContext {
+    mission: Mission;
+    task: Task;
+    error: string;
+    attempts: number;
+    policy: Policy;
+    currentProviderId?: string;
+    currentModelId?: string;
+}
+export declare class RecoveryManager {
+    private deps;
+    constructor(deps: RecoveryManagerDeps);
+    classify(error: string): FailureType;
+    decide(ctx: RecoveryContext): Promise<RecoveryDecision>;
+    private findAlternateProvider;
+    private findAlternateWorker;
+}

package/dist/kernel/recovery-manager.js

@@ -0,0 +1,156 @@
+export class RecoveryManager {
+    deps;
+    constructor(deps) {
+        this.deps = deps;
+    }
+    classify(error) {
+        const lower = error.toLowerCase();
+        if (/429|rate.?limit|too many requests/.test(lower))
+            return '429';
+        if (/timeout|timed out|deadline exceeded|abort/.test(lower))
+            return 'timeout';
+        if (/econnrefused|enotfound|unreachable|provider down|network|socket hang up|fetch failed/.test(lower)) {
+            return 'provider-down';
+        }
+        if (/hallucinat|fabricat|invented|not grounded/.test(lower))
+            return 'hallucination';
+        if (/tool|command|exec|spawn/.test(lower))
+            return 'tool-failure';
+        if (/verif|verify|acceptance|did not meet|failed check/.test(lower))
+            return 'verification-failure';
+        if (/plan|planning|objective|dependency/.test(lower))
+            return 'planning-failure';
+        if (/browser|playwright|page|dom|selector/.test(lower))
+            return 'browser-failure';
+        return 'unknown';
+    }
+    async decide(ctx) {
+        const failureType = this.classify(ctx.error);
+        const maxAttempts = ctx.policy.retry?.maxAttempts ?? 3;
+        const belowLimit = ctx.attempts < maxAttempts;
+        let action;
+        let reason;
+        let rotateToProviderId;
+        let rotateToModelId;
+        let newWorkerType;
+        switch (failureType) {
+            case '429':
+            case 'provider-down': {
+                if (belowLimit) {
+                    const alt = await this.findAlternateProvider(ctx);
+                    if (alt) {
+                        action = 'rotate-provider';
+                        reason = `${failureType}: rotate to ${alt.providerId}/${alt.modelId}`;
+                        rotateToProviderId = alt.providerId;
+                        rotateToModelId = alt.modelId;
+                    }
+                    else {
+                        action = belowLimit ? 'retry' : 'abort';
+                        reason = `${failureType}: ${action} (no alternate provider)`;
+                    }
+                }
+                else {
+                    action = 'abort';
+                    reason = `${failureType}: attempts exhausted (${ctx.attempts}/${maxAttempts})`;
+                }
+                break;
+            }
+            case 'timeout': {
+                action = belowLimit ? 'retry' : 'abort';
+                reason = `timeout: ${action} (attempt ${ctx.attempts}/${maxAttempts})`;
+                break;
+            }
+            case 'hallucination':
+            case 'tool-failure':
+            case 'verification-failure': {
+                if (belowLimit) {
+                    const altType = this.findAlternateWorker(ctx);
+                    if (altType) {
+                        action = 'spawn-different-worker';
+                        reason = `${failureType}: spawn ${altType} worker`;
+                        newWorkerType = altType;
+                    }
+                    else {
+                        action = 'retry';
+                        reason = `${failureType}: retry (attempt ${ctx.attempts}/${maxAttempts})`;
+                    }
+                }
+                else {
+                    action = 'replan';
+                    reason = `${failureType}: attempts exhausted → replan`;
+                }
+                break;
+            }
+            case 'planning-failure': {
+                action = 'replan';
+                reason = 'planning-failure: replan';
+                break;
+            }
+            case 'browser-failure': {
+                action = belowLimit ? 'retry' : 'replan';
+                reason = `browser-failure: ${action}`;
+                break;
+            }
+            default: {
+                action = belowLimit ? 'retry' : 'abort';
+                reason = `unknown failure: ${action} (attempt ${ctx.attempts}/${maxAttempts})`;
+            }
+        }
+        const decision = {
+            action,
+            reason,
+            rotateToProviderId,
+            rotateToModelId,
+            newWorkerType,
+        };
+        this.deps.eventBus.emit({
+            type: 'RECOVERY',
+            timestamp: Date.now(),
+            missionId: ctx.mission.id,
+            taskId: ctx.task.id,
+            data: { failureType, decision },
+        });
+        this.deps.logger.info(`Recovery[${failureType}] task ${ctx.task.id}: ${decision.action} — ${reason}`);
+        return decision;
+    }
+    async findAlternateProvider(ctx) {
+        const providers = (await this.deps.providerManager.getHealthyProviders())
+            .map(p => p.info)
+            .filter(p => p.id !== ctx.currentProviderId);
+        if (providers.length === 0)
+            return null;
+        const models = await this.deps.providerManager.getAvailableModels();
+        const candidates = models.filter(m => m.providerId !== ctx.currentProviderId || m.id !== ctx.currentModelId);
+        if (candidates.length === 0)
+            return null;
+        const policy = ctx.policy;
+        const ranked = this.deps.router.rank({
+            capabilities: ctx.task.capabilities,
+            preferences: { reasoning: 80 },
+            policy,
+            availableProviders: providers,
+            availableModels: candidates,
+        });
+        if (ranked.length === 0)
+            return null;
+        return { providerId: ranked[0].providerId, modelId: ranked[0].modelId };
+    }
+    findAlternateWorker(ctx) {
+        const current = this.deps.workerRuntime.getHandler(this.deps.workerRuntime.matchWorkerType(ctx.task.capabilities) ?? 'coding');
+        if (!current)
+            return undefined;
+        const all = this.deps.workerRuntime.listWorkerTypes();
+        for (const type of all) {
+            if (type === current.type)
+                continue;
+            const handler = this.deps.workerRuntime.getHandler(type);
+            if (!handler)
+                continue;
+            const overlap = handler.capabilities.filter(c => ctx.task.capabilities.includes(c)).length;
+            if (overlap >= Math.ceil(ctx.task.capabilities.length / 2)) {
+                return type;
+            }
+        }
+        return undefined;
+    }
+}

package/dist/kernel/router.d.ts

@@ -0,0 +1,44 @@
+/**
+ * OpenKernel — Capability Router
+ *
+ * Workers never request "Gemini" — they request capabilities + preferences
+ * ("coding, reasoning >90, context >128K"). The router decides the best
+ * model + provider.
+ *
+ * Routing score (spec: "Intelligent Router"):
+ *   capability + benchmark + reliability + speed + available quota
+ *   + context + policy weight − cost
+ *
+ * Every policy auto-routes across all healthy providers. The single exception
+ * is the `offline` mode, which is LOCKED to local providers.
+ */
+import type { ProviderInfo, RoutingDecision, RoutingRequest } from './types.js';
+import type { Logger } from './types.js';
+export declare class CapabilityRouter {
+    private logger;
+    constructor(logger: Logger);
+    route(request: RoutingRequest): Promise<RoutingDecision | null>;
+    rank(request: RoutingRequest): Array<RoutingDecision & {
+        providerInfo: ProviderInfo;
+        benchmarkScore: number;
+    }>;
+    private scoreCandidates;
+    private capabilityScore;
+    /**
+     * Reasoning/quality contribution in [0,1]. Honors the worker preference
+     * "reasoning >= N": a model that clears the bar gets full credit for its
+     * benchmark; one below the bar is proportionally discounted.
+     */
+    private benchmarkScore;
+    /**
+     * Estimate a 0–100 reasoning/quality benchmark for a model. Uses an explicit
+     * `benchmarkScore` when the provider supplies one; otherwise infers it from
+     * parameter size, model family, and context length.
+     */
+    private estimateBenchmark;
+    private parseParamSize;
+    private contextScore;
+    private costScore;
+    private costPreferenceMultiplier;
+    private buildReason;
+}