@decido/kernel-bridge 1.0.0 → 4.0.1

package/src/ai/index.ts

@@ -1,96 +0,0 @@
-// ─── AI Services ────────────────────────────────────────────
-
-// Inference Router
-export {
-    initProviders,
-    loadProviderKeys,
-    saveProviderKeys,
-    setProviderApiKey,
-    getProviderStatuses,
-    getAllProviders,
-    routeChat,
-    routeInference,
-    inferenceRouter,
-    type InferenceBackend,
-    type TaskType,
-    type RouterConfig,
-    type RoutedResponse,
-} from './services/InferenceRouter';
-
-// LLM Providers
-export type {
-    LLMProvider,
-    ChatMessage,
-    ChatOptions,
-    ChatResult,
-    ProviderStatus,
-} from './services/providers/LLMProvider';
-
-// Ollama Service
-export {
-    chat as ollamaChat,
-    chat,
-    chatStream as ollamaChatStream,
-    chatStream,
-    isOllamaAvailable,
-    listModels as ollamaListModels,
-    clearConversationHistory,
-    parseToolCalls,
-    stripToolCalls,
-    type ToolCallRequest,
-    type ChatWithToolsResult,
-} from './services/OllamaService';
-
-// MLX Bridge
-export {
-    listAvailableModels as mlxListModels,
-    runInference as mlxRunInference,
-    compareModels as mlxCompareModels,
-    pullModel as mlxPullModel,
-    benchmarkModel as mlxBenchmarkModel,
-    startLoRATraining,
-    type MLXModelInfo,
-    type InferenceResult,
-    type TrainingProgress,
-    type BenchmarkResult,
-} from './services/MLXBridge';
-
-// Embedding Service
-export { embeddingService } from './services/EmbeddingService';
-
-// Local Agent Responder
-export { processLocalMessage } from './services/LocalAgentResponder';
-
-// LLM Providers (individual implementations)
-export { AnthropicProvider } from './services/providers/AnthropicProvider';
-export { OpenAIProvider } from './services/providers/OpenAIProvider';
-export { GeminiProvider } from './services/providers/GeminiProvider';
-export { OllamaProvider } from './services/providers/OllamaProvider';
-
-// ─── Token Wallet ───────────────────────────────────────────
-
-export {
-    tokenWallet,
-    type TokenUsageEntry,
-    type WalletSummary,
-    type ProviderSummary,
-} from './services/TokenWallet';
-
-// ─── P2P Peer Mesh ──────────────────────────────────────────
-
-export {
-    peerMesh,
-    type PeerInfo,
-    type SharedResult,
-} from './services/PeerMesh';
-
-// ─── React Hooks ────────────────────────────────────────────
-
-export { useTokenWallet } from './hooks/useTokenWallet';
-export { usePeerMesh } from './hooks/usePeerMesh';
-
-// ─── UI Components ──────────────────────────────────────────
-
-export { TokenWalletPanel } from './components/TokenWalletPanel';
-export { PeerNetworkPanel } from './components/PeerNetworkPanel';
-

package/src/ai/services/EmbeddingService.ts

@@ -1,119 +0,0 @@
-/**
- * EmbeddingService — Local text embeddings for RAG pipeline
- * 
- * Generates vector embeddings from text using:
- *  1. Ollama embeddings API (nomic-embed-text)
- *  2. Simple TF-IDF fallback for offline use
- * 
- * Used by VectorStore for semantic similarity search.
- */
-
-// ─── Types ───────────────────────────────────────────────────
-
-export interface EmbeddingResult {
-    vector: number[];
-    dimensions: number;
-    model: string;
-    latencyMs: number;
-}
-
-export type EmbeddingBackend = 'ollama' | 'tfidf';
-
-// ─── Constants ───────────────────────────────────────────────
-
-const OLLAMA_URL = 'http://localhost:11434';
-const EMBED_MODEL = 'nomic-embed-text';
-const TFIDF_DIMS = 256;
-
-// ─── Ollama Embeddings ───────────────────────────────────────
-
-async function ollamaEmbed(text: string): Promise<EmbeddingResult> {
-    const start = Date.now();
-    try {
-        const res = await fetch(`${OLLAMA_URL}/api/embed`, {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({ model: EMBED_MODEL, input: text }),
-        });
-        if (!res.ok) throw new Error(`Ollama embed failed: ${res.status}`);
-        const data = await res.json();
-        const vector = data.embeddings?.[0] || data.embedding || [];
-        return {
-            vector,
-            dimensions: vector.length,
-            model: EMBED_MODEL,
-            latencyMs: Date.now() - start,
-        };
-    } catch (err) {
-        console.warn('[EmbeddingService] Ollama not available, falling back to TF-IDF', err);
-        return tfidfEmbed(text);
-    }
-}
-
-// ─── TF-IDF Fallback ─────────────────────────────────────────
-
-/** Simple hash-based embedding for offline use */
-function tfidfEmbed(text: string): EmbeddingResult {
-    const start = Date.now();
-    const tokens = text.toLowerCase()
-        .replace(/[^\w\s]/g, '')
-        .split(/\s+/)
-        .filter(t => t.length > 2);
-
-    const vector = new Array(TFIDF_DIMS).fill(0);
-
-    for (const token of tokens) {
-        let hash = 0;
-        for (let i = 0; i < token.length; i++) {
-            hash = ((hash << 5) - hash + token.charCodeAt(i)) | 0;
-        }
-        const idx = Math.abs(hash) % TFIDF_DIMS;
-        vector[idx] += 1.0 / tokens.length;
-    }
-
-    // L2 normalize
-    const norm = Math.sqrt(vector.reduce((s: number, v: number) => s + v * v, 0));
-    if (norm > 0) {
-        for (let i = 0; i < vector.length; i++) vector[i] /= norm;
-    }
-
-    return {
-        vector,
-        dimensions: TFIDF_DIMS,
-        model: 'tfidf-fallback',
-        latencyMs: Date.now() - start,
-    };
-}
-
-// ─── Public API ──────────────────────────────────────────────
-
-let preferredBackend: EmbeddingBackend = 'ollama';
-
-export async function embed(text: string): Promise<EmbeddingResult> {
-    if (preferredBackend === 'ollama') {
-        return ollamaEmbed(text);
-    }
-    return tfidfEmbed(text);
-}
-
-export async function embedBatch(texts: string[]): Promise<EmbeddingResult[]> {
-    return Promise.all(texts.map(t => embed(t)));
-}
-
-export function setBackend(backend: EmbeddingBackend): void {
-    preferredBackend = backend;
-}
-
-export function cosineSimilarity(a: number[], b: number[]): number {
-    if (a.length !== b.length) return 0;
-    let dot = 0, normA = 0, normB = 0;
-    for (let i = 0; i < a.length; i++) {
-        dot += a[i] * b[i];
-        normA += a[i] * a[i];
-        normB += b[i] * b[i];
-    }
-    const denom = Math.sqrt(normA) * Math.sqrt(normB);
-    return denom === 0 ? 0 : dot / denom;
-}
-
-export const embeddingService = { embed, embedBatch, setBackend, cosineSimilarity };

package/src/ai/services/InferenceRouter.ts

@@ -1,347 +0,0 @@
-/**
- * InferenceRouter — Multi-backend AI inference routing
- * 
- * Routes prompts to the optimal backend based on:
- *  - Provider availability (Ollama local → Gemini API → fallback)
- *  - Active provider setting from user config
- *  - Automatic fallback chain
- * 
- * Providers:
- *  1. Ollama (local, fast, tool-calling via Qwen2)
- *  2. Gemini (Google API, powerful, requires API key)
- *  3. MLX (local, Apple Silicon optimized)
- */
-
-import {
-    registerProvider,
-    getProvider,
-    getAllProviders,
-    type LLMProvider,
-    type ChatMessage,
-    type ChatResult,
-    type ProviderStatus,
-} from './providers/LLMProvider';
-import { OllamaProvider } from './providers/OllamaProvider';
-import { GeminiProvider } from './providers/GeminiProvider';
-import { AnthropicProvider } from './providers/AnthropicProvider';
-import { OpenAIProvider } from './providers/OpenAIProvider';
-import { tokenWallet } from './TokenWallet';
-
-// Re-export for consumers
-export { getAllProviders, type LLMProvider, type ProviderStatus };
-
-// ─── Types ───────────────────────────────────────────────────
-
-export type InferenceBackend = 'ollama' | 'gemini' | 'anthropic' | 'openai' | 'mlx' | 'auto';
-
-export type TaskType = 'tool-calling' | 'chat' | 'code' | 'analysis' | 'creative';
-
-export interface RouterConfig {
-    preferredBackend: InferenceBackend;
-    maxLatencyMs: number;
-    enableFallback: boolean;
-    temperature: number;
-    maxTokens: number;
-}
-
-export interface RoutedResponse {
-    text: string;
-    backend: InferenceBackend;
-    model: string;
-    latencyMs: number;
-    tokensPerSecond: number;
-    toolsInvoked: string[];
-}
-
-// ─── Default Config ──────────────────────────────────────────
-
-const DEFAULT_CONFIG: RouterConfig = {
-    preferredBackend: 'auto',
-    maxLatencyMs: 30000,
-    enableFallback: true,
-    temperature: 0.7,
-    maxTokens: 512,
-};
-
-// ─── Provider Initialization ─────────────────────────────────
-
-let _initialized = false;
-
-function ensureProviders(): void {
-    if (_initialized) return;
-    _initialized = true;
-
-    registerProvider(new OllamaProvider());
-    registerProvider(new GeminiProvider());
-    registerProvider(new AnthropicProvider());
-    registerProvider(new OpenAIProvider());
-
-    console.log('🔌 [InferenceRouter] 4 providers initialized (Ollama, Gemini, Anthropic, OpenAI)');
-}
-
-// ─── API Key Management ─────────────────────────────────────
-
-interface ProviderKeys {
-    gemini?: string;
-    openai?: string;
-    anthropic?: string;
-    [key: string]: string | undefined;
-}
-
-let _cachedKeys: ProviderKeys | null = null;
-
-async function getInvoke(): Promise<((cmd: string, args?: Record<string, unknown>) => Promise<unknown>) | null> {
-    try {
-        const tauri = await import('@tauri-apps/api/core');
-        return tauri.invoke;
-    } catch {
-        return null;
-    }
-}
-
-export async function loadProviderKeys(): Promise<ProviderKeys> {
-    if (_cachedKeys) return _cachedKeys;
-
-    try {
-        const invoke = await getInvoke();
-        if (invoke) {
-            const raw = await invoke('load_provider_keys') as string | null;
-            if (raw) {
-                _cachedKeys = JSON.parse(raw);
-                return _cachedKeys!;
-            }
-        }
-    } catch (e) {
-        console.warn('[InferenceRouter] Failed to load provider keys:', e);
-    }
-
-    // Fallback to localStorage
-    try {
-        const stored = localStorage.getItem('macia-provider-keys');
-        if (stored) {
-            _cachedKeys = JSON.parse(stored);
-            return _cachedKeys!;
-        }
-    } catch { /* ignore */ }
-
-    _cachedKeys = {};
-    return _cachedKeys;
-}
-
-export async function saveProviderKeys(keys: ProviderKeys): Promise<void> {
-    _cachedKeys = keys;
-
-    try {
-        const invoke = await getInvoke();
-        if (invoke) {
-            await invoke('save_provider_keys', {
-                json: JSON.stringify(keys, null, 2),
-            });
-            return;
-        }
-    } catch (e) {
-        console.warn('[InferenceRouter] Failed to save provider keys via Tauri:', e);
-    }
-
-    // Fallback to localStorage
-    try {
-        localStorage.setItem('macia-provider-keys', JSON.stringify(keys));
-    } catch { /* ignore */ }
-}
-
-/**
- * Initialize providers and load saved API keys.
- * Call once during app bootstrap.
- */
-export async function initProviders(): Promise<void> {
-    ensureProviders();
-
-    const keys = await loadProviderKeys();
-
-    // Apply saved keys to all providers
-    const providerKeyMap: Record<string, string | undefined> = {
-        gemini: keys.gemini,
-        anthropic: keys.anthropic,
-        openai: keys.openai,
-    };
-
-    for (const [id, key] of Object.entries(providerKeyMap)) {
-        if (key) {
-            const provider = getProvider(id);
-            provider?.setApiKey?.(key);
-            console.log(`🔑 [InferenceRouter] ${id} API key loaded`);
-        }
-    }
-}
-
-/**
- * Set/update an API key for a provider and persist it.
- */
-export async function setProviderApiKey(providerId: string, apiKey: string): Promise<void> {
-    const provider = getProvider(providerId);
-    if (provider?.setApiKey) {
-        provider.setApiKey(apiKey);
-    }
-
-    const keys = await loadProviderKeys();
-    keys[providerId] = apiKey;
-    await saveProviderKeys(keys);
-}
-
-// ─── Provider Status ─────────────────────────────────────────
-
-export async function getProviderStatuses(): Promise<Record<string, ProviderStatus>> {
-    ensureProviders();
-    const statuses: Record<string, ProviderStatus> = {};
-    for (const provider of getAllProviders()) {
-        statuses[provider.id] = await provider.checkStatus();
-    }
-    return statuses;
-}
-
-// ─── Task Classifier ─────────────────────────────────────────
-
-function classifyTask(prompt: string): TaskType {
-    const lower = prompt.toLowerCase();
-
-    const toolPatterns = [
-        'ejecuta', 'revisa', 'escanea', 'limpia', 'optimiza',
-        'monitorea', 'diagnostica', 'analiza el sistema',
-        'procesos', 'disco', 'memoria', 'red', 'seguridad',
-        'git', 'commit', 'deploy', 'backup',
-    ];
-    if (toolPatterns.some(p => lower.includes(p))) return 'tool-calling';
-
-    const codePatterns = ['codigo', 'funcion', 'clase', 'error', 'debug', 'refactor', 'typescript', 'python', 'rust'];
-    if (codePatterns.some(p => lower.includes(p))) return 'code';
-
-    const analysisPatterns = ['analiza', 'compara', 'benchmark', 'rendimiento', 'metricas', 'estadisticas'];
-    if (analysisPatterns.some(p => lower.includes(p))) return 'analysis';
-
-    const creativePatterns = ['genera', 'crea', 'escribe', 'inventa', 'imagina', 'diseña'];
-    if (creativePatterns.some(p => lower.includes(p))) return 'creative';
-
-    return 'chat';
-}
-
-// ─── Main Router ─────────────────────────────────────────────
-
-/**
- * Route a chat request to the best available provider.
- * 
- * This is the main entry point used by OllamaService and AgentToolLoop.
- */
-export async function routeChat(
-    messages: ChatMessage[],
-    config: Partial<RouterConfig> = {},
-): Promise<ChatResult & { backend: string }> {
-    ensureProviders();
-    const cfg = { ...DEFAULT_CONFIG, ...config };
-
-    // Determine which provider to try
-    const providerOrder = resolveProviderOrder(cfg.preferredBackend);
-
-    for (const providerId of providerOrder) {
-        const provider = getProvider(providerId);
-        if (!provider) continue;
-
-        const status = await provider.checkStatus();
-        if (status !== 'available') {
-            if (!cfg.enableFallback) {
-                throw new Error(`Provider ${provider.name} is ${status}`);
-            }
-            continue;
-        }
-
-        try {
-            const result = await provider.chat(messages, {
-                model: undefined, // use provider default
-                temperature: cfg.temperature,
-                maxTokens: cfg.maxTokens,
-            });
-
-            // 💰 Record usage in Token Wallet
-            tokenWallet.record({
-                provider: providerId,
-                model: result.model,
-                tokensUsed: result.tokensUsed,
-            });
-
-            return {
-                ...result,
-                backend: providerId,
-            };
-        } catch (err) {
-            console.warn(`[InferenceRouter] ${provider.name} failed:`, err);
-            if (!cfg.enableFallback) throw err;
-            // Try next provider
-        }
-    }
-
-    throw new Error('No hay backends de IA disponibles. Inicia Ollama o configura una API key de Gemini.');
-}
-
-function resolveProviderOrder(preferred: InferenceBackend): string[] {
-    switch (preferred) {
-        case 'ollama': return ['ollama', 'gemini', 'anthropic', 'openai'];
-        case 'gemini': return ['gemini', 'ollama', 'anthropic', 'openai'];
-        case 'anthropic': return ['anthropic', 'gemini', 'ollama', 'openai'];
-        case 'openai': return ['openai', 'gemini', 'ollama', 'anthropic'];
-        case 'auto':
-        default:
-            return ['ollama', 'gemini', 'anthropic', 'openai'];
-    }
-}
-
-// ─── Legacy API Compatibility ────────────────────────────────
-
-/**
- * Legacy `routeInference` function — routes a prompt string.
- * Used by AgentLoop, AgentPlanner, RAGPipeline.
- */
-export async function routeInference(
-    prompt: string,
-    config: Partial<RouterConfig> = {},
-): Promise<RoutedResponse> {
-    const messages: ChatMessage[] = [
-        { role: 'user', content: prompt },
-    ];
-
-    try {
-        const result = await routeChat(messages, config);
-        return {
-            text: result.text,
-            backend: result.backend as InferenceBackend,
-            model: result.model,
-            latencyMs: result.latencyMs,
-            tokensPerSecond: result.tokensUsed
-                ? result.tokensUsed / (result.latencyMs / 1000)
-                : 0,
-            toolsInvoked: [],
-        };
-    } catch {
-        return {
-            text: 'No hay backends disponibles. Inicia Ollama o configura un modelo.',
-            backend: 'auto',
-            model: 'none',
-            latencyMs: 0,
-            tokensPerSecond: 0,
-            toolsInvoked: [],
-        };
-    }
-}
-
-// ─── Convenience Export ──────────────────────────────────────
-
-export const inferenceRouter = {
-    route: routeInference,
-    routeChat,
-    classifyTask,
-    initProviders,
-    getProviderStatuses,
-    setProviderApiKey,
-    loadProviderKeys,
-    getAllProviders,
-    getProvider,
-    tokenWallet,
-};