claude-code-workflow 6.3.18 → 6.3.20

package/ccw/src/core/routes/litellm-api-routes.ts

@@ -1,12 +1,44 @@
-// @ts-nocheck
 /**
  * LiteLLM API Routes Module
  * Handles LiteLLM provider management, endpoint configuration, and cache management
  */
-import type { IncomingMessage, ServerResponse } from 'http';
 import { fileURLToPath } from 'url';
 import { dirname, join as pathJoin } from 'path';
+import { z } from 'zod';
 import { getSystemPython } from '../../utils/python-utils.js';
+import {
+  UvManager,
+  isUvAvailable,
+  ensureUvInstalled,
+  createCodexLensUvManager
+} from '../../utils/uv-manager.js';
+import { ensureLiteLLMEmbedderReady } from '../../tools/codex-lens.js';
+import type { RouteContext } from './types.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);
@@ -40,6 +72,12 @@ import {
   getEmbeddingPoolConfig,
   updateEmbeddingPoolConfig,
   discoverProvidersForModel,
+  getModelPools,
+  getModelPool,
+  addModelPool,
+  updateModelPool,
+  deleteModelPool,
+  getAvailableModelsForType,
   type ProviderCredential,
   type CustomEndpoint,
   type ProviderType,
@@ -48,6 +86,7 @@ import {
 } 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: {
@@ -66,14 +105,38 @@ export function clearCcwLitellmStatusCache() {
   ccwLitellmStatusCache.timestamp = 0;
 }
 
-export interface RouteContext {
-  pathname: string;
-  url: URL;
-  req: IncomingMessage;
-  res: ServerResponse;
-  initialPath: string;
-  handlePostRequest: (req: IncomingMessage, res: ServerResponse, handler: (body: unknown) => Promise<any>) => void;
-  broadcastToClients: (data: unknown) => void;
+/**
+ * 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: string | null): Promise<{ success: boolean; message?: string; error?: string }> {
+  // 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: any): any {
+  if (!provider) return provider;
+  return {
+    ...provider,
+    apiKey: '***',
+    apiKeys: Array.isArray(provider.apiKeys)
+      ? provider.apiKeys.map((entry: any) => ({ ...entry, key: '***' }))
+      : provider.apiKeys,
+  };
+}
+
+function sanitizeRotationEndpointForResponse(endpoint: any): any {
+  if (!endpoint) return endpoint;
+  return { ...endpoint, api_key: '***' };
 }
 
 // ===========================
@@ -83,11 +146,11 @@ export interface RouteContext {
 interface ModelInfo {
   id: string;
   name: string;
-  provider: ProviderType;
+  provider: string;
   description?: string;
 }
 
-const PROVIDER_MODELS: Record<ProviderType, ModelInfo[]> = {
+const PROVIDER_MODELS: Record<string, ModelInfo[]> = {
   openai: [
     { id: 'gpt-4-turbo', name: 'GPT-4 Turbo', provider: 'openai', description: '128K context' },
     { id: 'gpt-4', name: 'GPT-4', provider: 'openai', description: '8K context' },
@@ -132,7 +195,7 @@ export async function handleLiteLLMApiRoutes(ctx: RouteContext): Promise<boolean
   // 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 }));
     } catch (err) {
@@ -153,13 +216,14 @@ export async function handleLiteLLMApiRoutes(ctx: RouteContext): Promise<boolean
 
       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 as Error).message, status: 500 };
       }
@@ -181,7 +245,7 @@ export async function handleLiteLLMApiRoutes(ctx: RouteContext): Promise<boolean
       }
 
       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' });
       res.end(JSON.stringify({ error: (err as Error).message }));
@@ -199,13 +263,14 @@ export async function handleLiteLLMApiRoutes(ctx: RouteContext): Promise<boolean
 
       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 as Error).message, status: 404 };
       }
@@ -227,6 +292,14 @@ export async function handleLiteLLMApiRoutes(ctx: RouteContext): Promise<boolean
         return true;
       }
 
+      // Clean up health check service state for deleted provider
+      try {
+        const { getHealthCheckService } = await import('../services/health-check-service.js');
+        getHealthCheckService().cleanupProvider(providerId);
+      } catch (cleanupErr) {
+        console.warn('[Provider Delete] Failed to cleanup health check state:', cleanupErr);
+      }
+
       broadcastToClients({
         type: 'LITELLM_PROVIDER_DELETED',
         payload: { providerId, timestamp: new Date().toISOString() }
@@ -274,6 +347,201 @@ export async function handleLiteLLMApiRoutes(ctx: RouteContext): Promise<boolean
     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: unknown) => {
+      const { keyId } = body as { keyId?: string };
+
+      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: string | null = 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 as Error).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 as Error).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 as Error).message }));
+    }
+    return true;
+  }
+
   // ===========================
   // Endpoint Management Routes
   // ===========================
@@ -397,7 +665,7 @@ export async function handleLiteLLMApiRoutes(ctx: RouteContext): Promise<boolean
   // GET /api/litellm-api/models/:providerType - Get available models for provider type
   const modelsMatch = pathname.match(/^\/api\/litellm-api\/models\/([^/]+)$/);
   if (modelsMatch && req.method === 'GET') {
-    const providerType = modelsMatch[1] as ProviderType;
+    const providerType = modelsMatch[1];
 
     try {
       const models = PROVIDER_MODELS[providerType];
@@ -576,7 +844,7 @@ export async function handleLiteLLMApiRoutes(ctx: RouteContext): Promise<boolean
       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');
@@ -584,43 +852,29 @@ export async function handleLiteLLMApiRoutes(ctx: RouteContext): Promise<boolean
 
       let result: { installed: boolean; version?: string; error?: string } = { 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 as Error).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
@@ -687,11 +941,12 @@ export async function handleLiteLLMApiRoutes(ctx: RouteContext): Promise<boolean
   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) {
       res.writeHead(500, { 'Content-Type': 'application/json' });
@@ -789,6 +1044,46 @@ export async function handleLiteLLMApiRoutes(ctx: RouteContext): Promise<boolean
     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: Array<{ modelId: string; modelName: string; providers: string[] }> = [];
+      const modelMap = new Map<string, { modelId: string; modelName: string; providers: string[] }>();
+
+      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 as Error).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') {
@@ -810,6 +1105,186 @@ export async function handleLiteLLMApiRoutes(ctx: RouteContext): Promise<boolean
     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 as Error).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 as Error).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: unknown) => {
+      // 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 as Error).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: unknown) => {
+      // 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 as Error).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 as Error).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]) as import('../../types/litellm-api-config.js').ModelPoolType;
+
+    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 as Error).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 as Error).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 () => {
@@ -835,6 +1310,22 @@ export async function handleLiteLLMApiRoutes(ctx: RouteContext): Promise<boolean
           }
         }
 
+        // 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();
 
@@ -850,6 +1341,10 @@ export async function handleLiteLLMApiRoutes(ctx: RouteContext): Promise<boolean
               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 {
                 resolve({ success: false, error: error || 'Installation failed' });
@@ -874,7 +1369,7 @@ export async function handleLiteLLMApiRoutes(ctx: RouteContext): Promise<boolean
               // 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 });
             } else {
@@ -894,9 +1389,28 @@ export async function handleLiteLLMApiRoutes(ctx: RouteContext): Promise<boolean
   if (pathname === '/api/litellm-api/ccw-litellm/uninstall' && req.method === 'POST') {
     handlePostRequest(req, res, async () => {
       try {
-        const { spawn } = await import('child_process');
+        // 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();
 
-        // Use shared Python detection for consistent cross-platform behavior
+            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');
         const pythonCmd = getSystemPython();
 
         return new Promise((resolve) => {