infinicode 1.0.0 → 2.0.0

package/dist/kernel/providers/gemini-provider.js

@@ -0,0 +1,203 @@
+const GEMINI_DEFAULT_BASE = 'https://generativelanguage.googleapis.com/v1beta';
+export class GeminiProvider {
+    info;
+    apiKey;
+    baseURL;
+    timeoutMs;
+    knownModels;
+    constructor(options) {
+        this.apiKey = options.apiKey;
+        this.baseURL = (options.baseURL ?? GEMINI_DEFAULT_BASE).replace(/\/$/, '');
+        this.timeoutMs = options.timeoutMs ?? 30_000;
+        this.knownModels = options.knownModels ?? [];
+        this.info = {
+            id: options.id ?? 'gemini',
+            name: options.name ?? 'Gemini',
+            type: 'cloud',
+            healthy: false,
+            available: !!this.apiKey,
+            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 modelId = stripModelPrefix(request.model);
+        const url = `${this.baseURL}/models/${modelId}:generateContent?key=${this.apiKey}`;
+        const body = this.buildBody(request);
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(body),
+            signal: AbortSignal.timeout(this.timeoutMs),
+        });
+        if (!response.ok) {
+            throw new Error(`Gemini completion failed: HTTP ${response.status} ${await safeText(response)}`);
+        }
+        const data = (await response.json());
+        const content = data.candidates?.[0]?.content?.parts?.map(p => p.text ?? '').join('') ?? '';
+        const tokensIn = data.usageMetadata?.promptTokenCount ?? 0;
+        const tokensOut = data.usageMetadata?.candidatesTokenCount ?? 0;
+        return {
+            content,
+            providerId: this.info.id,
+            modelId: request.model,
+            tokensIn,
+            tokensOut,
+            durationMs: Date.now() - start,
+        };
+    }
+    async *completeStream(request) {
+        const modelId = stripModelPrefix(request.model);
+        const url = `${this.baseURL}/models/${modelId}:streamGenerateContent?key=${this.apiKey}&alt=sse`;
+        const body = this.buildBody(request);
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(body),
+            signal: AbortSignal.timeout(this.timeoutMs * 2),
+        });
+        if (!response.ok || !response.body) {
+            throw new Error(`Gemini 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.candidates?.[0]?.content?.parts?.map(p => p.text ?? '').join('') ?? '';
+                    if (delta) {
+                        yield { delta, done: false, providerId: this.info.id, modelId: request.model };
+                    }
+                }
+                catch {
+                    // skip malformed
+                }
+            }
+        }
+    }
+    async refresh() {
+        await this.fetchModels();
+    }
+    async verify() {
+        const start = Date.now();
+        try {
+            let model = this.knownModels[0]?.id;
+            if (!model) {
+                try {
+                    model = (await this.fetchModels())[0]?.id;
+                }
+                catch {
+                    // fall through to default
+                }
+            }
+            if (!model)
+                model = 'gemini-2.0-flash';
+            await this.complete({ model, prompt: 'ping', maxTokens: 1, temperature: 0 });
+            return { ok: true, latencyMs: Date.now() - start };
+        }
+        catch (err) {
+            return { ok: false, latencyMs: Date.now() - start, error: err instanceof Error ? err.message : String(err) };
+        }
+    }
+    buildBody(request) {
+        const contents = [];
+        if (request.systemPrompt) {
+            // Gemini accepts systemInstruction separately
+        }
+        if (request.context) {
+            const ctxStr = Object.entries(request.context)
+                .map(([k, v]) => `${k}: ${typeof v === 'string' ? v : JSON.stringify(v)}`)
+                .join('\n');
+            contents.push({ role: 'user', parts: [{ text: ctxStr }] });
+        }
+        contents.push({ role: 'user', parts: [{ text: request.prompt }] });
+        const body = {
+            contents,
+            generationConfig: {
+                temperature: request.temperature ?? 0.3,
+                maxOutputTokens: request.maxTokens ?? 4096,
+            },
+        };
+        if (request.systemPrompt) {
+            body.systemInstruction = { parts: [{ text: request.systemPrompt }] };
+        }
+        return body;
+    }
+    async fetchModels() {
+        try {
+            const url = `${this.baseURL}/models?key=${this.apiKey}`;
+            const response = await fetch(url, { signal: AbortSignal.timeout(this.timeoutMs) });
+            if (!response.ok)
+                throw new Error(`HTTP ${response.status}`);
+            const data = (await response.json());
+            return (data.models ?? [])
+                .filter(m => (m.supportedGenerationMethods ?? []).includes('generateContent'))
+                .map(m => this.toProviderModel(m.name, m.inputTokenLimit, m.displayName));
+        }
+        catch {
+            return this.knownModels.map(m => this.toProviderModel(m.id, m.contextLength, m.name));
+        }
+    }
+    toProviderModel(rawName, inputTokenLimit, displayName) {
+        const id = stripModelPrefix(rawName);
+        const known = this.knownModels.find(m => stripModelPrefix(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: displayName ?? known?.name ?? id,
+            providerId: this.info.id,
+            contextLength: inputTokenLimit ?? known?.contextLength ?? 32_000,
+            capabilities,
+            supportsStreaming: known?.supportsStreaming ?? true,
+            supportsFunctionCalling: known?.supportsFunctionCalling ?? true,
+            supportsVision: known?.supportsVision ?? lower.includes('vision'),
+            benchmarkScore: known?.benchmarkScore,
+            maxRequestTokens: known?.maxRequestTokens,
+            costPer1kTokens: known?.costPer1kTokens,
+        };
+    }
+}
+function stripModelPrefix(name) {
+    return name.replace(/^models\//, '');
+}
+async function safeText(response) {
+    try {
+        return await response.text();
+    }
+    catch {
+        return '';
+    }
+}

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

@@ -0,0 +1,44 @@
+/**
+ * OpenKernel — Ollama Provider
+ *
+ * Migrates the existing infinicode Ollama master logic (LAN + Tailscale fallback)
+ * into the provider-agnostic kernel interface.
+ *
+ * Exposes /api/tags models as ProviderModel entries, and routes completion
+ * requests through the OpenAI-compatible /v1/chat/completions endpoint.
+ */
+import type { CompletionChunk, CompletionRequest, CompletionResult, ProviderCapabilities, ProviderInfo, ProviderInterface, ProviderModel } from '../types.js';
+export interface OllamaProviderOptions {
+    id?: string;
+    name?: string;
+    baseURL: string;
+    fallbackURL?: string;
+    defaultModel?: string;
+    timeoutMs?: number;
+}
+export declare class OllamaProvider implements ProviderInterface {
+    info: ProviderInfo;
+    private baseURL;
+    private fallbackURL?;
+    private activeURL;
+    private defaultModel?;
+    private timeoutMs;
+    private cachedModels;
+    constructor(options: OllamaProviderOptions);
+    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 fetchModels;
+    private toProviderModel;
+    private guessContextLength;
+    private buildMessages;
+    private resolveURL;
+    getDefaultModel(): string | undefined;
+    getCachedModels(): ProviderModel[];
+}

package/dist/kernel/providers/ollama-provider.js

@@ -0,0 +1,241 @@
+export class OllamaProvider {
+    info;
+    baseURL;
+    fallbackURL;
+    activeURL;
+    defaultModel;
+    timeoutMs;
+    cachedModels = [];
+    constructor(options) {
+        const id = options.id ?? 'ollama';
+        this.baseURL = options.baseURL.replace(/\/$/, '');
+        this.fallbackURL = options.fallbackURL?.replace(/\/$/, '');
+        this.activeURL = this.baseURL;
+        this.defaultModel = options.defaultModel;
+        this.timeoutMs = options.timeoutMs ?? 10_000;
+        this.info = {
+            id,
+            name: options.name ?? 'Ollama',
+            type: 'local',
+            healthy: false,
+            available: false,
+            baseURL: this.baseURL,
+        };
+    }
+    async capabilities() {
+        const models = await this.fetchModels();
+        return {
+            streaming: true,
+            functionCalling: false,
+            vision: models.some(m => m.capabilities.includes('vision')),
+            maxContextLength: Math.max(8192, ...models.map(m => m.contextLength)),
+            models,
+        };
+    }
+    async complete(request) {
+        const start = Date.now();
+        const url = await this.resolveURL();
+        const endpoint = `${url}/v1/chat/completions`;
+        const body = {
+            model: request.model,
+            messages: this.buildMessages(request),
+            temperature: request.temperature ?? 0.3,
+            max_tokens: request.maxTokens ?? 4096,
+            stream: false,
+        };
+        const response = await fetch(endpoint, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(body),
+            signal: AbortSignal.timeout(this.timeoutMs * 3),
+        });
+        if (!response.ok) {
+            throw new Error(`Ollama completion failed: HTTP ${response.status}`);
+        }
+        const data = (await response.json());
+        const content = data.choices?.[0]?.message?.content ?? '';
+        const tokensIn = data.usage?.prompt_tokens ?? 0;
+        const tokensOut = data.usage?.completion_tokens ?? 0;
+        return {
+            content,
+            providerId: this.info.id,
+            modelId: request.model,
+            tokensIn,
+            tokensOut,
+            durationMs: Date.now() - start,
+        };
+    }
+    async *completeStream(request) {
+        const url = await this.resolveURL();
+        const endpoint = `${url}/v1/chat/completions`;
+        const body = {
+            model: request.model,
+            messages: this.buildMessages(request),
+            temperature: request.temperature ?? 0.3,
+            max_tokens: request.maxTokens ?? 4096,
+            stream: true,
+        };
+        const response = await fetch(endpoint, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(body),
+            signal: AbortSignal.timeout(this.timeoutMs * 6),
+        });
+        if (!response.ok || !response.body) {
+            throw new Error(`Ollama 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 malformed
+                }
+            }
+        }
+    }
+    async refresh() {
+        await this.fetchModels();
+    }
+    async verify() {
+        const start = Date.now();
+        try {
+            await this.resolveURL(); // throws if the Ollama host is unreachable
+            const model = this.defaultModel ?? (await this.fetchModels())[0]?.id;
+            if (!model)
+                return { ok: true, latencyMs: Date.now() - start }; // reachable, no models pulled yet
+            await this.complete({ model, prompt: 'ping', maxTokens: 1, temperature: 0 });
+            return { ok: true, latencyMs: Date.now() - start };
+        }
+        catch (err) {
+            return { ok: false, latencyMs: Date.now() - start, error: err instanceof Error ? err.message : String(err) };
+        }
+    }
+    async fetchModels() {
+        const url = await this.resolveURL();
+        const response = await fetch(`${url}/api/tags`, {
+            signal: AbortSignal.timeout(this.timeoutMs),
+        });
+        if (!response.ok) {
+            throw new Error(`Ollama tags failed: HTTP ${response.status}`);
+        }
+        const data = (await response.json());
+        this.cachedModels = (data.models ?? []).map(m => this.toProviderModel(m));
+        return this.cachedModels;
+    }
+    toProviderModel(m) {
+        const name = m.name;
+        const lower = name.toLowerCase();
+        const capabilities = ['reasoning'];
+        if (lower.includes('code') || lower.includes('coder') || lower.includes('stral')) {
+            capabilities.push('coding');
+        }
+        if (lower.includes('vision') || lower.includes('llava') || lower.includes('bakllava')) {
+            capabilities.push('vision', 'ocr');
+        }
+        const paramSize = m.details?.parameter_size;
+        const ctxGuess = this.guessContextLength(name, paramSize);
+        return {
+            id: name,
+            name,
+            providerId: this.info.id,
+            contextLength: ctxGuess,
+            capabilities,
+            supportsStreaming: true,
+            supportsFunctionCalling: false,
+            supportsVision: capabilities.includes('vision'),
+            costPer1kTokens: { input: 0, output: 0 },
+            metadata: {
+                size: m.size,
+                parameterSize: paramSize,
+                quantization: m.details?.quantization_level,
+                family: m.details?.family,
+                modifiedAt: m.modified_at,
+            },
+        };
+    }
+    guessContextLength(name, paramSize) {
+        const lower = name.toLowerCase();
+        if (lower.includes('128k'))
+            return 128_000;
+        if (lower.includes('32k'))
+            return 32_000;
+        if (lower.includes('mistral') || lower.includes('mixtral'))
+            return 32_000;
+        if (lower.includes('qwen2.5'))
+            return 32_000;
+        if (lower.includes('llama3.1'))
+            return 128_000;
+        if (lower.includes('codestral'))
+            return 32_000;
+        if (paramSize) {
+            const size = parseFloat(paramSize);
+            if (size >= 70)
+                return 128_000;
+            if (size >= 30)
+                return 32_000;
+        }
+        return 8192;
+    }
+    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;
+    }
+    async resolveURL() {
+        const candidates = [this.activeURL, this.fallbackURL, this.baseURL].filter((u, i, arr) => !!u && arr.indexOf(u) === i);
+        for (const candidate of candidates) {
+            try {
+                const response = await fetch(`${candidate}/api/tags`, {
+                    signal: AbortSignal.timeout(Math.min(this.timeoutMs, 5000)),
+                });
+                if (response.ok) {
+                    this.activeURL = candidate;
+                    this.info.baseURL = candidate;
+                    return candidate;
+                }
+            }
+            catch {
+                // try next
+            }
+        }
+        throw new Error(`Ollama unreachable: ${candidates.join(', ')}`);
+    }
+    getDefaultModel() {
+        return this.defaultModel;
+    }
+    getCachedModels() {
+        return this.cachedModels;
+    }
+}

package/dist/kernel/providers/openai-compatible-provider.d.ts

@@ -0,0 +1,43 @@
+/**
+ * OpenKernel — OpenAI-Compatible Provider
+ *
+ * Generic provider for any endpoint speaking the OpenAI chat completions API.
+ * Powers: OpenRouter, Groq, GitHub Models, NVIDIA, HF, vLLM, LM Studio, SGLang, etc.
+ */
+import type { CompletionChunk, CompletionRequest, CompletionResult, ProviderCapabilities, ProviderInfo, ProviderInterface, ProviderModel } from '../types.js';
+export interface OpenAICompatibleOptions {
+    id: string;
+    name: string;
+    type?: 'local' | 'cloud';
+    baseURL: string;
+    apiKey?: string;
+    headerName?: string;
+    timeoutMs?: number;
+    knownModels?: Array<Partial<ProviderModel> & {
+        id: string;
+    }>;
+}
+export declare class OpenAICompatibleProvider implements ProviderInterface {
+    info: ProviderInfo;
+    private baseURL;
+    private apiKey?;
+    private headerName;
+    private timeoutMs;
+    private knownModels;
+    constructor(options: OpenAICompatibleOptions);
+    capabilities(): Promise<ProviderCapabilities>;
+    complete(request: CompletionRequest): Promise<CompletionResult>;
+    completeStream(request: CompletionRequest): AsyncIterable<CompletionChunk>;
+    refresh(): Promise<void>;
+    verify(): Promise<{
+        ok: boolean;
+        latencyMs: number;
+        error?: string;
+        rateLimitTokens?: number;
+    }>;
+    private parseTokenLimit;
+    private fetchModels;
+    private toProviderModel;
+    private headers;
+    private buildMessages;
+}