infinicode 1.0.0 → 2.0.0

package/dist/kernel/provider-discovery.js

@@ -0,0 +1,179 @@
+/**
+ * Provider connection testing + model discovery.
+ *
+ * Used by the setup wizard to verify credentials and enumerate models
+ * across Ollama + all configured cloud providers.
+ */
+import ora from 'ora';
+import chalk from 'chalk';
+import { OllamaProvider, OpenAICompatibleProvider, GeminiProvider } from '../kernel/index.js';
+import { getProviderPreset, FREE_PROVIDERS } from './free-providers.js';
+export async function testOllamaProvider(baseURL, fallbackURL, timeoutMs = 8000) {
+    const provider = new OllamaProvider({ baseURL, fallbackURL, timeoutMs });
+    const start = Date.now();
+    try {
+        const caps = await provider.capabilities();
+        return {
+            providerId: 'ollama',
+            name: 'Ollama',
+            ok: true,
+            modelCount: caps.models.length,
+            latencyMs: Date.now() - start,
+        };
+    }
+    catch (err) {
+        return {
+            providerId: 'ollama',
+            name: 'Ollama',
+            ok: false,
+            error: err instanceof Error ? err.message : String(err),
+            modelCount: 0,
+        };
+    }
+}
+export async function testCloudProvider(cfg, timeoutMs = 8000) {
+    const preset = getProviderPreset(cfg.id);
+    const start = Date.now();
+    try {
+        const caps = cfg.id === 'gemini'
+            ? await new GeminiProvider({
+                id: cfg.id,
+                name: cfg.name,
+                apiKey: cfg.apiKey ?? '',
+                baseURL: cfg.baseURL,
+                timeoutMs,
+                knownModels: preset?.knownModels ?? [],
+            }).capabilities()
+            : await new OpenAICompatibleProvider({
+                id: cfg.id,
+                name: cfg.name,
+                baseURL: cfg.baseURL,
+                apiKey: cfg.apiKey,
+                headerName: cfg.headerName,
+                timeoutMs,
+                knownModels: preset?.knownModels ?? [],
+            }).capabilities();
+        return {
+            providerId: cfg.id,
+            name: cfg.name,
+            ok: true,
+            modelCount: caps.models.length,
+            latencyMs: Date.now() - start,
+        };
+    }
+    catch (err) {
+        return {
+            providerId: cfg.id,
+            name: cfg.name,
+            ok: false,
+            error: err instanceof Error ? err.message : String(err),
+            modelCount: 0,
+        };
+    }
+}
+export async function testProviderInteractive(label, fn) {
+    const spinner = ora(`Testing ${label}...`).start();
+    const result = await fn();
+    if (result.ok) {
+        spinner.succeed(`${label} connected — ${chalk.green(String(result.modelCount))} models, ${result.latencyMs ?? 0}ms`);
+    }
+    else {
+        spinner.fail(`${label} failed: ${result.error ?? 'unknown error'}`);
+    }
+    return result;
+}
+/**
+ * Discover all available models across all configured providers (Ollama + cloud).
+ * Returns a flat list tagged with providerId.
+ */
+export async function discoverAllModels(opts) {
+    const all = [];
+    // Ollama
+    try {
+        const provider = new OllamaProvider({ baseURL: opts.masterUrl, fallbackURL: opts.tailscaleMasterUrl });
+        const caps = await provider.capabilities();
+        for (const model of caps.models) {
+            all.push({ providerId: 'ollama', model });
+        }
+    }
+    catch {
+        // ollama offline — continue with cloud
+    }
+    // Cloud providers
+    for (const cfg of opts.cloudProviders) {
+        if (!cfg.enabled)
+            continue;
+        const preset = getProviderPreset(cfg.id);
+        try {
+            const provider = cfg.id === 'gemini'
+                ? new GeminiProvider({
+                    id: cfg.id,
+                    name: cfg.name,
+                    apiKey: cfg.apiKey ?? '',
+                    baseURL: cfg.baseURL,
+                    knownModels: preset?.knownModels ?? [],
+                })
+                : new OpenAICompatibleProvider({
+                    id: cfg.id,
+                    name: cfg.name,
+                    baseURL: cfg.baseURL,
+                    apiKey: cfg.apiKey,
+                    headerName: cfg.headerName,
+                    knownModels: preset?.knownModels ?? [],
+                });
+            const caps = await provider.capabilities();
+            for (const model of caps.models) {
+                all.push({ providerId: cfg.id, model });
+            }
+        }
+        catch {
+            // provider offline — continue
+        }
+    }
+    return all;
+}
+/**
+ * Build a friendly display label for a discovered model.
+ */
+export function modelLabel(dm) {
+    const ctx = dm.model.contextLength >= 1000
+        ? `${Math.round(dm.model.contextLength / 1000)}k`
+        : `${dm.model.contextLength}`;
+    const caps = dm.model.capabilities.slice(0, 3).join(',');
+    return `${dm.providerId}/${dm.model.id}  ${chalk.dim(`ctx=${ctx} caps=${caps}`)}`;
+}
+/**
+ * Suggest a recommended model for a worker type from the discovered pool.
+ * Falls back to the provider preset's recommended list if discovery found nothing.
+ */
+export function suggestModelForWorker(workerType, discovered) {
+    // 1. try preset recommendations that match discovered models
+    for (const preset of FREE_PROVIDERS) {
+        const recs = preset.recommended[workerType] ?? [];
+        for (const recId of recs) {
+            const hit = discovered.find(dm => dm.providerId === preset.id && dm.model.id === recId);
+            if (hit)
+                return hit;
+        }
+    }
+    // 2. any discovered model that has the matching capability
+    const capability = workerType === 'coding' ? 'coding'
+        : workerType === 'vision' ? 'vision'
+            : workerType === 'review' ? 'review'
+                : 'reasoning';
+    return discovered.find(dm => dm.model.capabilities.includes(capability)) ?? discovered[0];
+}
+/**
+ * Build a complete workerModels map by suggesting a model for each builtin worker type.
+ */
+export function suggestAllWorkerModels(discovered) {
+    const out = {};
+    const types = ['coding', 'research', 'architecture', 'review', 'documentation', 'translation', 'terminal', 'verification', 'vision', 'browser'];
+    for (const t of types) {
+        const hit = suggestModelForWorker(t, discovered);
+        if (hit) {
+            out[t] = { providerId: hit.providerId, modelId: hit.model.id };
+        }
+    }
+    return out;
+}

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

@@ -0,0 +1,38 @@
+/**
+ * OpenKernel — Provider Manager
+ *
+ * Tracks available models, quota, latency, health, capabilities.
+ * Tracks 429s, quota remaining, per-request success rate.
+ * Background refresh only. Never blocks execution.
+ */
+import type { ProviderInfo, ProviderInterface, ProviderModel } from './types.js';
+import type { EventBus } from './event-bus.js';
+import type { Logger } from './types.js';
+export declare class ProviderManager {
+    private eventBus;
+    private logger;
+    private providers;
+    private healthTimers;
+    private refreshIntervalMs;
+    private stats;
+    constructor(eventBus: EventBus, logger: Logger);
+    register(providerId: string, provider: ProviderInterface): void;
+    unregister(providerId: string): void;
+    get(providerId: string): ProviderInterface | undefined;
+    list(): ProviderInterface[];
+    listInfos(): ProviderInfo[];
+    getAvailableModels(): Promise<ProviderModel[]>;
+    getHealthyProviders(): Promise<ProviderInterface[]>;
+    /** Record a successful completion for success-rate + quota tracking. */
+    recordSuccess(providerId: string): void;
+    /** Record a failed completion (non-429) for success-rate tracking. */
+    recordFailure(providerId: string): void;
+    /** Record a 429 / rate-limit hit — decrements quota and may mark unhealthy. */
+    record429(providerId: string): void;
+    private pushQuota;
+    private estimateQuota;
+    private scheduleHealthCheck;
+    checkHealth(providerId: string): Promise<void>;
+    setRefreshInterval(ms: number): void;
+    destroy(): void;
+}

package/dist/kernel/provider-manager.js

@@ -0,0 +1,206 @@
+const QUOTA_WINDOW_MS = 60_000;
+const QUOTA_MAX_PER_MIN = 60;
+// A real 1-token completion costs a little, so re-verify with a token at most
+// this often; cheaper /models refreshes fill the gaps between verifications.
+const VERIFY_INTERVAL_MS = 5 * 60_000;
+export class ProviderManager {
+    eventBus;
+    logger;
+    providers = new Map();
+    healthTimers = new Map();
+    refreshIntervalMs = 60_000;
+    stats = new Map();
+    constructor(eventBus, logger) {
+        this.eventBus = eventBus;
+        this.logger = logger;
+    }
+    register(providerId, provider) {
+        this.providers.set(providerId, provider);
+        this.stats.set(providerId, {
+            totalRequests: 0,
+            successfulRequests: 0,
+            failedRequests: 0,
+            consecutiveFailures: 0,
+            quotaWindow: [],
+        });
+        this.logger.info(`Provider registered: ${providerId}`);
+        this.scheduleHealthCheck(providerId);
+        void this.checkHealth(providerId);
+    }
+    unregister(providerId) {
+        this.providers.delete(providerId);
+        this.stats.delete(providerId);
+        const timer = this.healthTimers.get(providerId);
+        if (timer) {
+            clearInterval(timer);
+            this.healthTimers.delete(providerId);
+        }
+    }
+    get(providerId) {
+        return this.providers.get(providerId);
+    }
+    list() {
+        return [...this.providers.values()];
+    }
+    listInfos() {
+        return this.list().map(p => p.info);
+    }
+    async getAvailableModels() {
+        const models = [];
+        for (const provider of this.providers.values()) {
+            if (!provider.info.healthy)
+                continue;
+            try {
+                const caps = await provider.capabilities();
+                models.push(...caps.models);
+            }
+            catch (err) {
+                this.logger.warn(`Failed to get models from ${provider.info.id}: ${err}`);
+            }
+        }
+        return models;
+    }
+    async getHealthyProviders() {
+        return this.list().filter(p => p.info.healthy);
+    }
+    /** Record a successful completion for success-rate + quota tracking. */
+    recordSuccess(providerId) {
+        const s = this.stats.get(providerId);
+        const info = this.providers.get(providerId)?.info;
+        if (s) {
+            s.totalRequests++;
+            s.successfulRequests++;
+            s.consecutiveFailures = 0;
+            this.pushQuota(s);
+            if (info) {
+                info.successRate = s.totalRequests > 0 ? s.successfulRequests / s.totalRequests : undefined;
+                info.quotaRemaining = this.estimateQuota(s);
+            }
+        }
+    }
+    /** Record a failed completion (non-429) for success-rate tracking. */
+    recordFailure(providerId) {
+        const s = this.stats.get(providerId);
+        const info = this.providers.get(providerId)?.info;
+        if (s) {
+            s.totalRequests++;
+            s.failedRequests++;
+            s.consecutiveFailures++;
+            if (info) {
+                info.successRate = s.totalRequests > 0 ? s.successfulRequests / s.totalRequests : undefined;
+                if (s.consecutiveFailures >= 3) {
+                    info.healthy = false;
+                    info.error = `${s.consecutiveFailures} consecutive failures`;
+                }
+            }
+        }
+    }
+    /** Record a 429 / rate-limit hit — decrements quota and may mark unhealthy. */
+    record429(providerId) {
+        const s = this.stats.get(providerId);
+        const info = this.providers.get(providerId)?.info;
+        if (s) {
+            s.totalRequests++;
+            s.failedRequests++;
+            s.consecutiveFailures++;
+            s.last429At = Date.now();
+            if (info) {
+                info.quotaRemaining = Math.max(0, (info.quotaRemaining ?? 0) - 1);
+                info.successRate = s.totalRequests > 0 ? s.successfulRequests / s.totalRequests : undefined;
+                if ((info.quotaRemaining ?? 0) <= 0) {
+                    info.healthy = false;
+                    info.error = 'rate-limited (quota exhausted)';
+                }
+            }
+        }
+    }
+    pushQuota(s) {
+        const now = Date.now();
+        s.quotaWindow.push(now);
+        s.quotaWindow = s.quotaWindow.filter(t => now - t < QUOTA_WINDOW_MS);
+    }
+    estimateQuota(s) {
+        const now = Date.now();
+        const recent = s.quotaWindow.filter(t => now - t < QUOTA_WINDOW_MS).length;
+        return Math.max(0, QUOTA_MAX_PER_MIN - recent);
+    }
+    scheduleHealthCheck(providerId) {
+        const timer = setInterval(() => {
+            void this.checkHealth(providerId);
+        }, this.refreshIntervalMs);
+        this.healthTimers.set(providerId, timer);
+    }
+    async checkHealth(providerId) {
+        const provider = this.providers.get(providerId);
+        if (!provider)
+            return;
+        const start = Date.now();
+        const s = this.stats.get(providerId);
+        const now = Date.now();
+        // Verify with a real token-authenticated completion on first check and
+        // periodically thereafter; use the cheap /models refresh in between.
+        const shouldVerify = typeof provider.verify === 'function' &&
+            (s?.lastVerifyAt === undefined || now - s.lastVerifyAt >= VERIFY_INTERVAL_MS);
+        try {
+            let latency;
+            if (shouldVerify && provider.verify) {
+                const result = await provider.verify();
+                if (s)
+                    s.lastVerifyAt = Date.now();
+                if (!result.ok)
+                    throw new Error(result.error ?? 'token verification failed');
+                latency = result.latencyMs;
+                // Real per-minute token limit from the tier's headers — applies to all
+                // of this provider's models in the router.
+                if (result.rateLimitTokens && result.rateLimitTokens > 0) {
+                    provider.info.maxRequestTokens = result.rateLimitTokens;
+                }
+            }
+            else if (provider.refresh) {
+                await provider.refresh();
+                latency = Date.now() - start;
+            }
+            else {
+                await provider.capabilities();
+                latency = Date.now() - start;
+            }
+            provider.info.healthy = true;
+            provider.info.available = true;
+            provider.info.latencyMs = latency;
+            provider.info.lastCheckedAt = Date.now();
+            provider.info.error = undefined;
+            if (s)
+                s.consecutiveFailures = 0;
+        }
+        catch (err) {
+            provider.info.healthy = false;
+            provider.info.available = false;
+            provider.info.error = err instanceof Error ? err.message : String(err);
+            provider.info.lastCheckedAt = Date.now();
+            this.logger.warn(`Provider ${providerId} health check failed: ${provider.info.error}`);
+        }
+        const event = {
+            type: 'PROVIDER_HEALTH',
+            timestamp: Date.now(),
+            data: {
+                providerId,
+                healthy: provider.info.healthy,
+                latencyMs: provider.info.latencyMs,
+                successRate: provider.info.successRate,
+                quotaRemaining: provider.info.quotaRemaining,
+            },
+        };
+        this.eventBus.emit(event);
+    }
+    setRefreshInterval(ms) {
+        this.refreshIntervalMs = ms;
+    }
+    destroy() {
+        for (const timer of this.healthTimers.values()) {
+            clearInterval(timer);
+        }
+        this.healthTimers.clear();
+        this.providers.clear();
+        this.stats.clear();
+    }
+}

package/dist/kernel/provider-url.d.ts

@@ -0,0 +1,18 @@
+/**
+ * OpenKernel — OpenAI-compatible base URL normalization.
+ *
+ * Different consumers append different suffixes to a provider base URL:
+ *   - the kernel provider and the Vercel AI SDK both ultimately POST to
+ *     `<base>/chat/completions` and GET `<base>/models`.
+ * Stored/preset base URLs are inconsistent — some include the API version
+ * segment (`/v1`), some don't, and a few providers speak `/chat/completions`
+ * directly with no version segment at all.
+ *
+ * `openAICompatBaseURL` returns the canonical base to which `/chat/completions`
+ * (or `/models`) should be appended — with exactly one version segment where
+ * the provider expects it. Using it on both surfaces guarantees the same,
+ * correct URL regardless of how the base was stored.
+ */
+export declare function openAICompatBaseURL(baseURL: string): string;
+export declare function openAICompatChatURL(baseURL: string): string;
+export declare function openAICompatModelsURL(baseURL: string): string;

package/dist/kernel/provider-url.js

@@ -0,0 +1,45 @@
+/**
+ * OpenKernel — OpenAI-compatible base URL normalization.
+ *
+ * Different consumers append different suffixes to a provider base URL:
+ *   - the kernel provider and the Vercel AI SDK both ultimately POST to
+ *     `<base>/chat/completions` and GET `<base>/models`.
+ * Stored/preset base URLs are inconsistent — some include the API version
+ * segment (`/v1`), some don't, and a few providers speak `/chat/completions`
+ * directly with no version segment at all.
+ *
+ * `openAICompatBaseURL` returns the canonical base to which `/chat/completions`
+ * (or `/models`) should be appended — with exactly one version segment where
+ * the provider expects it. Using it on both surfaces guarantees the same,
+ * correct URL regardless of how the base was stored.
+ */
+// Hosts whose OpenAI-compatible route lives directly under the host, with no
+// `/v1` version segment (e.g. GitHub Models / Azure AI Inference).
+const NO_VERSION_HOSTS = [
+    /(^|\.)models\.inference\.ai\.azure\.com$/i,
+    /(^|\.)models\.github\.ai$/i,
+];
+export function openAICompatBaseURL(baseURL) {
+    const url = (baseURL ?? '').trim().replace(/\/+$/, '');
+    if (!url)
+        return url;
+    let host = '';
+    try {
+        host = new URL(url).host;
+    }
+    catch {
+        // Not a parseable URL — fall through to suffix checks below.
+    }
+    if (host && NO_VERSION_HOSTS.some(rx => rx.test(host)))
+        return url;
+    // Already carries an explicit version segment (…/v1, …/v1beta, …/v2).
+    if (/\/v\d+[a-z]*$/i.test(url))
+        return url;
+    return `${url}/v1`;
+}
+export function openAICompatChatURL(baseURL) {
+    return `${openAICompatBaseURL(baseURL)}/chat/completions`;
+}
+export function openAICompatModelsURL(baseURL) {
+    return `${openAICompatBaseURL(baseURL)}/models`;
+}

package/dist/kernel/providers/gemini-provider.d.ts

@@ -0,0 +1,43 @@
+/**
+ * OpenKernel — Gemini Provider
+ *
+ * Google Generative Language API (Gemini family).
+ * Implements the kernel's ProviderInterface against
+ *   https://generativelanguage.googleapis.com/v1beta/models/{model}:generateContent
+ *   ...:streamGenerateContent
+ *
+ * Distinct from OpenAICompatibleProvider because Gemini's request/response
+ * shapes (contents/parts, safety ratings, candidate counts) differ materially.
+ */
+import type { CompletionChunk, CompletionRequest, CompletionResult, ProviderCapabilities, ProviderInfo, ProviderInterface, ProviderModel } from '../types.js';
+export interface GeminiProviderOptions {
+    id?: string;
+    name?: string;
+    apiKey: string;
+    /** Base URL without trailing slash. */
+    baseURL?: string;
+    timeoutMs?: number;
+    knownModels?: Array<Partial<ProviderModel> & {
+        id: string;
+    }>;
+}
+export declare class GeminiProvider implements ProviderInterface {
+    info: ProviderInfo;
+    private apiKey;
+    private baseURL;
+    private timeoutMs;
+    private knownModels;
+    constructor(options: GeminiProviderOptions);
+    capabilities(): Promise<ProviderCapabilities>;
+    complete(request: CompletionRequest): Promise<CompletionResult>;
+    completeStream(request: CompletionRequest): AsyncIterable<CompletionChunk>;
+    refresh(): Promise<void>;
+    verify(): Promise<{
+        ok: boolean;
+        latencyMs: number;
+        error?: string;
+    }>;
+    private buildBody;
+    private fetchModels;
+    private toProviderModel;
+}