escribano 0.4.4 → 0.5.0

package/dist/adapters/intelligence.mlx.adapter.js

@@ -1,11 +1,16 @@
 /**
- * Escribano - Intelligence Adapter (MLX-VLM)
+ * Escribano - Intelligence Adapter (MLX)
  *
- * Implements IntelligenceService using MLX-VLM via Unix domain socket.
- * Uses interleaved batching for 4.7x speedup over Ollama sequential processing.
+ * Implements IntelligenceService using MLX-VLM and MLX-LM via Unix domain sockets.
+ * Uses separate bridge processes for VLM (frame analysis) and LLM (text generation).
  *
  * Architecture:
- *   TypeScript (this file) <--Unix Socket--> Python (mlx_bridge.py)
+ *   TypeScript (this file) <--Unix Socket--> Python (mlx_bridge.py --mode vlm)
+ *   TypeScript (this file) <--Unix Socket--> Python (mlx_bridge.py --mode llm)
+ *
+ * The caller only sees a single IntelligenceService. Internally, we manage:
+ * - VLM bridge: spawns lazily on describeImages(), uses -vlm.sock
+ * - LLM bridge: spawns lazily on generateText(), uses -llm.sock
  *
  * See docs/adr/006-mlx-vlm-adapter.md for full design.
  */
@@ -15,29 +20,16 @@ import { createConnection } from 'node:net';
 import { dirname, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 const __dirname = dirname(fileURLToPath(import.meta.url));
-import { ESCRIBANO_HOME, ESCRIBANO_VENV, ESCRIBANO_VENV_PYTHON, getPythonPath, } from '../python-utils.js';
-const DEBUG_MLX = process.env.ESCRIBANO_VERBOSE === 'true';
+import { loadConfig } from '../config.js';
+import { getDbPath } from '../db/index.js';
+import { ESCRIBANO_HOME, ESCRIBANO_VENV_PYTHON, getPythonPath, } from '../python-utils.js';
+import { selectBestMLXModel } from '../utils/model-detector.js';
 function debugLog(...args) {
-    if (DEBUG_MLX) {
-        console.log('[VLM] [MLX]', ...args);
+    const config = loadConfig();
+    if (config.verbose) {
+        console.log('[MLX]', ...args);
     }
 }
-const DEFAULT_CONFIG = {
-    model: process.env.ESCRIBANO_VLM_MODEL ??
-        'mlx-community/Qwen3-VL-2B-Instruct-bf16',
-    batchSize: Number(process.env.ESCRIBANO_VLM_BATCH_SIZE) || 4,
-    maxTokens: Number(process.env.ESCRIBANO_VLM_MAX_TOKENS) || 2000,
-    socketPath: process.env.ESCRIBANO_MLX_SOCKET_PATH ?? '/tmp/escribano-mlx.sock',
-    bridgeScript: resolve(__dirname, '../../scripts/mlx_bridge.py'),
-    startupTimeout: Number(process.env.ESCRIBANO_MLX_STARTUP_TIMEOUT) || 120000,
-};
-/** pip binary inside Escribano's managed venv. */
-const _ESCRIBANO_VENV_PIP = resolve(ESCRIBANO_VENV, 'bin', 'pip');
-/**
- * Run a command, streaming stdout/stderr directly to the terminal.
- * Used for long-running setup tasks (venv creation, pip install) so the
- * user can see progress in real time.
- */
 function runVisible(cmd, args) {
     return new Promise((res, rej) => {
         const proc = spawn(cmd, args, { stdio: 'inherit' });
@@ -45,9 +37,6 @@ function runVisible(cmd, args) {
         proc.on('error', rej);
     });
 }
-/**
- * Run a command silently (discard output). Used for quick probe checks.
- */
 function runSilent(cmd, args) {
     return new Promise((res, rej) => {
         const proc = spawn(cmd, args, { stdio: 'ignore' });
@@ -55,25 +44,19 @@ function runSilent(cmd, args) {
         proc.on('error', rej);
     });
 }
-/**
- * Ensure ~/.escribano/venv exists and has mlx-vlm installed.
- * Uses plain `python3 -m venv` — no uv, no pip flags, no fuss.
- * On first run this takes a few minutes; subsequent runs are instant.
- */
 async function ensureEscribanoVenv() {
     if (!existsSync(ESCRIBANO_HOME)) {
         mkdirSync(ESCRIBANO_HOME, { recursive: true });
     }
     if (!existsSync(ESCRIBANO_VENV_PYTHON)) {
-        console.log('[VLM] First-time setup: creating Python environment at ~/.escribano/venv');
-        await runVisible('python3', ['-m', 'venv', ESCRIBANO_VENV]);
+        console.log('[MLX] First-time setup: creating Python environment at ~/.escribano/venv');
+        await runVisible('python3', ['-m', 'venv', `${ESCRIBANO_HOME}/venv`]);
     }
-    // Check whether mlx-vlm and required runtime deps are already importable (~0.3s probe)
     let mlxReady = false;
     try {
         await runSilent(ESCRIBANO_VENV_PYTHON, [
             '-c',
-            'import mlx_vlm; import torch; import torchvision',
+            'import mlx_vlm; import mlx_lm; import torch; import torchvision',
         ]);
         mlxReady = true;
     }
@@ -81,13 +64,12 @@ async function ensureEscribanoVenv() {
         // not installed yet
     }
     if (!mlxReady) {
-        console.log('[VLM] Installing mlx-vlm into ~/.escribano/venv (first run — this may take a few minutes)...');
-        // Ensure pip is available in the venv; ignore failures if ensurepip is disabled.
+        console.log('[MLX] Installing mlx-vlm into ~/.escribano/venv (first run — this may take a few minutes)...');
         try {
             await runVisible(ESCRIBANO_VENV_PYTHON, ['-m', 'ensurepip', '--upgrade']);
         }
         catch {
-            // ensurepip may be unavailable; continue and rely on existing pip if present.
+            // ensurepip may be unavailable
         }
         await runVisible(ESCRIBANO_VENV_PYTHON, [
             '-m',
@@ -96,25 +78,16 @@ async function ensureEscribanoVenv() {
             'mlx-vlm',
             'torch',
             'torchvision',
+            'mlx-lm',
         ]);
-        console.log('[VLM] mlx-vlm installed successfully.');
+        console.log('[MLX] mlx-vlm and mlx-lm installed successfully.');
     }
     return ESCRIBANO_VENV_PYTHON;
 }
-/**
- * Resolve the Python executable to use for the MLX bridge.
- * If the user has configured an explicit environment, use it.
- * Otherwise, transparently create and populate ~/.escribano/venv.
- */
 export async function resolvePythonPath() {
     return getPythonPath() ?? ensureEscribanoVenv();
 }
-// Global cleanup function to track the current bridge instance
 let globalCleanup = null;
-/**
- * Cleanup the MLX bridge process.
- * Should be called explicitly before process exit.
- */
 export function cleanupMlxBridge() {
     if (globalCleanup) {
         debugLog('Explicit cleanup called');
@@ -122,87 +95,123 @@ export function cleanupMlxBridge() {
         globalCleanup = null;
     }
 }
-/**
- * Create MLX-VLM intelligence service.
- *
- * Note: This adapter only implements describeImages() for VLM processing.
- * Other methods (classify, generate, etc.) are not implemented and will throw.
- */
 export function createMlxIntelligenceService(_config = {}) {
-    const mlxConfig = { ...DEFAULT_CONFIG };
-    const bridge = {
+    // Load unified config (respects env vars, config file, and RAM-aware defaults)
+    const config = loadConfig();
+    const mlxConfig = {
+        model: config.vlmModel,
+        batchSize: config.vlmBatchSize,
+        maxTokens: config.vlmMaxTokens,
+        socketPath: config.mlxSocketPath,
+        bridgeScript: resolve(__dirname, '../../scripts/mlx_bridge.py'),
+        startupTimeout: config.mlxStartupTimeout,
+    };
+    const vlmBridge = {
+        process: null,
+        socket: null,
+        ready: false,
+        connecting: false,
+    };
+    const llmBridge = {
         process: null,
         socket: null,
         ready: false,
         connecting: false,
+        loadedModel: null,
     };
-    // Cleanup on process exit
+    const getVlmSocketPath = () => mlxConfig.socketPath.replace('.sock', '-vlm.sock');
+    const getLlmSocketPath = () => mlxConfig.socketPath.replace('.sock', '-llm.sock');
     const cleanup = () => {
-        if (bridge.socket) {
+        if (vlmBridge.socket) {
             try {
-                bridge.socket.destroy();
+                vlmBridge.socket.destroy();
             }
-            catch {
-                // Ignore
+            catch { }
+            vlmBridge.socket = null;
+        }
+        if (vlmBridge.process) {
+            try {
+                vlmBridge.process.kill('SIGTERM');
             }
-            bridge.socket = null;
+            catch { }
+            vlmBridge.process = null;
         }
-        if (bridge.process) {
+        const vlmSock = getVlmSocketPath();
+        if (existsSync(vlmSock)) {
             try {
-                bridge.process.kill('SIGTERM');
+                unlinkSync(vlmSock);
             }
-            catch {
-                // Ignore
+            catch { }
+        }
+        vlmBridge.ready = false;
+        if (llmBridge.socket) {
+            try {
+                llmBridge.socket.destroy();
             }
-            bridge.process = null;
+            catch { }
+            llmBridge.socket = null;
         }
-        // Clean up socket file if it exists
-        if (existsSync(mlxConfig.socketPath)) {
+        if (llmBridge.process) {
             try {
-                unlinkSync(mlxConfig.socketPath);
+                llmBridge.process.kill('SIGTERM');
             }
-            catch {
-                // Ignore
+            catch { }
+            llmBridge.process = null;
+        }
+        const llmSock = getLlmSocketPath();
+        if (existsSync(llmSock)) {
+            try {
+                unlinkSync(llmSock);
             }
+            catch { }
         }
-        bridge.ready = false;
+        llmBridge.ready = false;
+        llmBridge.loadedModel = null;
     };
-    // Register global cleanup
     globalCleanup = cleanup;
-    // Also cleanup on process signals
     process.on('SIGTERM', cleanup);
     process.on('SIGINT', cleanup);
-    // Cleanup on beforeExit to ensure it runs before process.exit
     process.on('beforeExit', cleanup);
-    /**
-     * Start the Python bridge process.
-     */
-    const startBridge = async () => {
-        if (bridge.process && bridge.ready) {
+    const startBridge = async (bridgeState, mode, _socketPath) => {
+        if (bridgeState.process && bridgeState.ready)
             return;
-        }
-        debugLog('Starting MLX bridge...');
-        // Resolve (and if needed, auto-create) the Python environment before spawning.
+        debugLog(`Starting ${mode.toUpperCase()} bridge...`);
         const pythonPath = await resolvePythonPath();
         debugLog(`Using Python: ${pythonPath}`);
-        return new Promise((resolve, reject) => {
-            bridge.process = spawn(pythonPath, [mlxConfig.bridgeScript], {
+        return new Promise((resolvePromise, rejectPromise) => {
+            const env = {
+                ...process.env,
+                ESCRIBANO_MLX_SOCKET_PATH: mlxConfig.socketPath,
+                ESCRIBANO_DB_PATH: getDbPath(),
+                ESCRIBANO_DEBUG_LLM: String(config.debugLlm),
+            };
+            // Debug: log env vars being passed to Python bridge
+            if (config.debugLlm) {
+                console.log(`[MLX] Passing DEBUG_LLM=${config.debugLlm} to ${mode} bridge`);
+                console.log(`[MLX] DB_PATH: ${getDbPath()}`);
+            }
+            if (mode === 'vlm') {
+                env.ESCRIBANO_VLM_MODEL = mlxConfig.model;
+                env.ESCRIBANO_VLM_BATCH_SIZE = String(mlxConfig.batchSize);
+                env.ESCRIBANO_VLM_MAX_TOKENS = String(mlxConfig.maxTokens);
+            }
+            bridgeState.process = spawn(pythonPath, [mlxConfig.bridgeScript, '--mode', mode], {
                 stdio: ['ignore', 'pipe', 'pipe'],
-                env: {
-                    ...process.env,
-                    ESCRIBANO_VLM_MODEL: mlxConfig.model,
-                    ESCRIBANO_VLM_BATCH_SIZE: String(mlxConfig.batchSize),
-                    ESCRIBANO_VLM_MAX_TOKENS: String(mlxConfig.maxTokens),
-                    ESCRIBANO_MLX_SOCKET_PATH: mlxConfig.socketPath,
-                },
+                env,
             });
-            if (!bridge.process.stdout || !bridge.process.stderr) {
-                reject(new Error('Failed to create bridge process streams'));
+            if (!bridgeState.process.stdout || !bridgeState.process.stderr) {
+                rejectPromise(new Error('Failed to create bridge process streams'));
                 return;
             }
-            // Handle stdout (ready signal is JSON on first line)
             let readyReceived = false;
-            bridge.process.stdout.on('data', (data) => {
+            let startupTimer = null;
+            const clearStartupTimer = () => {
+                if (startupTimer) {
+                    clearTimeout(startupTimer);
+                    startupTimer = null;
+                }
+            };
+            bridgeState.process.stdout.on('data', (data) => {
                 const lines = data.toString().trim().split('\n');
                 for (const line of lines) {
                     if (!readyReceived && line.startsWith('{')) {
@@ -210,92 +219,91 @@ export function createMlxIntelligenceService(_config = {}) {
                             const msg = JSON.parse(line);
                             if (msg.status === 'ready') {
                                 readyReceived = true;
-                                bridge.ready = true;
-                                debugLog(`Bridge ready: ${msg.model}`);
-                                resolve();
+                                clearStartupTimer();
+                                bridgeState.ready = true;
+                                debugLog(`${mode.toUpperCase()} bridge ready: ${msg.model || msg.mode}`);
+                                resolvePromise();
                             }
                         }
-                        catch {
-                            // Not JSON, ignore
-                        }
+                        catch { }
                     }
                 }
             });
-            // Handle stderr (logs from Python)
-            bridge.process.stderr.on('data', (data) => {
+            bridgeState.process.stderr.on('data', (data) => {
                 const text = data.toString().trim();
-                if (text) {
+                if (text)
                     console.log(text);
-                }
             });
-            // Handle process exit
-            bridge.process.on('exit', (code, signal) => {
-                debugLog(`Bridge exited: code=${code} signal=${signal}`);
-                bridge.process = null;
-                bridge.ready = false;
+            bridgeState.process.on('exit', (code, signal) => {
+                debugLog(`${mode.toUpperCase()} bridge exited: code=${code} signal=${signal}`);
+                bridgeState.process = null;
+                bridgeState.ready = false;
                 if (!readyReceived) {
-                    reject(new Error(`Bridge failed to start: exit code ${code}`));
+                    clearStartupTimer();
+                    rejectPromise(new Error(`${mode.toUpperCase()} bridge failed to start: exit code ${code}`));
                 }
             });
-            bridge.process.on('error', (err) => {
-                debugLog(`Bridge error: ${err.message}`);
+            bridgeState.process.on('error', (err) => {
+                debugLog(`${mode.toUpperCase()} bridge error: ${err.message}`);
                 if (!readyReceived) {
-                    reject(new Error(`Failed to start bridge: ${err.message}`));
+                    clearStartupTimer();
+                    rejectPromise(new Error(`Failed to start ${mode.toUpperCase()} bridge: ${err.message}`));
                 }
             });
-            // Timeout for ready signal
-            setTimeout(() => {
+            startupTimer = setTimeout(() => {
                 if (!readyReceived) {
-                    reject(new Error(`Bridge startup timeout (${mlxConfig.startupTimeout / 1000}s)`));
+                    startupTimer = null;
+                    rejectPromise(new Error(`${mode.toUpperCase()} bridge startup timeout (${mlxConfig.startupTimeout / 1000}s)`));
                 }
             }, mlxConfig.startupTimeout);
         });
     };
-    /**
-     * Connect to the Unix socket.
-     */
-    const connect = () => {
-        return new Promise((resolve, reject) => {
-            if (bridge.socket && !bridge.socket.destroyed) {
-                resolve(bridge.socket);
+    const connect = (bridgeState, socketPath) => {
+        return new Promise((resolvePromise, rejectPromise) => {
+            if (bridgeState.socket && !bridgeState.socket.destroyed) {
+                resolvePromise(bridgeState.socket);
                 return;
             }
-            debugLog(`Connecting to socket: ${mlxConfig.socketPath}`);
-            const client = createConnection(mlxConfig.socketPath);
+            let connectionTimer = null;
+            const clearConnectionTimer = () => {
+                if (connectionTimer) {
+                    clearTimeout(connectionTimer);
+                    connectionTimer = null;
+                }
+            };
+            debugLog(`Connecting to socket: ${socketPath}`);
+            const client = createConnection(socketPath);
             client.on('connect', () => {
+                clearConnectionTimer();
                 debugLog('Socket connected');
-                bridge.socket = client;
-                resolve(client);
+                bridgeState.socket = client;
+                resolvePromise(client);
             });
             client.on('error', (err) => {
+                clearConnectionTimer();
                 debugLog(`Socket error: ${err.message}`);
-                bridge.socket = null;
-                reject(new Error(`Socket connection failed: ${err.message}`));
+                bridgeState.socket = null;
+                rejectPromise(new Error(`Socket connection failed: ${err.message}`));
             });
             client.on('close', () => {
                 debugLog('Socket closed');
-                bridge.socket = null;
+                bridgeState.socket = null;
             });
-            // Timeout
-            setTimeout(() => {
-                if (!bridge.socket) {
+            connectionTimer = setTimeout(() => {
+                if (!bridgeState.socket) {
+                    connectionTimer = null;
                     client.destroy();
-                    reject(new Error('Socket connection timeout'));
+                    rejectPromise(new Error('Socket connection timeout'));
                 }
             }, 5000);
         });
     };
-    /**
-     * Send request and receive streaming NDJSON responses.
-     */
-    const sendRequest = async (request, onBatch) => {
-        // Ensure bridge is running
-        if (!bridge.ready) {
-            await startBridge();
+    const sendRequest = async (bridgeState, socketPath, mode, request, onBatch) => {
+        if (!bridgeState.ready) {
+            await startBridge(bridgeState, mode, socketPath);
         }
-        // Connect to socket
-        const socket = await connect();
-        return new Promise((resolve, reject) => {
+        const socket = await connect(bridgeState, socketPath);
+        return new Promise((resolvePromise, rejectPromise) => {
             const responses = [];
             let buffer = '';
             const onData = (chunk) => {
@@ -309,19 +317,16 @@ export function createMlxIntelligenceService(_config = {}) {
                     try {
                         const response = JSON.parse(line);
                         if ('error' in response && response.error) {
-                            // Error response
-                            reject(new Error(response.error));
+                            rejectPromise(new Error(response.error));
                             socket.off('data', onData);
                             return;
                         }
+                        responses.push(response);
                         if ('done' in response && response.done) {
-                            // Final response
                             socket.off('data', onData);
-                            resolve(responses);
+                            resolvePromise(responses);
                             return;
                         }
-                        // Batch response
-                        responses.push(response);
                         if (onBatch && 'progress' in response) {
                             const resp = response;
                             onBatch(response, resp.progress);
@@ -329,52 +334,32 @@ export function createMlxIntelligenceService(_config = {}) {
                     }
                     catch {
                         debugLog(`Failed to parse response: ${line}`);
-                        // Continue processing, might be partial
                     }
                 }
             };
             socket.on('data', onData);
             socket.on('error', (err) => {
                 socket.off('data', onData);
-                reject(new Error(`Socket error: ${err.message}`));
+                rejectPromise(new Error(`Socket error: ${err.message}`));
             });
-            // Send request
             const requestJson = `${JSON.stringify(request)}\n`;
             debugLog(`Sending request: id=${request.id} method=${request.method}`);
             socket.write(requestJson);
         });
     };
-    // Return IntelligenceService implementation
     return {
-        /**
-         * Classify transcript - NOT IMPLEMENTED for MLX backend.
-         */
         async classify(_transcript, _visualLogs) {
-            throw new Error('MLX adapter does not support classify(). Use Ollama backend for this operation.');
+            throw new Error('MLX adapter does not support classify(). Use Ollama backend.');
         },
-        /**
-         * Classify segment - NOT IMPLEMENTED for MLX backend.
-         */
         async classifySegment(_segment, _transcript) {
-            throw new Error('MLX adapter does not support classifySegment(). Use Ollama backend for this operation.');
+            throw new Error('MLX adapter does not support classifySegment(). Use Ollama backend.');
         },
-        /**
-         * Extract metadata - NOT IMPLEMENTED for MLX backend.
-         */
         async extractMetadata(_transcript, _classification, _visualLogs) {
-            throw new Error('MLX adapter does not support extractMetadata(). Use Ollama backend for this operation.');
+            throw new Error('MLX adapter does not support extractMetadata(). Use Ollama backend.');
         },
-        /**
-         * Generate artifact - NOT IMPLEMENTED for MLX backend.
-         */
         async generate(_artifactType, _context) {
-            throw new Error('MLX adapter does not support generate(). Use Ollama backend for this operation.');
+            throw new Error('MLX adapter does not support generate(). Use Ollama backend.');
         },
-        /**
-         * Describe images using MLX-VLM with interleaved batching.
-         *
-         * This is the primary method for VLM frame processing.
-         */
         async describeImages(images, options = {}) {
             const total = images.length;
             if (total === 0) {
@@ -390,12 +375,10 @@ export function createMlxIntelligenceService(_config = {}) {
                 if (response.results) {
                     for (const result of response.results) {
                         allResults.push(result);
-                        // Fire callback for each frame
                         if (options.onImageProcessed) {
                             options.onImageProcessed(result, progress);
                         }
                     }
-                    // Log progress every 10 frames
                     if (progress.current % 10 === 0 ||
                         progress.current === progress.total) {
                         console.log(`[VLM] [${progress.current}/${progress.total}] frames processed`);
@@ -403,7 +386,7 @@ export function createMlxIntelligenceService(_config = {}) {
                 }
             };
             try {
-                await sendRequest({
+                await sendRequest(vlmBridge, getVlmSocketPath(), 'vlm', {
                     id: requestId,
                     method: 'describe_images',
                     params: {
@@ -427,29 +410,120 @@ export function createMlxIntelligenceService(_config = {}) {
                 throw new Error(`MLX VLM processing failed: ${message}`);
             }
         },
-        /**
-         * Embed text - NOT IMPLEMENTED for MLX backend.
-         */
         async embedText(_texts, _options) {
-            throw new Error('MLX adapter does not support embedText(). Use Ollama backend for this operation.');
+            throw new Error('MLX adapter does not support embedText(). Use Ollama backend.');
         },
-        /**
-         * Extract topics - NOT IMPLEMENTED for MLX backend.
-         */
         async extractTopics(_observations) {
-            throw new Error('MLX adapter does not support extractTopics(). Use Ollama backend for this operation.');
+            throw new Error('MLX adapter does not support extractTopics(). Use Ollama backend.');
+        },
+        async generateText(prompt, options) {
+            const modelSelection = await selectBestMLXModel();
+            const resolvedModel = options?.model || modelSelection.model;
+            const requestId = Date.now();
+            const llmSocketPath = getLlmSocketPath();
+            try {
+                if (llmBridge.loadedModel !== resolvedModel) {
+                    if (llmBridge.loadedModel) {
+                        debugLog(`Unloading previous LLM model: ${llmBridge.loadedModel}`);
+                        await sendRequest(llmBridge, llmSocketPath, 'llm', {
+                            id: requestId,
+                            method: 'unload_llm',
+                            params: {},
+                        });
+                    }
+                    debugLog(`Loading LLM model: ${resolvedModel}`);
+                    console.log(`[LLM] Loading model: ${resolvedModel}`);
+                    try {
+                        await sendRequest(llmBridge, llmSocketPath, 'llm', {
+                            id: requestId + 1,
+                            method: 'load_llm',
+                            params: { model: resolvedModel },
+                        });
+                        llmBridge.loadedModel = resolvedModel;
+                        console.log('[LLM] Model loaded');
+                    }
+                    catch (loadError) {
+                        llmBridge.loadedModel = null;
+                        throw loadError;
+                    }
+                }
+                debugLog(`Generating text (${prompt.length} chars)...`);
+                const responses = await sendRequest(llmBridge, llmSocketPath, 'llm', {
+                    id: requestId + 2,
+                    method: 'generate_text',
+                    params: {
+                        rawPrompt: prompt,
+                        maxTokens: options?.numPredict ?? 8000,
+                        temperature: 0.7,
+                        think: options?.think ?? false,
+                        debugContext: options?.debugContext,
+                    },
+                });
+                if (responses.length === 0) {
+                    throw new Error('No response from LLM generation');
+                }
+                const response = responses[0];
+                if (response.error) {
+                    throw new Error(`Text generation failed: ${response.error}`);
+                }
+                debugLog(`Generated ${response.text?.length || 0} chars`);
+                return response.text || '';
+            }
+            catch (error) {
+                const message = error.message;
+                console.error(`[LLM] ERROR: ${message}`);
+                throw error;
+            }
         },
-        /**
-         * Generate text - NOT IMPLEMENTED for MLX backend.
-         */
-        async generateText(_prompt, _options) {
-            throw new Error('MLX adapter does not support generateText(). Use Ollama backend for this operation.');
+        async loadLlm(model) {
+            const requestId = Date.now();
+            const llmSocketPath = getLlmSocketPath();
+            if (llmBridge.loadedModel && llmBridge.loadedModel !== model) {
+                await sendRequest(llmBridge, llmSocketPath, 'llm', {
+                    id: requestId,
+                    method: 'unload_llm',
+                    params: {},
+                });
+            }
+            try {
+                await sendRequest(llmBridge, llmSocketPath, 'llm', {
+                    id: requestId + 1,
+                    method: 'load_llm',
+                    params: { model },
+                });
+                llmBridge.loadedModel = model;
+            }
+            catch (loadError) {
+                llmBridge.loadedModel = null;
+                throw loadError;
+            }
+        },
+        async unloadVlm() {
+            if (!vlmBridge.ready)
+                return;
+            const requestId = Date.now();
+            await sendRequest(vlmBridge, getVlmSocketPath(), 'vlm', {
+                id: requestId,
+                method: 'unload_vlm',
+                params: {},
+            });
+        },
+        async unloadLlm() {
+            if (!llmBridge.ready)
+                return;
+            const requestId = Date.now();
+            await sendRequest(llmBridge, getLlmSocketPath(), 'llm', {
+                id: requestId,
+                method: 'unload_llm',
+                params: {},
+            });
+            llmBridge.loadedModel = null;
         },
         getResourceName() {
             return 'mlx-python';
         },
         getPid() {
-            return bridge.process?.pid ?? null;
+            return vlmBridge.process?.pid ?? llmBridge.process?.pid ?? null;
         },
     };
 }