@decido/kernel-bridge 1.0.0 → 4.0.1

package/src/ai/services/providers/OllamaProvider.ts

@@ -1,84 +0,0 @@
-/**
- * OllamaProvider — Local Ollama LLM provider
- * 
- * Wraps Ollama's REST API (localhost:11434) as an LLMProvider.
- * Supports tool-calling via <tool_call> blocks in system prompt.
- */
-
-import type { LLMProvider, ChatMessage, ChatOptions, ChatResult, ProviderStatus } from './LLMProvider';
-
-// ─── Config ─────────────────────────────────────────────────
-
-const OLLAMA_BASE_URL = 'http://localhost:11434';
-const DEFAULT_MODEL = 'qwen2:latest';
-
-// ─── Provider Implementation ────────────────────────────────
-
-export class OllamaProvider implements LLMProvider {
-    readonly id = 'ollama';
-    readonly name = 'Ollama (Local)';
-    readonly requiresApiKey = false;
-    readonly defaultModel = DEFAULT_MODEL;
-
-    async listModels(): Promise<string[]> {
-        try {
-            const res = await fetch(`${OLLAMA_BASE_URL}/api/tags`);
-            if (!res.ok) return [];
-            const data = await res.json();
-            return (data.models || []).map((m: { name: string }) => m.name);
-        } catch {
-            return [];
-        }
-    }
-
-    async checkStatus(): Promise<ProviderStatus> {
-        try {
-            const res = await fetch(`${OLLAMA_BASE_URL}/api/tags`, {
-                signal: AbortSignal.timeout(2000),
-            });
-            return res.ok ? 'available' : 'error';
-        } catch {
-            return 'unavailable';
-        }
-    }
-
-    async chat(messages: ChatMessage[], options?: ChatOptions): Promise<ChatResult> {
-        const model = options?.model || this.defaultModel;
-        const start = Date.now();
-
-        const ollamaMessages = messages.map(m => ({
-            role: m.role,
-            content: m.content,
-        }));
-
-        const res = await fetch(`${OLLAMA_BASE_URL}/api/chat`, {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({
-                model,
-                messages: ollamaMessages,
-                stream: false,
-                options: {
-                    temperature: options?.temperature ?? 0.7,
-                    num_predict: options?.maxTokens ?? 512,
-                },
-            }),
-            signal: options?.signal ?? AbortSignal.timeout(30000),
-        });
-
-        if (!res.ok) {
-            const errorText = await res.text();
-            throw new Error(`Ollama API error ${res.status}: ${errorText}`);
-        }
-
-        const data = await res.json();
-        const latencyMs = Date.now() - start;
-
-        return {
-            text: data.message?.content || '(sin respuesta)',
-            model,
-            latencyMs,
-            tokensUsed: data.eval_count,
-        };
-    }
-}

package/src/ai/services/providers/OpenAIProvider.ts

@@ -1,178 +0,0 @@
-/**
- * OpenAIProvider — GPT-4o / GPT-4 / GPT-3.5 LLM provider
- * 
- * Supports chat completion with streaming via SSE.
- * Compatible with OpenAI API and OpenAI-compatible endpoints (e.g., LM Studio).
- */
-
-import type { LLMProvider, ChatMessage, ChatOptions, ChatResult, ProviderStatus } from './LLMProvider';
-
-// ─── Config ─────────────────────────────────────────────────
-
-const OPENAI_API_BASE = 'https://api.openai.com/v1';
-const DEFAULT_MODEL = 'gpt-4o';
-
-const AVAILABLE_MODELS = [
-    'gpt-4o',
-    'gpt-4o-mini',
-    'gpt-4-turbo',
-    'gpt-4',
-    'gpt-3.5-turbo',
-    'o3-mini',
-];
-
-// ─── Provider Implementation ────────────────────────────────
-
-export class OpenAIProvider implements LLMProvider {
-    readonly id = 'openai';
-    readonly name = 'OpenAI';
-    readonly requiresApiKey = true;
-    readonly defaultModel = DEFAULT_MODEL;
-
-    private apiKey: string | null = null;
-    private baseUrl: string = OPENAI_API_BASE;
-
-    setApiKey(key: string): void {
-        this.apiKey = key;
-    }
-
-    /** Override base URL for OpenAI-compatible endpoints */
-    setBaseUrl(url: string): void {
-        this.baseUrl = url.replace(/\/$/, '');
-    }
-
-    async listModels(): Promise<string[]> {
-        if (!this.apiKey) return AVAILABLE_MODELS;
-
-        try {
-            const res = await fetch(`${this.baseUrl}/models`, {
-                headers: { Authorization: `Bearer ${this.apiKey}` },
-                signal: AbortSignal.timeout(5000),
-            });
-            if (!res.ok) return AVAILABLE_MODELS;
-            const data = await res.json();
-            const models = (data.data || [])
-                .map((m: { id: string }) => m.id)
-                .filter((id: string) => id.startsWith('gpt-') || id.startsWith('o'));
-            return models.length > 0 ? models : AVAILABLE_MODELS;
-        } catch {
-            return AVAILABLE_MODELS;
-        }
-    }
-
-    async checkStatus(): Promise<ProviderStatus> {
-        if (!this.apiKey) return 'unconfigured';
-
-        try {
-            const res = await fetch(`${this.baseUrl}/models`, {
-                headers: { Authorization: `Bearer ${this.apiKey}` },
-                signal: AbortSignal.timeout(5000),
-            });
-            return res.ok ? 'available' : 'error';
-        } catch {
-            return 'unavailable';
-        }
-    }
-
-    async chat(messages: ChatMessage[], options?: ChatOptions): Promise<ChatResult> {
-        if (!this.apiKey) {
-            throw new Error('OpenAI API key not configured. Set it in Settings → Providers.');
-        }
-
-        const model = options?.model || this.defaultModel;
-        const start = Date.now();
-
-        const body: Record<string, unknown> = {
-            model,
-            messages: messages.map(m => ({ role: m.role, content: m.content })),
-            temperature: options?.temperature ?? 0.7,
-            max_tokens: options?.maxTokens ?? 2048,
-        };
-
-        const res = await fetch(`${this.baseUrl}/chat/completions`, {
-            method: 'POST',
-            headers: {
-                Authorization: `Bearer ${this.apiKey}`,
-                'Content-Type': 'application/json',
-            },
-            body: JSON.stringify(body),
-            signal: options?.signal ?? AbortSignal.timeout(60000),
-        });
-
-        if (!res.ok) {
-            const errorBody = await res.text();
-            throw new Error(`OpenAI API error ${res.status}: ${errorBody}`);
-        }
-
-        const data = await res.json();
-        const latencyMs = Date.now() - start;
-
-        const text = data.choices?.[0]?.message?.content || '(sin respuesta)';
-        const tokensUsed =
-            (data.usage?.prompt_tokens || 0) + (data.usage?.completion_tokens || 0);
-
-        return { text, model, latencyMs, tokensUsed };
-    }
-
-    /** Stream chat completion — yields text chunks */
-    async *chatStream(
-        messages: ChatMessage[],
-        options?: ChatOptions,
-    ): AsyncGenerator<string, void, unknown> {
-        if (!this.apiKey) {
-            throw new Error('OpenAI API key not configured.');
-        }
-
-        const model = options?.model || this.defaultModel;
-
-        const body: Record<string, unknown> = {
-            model,
-            messages: messages.map(m => ({ role: m.role, content: m.content })),
-            temperature: options?.temperature ?? 0.7,
-            max_tokens: options?.maxTokens ?? 2048,
-            stream: true,
-        };
-
-        const res = await fetch(`${this.baseUrl}/chat/completions`, {
-            method: 'POST',
-            headers: {
-                Authorization: `Bearer ${this.apiKey}`,
-                'Content-Type': 'application/json',
-            },
-            body: JSON.stringify(body),
-            signal: options?.signal ?? AbortSignal.timeout(120000),
-        });
-
-        if (!res.ok) {
-            const errorBody = await res.text();
-            throw new Error(`OpenAI stream error ${res.status}: ${errorBody}`);
-        }
-
-        const reader = res.body?.getReader();
-        if (!reader) return;
-
-        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) {
-                if (!line.startsWith('data: ')) continue;
-                const data = line.slice(6).trim();
-                if (data === '[DONE]') return;
-
-                try {
-                    const chunk = JSON.parse(data);
-                    const delta = chunk.choices?.[0]?.delta?.content;
-                    if (delta) yield delta;
-                } catch { /* skip malformed */ }
-            }
-        }
-    }
-}

package/src/crypto.ts

@@ -1,54 +0,0 @@
-/**
- * Utility functions for decrypting the Zero-Trust encrypted Swarm Bus messages
- */
-
-/**
- * Decrypts a base64 encoded payload that contains [12-byte Nonce][Ciphertext]
- * using AES-256-GCM and the provided Swarm Key
- * 
- * @param base64Payload The encrypted base64 string from Redis
- * @param base64Key The base64 string representing the 32-byte Swarm Key
- * @returns The parsed JSON object of the event
- */
-export async function decryptEvent(base64Payload: string, base64Key: string): Promise<any> {
-    try {
-        // 1. Decode base64 key
-        const keyBuffer = Uint8Array.from(atob(base64Key), c => c.charCodeAt(0));
-
-        // 2. Decode base64 payload
-        const payloadBuffer = Uint8Array.from(atob(base64Payload), c => c.charCodeAt(0));
-
-        if (payloadBuffer.byteLength < 12) {
-            throw new Error("Payload too short to contain a valid nonce");
-        }
-
-        // 3. Extract Nonce (first 12 bytes) and Ciphertext (the rest)
-        const nonce = payloadBuffer.slice(0, 12);
-        const ciphertext = payloadBuffer.slice(12);
-
-        // 4. Import the key for subtle crypto
-        const cryptoKey = await crypto.subtle.importKey(
-            "raw",
-            keyBuffer,
-            { name: "AES-GCM" },
-            false,
-            ["decrypt"]
-        );
-
-        // 5. Decrypt
-        const decryptedBuffer = await crypto.subtle.decrypt(
-            { name: "AES-GCM", iv: nonce },
-            cryptoKey,
-            ciphertext
-        );
-
-        // 6. Parse JSON
-        const decoder = new TextDecoder();
-        const jsonString = decoder.decode(decryptedBuffer);
-
-        return JSON.parse(jsonString);
-    } catch (e) {
-        console.error("[Crypto Bridge] Failed to decrypt secure event:", e);
-        throw e;
-    }
-}

package/src/kernel.ts

@@ -1,376 +0,0 @@
-import { io, Socket } from 'socket.io-client';
-import { inferenceRouter, TaskType, InferenceBackend } from './ai/services/InferenceRouter';
-import { createSafeEvent } from '@decido/sdk';
-
-// Tauri modules are loaded dynamically to avoid breaking browser-only hosts
-// (e.g. theme-playground) where @tauri-apps/* is stubbed out by Vite.
-async function getTauriCore() { return import('@tauri-apps/api/core'); }
-async function getTauriEvent() { return import('@tauri-apps/api/event'); }
-
-export interface LogEntry {
-    id: string;
-    timestamp: number;
-    type: 'ipc_out' | 'ipc_in' | 'info' | 'error';
-    channel: string;
-    payload?: any;
-    duration?: number;
-}
-
-// -----------------------------------------------------
-// TRANSPORT ADAPTERS (Tauri vs WebSocket)
-// -----------------------------------------------------
-export interface KernelTransport {
-    name: string;
-    isConnectedToCloud: boolean;
-    connectToSwarm(tenantId: string, url: string, token?: string): void;
-    execute<T>(tenantId: string, cmd: string, args?: Record<string, unknown>): Promise<T>;
-    notify(title: string, body: string): Promise<void>;
-    vibrate(pattern: any): Promise<void>;
-    getEventHistory(tenantId: string, limit: number): Promise<any[]>;
-    listenEvents(onEvent: (payload: { type: string, channel: string, payload: any }) => void): () => void;
-}
-
-class TauriTransport implements KernelTransport {
-    name = "Anillo 0/1 (Tauri IPC)";
-    isConnectedToCloud = false;
-    private unlistenFns: (() => void)[] = [];
-
-    connectToSwarm(tenantId: string, url: string, token?: string) {
-        // En Anillo 0, Tauri (Rust) se encarga de la conexión WebSocket en background
-        // Podríamos enviar un invoke('connect_swarm') aquí si fuera necesario
-        console.log(`[Kernel/Tauri] Conexión nativa delegada a Core-Rust para tenant: ${tenantId}`);
-    }
-
-    async execute<T>(tenantId: string, cmd: string, args?: Record<string, unknown>): Promise<T> {
-        const { invoke } = await getTauriCore();
-        return invoke<T>(cmd, { tenantId, ...args });
-    }
-
-    async notify(title: string, body: string): Promise<void> {
-        try {
-            const { sendNotification } = await import('@tauri-apps/plugin-notification');
-            await sendNotification({ title, body });
-        } catch (e) {
-            console.log('[Kernel/Tauri] Notification plugin not available.');
-        }
-    }
-
-    async vibrate(pattern: any): Promise<void> {
-        try {
-            const { vibrate: nativeVibrate } = await import('@tauri-apps/plugin-haptics');
-            await nativeVibrate(pattern);
-        } catch (e) {
-            console.log('[Kernel/Tauri] Haptics not available on this platform.');
-        }
-    }
-
-    async getEventHistory(tenantId: string, limit: number): Promise<any[]> {
-        return this.execute<any[]>(tenantId, 'get_stream_history', { limit });
-    }
-
-    listenEvents(onEvent: (payload: { type: string, channel: string, payload: any }) => void): () => void {
-        let unlistenFn: (() => void) | null = null;
-        getTauriEvent().then(({ listen }) => {
-            listen('orchestrator-event', (event: any) => {
-                onEvent({ type: 'ipc_in', channel: 'orchestrator-event', payload: event.payload });
-            }).then(fn => {
-                unlistenFn = fn;
-                this.unlistenFns.push(fn);
-            });
-        });
-
-        return () => {
-            if (unlistenFn) {
-                unlistenFn();
-                this.unlistenFns = this.unlistenFns.filter(f => f !== unlistenFn);
-            }
-        };
-    }
-}
-
-class WebSocketTransport implements KernelTransport {
-    name = "Satélite Web (WebSocket)";
-    isConnectedToCloud = false;
-    private sockets: Record<string, Socket> = {};
-    private eventListeners: Set<(payload: { type: string, channel: string, payload: any }) => void> = new Set();
-
-    connectToSwarm(tenantId: string, url: string, token?: string) {
-        if (this.sockets[tenantId]) return;
-        const socket = io(url, { auth: token ? { token } : undefined });
-
-        socket.on('connect', () => {
-            this.isConnectedToCloud = true;
-            console.log(`✅ [Kernel/WS] Satélite conectado al Enjambre del Tenant: ${tenantId}`);
-        });
-
-        socket.on('orchestrator-event', (eventPayload) => {
-            this.eventListeners.forEach(cb => cb({ type: 'ipc_in', channel: 'orchestrator-event', payload: { tenantId, ...eventPayload } }));
-        });
-
-        socket.on('rpc_broadcast', (eventPayload) => {
-            console.log(`[Kernel] 🌐 Broadcast Recibido [${tenantId}]:`, eventPayload);
-            this.eventListeners.forEach(cb => cb({ type: 'ipc_in', channel: 'rpc_broadcast', payload: { tenantId, ...eventPayload } }));
-        });
-
-        this.sockets[tenantId] = socket;
-    }
-
-    async execute<T>(tenantId: string, cmd: string, args?: Record<string, unknown>): Promise<T> {
-        const socket = this.sockets[tenantId];
-        if (socket) {
-            return new Promise((resolve, reject) => {
-                socket.emit('rpc_call', { cmd, args }, (response: any) => {
-                    if (response.error) reject(new Error(response.error));
-                    else resolve(response.data as T);
-                });
-            });
-        }
-        console.warn(`[Kernel Mock] Executing ${cmd} for tenant ${tenantId}`, args);
-        return {} as T;
-    }
-
-    async notify(title: string, body: string): Promise<void> {
-        console.log(`[Notification Mock] ${title}: ${body}`);
-    }
-
-    async vibrate(pattern: any): Promise<void> {
-        if (typeof navigator !== 'undefined' && navigator.vibrate) {
-            navigator.vibrate(pattern === 'heavy' ? 200 : 50);
-        }
-    }
-
-    async getEventHistory(tenantId: string, limit: number): Promise<any[]> {
-        console.warn('[Kernel Mock] Cannot fetch stream history in Web Sandbox.');
-        return [];
-    }
-
-    listenEvents(onEvent: (payload: { type: string, channel: string, payload: any }) => void): () => void {
-        this.eventListeners.add(onEvent);
-        return () => this.eventListeners.delete(onEvent);
-    }
-}
-
-// -----------------------------------------------------
-// HIGH LEVEL KERNEL API
-// -----------------------------------------------------
-class DecidoKernel {
-    private logs: LogEntry[] = [];
-    private logListeners: Set<(logs: LogEntry[]) => void> = new Set();
-    private universalListeners: Set<(event: unknown) => void> = new Set();
-
-    private transport: KernelTransport;
-    private rateLimits: Map<string, { calls: number, resetAt: number }> = new Map();
-
-    private checkRateLimit(cmd: string): boolean {
-        const now = Date.now();
-        const limitWin = 1000; // 1 second window
-        const maxCalls = 50;   // 50 calls per second per command
-
-        let tracker = this.rateLimits.get(cmd);
-        if (!tracker || tracker.resetAt < now) {
-            tracker = { calls: 0, resetAt: now + limitWin };
-            this.rateLimits.set(cmd, tracker);
-        }
-
-        tracker.calls++;
-        if (tracker.calls > maxCalls) {
-            console.warn(`[Kernel Throttle] 🚨 Command ${cmd} blocked (Rate limit: >50 calls/sec). Possible plugin infinite loop.`);
-            return false;
-        }
-        return true;
-    }
-
-    constructor() {
-        // Factory detect
-        const isTauri = typeof window !== 'undefined' && '__TAURI_INTERNALS__' in window;
-        this.transport = isTauri ? new TauriTransport() : new WebSocketTransport();
-
-        console.log(`[Kernel] Entorno Detectado. Operando en Modo ${this.transport.name}.`);
-
-        // Global Event Hook
-        this.transport.listenEvents((event) => {
-            if (event.type === 'ipc_in') {
-                this.addLog({ type: 'ipc_in', channel: event.channel, payload: event.payload });
-                this.notifyUniversalListeners(event.payload.payload || event.payload);
-            }
-        });
-    }
-
-    public get isConnectedToCloud() {
-        return this.transport.isConnectedToCloud;
-    }
-
-    public connectToSwarm(tenantId: string, url: string, token?: string) {
-        this.transport.connectToSwarm(tenantId, url, token);
-    }
-
-    // Validador Zod y Notificador Universal
-    private notifyUniversalListeners(rawPayload: unknown) {
-        const parsed = createSafeEvent(rawPayload);
-
-        if (!parsed.success) {
-            console.error('[Kernel] 🚨 Inbound Mesh Event Failed Contract Validation:', parsed.error.format());
-            this.universalListeners.forEach(cb => cb({
-                type: 'system_alert',
-                source: 'kernel-bridge',
-                payload: {
-                    level: 'error',
-                    title: 'Contract Violation',
-                    message: 'A received event did not match the strict schema. Ignored.'
-                }
-            }));
-            return;
-        }
-        this.universalListeners.forEach(cb => cb(parsed.data));
-    }
-
-    injectEvent(payload: unknown) {
-        this.notifyUniversalListeners(payload);
-    }
-
-    private addLog(entry: Omit<LogEntry, 'id' | 'timestamp'>) {
-        const log: LogEntry = {
-            id: typeof crypto !== 'undefined' && crypto.randomUUID ? crypto.randomUUID() : Math.random().toString(36).substring(2, 9),
-            timestamp: Date.now(),
-            ...entry
-        };
-        this.logs = [log, ...this.logs].slice(0, 500);
-        this.logListeners.forEach(listener => listener(this.logs));
-    }
-
-    onLogsChange(callback: (logs: LogEntry[]) => void): () => void {
-        this.logListeners.add(callback);
-        callback(this.logs);
-        return () => this.logListeners.delete(callback);
-    }
-
-    async execute<T>(tenantIdOrCmd: string, cmdOrArgs?: string | Record<string, unknown>, argsOpts?: Record<string, unknown>): Promise<T> {
-        let tenantId = 'system';
-        let cmd = tenantIdOrCmd;
-        let args = cmdOrArgs as Record<string, unknown> | undefined;
-
-        if (typeof cmdOrArgs === 'string') {
-            tenantId = tenantIdOrCmd;
-            cmd = cmdOrArgs;
-            args = argsOpts;
-        }
-
-        if (!this.checkRateLimit(cmd)) {
-            throw new Error(`[Kernel Throttle] Request dropped for ${cmd} (Rate limit exceeded)`);
-        }
-
-        const start = performance.now();
-        try {
-            const result = await this.transport.execute<T>(tenantId, cmd, args);
-            this.addLog({ type: 'ipc_out', channel: cmd, payload: { tenantId, ...args }, duration: performance.now() - start });
-            return result;
-        } catch (error) {
-            this.addLog({ type: 'error', channel: cmd, payload: { tenantId, args, error }, duration: performance.now() - start });
-            throw error;
-        }
-    }
-
-    async notify(title: string, body: string): Promise<void> {
-        return this.transport.notify(title, body);
-    }
-
-    async vibrate(pattern: 'light' | 'medium' | 'heavy' | 'selection' | 'success' | 'warning' | 'error' = 'medium'): Promise<void> {
-        return this.transport.vibrate(pattern);
-    }
-
-    async captureScreen(tenantId: string = 'system'): Promise<string> {
-        return this.execute<string>(tenantId, 'capture_screen');
-    }
-
-    async getMachineId(tenantId: string = 'system'): Promise<string> {
-        return this.execute<string>(tenantId, 'get_machine_id');
-    }
-
-    async initiateSingularity(tenantId: string = 'system'): Promise<any[]> {
-        return this.execute<any[]>(tenantId, 'initiate_singularity');
-    }
-
-    async broadcastMessage(tenantId: string, message: string): Promise<number> {
-        return this.execute<number>(tenantId, 'broadcast_message', { message });
-    }
-
-    async fetchMemories(tenantId: string = 'system', query: string, limit: number = 20): Promise<any[]> {
-        return this.execute<any[]>(tenantId, 'fetch_memories', { query, limit });
-    }
-
-    async storeMemory(tenantId: string = 'system', text: string, metadata: Record<string, unknown> = {}): Promise<void> {
-        return this.execute<void>(tenantId, 'store_memory', { text, metadata });
-    }
-
-    async deleteMemory(tenantId: string = 'system', id: string): Promise<void> {
-        return this.execute<void>(tenantId, 'delete_memory', { id });
-    }
-
-    async reasonWithMLX(base64Image: string, prompt: string, previousError?: string): Promise<any> {
-        let finalPrompt = prompt;
-        if (previousError) {
-            finalPrompt += `\n\nWARNING: Your previous response failed to parse as JSON with the following error: ${previousError}. Fix the JSON syntax and return ONLY a valid JSON object.`;
-        }
-        try {
-            const response = await fetch('http://127.0.0.1:8080/v1/chat/completions', {
-                method: 'POST',
-                headers: { 'Content-Type': 'application/json' },
-                body: JSON.stringify({
-                    model: 'llava',
-                    messages: [{
-                        role: 'user',
-                        content: [
-                            { type: 'text', text: finalPrompt },
-                            { type: 'image_url', image_url: { url: base64Image } }
-                        ]
-                    }],
-                    max_tokens: 150, temperature: 0.1
-                })
-            });
-            const data = await response.json();
-            let content = data.choices[0].message.content.trim();
-            if (content.startsWith('```json')) content = content.replace(/```json\n?/, '').replace(/```$/, '').trim();
-            else if (content.startsWith('```')) content = content.replace(/```\n?/, '').replace(/```$/, '').trim();
-            return JSON.parse(content);
-        } catch (e: any) {
-            console.error('[MLX Bridge] Reasoning failed:', e);
-            throw e;
-        }
-    }
-
-    async executeAction(tenantId: string = 'system', action: any): Promise<any> {
-        return this.execute(tenantId, 'execute_action', { action });
-    }
-
-    async runAutonomousStep(tenantId: string = 'system', objective: string): Promise<void> {
-        const image = await this.captureScreen(tenantId);
-        let decision = null, retries = 0, lastError = null;
-        const instruction = `You are an AI OS agent. Based on the screen image, what action should be taken to achieve: "${objective}"? Return ONLY a strict JSON object of the action, no markdown. E.g. {"type": "mouseClick", "x": 100, "y": 200, "button": "left", "count": 1}`;
-        while (retries <= 2 && !decision) {
-            try {
-                decision = await this.reasonWithMLX(image, instruction, lastError || undefined);
-            } catch (error: any) {
-                lastError = error.message || String(error);
-                retries++;
-            }
-        }
-        if (!decision) return;
-        await this.executeAction(tenantId, decision);
-    }
-
-    async askAI(prompt: string, taskType: TaskType = 'reasoning' as any, forceProvider?: InferenceBackend): Promise<string> {
-        const result = await inferenceRouter.route(prompt, { preferredBackend: forceProvider || 'auto' });
-        return result.text;
-    }
-
-    onEvent(callback: (eventData: any) => void): () => void {
-        this.universalListeners.add(callback);
-        return () => this.universalListeners.delete(callback);
-    }
-
-    async getEventHistory(tenantId: string, limit: number = 50): Promise<any[]> {
-        return this.transport.getEventHistory(tenantId, limit);
-    }
-}
-
-export const kernel = new DecidoKernel();