vibecodingmachine-core 2026.3.9-907 → 2026.3.10-1548

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

@@ -1,1299 +1,1299 @@
-/**
- * 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');
-const quotaManagement = require('../quota-management');
-
-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')) &&
-      !errorMessage.startsWith('Quota limit reached'); // Don't re-mark our own internal exceeded messages
-
-    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 the Cline CLI with a prompt via stdin
-   */
-  async callCline(model, prompt, options = {}) {
-    const { onChunk, onComplete, onError } = options;
-    const { spawn } = require('child_process');
-
-    return new Promise((resolve) => {
-      let fullResponse = '';
-      let errorOutput = '';
-
-      const cline = spawn('cline', ['--dangerously-skip-permissions'], {
-        stdio: ['pipe', 'pipe', 'pipe']
-      });
-
-      cline.stdin.write(prompt);
-      cline.stdin.end();
-
-      cline.stdout.on('data', (data) => {
-        const chunk = data.toString();
-        fullResponse += chunk;
-        if (onChunk) onChunk(chunk);
-      });
-
-      cline.stderr.on('data', (data) => {
-        errorOutput += data.toString();
-      });
-
-      cline.on('close', (code) => {
-        if (code === 0) {
-          if (onComplete) onComplete(fullResponse);
-          resolve({ success: true, response: fullResponse });
-        } else {
-          const error = `Cline CLI exited with code ${code}: ${errorOutput}`;
-          if (onError) onError(error);
-          this.detectAndSaveRateLimit('cline', 'cline-cli', errorOutput);
-          resolve({ success: false, error });
-        }
-      });
-
-      cline.on('error', (err) => {
-        const error = `Failed to start Cline CLI: ${err.message}`;
-        if (onError) onError(error);
-        resolve({ success: false, error });
-      });
-    });
-  }
-
-  /**
-   * Check if Cline CLI is available
-   */
-  async isClineAvailable() {
-    const { spawn } = require('child_process');
-    return new Promise((resolve) => {
-      const proc = spawn('cline', ['--version'], { stdio: ['ignore', 'pipe', 'pipe'] });
-      proc.on('close', (code) => resolve(code === 0));
-      proc.on('error', () => resolve(false));
-      setTimeout(() => { proc.kill(); resolve(false); }, 2000);
-    });
-  }
-
-  /**
-   * Call the OpenCode CLI with a prompt via -p flag
-   */
-  async callOpenCode(model, prompt, options = {}) {
-    const { onChunk, onComplete, onError } = options;
-    const { spawn } = require('child_process');
-    const path = require('path');
-    const os = require('os');
-
-    return new Promise((resolve) => {
-      let fullResponse = '';
-      let errorOutput = '';
-
-      // Resolve opencode binary — check well-known path first
-      let cmd = 'opencode';
-      const knownPath = path.join(os.homedir(), '.opencode', 'bin', 'opencode');
-      try {
-        require('fs').accessSync(knownPath, require('fs').constants.X_OK);
-        cmd = knownPath;
-      } catch {
-        // fall back to PATH lookup
-      }
-
-      const opencode = spawn(cmd, ['-p', prompt], {
-        stdio: ['ignore', 'pipe', 'pipe']
-      });
-
-      opencode.stdout.on('data', (data) => {
-        const chunk = data.toString();
-        fullResponse += chunk;
-        if (onChunk) onChunk(chunk);
-      });
-
-      opencode.stderr.on('data', (data) => {
-        errorOutput += data.toString();
-      });
-
-      opencode.on('close', (code) => {
-        if (code === 0) {
-          if (onComplete) onComplete(fullResponse);
-          resolve({ success: true, response: fullResponse });
-        } else {
-          const error = `OpenCode CLI exited with code ${code}: ${errorOutput}`;
-          if (onError) onError(error);
-          this.detectAndSaveRateLimit('opencode', 'opencode-cli', errorOutput);
-          resolve({ success: false, error });
-        }
-      });
-
-      opencode.on('error', (err) => {
-        const error = `Failed to start OpenCode CLI: ${err.message}`;
-        if (onError) onError(error);
-        resolve({ success: false, error });
-      });
-    });
-  }
-
-  /**
-   * Check if OpenCode CLI is available
-   * @returns {Promise<boolean>}
-   */
-  async isOpenCodeAvailable() {
-    const { spawn } = require('child_process');
-    const path = require('path');
-    const os = require('os');
-
-    // Try well-known path first, then fall back to PATH
-    let cmd = 'opencode';
-    const knownPath = path.join(os.homedir(), '.opencode', 'bin', 'opencode');
-    try {
-      require('fs').accessSync(knownPath, require('fs').constants.X_OK);
-      cmd = knownPath;
-    } catch {
-      // fall back to PATH lookup
-    }
-
-    return new Promise((resolve) => {
-      const proc = spawn(cmd, ['--version'], { stdio: ['ignore', 'pipe', 'pipe'] });
-      proc.on('close', (code) => resolve(code === 0));
-      proc.on('error', () => resolve(false));
-      setTimeout(() => { proc.kill(); resolve(false); }, 5000);
-    });
-  }
-
-  /**
-   * Call the VS Code Copilot CLI with a prompt
-   */
-  async callVSCodeCopilotCLI(model, prompt, options = {}) {
-    const { onChunk, onComplete, onError } = options;
-    const { spawn } = require('child_process');
-    const os = require('os');
-
-    // Safe logging function to prevent EPIPE errors
-    const safeLog = (message) => {
-      try {
-        console.log(message);
-      } catch (err) {
-        // Ignore EPIPE errors that occur when stdout is closed
-        if (err.code === 'EPIPE') {
-          // Silently ignore - this happens during process shutdown
-        } else {
-          // Re-throw other errors
-          throw err;
-        }
-      }
-    };
-
-    safeLog(`[VS CODE COPILOT CLI] Starting call with model: ${model}`);
-    safeLog(`[VS CODE COPILOT CLI] Prompt: ${prompt.substring(0, 100)}...`);
-
-    // Set up environment with authentication if available
-    const env = { ...process.env };
-    if (!env.HOME) env.HOME = os.homedir();
-    
-    return new Promise((resolve) => {
-      let fullResponse = '';
-      let errorOutput = '';
-
-      // Non-interactive prompt invocation
-      // `copilot` uses `-p/--prompt` for non-interactive mode.
-      const args = ['-p', String(prompt), '-s', '--no-ask-user'];
-      const copilot = spawn('copilot', args, {
-        stdio: ['ignore', 'pipe', 'pipe'],
-        cwd: process.cwd(),
-        env
-      });
-
-      safeLog(`[VS CODE COPILOT CLI] Spawned process with PID: ${copilot.pid}`);
-
-      copilot.stdout.on('data', (data) => {
-        const text = data.toString();
-        fullResponse += text;
-        safeLog(`[VS CODE COPILOT CLI] STDOUT: ${text.substring(0, 200)}...`);
-        if (onChunk) onChunk(text);
-      });
-
-      copilot.stderr.on('data', (data) => {
-        const text = data.toString();
-        errorOutput += text;
-        safeLog(`[VS CODE COPILOT CLI] STDERR: ${text.substring(0, 200)}...`);
-      });
-
-      copilot.on('close', (code) => {
-        safeLog(`[VS CODE COPILOT CLI] Process closed with code: ${code}`);
-        safeLog(`[VS CODE COPILOT CLI] Full response length: ${fullResponse.length}`);
-        safeLog(`[VS CODE COPILOT CLI] Error output length: ${errorOutput.length}`);
-        safeLog(`[VS CODE COPILOT CLI] Error output: ${errorOutput}`);
-        
-        if (code === 0) {
-          if (onComplete) onComplete(fullResponse);
-          resolve({ success: true, response: fullResponse });
-        } else {
-          // Check if this is an authentication error and provide a helpful message
-          const isAuthError = this.checkForAuthenticationError(errorOutput);
-          let error = `VS Code Copilot CLI exited with code ${code}: ${errorOutput}`;
-          
-          if (isAuthError) {
-            error = `VS Code Copilot CLI requires authentication. Run 'copilot login' to authenticate with GitHub, or set COPILOT_GITHUB_TOKEN environment variable.`;
-            safeLog(`[VS CODE COPILOT CLI] Authentication error detected: ${error}`);
-
-            // If we had previously marked this provider as rate limited, clear that stale state.
-            // Auth/setup failures should never surface as rate limit in the GUI.
-            try {
-              if (this.providerManager && typeof this.providerManager.clearProviderRateLimits === 'function') {
-                this.providerManager.clearProviderRateLimits('vscode-copilot-cli');
-              }
-            } catch (_) { }
-          }
-          
-          safeLog(`[VS CODE COPILOT CLI] Error: ${error}`);
-          if (onError) onError(error);
-          
-          // Check if this is actually a rate limit error before calling detectAndSaveRateLimit
-          const isRateLimitError = this.checkForRateLimitError(errorOutput);
-          safeLog(`[VS CODE COPILOT CLI] Is rate limit error: ${isRateLimitError}`);
-          
-          if (isRateLimitError) {
-            this.detectAndSaveRateLimit('vscode-copilot-cli', 'copilot-cli', errorOutput);
-          }
-          
-          resolve({ success: false, error });
-        }
-      });
-
-      copilot.on('error', (err) => {
-        const error = `Failed to start VS Code Copilot CLI: ${err.message}`;
-        safeLog(`[VS CODE COPILOT CLI] Spawn error: ${error}`);
-        if (onError) onError(error);
-        resolve({ success: false, error });
-      });
-    });
-  }
-
-  /**
-   * Check if error output indicates an authentication error
-   */
-  checkForAuthenticationError(errorOutput) {
-    const authIndicators = [
-      'No authentication information found',
-      'authentication information found',
-      'not authenticated',
-      'COPILOT_GITHUB_TOKEN',
-      'GH_TOKEN',
-      'GITHUB_TOKEN',
-      '/login',
-      'gh auth login',
-      'OAuth Token',
-      'Personal Access Token'
-    ];
-
-    const isAuthError = authIndicators.some(indicator => 
-      errorOutput.includes(indicator)
-    );
-
-    console.log(`[AUTH CHECK] Error output: "${errorOutput}"`);
-    console.log(`[AUTH CHECK] Is authentication error: ${isAuthError}`);
-
-    return isAuthError;
-  }
-
-  /**
-   * Check if error output indicates a genuine rate limit error
-   */
-  checkForRateLimitError(errorOutput) {
-    // VS Code Copilot CLI specific rate limit indicators
-    const rateLimitIndicators = [
-      'rate limit',
-      'Rate limit',
-      'too many requests',
-      'Too many requests',
-      '429',
-      'quota exceeded',
-      'Quota exceeded',
-      'usage limit',
-      'Usage limit',
-      'limit reached',
-      'Limit reached',
-      'weekly limit',
-      'Weekly limit',
-      'daily limit',
-      'Daily limit'
-    ];
-
-    // Exclude common authentication and setup errors that are NOT rate limits
-    const nonRateLimitIndicators = [
-      'authentication information found',
-      'Authentication information found',
-      'No authentication',
-      'not authenticated',
-      'COPILOT_GITHUB_TOKEN',
-      'GH_TOKEN',
-      'GITHUB_TOKEN',
-      '/login',
-      'gh auth login',
-      'OAuth Token',
-      'Personal Access Token',
-      'GitHub CLI'
-    ];
-
-    // First check if it contains non-rate-limit indicators
-    const isNonRateLimit = nonRateLimitIndicators.some(indicator => 
-      errorOutput.includes(indicator)
-    );
-
-    if (isNonRateLimit) {
-      console.log(`[RATE LIMIT CHECK] Contains non-rate-limit indicators, not a rate limit`);
-      return false;
-    }
-
-    // Only consider it a rate limit if it contains specific rate limit indicators
-    const isRateLimit = rateLimitIndicators.some(indicator => 
-      errorOutput.includes(indicator)
-    );
-
-    console.log(`[RATE LIMIT CHECK] Error output: "${errorOutput}"`);
-    console.log(`[RATE LIMIT CHECK] Is rate limit: ${isRateLimit}`);
-
-    return isRateLimit;
-  }
-
-  /**
-   * Check if VS Code Copilot CLI is available AND authenticated
-   * @returns {Promise<{available: boolean, needsAuth: boolean, authMethod?: string}>}
-   */
-  async isVSCodeCopilotCLIAvailable() {
-    const { spawn } = require('child_process');
-    const os = require('os');
-
-    // Safe logging function to prevent EPIPE errors
-    const safeLog = (message) => {
-      try {
-        console.log(message);
-      } catch (err) {
-        // Ignore EPIPE errors that occur when stdout is closed
-        if (err.code === 'EPIPE') {
-          // Silently ignore - this happens during process shutdown
-        } else {
-          // Re-throw other errors
-          throw err;
-        }
-      }
-    };
-
-    safeLog(`[VS CODE COPILOT CLI] Checking availability and authentication...`);
-
-    return new Promise((resolve) => {
-      // First check if the CLI is installed
-      const baseEnv = { ...process.env };
-      if (!baseEnv.HOME) baseEnv.HOME = os.homedir();
-
-      const versionProc = spawn('copilot', ['--version'], { stdio: ['ignore', 'pipe', 'pipe'], env: baseEnv });
-      
-      let versionStdout = '';
-      let versionStderr = '';
-      let versionTimeout;
-      
-      versionProc.stdout.on('data', (data) => {
-        versionStdout += data.toString();
-        safeLog(`[VS CODE COPILOT CLI] Version check STDOUT: ${data.toString().trim()}`);
-      });
-      
-      versionProc.stderr.on('data', (data) => {
-        versionStderr += data.toString();
-        safeLog(`[VS CODE COPILOT CLI] Version check STDERR: ${data.toString().trim()}`);
-      });
-
-      versionProc.on('close', (versionCode) => {
-        clearTimeout(versionTimeout);
-        safeLog(`[VS CODE COPILOT CLI] Version check exited with code: ${versionCode}`);
-        
-        if (versionCode !== 0) {
-          safeLog(`[VS CODE COPILOT CLI] Not installed or not in PATH`);
-          resolve({ available: false, needsAuth: false });
-          return;
-        }
-
-        // CLI is installed, now check if it's authenticated using a short non-interactive prompt.
-        // Note: This CLI does not support `copilot whoami`, and GitHub CLI (`gh`) may not be installed.
-        // We keep this probe short and interpret device-flow output as needsAuth.
-        safeLog(`[VS CODE COPILOT CLI] CLI is installed, checking authentication (non-interactive probe)...`);
-
-        const probeArgs = ['-p', 'Reply with OK', '-s', '--no-ask-user'];
-        const probeProc = spawn('copilot', probeArgs, { stdio: ['ignore', 'pipe', 'pipe'], env: baseEnv });
-
-        let probeStdout = '';
-        let probeStderr = '';
-        let probeFinished = false;
-        const finishProbe = (code) => {
-          if (probeFinished) return;
-          probeFinished = true;
-          const out = (probeStdout || '').trim();
-          const err = (probeStderr || '').trim();
-          safeLog(`[VS CODE COPILOT CLI] Probe exited with code: ${code}`);
-          if (out) safeLog(`[VS CODE COPILOT CLI] Probe STDOUT: ${out.substring(0, 200)}`);
-          if (err) safeLog(`[VS CODE COPILOT CLI] Probe STDERR: ${err.substring(0, 200)}`);
-
-          // For copilot CLI, we consider it working if we get "OK" output even with exit code 1
-          // The --no-ask-user flag seems to cause exit code 1 but still provides the response
-          const isWorking = (code === 0 && out) || (code === 1 && out.trim() === 'OK');
-          
-          if (isWorking) {
-            resolve({ available: true, needsAuth: false, authMethod: 'existing' });
-            return;
-          }
-
-          const combined = `${out}\n${err}`;
-          
-          // Check for rate limit first
-          const isRateLimited = 
-            combined.includes('402 You have no quota') ||
-            combined.includes('quota') ||
-            combined.includes('rate limit') ||
-            combined.includes('Rate limit');
-            
-          if (isRateLimited) {
-            safeLog(`[VS CODE COPILOT CLI] Detected rate limit error`);
-            resolve({ available: true, needsAuth: false, authMethod: 'existing', rateLimited: true });
-            return;
-          }
-          
-          const needsAuth =
-            combined.includes('copilot login') ||
-            combined.includes('Authenticate with Copilot') ||
-            combined.includes('github.com/login/device') ||
-            combined.includes('To authenticate') ||
-            combined.includes('Waiting for authorization');
-
-          resolve({ available: true, needsAuth: Boolean(needsAuth), authMethod: needsAuth ? 'manual' : 'unknown' });
-        };
-
-        probeProc.stdout.on('data', (data) => { probeStdout += data.toString(); });
-        probeProc.stderr.on('data', (data) => { probeStderr += data.toString(); });
-        probeProc.on('close', (code) => finishProbe(code));
-        probeProc.on('error', () => finishProbe(1));
-        setTimeout(() => {
-          try { probeProc.kill(); } catch (_) { }
-          finishProbe(1);
-        }, 8000);
-      });
-      
-      versionProc.on('error', (err) => {
-        clearTimeout(versionTimeout);
-        safeLog(`[VS CODE COPILOT CLI] Version check error: ${err.message}`);
-        resolve({ available: false, needsAuth: false });
-      });
-      
-      versionTimeout = setTimeout(() => { 
-        safeLog(`[VS CODE COPILOT CLI] Version check timeout, killing process`);
-        versionProc.kill(); 
-        resolve({ available: false, needsAuth: false }); 
-      }, 5000);
-    });
-  }
-
-  /**
-   * Attempt to authenticate VS Code Copilot CLI automatically
-   * @returns {Promise<{success: boolean, method: string, reason?: string}>}
-   */
-  async attemptAutoAuthentication() {
-    const { spawn } = require('child_process');
-    
-    // Safe logging function to prevent EPIPE errors
-    const safeLog = (message) => {
-      try {
-        console.log(message);
-      } catch (err) {
-        // Ignore EPIPE errors that occur when stdout is closed
-        if (err.code === 'EPIPE') {
-          // Silently ignore - this happens during process shutdown
-        } else {
-          // Re-throw other errors
-          throw err;
-        }
-      }
-    };
-    
-    safeLog(`[VS CODE COPILOT CLI] Attempting auto-authentication...`);
-    
-    // Method 1: Check if GitHub CLI is authenticated and get token
-    try {
-      safeLog(`[VS CODE COPILOT CLI] Method 1: Checking GitHub CLI authentication...`);
-      const ghAuth = spawn('gh', ['auth', 'status'], { stdio: ['ignore', 'pipe', 'pipe'] });
-      
-      let ghStdout = '';
-      let ghStderr = '';
-      
-      ghAuth.stdout.on('data', (data) => {
-        ghStdout += data.toString();
-      });
-      
-      ghAuth.stderr.on('data', (data) => {
-        ghStderr += data.toString();
-      });
-      
-      const ghResult = await new Promise((resolve) => {
-        ghAuth.on('close', (code) => {
-          resolve({ code, stdout: ghStdout, stderr: ghStderr });
-        });
-        
-        ghAuth.on('error', () => {
-          resolve({ code: -1, stdout: '', stderr: 'gh command not found' });
-        });
-        
-        setTimeout(() => { ghAuth.kill(); resolve({ code: -1, stdout: '', stderr: 'timeout' }); }, 5000);
-      });
-      
-      if (ghResult.code === 0 && ghResult.stdout.includes('Logged in to')) {
-        safeLog(`[VS CODE COPILOT CLI] GitHub CLI is authenticated, getting token...`);
-        
-        // Get token from GitHub CLI
-        const ghToken = spawn('gh', ['auth', 'token'], { stdio: ['ignore', 'pipe', 'pipe'] });
-        
-        let tokenStdout = '';
-        let tokenStderr = '';
-        
-        ghToken.stdout.on('data', (data) => {
-          tokenStdout += data.toString();
-        });
-        
-        ghToken.stderr.on('data', (data) => {
-          tokenStderr += data.toString();
-        });
-        
-        const tokenResult = await new Promise((resolve) => {
-          ghToken.on('close', (code) => {
-            resolve({ code, stdout: tokenStdout, stderr: tokenStderr });
-          });
-          
-          ghToken.on('error', () => {
-            resolve({ code: 1, stdout: '', stderr: 'Failed to spawn gh auth token' });
-          });
-          
-          setTimeout(() => {
-            try { ghToken.kill(); } catch (_) { }
-            resolve({ code: 1, stdout: '', stderr: 'Timeout getting token' });
-          }, 5000);
-        });
-        
-        if (tokenResult.code === 0 && tokenResult.stdout) {
-          safeLog(`[VS CODE COPILOT CLI] Got token from GitHub CLI, testing with Copilot CLI...`);
-          
-          // Test the token with Copilot CLI
-          const testResult = await this.testTokenWithCopilot(tokenResult.stdout);
-          if (testResult.success) {
-            return { success: true, method: 'github-cli' };
-          } else {
-            safeLog(`[VS CODE COPILOT CLI] GitHub CLI token failed with Copilot: ${testResult.reason}`);
-          }
-        }
-      }
-    } catch (error) {
-      safeLog(`[VS CODE COPILOT CLI] GitHub CLI method failed: ${error.message}`);
-    }
-    
-    // Method 2: Check environment variables
-    safeLog(`[VS CODE COPILOT CLI] Method 2: Checking environment variables...`);
-    const envVars = ['COPILOT_GITHUB_TOKEN', 'GH_TOKEN', 'GITHUB_TOKEN'];
-    
-    for (const envVar of envVars) {
-      const token = process.env[envVar];
-      if (token) {
-        safeLog(`[VS CODE COPILOT CLI] Found ${envVar}, testing with Copilot CLI...`);
-        
-        const testResult = await this.testTokenWithCopilot(token);
-        if (testResult.success) {
-          return { success: true, method: `env-${envVar}` };
-        } else {
-          safeLog(`[VS CODE COPILOT CLI] ${envVar} token failed with Copilot: ${testResult.reason}`);
-        }
-      }
-    }
-    
-    safeLog(`[VS CODE COPILOT CLI] All auto-authentication methods failed`);
-    return { success: false, method: 'none', reason: 'No valid authentication found' };
-  }
-
-  /**
-   * Test if a token works with VS Code Copilot CLI
-   * @param {string} token - GitHub token to test
-   * @returns {Promise<{success: boolean, reason?: string}>}
-   */
-  async testTokenWithCopilot(token) {
-    const { spawn } = require('child_process');
-    
-    return new Promise((resolve) => {
-      const env = { ...process.env, COPILOT_GITHUB_TOKEN: token };
-      
-      const testProc = spawn('copilot', ['-p', 'test', '-s'], { 
-        stdio: ['ignore', 'pipe', 'pipe'],
-        env,
-        timeout: 5000
-      });
-      
-      let stderr = '';
-      
-      testProc.stderr.on('data', (data) => {
-        stderr += data.toString();
-      });
-      
-      testProc.on('close', (code) => {
-        const needsAuth = stderr.includes('No authentication information found') ||
-                         stderr.includes('authentication information found') ||
-                         stderr.includes('not authenticated');
-        
-        if (needsAuth) {
-          resolve({ success: false, reason: 'Token not valid for Copilot CLI' });
-        } else {
-          resolve({ success: true });
-        }
-      });
-      
-      testProc.on('error', (err) => {
-        resolve({ success: false, reason: err.message });
-      });
-      
-      setTimeout(() => { 
-        testProc.kill(); 
-        resolve({ success: false, reason: 'timeout' }); 
-      }, 5000);
-    });
-  }
-
-  /**
-   * 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, fallbackModels = [] } = config;
-    const modelsToTry = [model, ...fallbackModels];
-    let lastError = null;
-
-    for (const currentModel of modelsToTry) {
-      if (currentModel !== model) {
-        this.logger.log(`⚠️  Quota/Limit reached for previous model, failing over to ${currentModel}...`);
-      }
-
-      const agentId = `${provider}:${currentModel}`;
-      try {
-        const quota = await quotaManagement.fetchQuotaForAgent(agentId);
-        if (quota.isExceeded()) {
-          const errorMessage = `Quota limit reached for ${currentModel}. Resets at ${quota.resetsAt ? quota.resetsAt.toLocaleString() : 'a later time'}.`;
-          lastError = { success: false, error: errorMessage };
-          continue; // Try next model
-        }
-      } catch (error) {
-        this.logger.error(`Failed to check quota for ${agentId}: ${error.message}`);
-      }
-
-      const currentConfig = { ...config, model: currentModel };
-      let result;
-
-      switch (provider) {
-        case 'ollama':
-          result = await this.callOllama(currentModel, prompt, options);
-          break;
-        case 'anthropic':
-          result = await this.callAnthropic(currentModel, prompt, { ...options, apiKey });
-          break;
-        case 'groq':
-          result = await this.callGroq(currentModel, prompt, { ...options, apiKey });
-          break;
-        case 'bedrock':
-          result = await this.callBedrock(currentModel, prompt, { ...options, region, accessKeyId, secretAccessKey });
-          break;
-        case 'claude-code':
-          result = await this.callClaudeCode(currentModel, prompt, options);
-          break;
-        case 'cline':
-          result = await this.callCline(currentModel, prompt, options);
-          break;
-        case 'opencode':
-          result = await this.callOpenCode(currentModel, prompt, options);
-          break;
-        case 'vscode-copilot-cli':
-          result = await this.callVSCodeCopilotCLI(currentModel, prompt, options);
-          break;
-        default:
-          return { success: false, error: `Unknown provider: ${provider}` };
-      }
-
-      if (result.success) {
-        return result;
-      }
-
-      // If failed, check for rate limit to save it
-      this.detectAndSaveRateLimit(provider, currentModel, result.error || '');
-      lastError = result;
-
-      // If it's a "fatal" error that isn't a rate limit, we might want to stop? 
-      // But usually we want to try the next model if possible.
-    }
-
-    return lastError || { success: false, error: `All models for ${provider} failed.` };
-  }
-
-  /**
-   * 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');
+const quotaManagement = require('../quota-management');
+
+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')) &&
+      !errorMessage.startsWith('Quota limit reached'); // Don't re-mark our own internal exceeded messages
+
+    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 the Cline CLI with a prompt via stdin
+   */
+  async callCline(model, prompt, options = {}) {
+    const { onChunk, onComplete, onError } = options;
+    const { spawn } = require('child_process');
+
+    return new Promise((resolve) => {
+      let fullResponse = '';
+      let errorOutput = '';
+
+      const cline = spawn('cline', ['--dangerously-skip-permissions'], {
+        stdio: ['pipe', 'pipe', 'pipe']
+      });
+
+      cline.stdin.write(prompt);
+      cline.stdin.end();
+
+      cline.stdout.on('data', (data) => {
+        const chunk = data.toString();
+        fullResponse += chunk;
+        if (onChunk) onChunk(chunk);
+      });
+
+      cline.stderr.on('data', (data) => {
+        errorOutput += data.toString();
+      });
+
+      cline.on('close', (code) => {
+        if (code === 0) {
+          if (onComplete) onComplete(fullResponse);
+          resolve({ success: true, response: fullResponse });
+        } else {
+          const error = `Cline CLI exited with code ${code}: ${errorOutput}`;
+          if (onError) onError(error);
+          this.detectAndSaveRateLimit('cline', 'cline-cli', errorOutput);
+          resolve({ success: false, error });
+        }
+      });
+
+      cline.on('error', (err) => {
+        const error = `Failed to start Cline CLI: ${err.message}`;
+        if (onError) onError(error);
+        resolve({ success: false, error });
+      });
+    });
+  }
+
+  /**
+   * Check if Cline CLI is available
+   */
+  async isClineAvailable() {
+    const { spawn } = require('child_process');
+    return new Promise((resolve) => {
+      const proc = spawn('cline', ['--version'], { stdio: ['ignore', 'pipe', 'pipe'] });
+      proc.on('close', (code) => resolve(code === 0));
+      proc.on('error', () => resolve(false));
+      setTimeout(() => { proc.kill(); resolve(false); }, 2000);
+    });
+  }
+
+  /**
+   * Call the OpenCode CLI with a prompt via -p flag
+   */
+  async callOpenCode(model, prompt, options = {}) {
+    const { onChunk, onComplete, onError } = options;
+    const { spawn } = require('child_process');
+    const path = require('path');
+    const os = require('os');
+
+    return new Promise((resolve) => {
+      let fullResponse = '';
+      let errorOutput = '';
+
+      // Resolve opencode binary — check well-known path first
+      let cmd = 'opencode';
+      const knownPath = path.join(os.homedir(), '.opencode', 'bin', 'opencode');
+      try {
+        require('fs').accessSync(knownPath, require('fs').constants.X_OK);
+        cmd = knownPath;
+      } catch {
+        // fall back to PATH lookup
+      }
+
+      const opencode = spawn(cmd, ['-p', prompt], {
+        stdio: ['ignore', 'pipe', 'pipe']
+      });
+
+      opencode.stdout.on('data', (data) => {
+        const chunk = data.toString();
+        fullResponse += chunk;
+        if (onChunk) onChunk(chunk);
+      });
+
+      opencode.stderr.on('data', (data) => {
+        errorOutput += data.toString();
+      });
+
+      opencode.on('close', (code) => {
+        if (code === 0) {
+          if (onComplete) onComplete(fullResponse);
+          resolve({ success: true, response: fullResponse });
+        } else {
+          const error = `OpenCode CLI exited with code ${code}: ${errorOutput}`;
+          if (onError) onError(error);
+          this.detectAndSaveRateLimit('opencode', 'opencode-cli', errorOutput);
+          resolve({ success: false, error });
+        }
+      });
+
+      opencode.on('error', (err) => {
+        const error = `Failed to start OpenCode CLI: ${err.message}`;
+        if (onError) onError(error);
+        resolve({ success: false, error });
+      });
+    });
+  }
+
+  /**
+   * Check if OpenCode CLI is available
+   * @returns {Promise<boolean>}
+   */
+  async isOpenCodeAvailable() {
+    const { spawn } = require('child_process');
+    const path = require('path');
+    const os = require('os');
+
+    // Try well-known path first, then fall back to PATH
+    let cmd = 'opencode';
+    const knownPath = path.join(os.homedir(), '.opencode', 'bin', 'opencode');
+    try {
+      require('fs').accessSync(knownPath, require('fs').constants.X_OK);
+      cmd = knownPath;
+    } catch {
+      // fall back to PATH lookup
+    }
+
+    return new Promise((resolve) => {
+      const proc = spawn(cmd, ['--version'], { stdio: ['ignore', 'pipe', 'pipe'] });
+      proc.on('close', (code) => resolve(code === 0));
+      proc.on('error', () => resolve(false));
+      setTimeout(() => { proc.kill(); resolve(false); }, 5000);
+    });
+  }
+
+  /**
+   * Call the VS Code Copilot CLI with a prompt
+   */
+  async callVSCodeCopilotCLI(model, prompt, options = {}) {
+    const { onChunk, onComplete, onError } = options;
+    const { spawn } = require('child_process');
+    const os = require('os');
+
+    // Safe logging function to prevent EPIPE errors
+    const safeLog = (message) => {
+      try {
+        console.log(message);
+      } catch (err) {
+        // Ignore EPIPE errors that occur when stdout is closed
+        if (err.code === 'EPIPE') {
+          // Silently ignore - this happens during process shutdown
+        } else {
+          // Re-throw other errors
+          throw err;
+        }
+      }
+    };
+
+    safeLog(`[VS CODE COPILOT CLI] Starting call with model: ${model}`);
+    safeLog(`[VS CODE COPILOT CLI] Prompt: ${prompt.substring(0, 100)}...`);
+
+    // Set up environment with authentication if available
+    const env = { ...process.env };
+    if (!env.HOME) env.HOME = os.homedir();
+    
+    return new Promise((resolve) => {
+      let fullResponse = '';
+      let errorOutput = '';
+
+      // Non-interactive prompt invocation
+      // `copilot` uses `-p/--prompt` for non-interactive mode.
+      const args = ['-p', String(prompt), '-s', '--no-ask-user'];
+      const copilot = spawn('copilot', args, {
+        stdio: ['ignore', 'pipe', 'pipe'],
+        cwd: process.cwd(),
+        env
+      });
+
+      safeLog(`[VS CODE COPILOT CLI] Spawned process with PID: ${copilot.pid}`);
+
+      copilot.stdout.on('data', (data) => {
+        const text = data.toString();
+        fullResponse += text;
+        safeLog(`[VS CODE COPILOT CLI] STDOUT: ${text.substring(0, 200)}...`);
+        if (onChunk) onChunk(text);
+      });
+
+      copilot.stderr.on('data', (data) => {
+        const text = data.toString();
+        errorOutput += text;
+        safeLog(`[VS CODE COPILOT CLI] STDERR: ${text.substring(0, 200)}...`);
+      });
+
+      copilot.on('close', (code) => {
+        safeLog(`[VS CODE COPILOT CLI] Process closed with code: ${code}`);
+        safeLog(`[VS CODE COPILOT CLI] Full response length: ${fullResponse.length}`);
+        safeLog(`[VS CODE COPILOT CLI] Error output length: ${errorOutput.length}`);
+        safeLog(`[VS CODE COPILOT CLI] Error output: ${errorOutput}`);
+        
+        if (code === 0) {
+          if (onComplete) onComplete(fullResponse);
+          resolve({ success: true, response: fullResponse });
+        } else {
+          // Check if this is an authentication error and provide a helpful message
+          const isAuthError = this.checkForAuthenticationError(errorOutput);
+          let error = `VS Code Copilot CLI exited with code ${code}: ${errorOutput}`;
+          
+          if (isAuthError) {
+            error = `VS Code Copilot CLI requires authentication. Run 'copilot login' to authenticate with GitHub, or set COPILOT_GITHUB_TOKEN environment variable.`;
+            safeLog(`[VS CODE COPILOT CLI] Authentication error detected: ${error}`);
+
+            // If we had previously marked this provider as rate limited, clear that stale state.
+            // Auth/setup failures should never surface as rate limit in the GUI.
+            try {
+              if (this.providerManager && typeof this.providerManager.clearProviderRateLimits === 'function') {
+                this.providerManager.clearProviderRateLimits('vscode-copilot-cli');
+              }
+            } catch (_) { }
+          }
+          
+          safeLog(`[VS CODE COPILOT CLI] Error: ${error}`);
+          if (onError) onError(error);
+          
+          // Check if this is actually a rate limit error before calling detectAndSaveRateLimit
+          const isRateLimitError = this.checkForRateLimitError(errorOutput);
+          safeLog(`[VS CODE COPILOT CLI] Is rate limit error: ${isRateLimitError}`);
+          
+          if (isRateLimitError) {
+            this.detectAndSaveRateLimit('vscode-copilot-cli', 'copilot-cli', errorOutput);
+          }
+          
+          resolve({ success: false, error });
+        }
+      });
+
+      copilot.on('error', (err) => {
+        const error = `Failed to start VS Code Copilot CLI: ${err.message}`;
+        safeLog(`[VS CODE COPILOT CLI] Spawn error: ${error}`);
+        if (onError) onError(error);
+        resolve({ success: false, error });
+      });
+    });
+  }
+
+  /**
+   * Check if error output indicates an authentication error
+   */
+  checkForAuthenticationError(errorOutput) {
+    const authIndicators = [
+      'No authentication information found',
+      'authentication information found',
+      'not authenticated',
+      'COPILOT_GITHUB_TOKEN',
+      'GH_TOKEN',
+      'GITHUB_TOKEN',
+      '/login',
+      'gh auth login',
+      'OAuth Token',
+      'Personal Access Token'
+    ];
+
+    const isAuthError = authIndicators.some(indicator => 
+      errorOutput.includes(indicator)
+    );
+
+    console.log(`[AUTH CHECK] Error output: "${errorOutput}"`);
+    console.log(`[AUTH CHECK] Is authentication error: ${isAuthError}`);
+
+    return isAuthError;
+  }
+
+  /**
+   * Check if error output indicates a genuine rate limit error
+   */
+  checkForRateLimitError(errorOutput) {
+    // VS Code Copilot CLI specific rate limit indicators
+    const rateLimitIndicators = [
+      'rate limit',
+      'Rate limit',
+      'too many requests',
+      'Too many requests',
+      '429',
+      'quota exceeded',
+      'Quota exceeded',
+      'usage limit',
+      'Usage limit',
+      'limit reached',
+      'Limit reached',
+      'weekly limit',
+      'Weekly limit',
+      'daily limit',
+      'Daily limit'
+    ];
+
+    // Exclude common authentication and setup errors that are NOT rate limits
+    const nonRateLimitIndicators = [
+      'authentication information found',
+      'Authentication information found',
+      'No authentication',
+      'not authenticated',
+      'COPILOT_GITHUB_TOKEN',
+      'GH_TOKEN',
+      'GITHUB_TOKEN',
+      '/login',
+      'gh auth login',
+      'OAuth Token',
+      'Personal Access Token',
+      'GitHub CLI'
+    ];
+
+    // First check if it contains non-rate-limit indicators
+    const isNonRateLimit = nonRateLimitIndicators.some(indicator => 
+      errorOutput.includes(indicator)
+    );
+
+    if (isNonRateLimit) {
+      console.log(`[RATE LIMIT CHECK] Contains non-rate-limit indicators, not a rate limit`);
+      return false;
+    }
+
+    // Only consider it a rate limit if it contains specific rate limit indicators
+    const isRateLimit = rateLimitIndicators.some(indicator => 
+      errorOutput.includes(indicator)
+    );
+
+    console.log(`[RATE LIMIT CHECK] Error output: "${errorOutput}"`);
+    console.log(`[RATE LIMIT CHECK] Is rate limit: ${isRateLimit}`);
+
+    return isRateLimit;
+  }
+
+  /**
+   * Check if VS Code Copilot CLI is available AND authenticated
+   * @returns {Promise<{available: boolean, needsAuth: boolean, authMethod?: string}>}
+   */
+  async isVSCodeCopilotCLIAvailable() {
+    const { spawn } = require('child_process');
+    const os = require('os');
+
+    // Safe logging function to prevent EPIPE errors
+    const safeLog = (message) => {
+      try {
+        console.log(message);
+      } catch (err) {
+        // Ignore EPIPE errors that occur when stdout is closed
+        if (err.code === 'EPIPE') {
+          // Silently ignore - this happens during process shutdown
+        } else {
+          // Re-throw other errors
+          throw err;
+        }
+      }
+    };
+
+    safeLog(`[VS CODE COPILOT CLI] Checking availability and authentication...`);
+
+    return new Promise((resolve) => {
+      // First check if the CLI is installed
+      const baseEnv = { ...process.env };
+      if (!baseEnv.HOME) baseEnv.HOME = os.homedir();
+
+      const versionProc = spawn('copilot', ['--version'], { stdio: ['ignore', 'pipe', 'pipe'], env: baseEnv });
+      
+      let versionStdout = '';
+      let versionStderr = '';
+      let versionTimeout;
+      
+      versionProc.stdout.on('data', (data) => {
+        versionStdout += data.toString();
+        safeLog(`[VS CODE COPILOT CLI] Version check STDOUT: ${data.toString().trim()}`);
+      });
+      
+      versionProc.stderr.on('data', (data) => {
+        versionStderr += data.toString();
+        safeLog(`[VS CODE COPILOT CLI] Version check STDERR: ${data.toString().trim()}`);
+      });
+
+      versionProc.on('close', (versionCode) => {
+        clearTimeout(versionTimeout);
+        safeLog(`[VS CODE COPILOT CLI] Version check exited with code: ${versionCode}`);
+        
+        if (versionCode !== 0) {
+          safeLog(`[VS CODE COPILOT CLI] Not installed or not in PATH`);
+          resolve({ available: false, needsAuth: false });
+          return;
+        }
+
+        // CLI is installed, now check if it's authenticated using a short non-interactive prompt.
+        // Note: This CLI does not support `copilot whoami`, and GitHub CLI (`gh`) may not be installed.
+        // We keep this probe short and interpret device-flow output as needsAuth.
+        safeLog(`[VS CODE COPILOT CLI] CLI is installed, checking authentication (non-interactive probe)...`);
+
+        const probeArgs = ['-p', 'Reply with OK', '-s', '--no-ask-user'];
+        const probeProc = spawn('copilot', probeArgs, { stdio: ['ignore', 'pipe', 'pipe'], env: baseEnv });
+
+        let probeStdout = '';
+        let probeStderr = '';
+        let probeFinished = false;
+        const finishProbe = (code) => {
+          if (probeFinished) return;
+          probeFinished = true;
+          const out = (probeStdout || '').trim();
+          const err = (probeStderr || '').trim();
+          safeLog(`[VS CODE COPILOT CLI] Probe exited with code: ${code}`);
+          if (out) safeLog(`[VS CODE COPILOT CLI] Probe STDOUT: ${out.substring(0, 200)}`);
+          if (err) safeLog(`[VS CODE COPILOT CLI] Probe STDERR: ${err.substring(0, 200)}`);
+
+          // For copilot CLI, we consider it working if we get "OK" output even with exit code 1
+          // The --no-ask-user flag seems to cause exit code 1 but still provides the response
+          const isWorking = (code === 0 && out) || (code === 1 && out.trim() === 'OK');
+          
+          if (isWorking) {
+            resolve({ available: true, needsAuth: false, authMethod: 'existing' });
+            return;
+          }
+
+          const combined = `${out}\n${err}`;
+          
+          // Check for rate limit first
+          const isRateLimited = 
+            combined.includes('402 You have no quota') ||
+            combined.includes('quota') ||
+            combined.includes('rate limit') ||
+            combined.includes('Rate limit');
+            
+          if (isRateLimited) {
+            safeLog(`[VS CODE COPILOT CLI] Detected rate limit error`);
+            resolve({ available: true, needsAuth: false, authMethod: 'existing', rateLimited: true });
+            return;
+          }
+          
+          const needsAuth =
+            combined.includes('copilot login') ||
+            combined.includes('Authenticate with Copilot') ||
+            combined.includes('github.com/login/device') ||
+            combined.includes('To authenticate') ||
+            combined.includes('Waiting for authorization');
+
+          resolve({ available: true, needsAuth: Boolean(needsAuth), authMethod: needsAuth ? 'manual' : 'unknown' });
+        };
+
+        probeProc.stdout.on('data', (data) => { probeStdout += data.toString(); });
+        probeProc.stderr.on('data', (data) => { probeStderr += data.toString(); });
+        probeProc.on('close', (code) => finishProbe(code));
+        probeProc.on('error', () => finishProbe(1));
+        setTimeout(() => {
+          try { probeProc.kill(); } catch (_) { }
+          finishProbe(1);
+        }, 8000);
+      });
+      
+      versionProc.on('error', (err) => {
+        clearTimeout(versionTimeout);
+        safeLog(`[VS CODE COPILOT CLI] Version check error: ${err.message}`);
+        resolve({ available: false, needsAuth: false });
+      });
+      
+      versionTimeout = setTimeout(() => { 
+        safeLog(`[VS CODE COPILOT CLI] Version check timeout, killing process`);
+        versionProc.kill(); 
+        resolve({ available: false, needsAuth: false }); 
+      }, 5000);
+    });
+  }
+
+  /**
+   * Attempt to authenticate VS Code Copilot CLI automatically
+   * @returns {Promise<{success: boolean, method: string, reason?: string}>}
+   */
+  async attemptAutoAuthentication() {
+    const { spawn } = require('child_process');
+    
+    // Safe logging function to prevent EPIPE errors
+    const safeLog = (message) => {
+      try {
+        console.log(message);
+      } catch (err) {
+        // Ignore EPIPE errors that occur when stdout is closed
+        if (err.code === 'EPIPE') {
+          // Silently ignore - this happens during process shutdown
+        } else {
+          // Re-throw other errors
+          throw err;
+        }
+      }
+    };
+    
+    safeLog(`[VS CODE COPILOT CLI] Attempting auto-authentication...`);
+    
+    // Method 1: Check if GitHub CLI is authenticated and get token
+    try {
+      safeLog(`[VS CODE COPILOT CLI] Method 1: Checking GitHub CLI authentication...`);
+      const ghAuth = spawn('gh', ['auth', 'status'], { stdio: ['ignore', 'pipe', 'pipe'] });
+      
+      let ghStdout = '';
+      let ghStderr = '';
+      
+      ghAuth.stdout.on('data', (data) => {
+        ghStdout += data.toString();
+      });
+      
+      ghAuth.stderr.on('data', (data) => {
+        ghStderr += data.toString();
+      });
+      
+      const ghResult = await new Promise((resolve) => {
+        ghAuth.on('close', (code) => {
+          resolve({ code, stdout: ghStdout, stderr: ghStderr });
+        });
+        
+        ghAuth.on('error', () => {
+          resolve({ code: -1, stdout: '', stderr: 'gh command not found' });
+        });
+        
+        setTimeout(() => { ghAuth.kill(); resolve({ code: -1, stdout: '', stderr: 'timeout' }); }, 5000);
+      });
+      
+      if (ghResult.code === 0 && ghResult.stdout.includes('Logged in to')) {
+        safeLog(`[VS CODE COPILOT CLI] GitHub CLI is authenticated, getting token...`);
+        
+        // Get token from GitHub CLI
+        const ghToken = spawn('gh', ['auth', 'token'], { stdio: ['ignore', 'pipe', 'pipe'] });
+        
+        let tokenStdout = '';
+        let tokenStderr = '';
+        
+        ghToken.stdout.on('data', (data) => {
+          tokenStdout += data.toString();
+        });
+        
+        ghToken.stderr.on('data', (data) => {
+          tokenStderr += data.toString();
+        });
+        
+        const tokenResult = await new Promise((resolve) => {
+          ghToken.on('close', (code) => {
+            resolve({ code, stdout: tokenStdout, stderr: tokenStderr });
+          });
+          
+          ghToken.on('error', () => {
+            resolve({ code: 1, stdout: '', stderr: 'Failed to spawn gh auth token' });
+          });
+          
+          setTimeout(() => {
+            try { ghToken.kill(); } catch (_) { }
+            resolve({ code: 1, stdout: '', stderr: 'Timeout getting token' });
+          }, 5000);
+        });
+        
+        if (tokenResult.code === 0 && tokenResult.stdout) {
+          safeLog(`[VS CODE COPILOT CLI] Got token from GitHub CLI, testing with Copilot CLI...`);
+          
+          // Test the token with Copilot CLI
+          const testResult = await this.testTokenWithCopilot(tokenResult.stdout);
+          if (testResult.success) {
+            return { success: true, method: 'github-cli' };
+          } else {
+            safeLog(`[VS CODE COPILOT CLI] GitHub CLI token failed with Copilot: ${testResult.reason}`);
+          }
+        }
+      }
+    } catch (error) {
+      safeLog(`[VS CODE COPILOT CLI] GitHub CLI method failed: ${error.message}`);
+    }
+    
+    // Method 2: Check environment variables
+    safeLog(`[VS CODE COPILOT CLI] Method 2: Checking environment variables...`);
+    const envVars = ['COPILOT_GITHUB_TOKEN', 'GH_TOKEN', 'GITHUB_TOKEN'];
+    
+    for (const envVar of envVars) {
+      const token = process.env[envVar];
+      if (token) {
+        safeLog(`[VS CODE COPILOT CLI] Found ${envVar}, testing with Copilot CLI...`);
+        
+        const testResult = await this.testTokenWithCopilot(token);
+        if (testResult.success) {
+          return { success: true, method: `env-${envVar}` };
+        } else {
+          safeLog(`[VS CODE COPILOT CLI] ${envVar} token failed with Copilot: ${testResult.reason}`);
+        }
+      }
+    }
+    
+    safeLog(`[VS CODE COPILOT CLI] All auto-authentication methods failed`);
+    return { success: false, method: 'none', reason: 'No valid authentication found' };
+  }
+
+  /**
+   * Test if a token works with VS Code Copilot CLI
+   * @param {string} token - GitHub token to test
+   * @returns {Promise<{success: boolean, reason?: string}>}
+   */
+  async testTokenWithCopilot(token) {
+    const { spawn } = require('child_process');
+    
+    return new Promise((resolve) => {
+      const env = { ...process.env, COPILOT_GITHUB_TOKEN: token };
+      
+      const testProc = spawn('copilot', ['-p', 'test', '-s'], { 
+        stdio: ['ignore', 'pipe', 'pipe'],
+        env,
+        timeout: 5000
+      });
+      
+      let stderr = '';
+      
+      testProc.stderr.on('data', (data) => {
+        stderr += data.toString();
+      });
+      
+      testProc.on('close', (code) => {
+        const needsAuth = stderr.includes('No authentication information found') ||
+                         stderr.includes('authentication information found') ||
+                         stderr.includes('not authenticated');
+        
+        if (needsAuth) {
+          resolve({ success: false, reason: 'Token not valid for Copilot CLI' });
+        } else {
+          resolve({ success: true });
+        }
+      });
+      
+      testProc.on('error', (err) => {
+        resolve({ success: false, reason: err.message });
+      });
+      
+      setTimeout(() => { 
+        testProc.kill(); 
+        resolve({ success: false, reason: 'timeout' }); 
+      }, 5000);
+    });
+  }
+
+  /**
+   * 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, fallbackModels = [] } = config;
+    const modelsToTry = [model, ...fallbackModels];
+    let lastError = null;
+
+    for (const currentModel of modelsToTry) {
+      if (currentModel !== model) {
+        this.logger.log(`⚠️  Quota/Limit reached for previous model, failing over to ${currentModel}...`);
+      }
+
+      const agentId = `${provider}:${currentModel}`;
+      try {
+        const quota = await quotaManagement.fetchQuotaForAgent(agentId);
+        if (quota.isExceeded()) {
+          const errorMessage = `Quota limit reached for ${currentModel}. Resets at ${quota.resetsAt ? quota.resetsAt.toLocaleString() : 'a later time'}.`;
+          lastError = { success: false, error: errorMessage };
+          continue; // Try next model
+        }
+      } catch (error) {
+        this.logger.error(`Failed to check quota for ${agentId}: ${error.message}`);
+      }
+
+      const currentConfig = { ...config, model: currentModel };
+      let result;
+
+      switch (provider) {
+        case 'ollama':
+          result = await this.callOllama(currentModel, prompt, options);
+          break;
+        case 'anthropic':
+          result = await this.callAnthropic(currentModel, prompt, { ...options, apiKey });
+          break;
+        case 'groq':
+          result = await this.callGroq(currentModel, prompt, { ...options, apiKey });
+          break;
+        case 'bedrock':
+          result = await this.callBedrock(currentModel, prompt, { ...options, region, accessKeyId, secretAccessKey });
+          break;
+        case 'claude-code':
+          result = await this.callClaudeCode(currentModel, prompt, options);
+          break;
+        case 'cline':
+          result = await this.callCline(currentModel, prompt, options);
+          break;
+        case 'opencode':
+          result = await this.callOpenCode(currentModel, prompt, options);
+          break;
+        case 'vscode-copilot-cli':
+          result = await this.callVSCodeCopilotCLI(currentModel, prompt, options);
+          break;
+        default:
+          return { success: false, error: `Unknown provider: ${provider}` };
+      }
+
+      if (result.success) {
+        return result;
+      }
+
+      // If failed, check for rate limit to save it
+      this.detectAndSaveRateLimit(provider, currentModel, result.error || '');
+      lastError = result;
+
+      // If it's a "fatal" error that isn't a rate limit, we might want to stop? 
+      // But usually we want to try the next model if possible.
+    }
+
+    return lastError || { success: false, error: `All models for ${provider} failed.` };
+  }
+
+  /**
+   * 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;
+