claude-code-workflow 6.3.18 → 6.3.19

package/ccw/dist/core/routes/litellm-api-routes.js

@@ -1,14 +1,44 @@
+/**
+ * LiteLLM API Routes Module
+ * Handles LiteLLM provider management, endpoint configuration, and cache management
+ */
 import { fileURLToPath } from 'url';
 import { dirname, join as pathJoin } from 'path';
+import { z } from 'zod';
 import { getSystemPython } from '../../utils/python-utils.js';
+import { isUvAvailable, createCodexLensUvManager } from '../../utils/uv-manager.js';
+import { ensureLiteLLMEmbedderReady } from '../../tools/codex-lens.js';
+// ========== Input Validation Schemas ==========
+/**
+ * Validation schema for ModelPoolConfig
+ * Used to validate incoming API requests for model pool operations
+ */
+const ModelPoolConfigSchema = z.object({
+    modelType: z.enum(['embedding', 'llm', 'reranker']),
+    enabled: z.boolean(),
+    targetModel: z.string().min(1, 'Target model is required'),
+    strategy: z.enum(['round_robin', 'latency_aware', 'weighted_random']),
+    autoDiscover: z.boolean(),
+    excludedProviderIds: z.array(z.string()).optional().default([]),
+    defaultCooldown: z.number().int().min(0).default(60),
+    defaultMaxConcurrentPerKey: z.number().int().min(1).default(4),
+    name: z.string().optional(),
+    description: z.string().optional(),
+});
+/**
+ * Partial schema for updating ModelPoolConfig
+ * All fields are optional for PATCH-like updates
+ */
+const ModelPoolConfigUpdateSchema = ModelPoolConfigSchema.partial();
 // Get current module path for package-relative lookups
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 // Package root: routes -> core -> src -> ccw -> package root
 const PACKAGE_ROOT = pathJoin(__dirname, '..', '..', '..', '..');
-import { getAllProviders, getProvider, addProvider, updateProvider, deleteProvider, getAllEndpoints, getEndpoint, addEndpoint, updateEndpoint, deleteEndpoint, getDefaultEndpoint, setDefaultEndpoint, getGlobalCacheSettings, updateGlobalCacheSettings, loadLiteLLMApiConfig, saveLiteLLMYamlConfig, generateLiteLLMYamlConfig, getCodexLensEmbeddingRotation, updateCodexLensEmbeddingRotation, getEmbeddingProvidersForRotation, generateRotationEndpoints, syncCodexLensConfig, getEmbeddingPoolConfig, updateEmbeddingPoolConfig, discoverProvidersForModel, } from '../../config/litellm-api-config-manager.js';
+import { getAllProviders, getProvider, addProvider, updateProvider, deleteProvider, getAllEndpoints, getEndpoint, addEndpoint, updateEndpoint, deleteEndpoint, getDefaultEndpoint, setDefaultEndpoint, getGlobalCacheSettings, updateGlobalCacheSettings, loadLiteLLMApiConfig, saveLiteLLMYamlConfig, generateLiteLLMYamlConfig, getCodexLensEmbeddingRotation, updateCodexLensEmbeddingRotation, getEmbeddingProvidersForRotation, generateRotationEndpoints, syncCodexLensConfig, getEmbeddingPoolConfig, updateEmbeddingPoolConfig, discoverProvidersForModel, getModelPools, getModelPool, addModelPool, updateModelPool, deleteModelPool, getAvailableModelsForType, } from '../../config/litellm-api-config-manager.js';
 import { getContextCacheStore } from '../../tools/context-cache-store.js';
 import { getLiteLLMClient } from '../../tools/litellm-client.js';
+import { testApiKeyConnection, getDefaultApiBase } from '../services/api-key-tester.js';
 // Cache for ccw-litellm status check
 let ccwLitellmStatusCache = {
     data: null,
@@ -20,6 +50,39 @@ export function clearCcwLitellmStatusCache() {
     ccwLitellmStatusCache.data = null;
     ccwLitellmStatusCache.timestamp = 0;
 }
+/**
+ * Install ccw-litellm using UV package manager
+ * Delegates to ensureLiteLLMEmbedderReady for consistent dependency handling
+ * This ensures ccw-litellm installation doesn't break fastembed's onnxruntime dependencies
+ * @param _packagePath - Ignored, ensureLiteLLMEmbedderReady handles path discovery
+ * @returns Installation result
+ */
+async function installCcwLitellmWithUv(_packagePath) {
+    // Delegate to the robust installation logic in codex-lens.ts
+    // This ensures consistent dependency handling within the shared venv,
+    // preventing onnxruntime conflicts that would break fastembed
+    const result = await ensureLiteLLMEmbedderReady();
+    if (result.success) {
+        clearCcwLitellmStatusCache();
+    }
+    return result;
+}
+function sanitizeProviderForResponse(provider) {
+    if (!provider)
+        return provider;
+    return {
+        ...provider,
+        apiKey: '***',
+        apiKeys: Array.isArray(provider.apiKeys)
+            ? provider.apiKeys.map((entry) => ({ ...entry, key: '***' }))
+            : provider.apiKeys,
+    };
+}
+function sanitizeRotationEndpointForResponse(endpoint) {
+    if (!endpoint)
+        return endpoint;
+    return { ...endpoint, api_key: '***' };
+}
 const PROVIDER_MODELS = {
     openai: [
         { id: 'gpt-4-turbo', name: 'GPT-4 Turbo', provider: 'openai', description: '128K context' },
@@ -62,7 +125,7 @@ export async function handleLiteLLMApiRoutes(ctx) {
     // GET /api/litellm-api/providers - List all providers
     if (pathname === '/api/litellm-api/providers' && req.method === 'GET') {
         try {
-            const providers = getAllProviders(initialPath);
+            const providers = getAllProviders(initialPath).map(sanitizeProviderForResponse);
             res.writeHead(200, { 'Content-Type': 'application/json' });
             res.end(JSON.stringify({ providers, count: providers.length }));
         }
@@ -81,11 +144,12 @@ export async function handleLiteLLMApiRoutes(ctx) {
             }
             try {
                 const provider = addProvider(initialPath, providerData);
+                const sanitizedProvider = sanitizeProviderForResponse(provider);
                 broadcastToClients({
                     type: 'LITELLM_PROVIDER_CREATED',
-                    payload: { provider, timestamp: new Date().toISOString() }
+                    payload: { provider: sanitizedProvider, timestamp: new Date().toISOString() }
                 });
-                return { success: true, provider };
+                return { success: true, provider: sanitizedProvider };
             }
             catch (err) {
                 return { error: err.message, status: 500 };
@@ -105,7 +169,7 @@ export async function handleLiteLLMApiRoutes(ctx) {
                 return true;
             }
             res.writeHead(200, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify(provider));
+            res.end(JSON.stringify(sanitizeProviderForResponse(provider)));
         }
         catch (err) {
             res.writeHead(500, { 'Content-Type': 'application/json' });
@@ -121,11 +185,12 @@ export async function handleLiteLLMApiRoutes(ctx) {
             const updates = body;
             try {
                 const provider = updateProvider(initialPath, providerId, updates);
+                const sanitizedProvider = sanitizeProviderForResponse(provider);
                 broadcastToClients({
                     type: 'LITELLM_PROVIDER_UPDATED',
-                    payload: { provider, timestamp: new Date().toISOString() }
+                    payload: { provider: sanitizedProvider, timestamp: new Date().toISOString() }
                 });
-                return { success: true, provider };
+                return { success: true, provider: sanitizedProvider };
             }
             catch (err) {
                 return { error: err.message, status: 404 };
@@ -185,6 +250,177 @@ export async function handleLiteLLMApiRoutes(ctx) {
         }
         return true;
     }
+    // POST /api/litellm-api/providers/:id/test-key - Test specific API key
+    const providerTestKeyMatch = pathname.match(/^\/api\/litellm-api\/providers\/([^/]+)\/test-key$/);
+    if (providerTestKeyMatch && req.method === 'POST') {
+        const providerId = providerTestKeyMatch[1];
+        handlePostRequest(req, res, async (body) => {
+            const { keyId } = body;
+            if (!keyId) {
+                return { valid: false, error: 'keyId is required', status: 400 };
+            }
+            try {
+                const provider = getProvider(initialPath, providerId);
+                if (!provider) {
+                    return { valid: false, error: 'Provider not found', status: 404 };
+                }
+                // Find the specific API key
+                let apiKeyValue = null;
+                let keyLabel = 'Default';
+                if (keyId === 'default' && provider.apiKey) {
+                    // Use the single default apiKey
+                    apiKeyValue = provider.apiKey;
+                }
+                else if (provider.apiKeys && provider.apiKeys.length > 0) {
+                    const keyEntry = provider.apiKeys.find(k => k.id === keyId);
+                    if (keyEntry) {
+                        apiKeyValue = keyEntry.key;
+                        keyLabel = keyEntry.label || keyEntry.id;
+                    }
+                }
+                if (!apiKeyValue) {
+                    return { valid: false, error: 'API key not found' };
+                }
+                // Resolve environment variables
+                const { resolveEnvVar } = await import('../../config/litellm-api-config-manager.js');
+                const resolvedKey = resolveEnvVar(apiKeyValue);
+                if (!resolvedKey) {
+                    return { valid: false, error: 'API key is empty or environment variable not set' };
+                }
+                // Determine API base URL
+                const apiBase = provider.apiBase || getDefaultApiBase(provider.type);
+                // Test the API key with appropriate endpoint based on provider type
+                const startTime = Date.now();
+                const testResult = await testApiKeyConnection(provider.type, apiBase, resolvedKey);
+                const latencyMs = Date.now() - startTime;
+                // Update key health status in provider config
+                if (provider.apiKeys && provider.apiKeys.length > 0) {
+                    const keyEntry = provider.apiKeys.find(k => k.id === keyId);
+                    if (keyEntry) {
+                        keyEntry.healthStatus = testResult.valid ? 'healthy' : 'unhealthy';
+                        keyEntry.lastHealthCheck = new Date().toISOString();
+                        if (!testResult.valid) {
+                            keyEntry.lastError = testResult.error;
+                        }
+                        else {
+                            delete keyEntry.lastError;
+                        }
+                        // Save updated provider
+                        try {
+                            updateProvider(initialPath, providerId, { apiKeys: provider.apiKeys });
+                        }
+                        catch (updateErr) {
+                            console.warn('[test-key] Failed to update key health status:', updateErr);
+                        }
+                    }
+                }
+                return {
+                    valid: testResult.valid,
+                    error: testResult.error,
+                    latencyMs: testResult.valid ? latencyMs : undefined,
+                    keyLabel,
+                };
+            }
+            catch (err) {
+                return { valid: false, error: err.message };
+            }
+        });
+        return true;
+    }
+    // GET /api/litellm-api/providers/:id/health-status - Get health status for all keys
+    const providerHealthStatusMatch = pathname.match(/^\/api\/litellm-api\/providers\/([^/]+)\/health-status$/);
+    if (providerHealthStatusMatch && req.method === 'GET') {
+        const providerId = providerHealthStatusMatch[1];
+        try {
+            const provider = getProvider(initialPath, providerId);
+            if (!provider) {
+                res.writeHead(404, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ error: 'Provider not found' }));
+                return true;
+            }
+            // Import health check service to get runtime state
+            const { getHealthCheckService } = await import('../services/health-check-service.js');
+            const healthService = getHealthCheckService();
+            const healthStatus = healthService.getProviderHealthStatus(providerId);
+            // Merge persisted key data with runtime health status
+            const keys = (provider.apiKeys || []).map(key => {
+                const runtimeStatus = healthStatus.find(s => s.keyId === key.id);
+                return {
+                    keyId: key.id,
+                    label: key.label || key.id,
+                    status: runtimeStatus?.status || key.healthStatus || 'unknown',
+                    lastCheck: runtimeStatus?.lastCheck || key.lastHealthCheck,
+                    lastLatencyMs: key.lastLatencyMs,
+                    consecutiveFailures: runtimeStatus?.consecutiveFailures || 0,
+                    inCooldown: runtimeStatus?.inCooldown || false,
+                    lastError: runtimeStatus?.lastError || key.lastError,
+                };
+            });
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({
+                providerId,
+                providerName: provider.name,
+                keys,
+            }));
+        }
+        catch (err) {
+            res.writeHead(500, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: err.message }));
+        }
+        return true;
+    }
+    // POST /api/litellm-api/providers/:id/health-check-now - Trigger immediate health check
+    const providerHealthCheckNowMatch = pathname.match(/^\/api\/litellm-api\/providers\/([^/]+)\/health-check-now$/);
+    if (providerHealthCheckNowMatch && req.method === 'POST') {
+        const providerId = providerHealthCheckNowMatch[1];
+        try {
+            const provider = getProvider(initialPath, providerId);
+            if (!provider) {
+                res.writeHead(404, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ error: 'Provider not found' }));
+                return true;
+            }
+            // Import health check service and trigger check
+            const { getHealthCheckService } = await import('../services/health-check-service.js');
+            const healthService = getHealthCheckService();
+            // Trigger immediate check (async, but we wait for completion)
+            await healthService.checkProviderNow(providerId);
+            // Get updated status
+            const healthStatus = healthService.getProviderHealthStatus(providerId);
+            // Reload provider to get updated persisted data
+            const updatedProvider = getProvider(initialPath, providerId);
+            const keys = (updatedProvider?.apiKeys || []).map(key => {
+                const runtimeStatus = healthStatus.find(s => s.keyId === key.id);
+                return {
+                    keyId: key.id,
+                    label: key.label || key.id,
+                    status: runtimeStatus?.status || key.healthStatus || 'unknown',
+                    lastCheck: runtimeStatus?.lastCheck || key.lastHealthCheck,
+                    lastLatencyMs: key.lastLatencyMs,
+                    consecutiveFailures: runtimeStatus?.consecutiveFailures || 0,
+                    inCooldown: runtimeStatus?.inCooldown || false,
+                    lastError: runtimeStatus?.lastError || key.lastError,
+                };
+            });
+            broadcastToClients({
+                type: 'PROVIDER_HEALTH_CHECKED',
+                payload: { providerId, keys, timestamp: new Date().toISOString() }
+            });
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({
+                success: true,
+                providerId,
+                providerName: updatedProvider?.name,
+                keys,
+                checkedAt: new Date().toISOString(),
+            }));
+        }
+        catch (err) {
+            res.writeHead(500, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ success: false, error: err.message }));
+        }
+        return true;
+    }
     // ===========================
     // Endpoint Management Routes
     // ===========================
@@ -448,50 +684,36 @@ export async function handleLiteLLMApiRoutes(ctx) {
             res.end(JSON.stringify(ccwLitellmStatusCache.data));
             return true;
         }
-        // Async check - use pip show for more reliable detection
+        // Async check - use CodexLens venv Python for reliable detection
         try {
             const { exec } = await import('child_process');
             const { promisify } = await import('util');
             const execAsync = promisify(exec);
             let result = { installed: false };
-            // Method 1: Try pip show ccw-litellm (most reliable)
-            try {
-                const { stdout } = await execAsync('pip show ccw-litellm', {
-                    timeout: 10000,
-                    windowsHide: true,
-                    shell: true,
-                });
-                // Parse version from pip show output
-                const versionMatch = stdout.match(/Version:\s*(.+)/i);
-                if (versionMatch) {
-                    result = { installed: true, version: versionMatch[1].trim() };
-                    console.log(`[ccw-litellm status] Found via pip show: ${result.version}`);
-                }
-            }
-            catch (pipErr) {
-                console.log('[ccw-litellm status] pip show failed, trying python import...');
-                // Method 2: Fallback to Python import
-                const pythonExecutables = ['python', 'python3', 'py'];
-                for (const pythonExe of pythonExecutables) {
-                    try {
-                        // Use simpler Python code without complex quotes
-                        const { stdout } = await execAsync(`${pythonExe} -c "import ccw_litellm; print(ccw_litellm.__version__)"`, {
-                            timeout: 5000,
-                            windowsHide: true,
-                            shell: true,
-                        });
-                        const version = stdout.trim();
-                        if (version) {
-                            result = { installed: true, version };
-                            console.log(`[ccw-litellm status] Found with ${pythonExe}: ${version}`);
-                            break;
-                        }
-                    }
-                    catch (err) {
-                        result.error = err.message;
-                        console.log(`[ccw-litellm status] ${pythonExe} failed:`, result.error.substring(0, 100));
+            // Check ONLY in CodexLens venv (where UV installs packages)
+            // Do NOT fallback to system pip - we want isolated venv dependencies
+            const uv = createCodexLensUvManager();
+            const venvPython = uv.getVenvPython();
+            if (uv.isVenvValid()) {
+                try {
+                    const { stdout } = await execAsync(`"${venvPython}" -c "import ccw_litellm; print(ccw_litellm.__version__)"`, {
+                        timeout: 10000,
+                        windowsHide: true,
+                    });
+                    const version = stdout.trim();
+                    if (version) {
+                        result = { installed: true, version };
+                        console.log(`[ccw-litellm status] Found in CodexLens venv: ${version}`);
                     }
                 }
+                catch (venvErr) {
+                    console.log('[ccw-litellm status] Not found in CodexLens venv');
+                    result = { installed: false };
+                }
+            }
+            else {
+                console.log('[ccw-litellm status] CodexLens venv not valid');
+                result = { installed: false };
             }
             // Update cache
             ccwLitellmStatusCache = {
@@ -551,10 +773,11 @@ export async function handleLiteLLMApiRoutes(ctx) {
     if (pathname === '/api/litellm-api/codexlens/rotation/endpoints' && req.method === 'GET') {
         try {
             const endpoints = generateRotationEndpoints(initialPath);
+            const sanitizedEndpoints = endpoints.map(sanitizeRotationEndpointForResponse);
             res.writeHead(200, { 'Content-Type': 'application/json' });
             res.end(JSON.stringify({
-                endpoints,
-                count: endpoints.length,
+                endpoints: sanitizedEndpoints,
+                count: sanitizedEndpoints.length,
             }));
         }
         catch (err) {
@@ -643,6 +866,44 @@ export async function handleLiteLLMApiRoutes(ctx) {
         });
         return true;
     }
+    // GET /api/litellm-api/reranker-pool - Get available reranker models from all providers
+    if (pathname === '/api/litellm-api/reranker-pool' && req.method === 'GET') {
+        try {
+            // Get list of all available reranker models from all providers
+            const config = loadLiteLLMApiConfig(initialPath);
+            const availableModels = [];
+            const modelMap = new Map();
+            for (const provider of config.providers) {
+                if (!provider.enabled || !provider.rerankerModels)
+                    continue;
+                for (const model of provider.rerankerModels) {
+                    if (!model.enabled)
+                        continue;
+                    const key = model.id;
+                    if (modelMap.has(key)) {
+                        modelMap.get(key).providers.push(provider.name);
+                    }
+                    else {
+                        modelMap.set(key, {
+                            modelId: model.id,
+                            modelName: model.name,
+                            providers: [provider.name],
+                        });
+                    }
+                }
+            }
+            availableModels.push(...Array.from(modelMap.values()));
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({
+                availableModels,
+            }));
+        }
+        catch (err) {
+            res.writeHead(500, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: err.message }));
+        }
+        return true;
+    }
     // GET /api/litellm-api/embedding-pool/discover/:model - Preview auto-discovery results
     const discoverMatch = pathname.match(/^\/api\/litellm-api\/embedding-pool\/discover\/([^/]+)$/);
     if (discoverMatch && req.method === 'GET') {
@@ -662,6 +923,165 @@ export async function handleLiteLLMApiRoutes(ctx) {
         }
         return true;
     }
+    // ========== Multi-Model Pool Management ==========
+    // GET /api/litellm-api/model-pools - Get all model pool configurations
+    if (pathname === '/api/litellm-api/model-pools' && req.method === 'GET') {
+        try {
+            const pools = getModelPools(initialPath);
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ pools }));
+        }
+        catch (err) {
+            res.writeHead(500, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: err.message }));
+        }
+        return true;
+    }
+    // GET /api/litellm-api/model-pools/:id - Get specific pool configuration
+    const poolGetMatch = pathname.match(/^\/api\/litellm-api\/model-pools\/([^/]+)$/);
+    if (poolGetMatch && req.method === 'GET') {
+        const poolId = decodeURIComponent(poolGetMatch[1]);
+        try {
+            const pool = getModelPool(initialPath, poolId);
+            if (!pool) {
+                res.writeHead(404, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ error: 'Pool not found' }));
+                return true;
+            }
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ pool }));
+        }
+        catch (err) {
+            res.writeHead(500, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: err.message }));
+        }
+        return true;
+    }
+    // POST /api/litellm-api/model-pools - Create new model pool
+    if (pathname === '/api/litellm-api/model-pools' && req.method === 'POST') {
+        handlePostRequest(req, res, async (body) => {
+            // Validate input using zod schema
+            const validationResult = ModelPoolConfigSchema.safeParse(body);
+            if (!validationResult.success) {
+                return {
+                    error: 'Invalid request body',
+                    details: validationResult.error.issues.map(e => ({
+                        field: String(e.path.join('.')),
+                        message: e.message
+                    })),
+                    status: 400
+                };
+            }
+            try {
+                const poolConfig = validationResult.data;
+                const result = addModelPool(initialPath, poolConfig);
+                broadcastToClients({
+                    type: 'MODEL_POOL_CREATED',
+                    payload: { poolId: result.poolId, timestamp: new Date().toISOString() }
+                });
+                return { success: true, ...result };
+            }
+            catch (err) {
+                return { error: err.message, status: 500 };
+            }
+        });
+        return true;
+    }
+    // PUT /api/litellm-api/model-pools/:id - Update model pool
+    const poolPutMatch = pathname.match(/^\/api\/litellm-api\/model-pools\/([^/]+)$/);
+    if (poolPutMatch && req.method === 'PUT') {
+        const poolId = decodeURIComponent(poolPutMatch[1]);
+        handlePostRequest(req, res, async (body) => {
+            // Validate input using partial schema (all fields optional for updates)
+            const validationResult = ModelPoolConfigUpdateSchema.safeParse(body);
+            if (!validationResult.success) {
+                return {
+                    error: 'Invalid request body',
+                    details: validationResult.error.issues.map(e => ({
+                        field: String(e.path.join('.')),
+                        message: e.message
+                    })),
+                    status: 400
+                };
+            }
+            try {
+                const updates = validationResult.data;
+                const result = updateModelPool(initialPath, poolId, updates);
+                if (!result.success) {
+                    return { error: 'Pool not found', status: 404 };
+                }
+                broadcastToClients({
+                    type: 'MODEL_POOL_UPDATED',
+                    payload: { poolId, syncResult: result.syncResult, timestamp: new Date().toISOString() }
+                });
+                return result;
+            }
+            catch (err) {
+                return { error: err.message, status: 500 };
+            }
+        });
+        return true;
+    }
+    // DELETE /api/litellm-api/model-pools/:id - Delete model pool
+    const poolDeleteMatch = pathname.match(/^\/api\/litellm-api\/model-pools\/([^/]+)$/);
+    if (poolDeleteMatch && req.method === 'DELETE') {
+        const poolId = decodeURIComponent(poolDeleteMatch[1]);
+        try {
+            const result = deleteModelPool(initialPath, poolId);
+            if (!result.success) {
+                res.writeHead(404, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ error: 'Pool not found' }));
+                return true;
+            }
+            broadcastToClients({
+                type: 'MODEL_POOL_DELETED',
+                payload: { poolId, syncResult: result.syncResult, timestamp: new Date().toISOString() }
+            });
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify(result));
+        }
+        catch (err) {
+            res.writeHead(500, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: err.message }));
+        }
+        return true;
+    }
+    // GET /api/litellm-api/model-pools/available-models/:modelType - Get available models for type
+    const availableModelsMatch = pathname.match(/^\/api\/litellm-api\/model-pools\/available-models\/([^/]+)$/);
+    if (availableModelsMatch && req.method === 'GET') {
+        const modelType = decodeURIComponent(availableModelsMatch[1]);
+        try {
+            const availableModels = getAvailableModelsForType(initialPath, modelType);
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ availableModels, modelType }));
+        }
+        catch (err) {
+            res.writeHead(500, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: err.message }));
+        }
+        return true;
+    }
+    // GET /api/litellm-api/model-pools/discover/:modelType/:model - Discover providers for model
+    const discoverPoolMatch = pathname.match(/^\/api\/litellm-api\/model-pools\/discover\/([^/]+)\/([^/]+)$/);
+    if (discoverPoolMatch && req.method === 'GET') {
+        const modelType = decodeURIComponent(discoverPoolMatch[1]);
+        const targetModel = decodeURIComponent(discoverPoolMatch[2]);
+        try {
+            const discovered = discoverProvidersForModel(initialPath, targetModel);
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({
+                modelType,
+                targetModel,
+                discovered,
+                count: discovered.length,
+            }));
+        }
+        catch (err) {
+            res.writeHead(500, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: err.message }));
+        }
+        return true;
+    }
     // POST /api/litellm-api/ccw-litellm/install - Install ccw-litellm package
     if (pathname === '/api/litellm-api/ccw-litellm/install' && req.method === 'POST') {
         handlePostRequest(req, res, async () => {
@@ -684,6 +1104,21 @@ export async function handleLiteLLMApiRoutes(ctx) {
                         break;
                     }
                 }
+                // Priority: Use UV if available
+                if (await isUvAvailable()) {
+                    const uvResult = await installCcwLitellmWithUv(packagePath || null);
+                    if (uvResult.success) {
+                        // Broadcast installation event
+                        broadcastToClients({
+                            type: 'CCW_LITELLM_INSTALLED',
+                            payload: { timestamp: new Date().toISOString(), method: 'uv' }
+                        });
+                        return { ...uvResult, path: packagePath || undefined };
+                    }
+                    // UV install failed, fall through to pip fallback
+                    console.log('[ccw-litellm install] UV install failed, falling back to pip:', uvResult.error);
+                }
+                // Fallback: Use pip for installation
                 // Use shared Python detection for consistent cross-platform behavior
                 const pythonCmd = getSystemPython();
                 if (!packagePath) {
@@ -698,6 +1133,10 @@ export async function handleLiteLLMApiRoutes(ctx) {
                             if (code === 0) {
                                 // Clear status cache after successful installation
                                 clearCcwLitellmStatusCache();
+                                broadcastToClients({
+                                    type: 'CCW_LITELLM_INSTALLED',
+                                    payload: { timestamp: new Date().toISOString(), method: 'pip' }
+                                });
                                 resolve({ success: true, message: 'ccw-litellm installed from PyPI' });
                             }
                             else {
@@ -721,7 +1160,7 @@ export async function handleLiteLLMApiRoutes(ctx) {
                             // Broadcast installation event
                             broadcastToClients({
                                 type: 'CCW_LITELLM_INSTALLED',
-                                payload: { timestamp: new Date().toISOString() }
+                                payload: { timestamp: new Date().toISOString(), method: 'pip' }
                             });
                             resolve({ success: true, message: 'ccw-litellm installed successfully', path: packagePath });
                         }
@@ -742,8 +1181,26 @@ export async function handleLiteLLMApiRoutes(ctx) {
     if (pathname === '/api/litellm-api/ccw-litellm/uninstall' && req.method === 'POST') {
         handlePostRequest(req, res, async () => {
             try {
+                // Priority 1: Use UV to uninstall from CodexLens venv
+                if (await isUvAvailable()) {
+                    const uv = createCodexLensUvManager();
+                    if (uv.isVenvValid()) {
+                        console.log('[ccw-litellm uninstall] Using UV to uninstall from CodexLens venv...');
+                        const uvResult = await uv.uninstall(['ccw-litellm']);
+                        clearCcwLitellmStatusCache();
+                        if (uvResult.success) {
+                            broadcastToClients({
+                                type: 'CCW_LITELLM_UNINSTALLED',
+                                payload: { timestamp: new Date().toISOString() }
+                            });
+                            return { success: true, message: 'ccw-litellm uninstalled successfully via UV' };
+                        }
+                        console.log('[ccw-litellm uninstall] UV uninstall failed, falling back to pip:', uvResult.error);
+                    }
+                }
+                // Priority 2: Fallback to system pip uninstall
+                console.log('[ccw-litellm uninstall] Using pip fallback...');
                 const { spawn } = await import('child_process');
-                // Use shared Python detection for consistent cross-platform behavior
                 const pythonCmd = getSystemPython();
                 return new Promise((resolve) => {
                     const proc = spawn(pythonCmd, ['-m', 'pip', 'uninstall', '-y', 'ccw-litellm'], { shell: true, timeout: 120000 });