vibecodingmachine-core 1.0.2 → 2025.11.2-7.1302

package/src/llm/direct-llm-manager.cjs

@@ -1,609 +1,609 @@
-/**
- * Direct LLM API Manager - Call LLM APIs directly without IDE CLI tools
- * Supports: Ollama (local), Anthropic, Groq, AWS Bedrock
- */
-
-const https = require('https');
-const http = require('http');
-
-class DirectLLMManager {
-  constructor(sharedProviderManager = null) {
-    this.logger = console;
-    // Use shared ProviderManager if provided, otherwise create new instance
-    // IMPORTANT: Pass shared instance to maintain rate limit state across calls
-    if (sharedProviderManager) {
-      this.providerManager = sharedProviderManager;
-    } else {
-      try {
-        const ProviderManager = require('../ide-integration/provider-manager.cjs');
-        this.providerManager = new ProviderManager();
-      } catch (err) {
-        this.providerManager = null;
-      }
-    }
-  }
-  
-  /**
-   * Detect and save rate limit from error message
-   * @param {string} provider - Provider name
-   * @param {string} model - Model name
-   * @param {string} errorMessage - Error message from API
-   */
-  detectAndSaveRateLimit(provider, model, errorMessage) {
-    if (!this.providerManager) return;
-    
-    // Check for rate limit indicators
-    const isRateLimit = errorMessage.includes('rate limit') || 
-                       errorMessage.includes('Rate limit') ||
-                       errorMessage.includes('too many requests') ||
-                       errorMessage.includes('429') ||
-                       errorMessage.includes('quota') ||
-                       errorMessage.includes('Weekly limit reached') ||
-                       errorMessage.includes('Daily limit reached') ||
-                       errorMessage.includes('limit reached');
-    
-    if (isRateLimit) {
-      this.providerManager.markRateLimited(provider, model, errorMessage);
-    }
-  }
-
-  /**
-   * Call Ollama API directly (local)
-   * @param {string} model - Model name (e.g., "qwen2.5-coder:32b")
-   * @param {string} prompt - Prompt to send
-   * @param {Object} options - Options (onChunk, onComplete, onError)
-   * @returns {Promise<{success: boolean, response?: string, error?: string}>}
-   */
-  async callOllama(model, prompt, options = {}) {
-    const { onChunk, onComplete, onError, temperature = 0.2 } = options;
-    
-    return new Promise((resolve) => {
-      let fullResponse = '';
-      
-      const postData = JSON.stringify({
-        model: model,
-        prompt: prompt,
-        stream: true,
-        options: {
-          temperature: temperature
-        }
-      });
-
-      const req = http.request({
-        hostname: 'localhost',
-        port: 11434,
-        path: '/api/generate',
-        method: 'POST',
-        headers: {
-          'Content-Type': 'application/json',
-          'Content-Length': Buffer.byteLength(postData)
-        }
-      }, (res) => {
-        let buffer = '';
-        
-        res.on('data', (chunk) => {
-          buffer += chunk.toString();
-          const lines = buffer.split('\n');
-          buffer = lines.pop(); // Keep incomplete line in buffer
-          
-          for (const line of lines) {
-            if (!line.trim()) continue;
-            
-            try {
-              const data = JSON.parse(line);
-              if (data.response) {
-                fullResponse += data.response;
-                if (onChunk) onChunk(data.response);
-              }
-              
-              if (data.done) {
-                if (onComplete) onComplete(fullResponse);
-                resolve({
-                  success: true,
-                  response: fullResponse,
-                  model: data.model,
-                  context: data.context
-                });
-              }
-            } catch (err) {
-              // Ignore JSON parse errors for partial chunks
-            }
-          }
-        });
-        
-        res.on('end', () => {
-          if (!fullResponse) {
-            const error = 'No response received from Ollama';
-            if (onError) onError(error);
-            resolve({ success: false, error });
-          }
-        });
-      });
-
-      req.on('error', (error) => {
-        const errorMsg = `Ollama API error: ${error.message}`;
-        if (onError) onError(errorMsg);
-        resolve({ success: false, error: errorMsg });
-      });
-
-      req.write(postData);
-      req.end();
-    });
-  }
-
-  /**
-   * Call Anthropic API directly
-   * @param {string} model - Model name (e.g., "claude-sonnet-4-20250514")
-   * @param {string} prompt - Prompt to send
-   * @param {Object} options - Options (apiKey, onChunk, onComplete, onError)
-   * @returns {Promise<{success: boolean, response?: string, error?: string}>}
-   */
-  async callAnthropic(model, prompt, options = {}) {
-    const { apiKey, onChunk, onComplete, onError, temperature = 0.2, maxTokens = 8192 } = options;
-    
-    if (!apiKey) {
-      const error = 'Anthropic API key required';
-      if (onError) onError(error);
-      return { success: false, error };
-    }
-
-    return new Promise((resolve) => {
-      let fullResponse = '';
-      
-      const postData = JSON.stringify({
-        model: model,
-        max_tokens: maxTokens,
-        temperature: temperature,
-        messages: [
-          { role: 'user', content: prompt }
-        ],
-        stream: true
-      });
-
-      const req = https.request({
-        hostname: 'api.anthropic.com',
-        path: '/v1/messages',
-        method: 'POST',
-        headers: {
-          'Content-Type': 'application/json',
-          'x-api-key': apiKey,
-          'anthropic-version': '2023-06-01',
-          'Content-Length': Buffer.byteLength(postData)
-        }
-      }, (res) => {
-        let buffer = '';
-        
-        res.on('data', (chunk) => {
-          buffer += chunk.toString();
-          const lines = buffer.split('\n');
-          buffer = lines.pop();
-          
-          for (const line of lines) {
-            if (!line.trim() || !line.startsWith('data: ')) continue;
-            
-            try {
-              const jsonStr = line.slice(6); // Remove "data: " prefix
-              if (jsonStr === '[DONE]') continue;
-              
-              const data = JSON.parse(jsonStr);
-              
-              if (data.type === 'content_block_delta' && data.delta?.text) {
-                fullResponse += data.delta.text;
-                if (onChunk) onChunk(data.delta.text);
-              } else if (data.type === 'message_stop') {
-                if (onComplete) onComplete(fullResponse);
-                resolve({
-                  success: true,
-                  response: fullResponse,
-                  model: model
-                });
-              }
-            } catch (err) {
-              // Ignore JSON parse errors
-            }
-          }
-        });
-        
-        res.on('end', () => {
-          if (!fullResponse) {
-            const error = 'No response received from Anthropic';
-            if (onError) onError(error);
-            resolve({ success: false, error });
-          }
-        });
-      });
-
-      req.on('error', (error) => {
-        const errorMsg = `Anthropic API error: ${error.message}`;
-        if (onError) onError(errorMsg);
-        resolve({ success: false, error: errorMsg });
-      });
-
-      req.write(postData);
-      req.end();
-    });
-  }
-
-  /**
-   * Call Groq API directly
-   * @param {string} model - Model name (e.g., "llama-3.3-70b-versatile")
-   * @param {string} prompt - Prompt to send
-   * @param {Object} options - Options (apiKey, onChunk, onComplete, onError)
-   * @returns {Promise<{success: boolean, response?: string, error?: string}>}
-   */
-  async callGroq(model, prompt, options = {}) {
-    const { apiKey, onChunk, onComplete, onError, temperature = 0.2, maxTokens = 8192 } = options;
-    
-    if (!apiKey) {
-      const error = 'Groq API key required';
-      if (onError) onError(error);
-      return { success: false, error };
-    }
-
-    return new Promise((resolve) => {
-      let fullResponse = '';
-      
-      const postData = JSON.stringify({
-        model: model,
-        messages: [
-          { role: 'user', content: prompt }
-        ],
-        temperature: temperature,
-        max_tokens: maxTokens,
-        stream: true
-      });
-
-      const req = https.request({
-        hostname: 'api.groq.com',
-        path: '/openai/v1/chat/completions',
-        method: 'POST',
-        headers: {
-          'Content-Type': 'application/json',
-          'Authorization': `Bearer ${apiKey}`,
-          'Content-Length': Buffer.byteLength(postData)
-        }
-      }, (res) => {
-        let buffer = '';
-        let statusCode = res.statusCode;
-        
-        // Check for rate limit or error status codes
-        if (statusCode === 429 || statusCode >= 400) {
-          let errorBody = '';
-          res.on('data', (chunk) => {
-            errorBody += chunk.toString();
-          });
-          res.on('end', () => {
-            const errorMsg = `Groq API error (${statusCode}): ${errorBody || 'No error details'}`;
-            this.detectAndSaveRateLimit('groq', model, errorMsg);
-            if (onError) onError(errorMsg);
-            resolve({ success: false, error: errorMsg });
-          });
-          return;
-        }
-        
-        res.on('data', (chunk) => {
-          buffer += chunk.toString();
-          const lines = buffer.split('\n');
-          buffer = lines.pop();
-          
-          for (const line of lines) {
-            if (!line.trim() || !line.startsWith('data: ')) continue;
-            
-            try {
-              const jsonStr = line.slice(6);
-              if (jsonStr === '[DONE]') {
-                if (onComplete) onComplete(fullResponse);
-                resolve({
-                  success: true,
-                  response: fullResponse,
-                  model: model
-                });
-                return;
-              }
-              
-              const data = JSON.parse(jsonStr);
-              const content = data.choices?.[0]?.delta?.content;
-              
-              if (content) {
-                fullResponse += content;
-                if (onChunk) onChunk(content);
-              }
-            } catch (err) {
-              // Ignore JSON parse errors
-            }
-          }
-        });
-        
-        res.on('end', () => {
-          if (fullResponse) {
-            if (onComplete) onComplete(fullResponse);
-            resolve({ success: true, response: fullResponse, model });
-          } else {
-            const error = buffer || 'No response received from Groq';
-            this.detectAndSaveRateLimit('groq', model, error);
-            if (onError) onError(error);
-            resolve({ success: false, error });
-          }
-        });
-      });
-
-      req.on('error', (error) => {
-        const errorMsg = `Groq API error: ${error.message}`;
-        this.detectAndSaveRateLimit('groq', model, errorMsg);
-        if (onError) onError(errorMsg);
-        resolve({ success: false, error: errorMsg });
-      });
-
-      req.write(postData);
-      req.end();
-    });
-  }
-
-  /**
-   * Call AWS Bedrock API directly
-   * @param {string} model - Model ID (e.g., "anthropic.claude-sonnet-4-v1")
-   * @param {string} prompt - Prompt to send
-   * @param {Object} options - Options (region, accessKeyId, secretAccessKey, onChunk, onComplete, onError)
-   * @returns {Promise<{success: boolean, response?: string, error?: string}>}
-   */
-  async callBedrock(model, prompt, options = {}) {
-    const { region, accessKeyId, secretAccessKey, onChunk, onComplete, onError, temperature = 0.2, maxTokens = 8192 } = options;
-    
-    if (!region || !accessKeyId || !secretAccessKey) {
-      const error = 'AWS credentials required (region, accessKeyId, secretAccessKey)';
-      if (onError) onError(error);
-      return { success: false, error };
-    }
-
-    try {
-      // Use AWS SDK v3 for Bedrock
-      const { BedrockRuntimeClient, InvokeModelWithResponseStreamCommand } = require('@aws-sdk/client-bedrock-runtime');
-      
-      const client = new BedrockRuntimeClient({
-        region: region,
-        credentials: {
-          accessKeyId: accessKeyId,
-          secretAccessKey: secretAccessKey
-        }
-      });
-
-      // Format request based on model provider
-      let requestBody;
-      if (model.startsWith('anthropic.')) {
-        requestBody = {
-          anthropic_version: 'bedrock-2023-05-31',
-          max_tokens: maxTokens,
-          temperature: temperature,
-          messages: [
-            { role: 'user', content: prompt }
-          ]
-        };
-      } else if (model.startsWith('meta.')) {
-        requestBody = {
-          prompt: prompt,
-          temperature: temperature,
-          max_gen_len: maxTokens
-        };
-      } else {
-        return { success: false, error: `Unsupported Bedrock model: ${model}` };
-      }
-
-      const command = new InvokeModelWithResponseStreamCommand({
-        modelId: model,
-        contentType: 'application/json',
-        accept: 'application/json',
-        body: JSON.stringify(requestBody)
-      });
-
-      const response = await client.send(command);
-      let fullResponse = '';
-
-      for await (const event of response.body) {
-        if (event.chunk) {
-          const chunk = JSON.parse(new TextDecoder().decode(event.chunk.bytes));
-          
-          let text = '';
-          if (chunk.delta?.text) {
-            text = chunk.delta.text; // Anthropic format
-          } else if (chunk.generation) {
-            text = chunk.generation; // Meta Llama format
-          }
-          
-          if (text) {
-            fullResponse += text;
-            if (onChunk) onChunk(text);
-          }
-        }
-      }
-
-      if (onComplete) onComplete(fullResponse);
-      return { success: true, response: fullResponse, model };
-      
-    } catch (error) {
-      const errorMsg = `AWS Bedrock error: ${error.message}`;
-      if (onError) onError(errorMsg);
-      return { success: false, error: errorMsg };
-    }
-  }
-
-  /**
-   * Call Claude Code CLI
-   * @param {string} model - Model name (ignored, uses Claude Pro subscription)
-   * @param {string} prompt - Prompt to send
-   * @param {Object} options - Options (onChunk, onComplete, onError)
-   * @returns {Promise<{success: boolean, response?: string, error?: string}>}
-   */
-  async callClaudeCode(model, prompt, options = {}) {
-    const { onChunk, onComplete, onError } = options;
-    const { spawn } = require('child_process');
-    
-    return new Promise((resolve) => {
-      let fullResponse = '';
-      let errorOutput = '';
-      
-      // Call claude CLI with the prompt
-      const claude = spawn('claude', ['--dangerously-skip-permissions'], {
-        stdio: ['pipe', 'pipe', 'pipe']
-      });
-      
-      // Send prompt to stdin
-      claude.stdin.write(prompt);
-      claude.stdin.end();
-      
-      // Capture stdout
-      claude.stdout.on('data', (data) => {
-        const chunk = data.toString();
-        fullResponse += chunk;
-        if (onChunk) onChunk(chunk);
-      });
-      
-      // Capture stderr
-      claude.stderr.on('data', (data) => {
-        errorOutput += data.toString();
-      });
-      
-      // Handle completion
-      claude.on('close', (code) => {
-        if (code === 0) {
-          if (onComplete) onComplete(fullResponse);
-          resolve({ success: true, response: fullResponse });
-        } else {
-          const error = `Claude CLI exited with code ${code}: ${errorOutput}`;
-          if (onError) onError(error);
-          // Check for rate limits
-          this.detectAndSaveRateLimit('claude-code', 'claude-code-cli', errorOutput);
-          resolve({ success: false, error });
-        }
-      });
-      
-      // Handle spawn errors
-      claude.on('error', (err) => {
-        const error = `Failed to start Claude CLI: ${err.message}`;
-        if (onError) onError(error);
-        resolve({ success: false, error });
-      });
-    });
-  }
-
-  /**
-   * Call any LLM provider
-   * @param {Object} config - Provider configuration
-   * @param {string} prompt - Prompt to send
-   * @param {Object} options - Options
-   * @returns {Promise<{success: boolean, response?: string, error?: string}>}
-   */
-  async call(config, prompt, options = {}) {
-    const { provider, model, apiKey, region, accessKeyId, secretAccessKey } = config;
-
-    switch (provider) {
-      case 'ollama':
-        return this.callOllama(model, prompt, options);
-      
-      case 'anthropic':
-        return this.callAnthropic(model, prompt, { ...options, apiKey });
-      
-      case 'groq':
-        return this.callGroq(model, prompt, { ...options, apiKey });
-      
-      case 'bedrock':
-        return this.callBedrock(model, prompt, { ...options, region, accessKeyId, secretAccessKey });
-      
-      case 'claude-code':
-        return this.callClaudeCode(model, prompt, options);
-      
-      default:
-        return { success: false, error: `Unknown provider: ${provider}` };
-    }
-  }
-
-  /**
-   * Check if Ollama is available
-   * @returns {Promise<boolean>}
-   */
-  async isOllamaAvailable() {
-    return new Promise((resolve) => {
-      const req = http.request({
-        hostname: 'localhost',
-        port: 11434,
-        path: '/api/tags',
-        method: 'GET',
-        timeout: 2000
-      }, (res) => {
-        resolve(res.statusCode === 200);
-      });
-
-      req.on('error', () => resolve(false));
-      req.on('timeout', () => {
-        req.destroy();
-        resolve(false);
-      });
-
-      req.end();
-    });
-  }
-
-  /**
-   * Check if Claude Code CLI is available
-   * @returns {Promise<boolean>}
-   */
-  async isClaudeCodeAvailable() {
-    const { spawn } = require('child_process');
-    
-    return new Promise((resolve) => {
-      const claude = spawn('claude', ['--version'], {
-        stdio: ['ignore', 'pipe', 'pipe']
-      });
-      
-      claude.on('close', (code) => {
-        resolve(code === 0);
-      });
-      
-      claude.on('error', () => {
-        resolve(false);
-      });
-      
-      // Timeout after 2 seconds
-      setTimeout(() => {
-        claude.kill();
-        resolve(false);
-      }, 2000);
-    });
-  }
-
-  /**
-   * Get list of installed Ollama models
-   * @returns {Promise<string[]>}
-   */
-  async getOllamaModels() {
-    return new Promise((resolve) => {
-      const req = http.request({
-        hostname: 'localhost',
-        port: 11434,
-        path: '/api/tags',
-        method: 'GET'
-      }, (res) => {
-        let data = '';
-        
-        res.on('data', (chunk) => {
-          data += chunk.toString();
-        });
-        
-        res.on('end', () => {
-          try {
-            const json = JSON.parse(data);
-            const models = json.models?.map(m => m.name) || [];
-            resolve(models);
-          } catch (err) {
-            resolve([]);
-          }
-        });
-      });
-
-      req.on('error', () => resolve([]));
-      req.end();
-    });
-  }
-}
-
-module.exports = DirectLLMManager;
-
+/**
+ * Direct LLM API Manager - Call LLM APIs directly without IDE CLI tools
+ * Supports: Ollama (local), Anthropic, Groq, AWS Bedrock
+ */
+
+const https = require('https');
+const http = require('http');
+
+class DirectLLMManager {
+  constructor(sharedProviderManager = null) {
+    this.logger = console;
+    // Use shared ProviderManager if provided, otherwise create new instance
+    // IMPORTANT: Pass shared instance to maintain rate limit state across calls
+    if (sharedProviderManager) {
+      this.providerManager = sharedProviderManager;
+    } else {
+      try {
+        const ProviderManager = require('../ide-integration/provider-manager.cjs');
+        this.providerManager = new ProviderManager();
+      } catch (err) {
+        this.providerManager = null;
+      }
+    }
+  }
+  
+  /**
+   * Detect and save rate limit from error message
+   * @param {string} provider - Provider name
+   * @param {string} model - Model name
+   * @param {string} errorMessage - Error message from API
+   */
+  detectAndSaveRateLimit(provider, model, errorMessage) {
+    if (!this.providerManager) return;
+    
+    // Check for rate limit indicators
+    const isRateLimit = errorMessage.includes('rate limit') || 
+                       errorMessage.includes('Rate limit') ||
+                       errorMessage.includes('too many requests') ||
+                       errorMessage.includes('429') ||
+                       errorMessage.includes('quota') ||
+                       errorMessage.includes('Weekly limit reached') ||
+                       errorMessage.includes('Daily limit reached') ||
+                       errorMessage.includes('limit reached');
+    
+    if (isRateLimit) {
+      this.providerManager.markRateLimited(provider, model, errorMessage);
+    }
+  }
+
+  /**
+   * Call Ollama API directly (local)
+   * @param {string} model - Model name (e.g., "qwen2.5-coder:32b")
+   * @param {string} prompt - Prompt to send
+   * @param {Object} options - Options (onChunk, onComplete, onError)
+   * @returns {Promise<{success: boolean, response?: string, error?: string}>}
+   */
+  async callOllama(model, prompt, options = {}) {
+    const { onChunk, onComplete, onError, temperature = 0.2 } = options;
+    
+    return new Promise((resolve) => {
+      let fullResponse = '';
+      
+      const postData = JSON.stringify({
+        model: model,
+        prompt: prompt,
+        stream: true,
+        options: {
+          temperature: temperature
+        }
+      });
+
+      const req = http.request({
+        hostname: 'localhost',
+        port: 11434,
+        path: '/api/generate',
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Content-Length': Buffer.byteLength(postData)
+        }
+      }, (res) => {
+        let buffer = '';
+        
+        res.on('data', (chunk) => {
+          buffer += chunk.toString();
+          const lines = buffer.split('\n');
+          buffer = lines.pop(); // Keep incomplete line in buffer
+          
+          for (const line of lines) {
+            if (!line.trim()) continue;
+            
+            try {
+              const data = JSON.parse(line);
+              if (data.response) {
+                fullResponse += data.response;
+                if (onChunk) onChunk(data.response);
+              }
+              
+              if (data.done) {
+                if (onComplete) onComplete(fullResponse);
+                resolve({
+                  success: true,
+                  response: fullResponse,
+                  model: data.model,
+                  context: data.context
+                });
+              }
+            } catch (err) {
+              // Ignore JSON parse errors for partial chunks
+            }
+          }
+        });
+        
+        res.on('end', () => {
+          if (!fullResponse) {
+            const error = 'No response received from Ollama';
+            if (onError) onError(error);
+            resolve({ success: false, error });
+          }
+        });
+      });
+
+      req.on('error', (error) => {
+        const errorMsg = `Ollama API error: ${error.message}`;
+        if (onError) onError(errorMsg);
+        resolve({ success: false, error: errorMsg });
+      });
+
+      req.write(postData);
+      req.end();
+    });
+  }
+
+  /**
+   * Call Anthropic API directly
+   * @param {string} model - Model name (e.g., "claude-sonnet-4-20250514")
+   * @param {string} prompt - Prompt to send
+   * @param {Object} options - Options (apiKey, onChunk, onComplete, onError)
+   * @returns {Promise<{success: boolean, response?: string, error?: string}>}
+   */
+  async callAnthropic(model, prompt, options = {}) {
+    const { apiKey, onChunk, onComplete, onError, temperature = 0.2, maxTokens = 8192 } = options;
+    
+    if (!apiKey) {
+      const error = 'Anthropic API key required';
+      if (onError) onError(error);
+      return { success: false, error };
+    }
+
+    return new Promise((resolve) => {
+      let fullResponse = '';
+      
+      const postData = JSON.stringify({
+        model: model,
+        max_tokens: maxTokens,
+        temperature: temperature,
+        messages: [
+          { role: 'user', content: prompt }
+        ],
+        stream: true
+      });
+
+      const req = https.request({
+        hostname: 'api.anthropic.com',
+        path: '/v1/messages',
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'x-api-key': apiKey,
+          'anthropic-version': '2023-06-01',
+          'Content-Length': Buffer.byteLength(postData)
+        }
+      }, (res) => {
+        let buffer = '';
+        
+        res.on('data', (chunk) => {
+          buffer += chunk.toString();
+          const lines = buffer.split('\n');
+          buffer = lines.pop();
+          
+          for (const line of lines) {
+            if (!line.trim() || !line.startsWith('data: ')) continue;
+            
+            try {
+              const jsonStr = line.slice(6); // Remove "data: " prefix
+              if (jsonStr === '[DONE]') continue;
+              
+              const data = JSON.parse(jsonStr);
+              
+              if (data.type === 'content_block_delta' && data.delta?.text) {
+                fullResponse += data.delta.text;
+                if (onChunk) onChunk(data.delta.text);
+              } else if (data.type === 'message_stop') {
+                if (onComplete) onComplete(fullResponse);
+                resolve({
+                  success: true,
+                  response: fullResponse,
+                  model: model
+                });
+              }
+            } catch (err) {
+              // Ignore JSON parse errors
+            }
+          }
+        });
+        
+        res.on('end', () => {
+          if (!fullResponse) {
+            const error = 'No response received from Anthropic';
+            if (onError) onError(error);
+            resolve({ success: false, error });
+          }
+        });
+      });
+
+      req.on('error', (error) => {
+        const errorMsg = `Anthropic API error: ${error.message}`;
+        if (onError) onError(errorMsg);
+        resolve({ success: false, error: errorMsg });
+      });
+
+      req.write(postData);
+      req.end();
+    });
+  }
+
+  /**
+   * Call Groq API directly
+   * @param {string} model - Model name (e.g., "llama-3.3-70b-versatile")
+   * @param {string} prompt - Prompt to send
+   * @param {Object} options - Options (apiKey, onChunk, onComplete, onError)
+   * @returns {Promise<{success: boolean, response?: string, error?: string}>}
+   */
+  async callGroq(model, prompt, options = {}) {
+    const { apiKey, onChunk, onComplete, onError, temperature = 0.2, maxTokens = 8192 } = options;
+    
+    if (!apiKey) {
+      const error = 'Groq API key required';
+      if (onError) onError(error);
+      return { success: false, error };
+    }
+
+    return new Promise((resolve) => {
+      let fullResponse = '';
+      
+      const postData = JSON.stringify({
+        model: model,
+        messages: [
+          { role: 'user', content: prompt }
+        ],
+        temperature: temperature,
+        max_tokens: maxTokens,
+        stream: true
+      });
+
+      const req = https.request({
+        hostname: 'api.groq.com',
+        path: '/openai/v1/chat/completions',
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': `Bearer ${apiKey}`,
+          'Content-Length': Buffer.byteLength(postData)
+        }
+      }, (res) => {
+        let buffer = '';
+        let statusCode = res.statusCode;
+        
+        // Check for rate limit or error status codes
+        if (statusCode === 429 || statusCode >= 400) {
+          let errorBody = '';
+          res.on('data', (chunk) => {
+            errorBody += chunk.toString();
+          });
+          res.on('end', () => {
+            const errorMsg = `Groq API error (${statusCode}): ${errorBody || 'No error details'}`;
+            this.detectAndSaveRateLimit('groq', model, errorMsg);
+            if (onError) onError(errorMsg);
+            resolve({ success: false, error: errorMsg });
+          });
+          return;
+        }
+        
+        res.on('data', (chunk) => {
+          buffer += chunk.toString();
+          const lines = buffer.split('\n');
+          buffer = lines.pop();
+          
+          for (const line of lines) {
+            if (!line.trim() || !line.startsWith('data: ')) continue;
+            
+            try {
+              const jsonStr = line.slice(6);
+              if (jsonStr === '[DONE]') {
+                if (onComplete) onComplete(fullResponse);
+                resolve({
+                  success: true,
+                  response: fullResponse,
+                  model: model
+                });
+                return;
+              }
+              
+              const data = JSON.parse(jsonStr);
+              const content = data.choices?.[0]?.delta?.content;
+              
+              if (content) {
+                fullResponse += content;
+                if (onChunk) onChunk(content);
+              }
+            } catch (err) {
+              // Ignore JSON parse errors
+            }
+          }
+        });
+        
+        res.on('end', () => {
+          if (fullResponse) {
+            if (onComplete) onComplete(fullResponse);
+            resolve({ success: true, response: fullResponse, model });
+          } else {
+            const error = buffer || 'No response received from Groq';
+            this.detectAndSaveRateLimit('groq', model, error);
+            if (onError) onError(error);
+            resolve({ success: false, error });
+          }
+        });
+      });
+
+      req.on('error', (error) => {
+        const errorMsg = `Groq API error: ${error.message}`;
+        this.detectAndSaveRateLimit('groq', model, errorMsg);
+        if (onError) onError(errorMsg);
+        resolve({ success: false, error: errorMsg });
+      });
+
+      req.write(postData);
+      req.end();
+    });
+  }
+
+  /**
+   * Call AWS Bedrock API directly
+   * @param {string} model - Model ID (e.g., "anthropic.claude-sonnet-4-v1")
+   * @param {string} prompt - Prompt to send
+   * @param {Object} options - Options (region, accessKeyId, secretAccessKey, onChunk, onComplete, onError)
+   * @returns {Promise<{success: boolean, response?: string, error?: string}>}
+   */
+  async callBedrock(model, prompt, options = {}) {
+    const { region, accessKeyId, secretAccessKey, onChunk, onComplete, onError, temperature = 0.2, maxTokens = 8192 } = options;
+    
+    if (!region || !accessKeyId || !secretAccessKey) {
+      const error = 'AWS credentials required (region, accessKeyId, secretAccessKey)';
+      if (onError) onError(error);
+      return { success: false, error };
+    }
+
+    try {
+      // Use AWS SDK v3 for Bedrock
+      const { BedrockRuntimeClient, InvokeModelWithResponseStreamCommand } = require('@aws-sdk/client-bedrock-runtime');
+      
+      const client = new BedrockRuntimeClient({
+        region: region,
+        credentials: {
+          accessKeyId: accessKeyId,
+          secretAccessKey: secretAccessKey
+        }
+      });
+
+      // Format request based on model provider
+      let requestBody;
+      if (model.startsWith('anthropic.')) {
+        requestBody = {
+          anthropic_version: 'bedrock-2023-05-31',
+          max_tokens: maxTokens,
+          temperature: temperature,
+          messages: [
+            { role: 'user', content: prompt }
+          ]
+        };
+      } else if (model.startsWith('meta.')) {
+        requestBody = {
+          prompt: prompt,
+          temperature: temperature,
+          max_gen_len: maxTokens
+        };
+      } else {
+        return { success: false, error: `Unsupported Bedrock model: ${model}` };
+      }
+
+      const command = new InvokeModelWithResponseStreamCommand({
+        modelId: model,
+        contentType: 'application/json',
+        accept: 'application/json',
+        body: JSON.stringify(requestBody)
+      });
+
+      const response = await client.send(command);
+      let fullResponse = '';
+
+      for await (const event of response.body) {
+        if (event.chunk) {
+          const chunk = JSON.parse(new TextDecoder().decode(event.chunk.bytes));
+          
+          let text = '';
+          if (chunk.delta?.text) {
+            text = chunk.delta.text; // Anthropic format
+          } else if (chunk.generation) {
+            text = chunk.generation; // Meta Llama format
+          }
+          
+          if (text) {
+            fullResponse += text;
+            if (onChunk) onChunk(text);
+          }
+        }
+      }
+
+      if (onComplete) onComplete(fullResponse);
+      return { success: true, response: fullResponse, model };
+      
+    } catch (error) {
+      const errorMsg = `AWS Bedrock error: ${error.message}`;
+      if (onError) onError(errorMsg);
+      return { success: false, error: errorMsg };
+    }
+  }
+
+  /**
+   * Call Claude Code CLI
+   * @param {string} model - Model name (ignored, uses Claude Pro subscription)
+   * @param {string} prompt - Prompt to send
+   * @param {Object} options - Options (onChunk, onComplete, onError)
+   * @returns {Promise<{success: boolean, response?: string, error?: string}>}
+   */
+  async callClaudeCode(model, prompt, options = {}) {
+    const { onChunk, onComplete, onError } = options;
+    const { spawn } = require('child_process');
+    
+    return new Promise((resolve) => {
+      let fullResponse = '';
+      let errorOutput = '';
+      
+      // Call claude CLI with the prompt
+      const claude = spawn('claude', ['--dangerously-skip-permissions'], {
+        stdio: ['pipe', 'pipe', 'pipe']
+      });
+      
+      // Send prompt to stdin
+      claude.stdin.write(prompt);
+      claude.stdin.end();
+      
+      // Capture stdout
+      claude.stdout.on('data', (data) => {
+        const chunk = data.toString();
+        fullResponse += chunk;
+        if (onChunk) onChunk(chunk);
+      });
+      
+      // Capture stderr
+      claude.stderr.on('data', (data) => {
+        errorOutput += data.toString();
+      });
+      
+      // Handle completion
+      claude.on('close', (code) => {
+        if (code === 0) {
+          if (onComplete) onComplete(fullResponse);
+          resolve({ success: true, response: fullResponse });
+        } else {
+          const error = `Claude CLI exited with code ${code}: ${errorOutput}`;
+          if (onError) onError(error);
+          // Check for rate limits
+          this.detectAndSaveRateLimit('claude-code', 'claude-code-cli', errorOutput);
+          resolve({ success: false, error });
+        }
+      });
+      
+      // Handle spawn errors
+      claude.on('error', (err) => {
+        const error = `Failed to start Claude CLI: ${err.message}`;
+        if (onError) onError(error);
+        resolve({ success: false, error });
+      });
+    });
+  }
+
+  /**
+   * Call any LLM provider
+   * @param {Object} config - Provider configuration
+   * @param {string} prompt - Prompt to send
+   * @param {Object} options - Options
+   * @returns {Promise<{success: boolean, response?: string, error?: string}>}
+   */
+  async call(config, prompt, options = {}) {
+    const { provider, model, apiKey, region, accessKeyId, secretAccessKey } = config;
+
+    switch (provider) {
+      case 'ollama':
+        return this.callOllama(model, prompt, options);
+      
+      case 'anthropic':
+        return this.callAnthropic(model, prompt, { ...options, apiKey });
+      
+      case 'groq':
+        return this.callGroq(model, prompt, { ...options, apiKey });
+      
+      case 'bedrock':
+        return this.callBedrock(model, prompt, { ...options, region, accessKeyId, secretAccessKey });
+      
+      case 'claude-code':
+        return this.callClaudeCode(model, prompt, options);
+      
+      default:
+        return { success: false, error: `Unknown provider: ${provider}` };
+    }
+  }
+
+  /**
+   * Check if Ollama is available
+   * @returns {Promise<boolean>}
+   */
+  async isOllamaAvailable() {
+    return new Promise((resolve) => {
+      const req = http.request({
+        hostname: 'localhost',
+        port: 11434,
+        path: '/api/tags',
+        method: 'GET',
+        timeout: 2000
+      }, (res) => {
+        resolve(res.statusCode === 200);
+      });
+
+      req.on('error', () => resolve(false));
+      req.on('timeout', () => {
+        req.destroy();
+        resolve(false);
+      });
+
+      req.end();
+    });
+  }
+
+  /**
+   * Check if Claude Code CLI is available
+   * @returns {Promise<boolean>}
+   */
+  async isClaudeCodeAvailable() {
+    const { spawn } = require('child_process');
+    
+    return new Promise((resolve) => {
+      const claude = spawn('claude', ['--version'], {
+        stdio: ['ignore', 'pipe', 'pipe']
+      });
+      
+      claude.on('close', (code) => {
+        resolve(code === 0);
+      });
+      
+      claude.on('error', () => {
+        resolve(false);
+      });
+      
+      // Timeout after 2 seconds
+      setTimeout(() => {
+        claude.kill();
+        resolve(false);
+      }, 2000);
+    });
+  }
+
+  /**
+   * Get list of installed Ollama models
+   * @returns {Promise<string[]>}
+   */
+  async getOllamaModels() {
+    return new Promise((resolve) => {
+      const req = http.request({
+        hostname: 'localhost',
+        port: 11434,
+        path: '/api/tags',
+        method: 'GET'
+      }, (res) => {
+        let data = '';
+        
+        res.on('data', (chunk) => {
+          data += chunk.toString();
+        });
+        
+        res.on('end', () => {
+          try {
+            const json = JSON.parse(data);
+            const models = json.models?.map(m => m.name) || [];
+            resolve(models);
+          } catch (err) {
+            resolve([]);
+          }
+        });
+      });
+
+      req.on('error', () => resolve([]));
+      req.end();
+    });
+  }
+}
+
+module.exports = DirectLLMManager;
+