gitarsenal-cli 1.9.25 → 1.9.27

package/python/llm_debugging.py

@@ -2,362 +2,189 @@ import os
 import re
 import json
 import requests
-import openai
-import anthropic
 import time
 import getpass
+from pathlib import Path
 
 
 def get_stored_credentials():
     """Load stored credentials from ~/.gitarsenal/credentials.json"""
-    import json
-    from pathlib import Path
-    
     try:
         credentials_file = Path.home() / ".gitarsenal" / "credentials.json"
         if credentials_file.exists():
             with open(credentials_file, 'r') as f:
-                credentials = json.load(f)
-            return credentials
-        else:
-            return {}
+                return json.load(f)
+        return {}
     except Exception as e:
         print(f"⚠️ Error loading stored credentials: {e}")
         return {}
 
+
 def generate_auth_context(stored_credentials):
-    """Generate simple authentication context for the OpenAI prompt"""
+    """Generate authentication context for the LLM prompt"""
     if not stored_credentials:
         return "No stored credentials available."
     
     auth_context = "Available stored credentials (use actual values in commands):\n"
-    
     for key, value in stored_credentials.items():
-        # Mask the actual value for security in logs, but provide the real value
         masked_value = value[:8] + "..." if len(value) > 8 else "***"
         auth_context += f"- {key}: {masked_value} (actual value: {value})\n"
     
     return auth_context
 
+
 def get_current_debug_model():
     """Get the currently configured debugging model preference"""
-    return os.environ.get("GITARSENAL_DEBUG_MODEL", "anthropic")
+    return os.environ.get("GITARSENAL_DEBUG_MODEL", "openai")
 
-def call_llm_for_debug(command, error_output, api_key=None, current_dir=None, sandbox=None):
-    """Unified function to call LLM for debugging - routes to OpenAI, Anthropic, or OpenRouter based on configuration"""
-    current_model = get_current_debug_model()
-    
-    print(f"🔍 DEBUG: Using {current_model.upper()} for debugging...")
-    
-    if current_model == "anthropic":
-        # Try to get Anthropic API key if not provided
-        if not api_key:
-            # First try environment variable
-            api_key = os.environ.get("ANTHROPIC_API_KEY")
-            
-            # If not in environment, try to fetch from server using fetch_modal_tokens
-            if not api_key:
-                try:
-                    from fetch_modal_tokens import get_tokens
-                    _, _, _, api_key = get_tokens()
-                except Exception as e:
-                    print(f"⚠️ Error fetching Anthropic API key from server: {e}")
-            
-            # Then try credentials manager
-            if not api_key:
-                try:
-                    from credentials_manager import CredentialsManager
-                    credentials_manager = CredentialsManager()
-                    api_key = credentials_manager.get_anthropic_api_key()
-                except Exception as e:
-                    print(f"⚠️ Error getting Anthropic API key from credentials manager: {e}")
-        
-        return call_anthropic_for_debug(command, error_output, api_key, current_dir, sandbox)
-    elif current_model == "openrouter":
-        # Try to get OpenRouter API key if not provided
-        if not api_key:
-            # First try environment variable
-            api_key = os.environ.get("OPENROUTER_API_KEY")
-            
-            # If not in environment, try to fetch from server using fetch_modal_tokens
-            if not api_key:
-                try:
-                    from fetch_modal_tokens import get_tokens
-                    # Assuming OpenRouter key is the 5th token in the tuple
-                    tokens = get_tokens()
-                    if len(tokens) >= 5:
-                        api_key = tokens[4]
-                except Exception as e:
-                    print(f"⚠️ Error fetching OpenRouter API key from server: {e}")
-            
-            # Then try credentials manager
-            if not api_key:
-                try:
-                    from credentials_manager import CredentialsManager
-                    credentials_manager = CredentialsManager()
-                    api_key = credentials_manager.get_openrouter_api_key()
-                except Exception as e:
-                    print(f"⚠️ Error getting OpenRouter API key from credentials manager: {e}")
-        
-        return call_openrouter_for_debug(command, error_output, api_key, current_dir, sandbox)
-    else:
-        # Default to OpenAI
-        # Try to get OpenAI API key if not provided
-        if not api_key:
-            # First try environment variable
-            api_key = os.environ.get("OPENAI_API_KEY")
-            
-            # If not in environment, try to fetch from server using fetch_modal_tokens
-            if not api_key:
-                try:
-                    from fetch_modal_tokens import get_tokens
-                    _, _, api_key, _ = get_tokens()
-                except Exception as e:
-                    print(f"⚠️ Error fetching OpenAI API key from server: {e}")
-            
-            # Then try credentials manager
-            if not api_key:
-                try:
-                    from credentials_manager import CredentialsManager
-                    credentials_manager = CredentialsManager()
-                    api_key = credentials_manager.get_openai_api_key()
-                except Exception as e:
-                    print(f"⚠️ Error getting OpenAI API key from credentials manager: {e}")
-        
-        return call_openai_for_debug(command, error_output, api_key, current_dir, sandbox)
 
-def call_openai_for_debug(command, error_output, api_key=None, current_dir=None, sandbox=None):
-    """Call OpenAI to debug a failed command and suggest a fix"""
-    print("\n🔍 DEBUG: Starting LLM debugging...")
-    print(f"🔍 DEBUG: Command: {command}")
-    print(f"🔍 DEBUG: Error output length: {len(error_output) if error_output else 0}")
-    print(f"🔍 DEBUG: Current directory: {current_dir}")
-    print(f"🔍 DEBUG: Sandbox available: {sandbox is not None}")
+def _to_str(maybe_bytes):
+    """Convert bytes to string safely"""
+    try:
+        return maybe_bytes.decode('utf-8') if isinstance(maybe_bytes, (bytes, bytearray)) else maybe_bytes
+    except UnicodeDecodeError:
+        if isinstance(maybe_bytes, (bytes, bytearray)):
+            return maybe_bytes.decode('utf-8', errors='replace')
+        return str(maybe_bytes)
+    except Exception:
+        return str(maybe_bytes)
+
+
+def get_api_key(provider):
+    """Get API key for the specified provider from multiple sources"""
+    env_var_map = {
+        "openai": "OPENAI_API_KEY",
+        "anthropic": "ANTHROPIC_API_KEY", 
+        "openrouter": "OPENROUTER_API_KEY",
+        "groq": "GROQ_API_KEY"
+    }
     
-    # Define _to_str function locally to avoid NameError
-    def _to_str(maybe_bytes):
-        try:
-            return (maybe_bytes.decode('utf-8') if isinstance(maybe_bytes, (bytes, bytearray)) else maybe_bytes)
-        except UnicodeDecodeError:
-            # Handle non-UTF-8 bytes by replacing invalid characters
-            if isinstance(maybe_bytes, (bytes, bytearray)):
-                return maybe_bytes.decode('utf-8', errors='replace')
-            else:
-                return str(maybe_bytes)
-        except Exception:
-            # Last resort fallback
-            return str(maybe_bytes)
-            
-    # Skip debugging for certain commands that commonly return non-zero exit codes
-    # but aren't actually errors (like test commands)
-    if command.strip().startswith("test "):
-        print("🔍 Skipping debugging for test command - non-zero exit code is expected behavior")
-        return None
-        
-    # Validate error_output - if it's empty, we can't debug effectively
-    if not error_output or not error_output.strip():
-        print("⚠️ Error output is empty. Cannot effectively debug the command.")
-        print("⚠️ Skipping OpenAI debugging due to lack of error information.")
-        return None
+    key_file_map = {
+        "openai": "openai_key",
+        "anthropic": "anthropic_key",
+        "openrouter": "openrouter_key",
+        "groq": "groq_key"
+    }
     
-    # Try to get API key from multiple sources
-    if not api_key:
-        print("🔍 DEBUG: No API key provided, searching for one...")
-        
-        # First try environment variable
-        api_key = os.environ.get("OPENAI_API_KEY")
-        print(f"🔍 DEBUG: API key from environment: {'Found' if api_key else 'Not found'}")
-        if api_key:
-            print(f"🔍 DEBUG: Environment API key value: {api_key}")
-        
-        # If not in environment, try to fetch from server using fetch_modal_tokens
-        if not api_key:
-            try:
-                print("🔍 DEBUG: Trying to fetch API key from server...")
-                from fetch_modal_tokens import get_tokens
-                _, _, api_key, _ = get_tokens()
-                if api_key:
-                    # Set in environment for this session
-                    os.environ["OPENAI_API_KEY"] = api_key
-                else:
-                    print("⚠️ Could not fetch OpenAI API key from server")
-            except Exception as e:
-                print(f"⚠️ Error fetching API key from server: {e}")
-        
-        # Store the API key in a persistent file if found
-        if api_key:
-            try:
-                os.makedirs(os.path.expanduser("~/.gitarsenal"), exist_ok=True)
-                with open(os.path.expanduser("~/.gitarsenal/openai_key"), "w") as f:
-                    f.write(api_key)
-                print("✅ Saved OpenAI API key for future use")
-            except Exception as e:
-                print(f"⚠️ Could not save API key: {e}")
-        
-        # Try to load from saved file if not in environment
-        if not api_key:
-            try:
-                key_file = os.path.expanduser("~/.gitarsenal/openai_key")
-                print(f"🔍 DEBUG: Checking for saved API key at: {key_file}")
-                if os.path.exists(key_file):
-                    with open(key_file, "r") as f:
-                        api_key = f.read().strip()
-                    if api_key:
-                        print("✅ Loaded OpenAI API key from saved file")
-                        print(f"🔍 DEBUG: API key from file: {api_key}")
-                        print(f"🔍 DEBUG: API key length: {len(api_key)}")
-                        # Also set in environment for this session
-                        os.environ["OPENAI_API_KEY"] = api_key
-                    else:
-                        print("🔍 DEBUG: Saved file exists but is empty")
-                else:
-                    print("🔍 DEBUG: No saved API key file found")
-            except Exception as e:
-                print(f"⚠️ Could not load saved API key: {e}")
-        
-        # Then try credentials manager
-        if not api_key:
-            print("🔍 DEBUG: Trying credentials manager...")
-            try:
-                from credentials_manager import CredentialsManager
-                credentials_manager = CredentialsManager()
-                api_key = credentials_manager.get_openai_api_key()
-                if api_key:
-                    print(f"🔍 DEBUG: API key from credentials manager: Found")
-                    print(f"🔍 DEBUG: Credentials manager API key value: {api_key}")
-                    # Set in environment for this session
-                    os.environ["OPENAI_API_KEY"] = api_key
-                else:
-                    print(f"🔍 DEBUG: API key from credentials manager: Not found")
-            except ImportError as e:
-                print(f"🔍 DEBUG: Credentials manager not available: {e}")
-                # Fall back to direct input if credentials_manager is not available
-                pass
-        
-        # Finally, prompt the user if still no API key
-        if not api_key:
-            print("🔍 DEBUG: No API key found in any source, prompting user...")
-            print("\n" + "="*60)
-            print("🔑 OPENAI API KEY REQUIRED FOR DEBUGGING")
-            print("="*60)
-            print("To debug failed commands, an OpenAI API key is needed.")
-            print("📝 Please paste your OpenAI API key below:")
-            print("   (Your input will be hidden for security)")
-            print("-" * 60)
-            
-            try:
-                api_key = getpass.getpass("OpenAI API Key: ").strip()
-                if not api_key:
-                    print("❌ No API key provided. Skipping debugging.")
-                    return None
-                print("✅ API key received successfully!")
-                print(f"🔍 DEBUG: User-provided API key: {api_key}")
-                # Save the API key to environment for future use in this session
-                os.environ["OPENAI_API_KEY"] = api_key
-            except KeyboardInterrupt:
-                print("\n❌ API key input cancelled by user.")
-                return None
-            except Exception as e:
-                print(f"❌ Error getting API key: {e}")
-                return None
+    token_index_map = {
+        "openai": 2,
+        "anthropic": 3,
+        "openrouter": 4,
+        "groq": 5,
+    }
     
-    # If we still don't have an API key, we can't proceed
-    if not api_key:
-        print("❌ No OpenAI API key available. Cannot perform LLM debugging.")
-        print("💡 To enable LLM debugging, set the OPENAI_API_KEY environment variable")
+    env_var = env_var_map.get(provider)
+    if not env_var:
         return None
     
-    # print(f"✅ OpenAI API key available (length: {len(api_key)})")
+    # Try environment variable first
+    api_key = os.environ.get(env_var)
+    if api_key:
+        return api_key
     
-    # Gather additional context to help with debugging
-    directory_context = ""
+    # Try fetch from server
+    try:
+        from fetch_modal_tokens import get_tokens
+        tokens = get_tokens()
+        token_index = token_index_map.get(provider)
+        if token_index is not None and len(tokens) > token_index:
+            api_key = tokens[token_index]
+            if api_key:
+                os.environ[env_var] = api_key
+                return api_key
+    except Exception:
+        pass
+    
+    # Try credentials manager
+    try:
+        from credentials_manager import CredentialsManager
+        credentials_manager = CredentialsManager()
+        method_name = f"get_{provider}_api_key"
+        if hasattr(credentials_manager, method_name):
+            api_key = getattr(credentials_manager, method_name)()
+            if api_key:
+                os.environ[env_var] = api_key
+                return api_key
+    except Exception:
+        pass
+    
+    # Try saved file
+    try:
+        key_file = Path.home() / ".gitarsenal" / key_file_map[provider]
+        if key_file.exists():
+            api_key = key_file.read_text().strip()
+            if api_key:
+                os.environ[env_var] = api_key
+                return api_key
+    except Exception:
+        pass
+    
+    return None
+
+
+def save_api_key(provider, api_key):
+    """Save API key to persistent file"""
+    key_file_map = {
+        "openai": "openai_key",
+        "anthropic": "anthropic_key",
+        "openrouter": "openrouter_key",
+        "groq": "groq_key"
+    }
+    
+    try:
+        gitarsenal_dir = Path.home() / ".gitarsenal"
+        gitarsenal_dir.mkdir(exist_ok=True)
+        key_file = gitarsenal_dir / key_file_map[provider]
+        key_file.write_text(api_key)
+    except Exception as e:
+        print(f"⚠️ Could not save {provider} API key: {e}")
+
+
+def gather_context(sandbox, current_dir):
+    """Gather system and directory context for debugging"""
     system_info = ""
-    command_history = ""
+    directory_context = ""
     file_context = ""
     
-    if sandbox:
-        try:
-            print("🔍 Getting system information for better debugging...")
-            
-            # Get OS information
-            os_info_cmd = """
-            echo "OS Information:"
-            cat /etc/os-release 2>/dev/null || echo "OS release info not available"
-            echo -e "\nKernel Information:"
-            uname -a
-            echo -e "\nPython Information:"
-            python --version
-            pip --version
-            echo -e "\nPackage Manager:"
-            which apt 2>/dev/null && echo "apt available" || echo "apt not available"
-            which yum 2>/dev/null && echo "yum available" || echo "yum not available"
-            which dnf 2>/dev/null && echo "dnf available" || echo "dnf not available"
-            which apk 2>/dev/null && echo "apk available" || echo "apk not available"
-            echo -e "\nEnvironment Variables:"
-            env | grep -E "^(PATH|PYTHON|VIRTUAL_ENV|HOME|USER|SHELL|LANG)" || echo "No relevant env vars found"
-            """
-            
-            os_result = sandbox.exec("bash", "-c", os_info_cmd)
-            os_output = ""
-            for line in os_result.stdout:
-                os_output += _to_str(line)
-            os_result.wait()
-            
-            system_info = f"""
-System Information:
-{os_output}
-"""
-            print("✅ System information gathered successfully")
-        except Exception as e:
-            print(f"⚠️ Error getting system information: {e}")
-            system_info = "System information not available\n"
+    if not sandbox:
+        return system_info, directory_context, file_context
     
-    if current_dir and sandbox:
+    # Get system information
+    try:
+        os_info_cmd = """
+        echo "OS Information:"
+        cat /etc/os-release 2>/dev/null || echo "OS release info not available"
+        echo -e "\nKernel Information:"
+        uname -a
+        echo -e "\nPython Information:"
+        python --version
+        pip --version
+        """
+        
+        os_result = sandbox.exec("bash", "-c", os_info_cmd)
+        os_output = ""
+        for line in os_result.stdout:
+            os_output += _to_str(line)
+        os_result.wait()
+        
+        system_info = f"\nSystem Information:\n{os_output}"
+    except Exception:
+        system_info = "System information not available\n"
+    
+    # Get directory context
+    if current_dir:
         try:
-            # print("🔍 Getting directory context for better debugging...")
-            
-            # Get current directory contents
             ls_result = sandbox.exec("bash", "-c", "ls -la")
             ls_output = ""
             for line in ls_result.stdout:
                 ls_output += _to_str(line)
             ls_result.wait()
             
-            # Get parent directory contents
-            parent_result = sandbox.exec("bash", "-c", "ls -la ../")
-            parent_ls = ""
-            for line in parent_result.stdout:
-                parent_ls += _to_str(line)
-            parent_result.wait()
-                
-            directory_context = f"""
-Current directory contents:
-{ls_output}
-
-Parent directory contents:
-{parent_ls}
-"""
-            print("✅ Directory context gathered successfully")
+            directory_context = f"\nCurrent directory contents:\n{ls_output}"
             
-            # Check for relevant files that might provide additional context
-            # For example, if error mentions a specific file, try to get its content
+            # Check for common config files
+            common_config_files = ["package.json", "requirements.txt", "pyproject.toml", "setup.py"]
             relevant_files = []
-            error_files = re.findall(r'(?:No such file or directory|cannot open|not found): ([^\s:]+)', error_output)
-            if error_files:
-                for file_path in error_files:
-                    # Clean up the file path
-                    file_path = file_path.strip("'\"")
-                    if not os.path.isabs(file_path):
-                        file_path = os.path.join(current_dir, file_path)
-                
-                # Try to get the parent directory if the file doesn't exist
-                if '/' in file_path:
-                    parent_file_dir = os.path.dirname(file_path)
-                    relevant_files.append(parent_file_dir)
-            
-            # Look for package.json, requirements.txt, etc.
-            common_config_files = ["package.json", "requirements.txt", "pyproject.toml", "setup.py", 
-                                 "Pipfile", "Dockerfile", "docker-compose.yml", "Makefile"]
             
             for config_file in common_config_files:
                 check_cmd = f"test -f {current_dir}/{config_file}"
@@ -366,65 +193,32 @@ Parent directory contents:
                 if check_result.returncode == 0:
                     relevant_files.append(f"{current_dir}/{config_file}")
             
-            # Get content of relevant files
+            # Get content of relevant files (limit to 2)
             if relevant_files:
                 file_context = "\nRelevant file contents:\n"
-                for file_path in relevant_files[:2]:  # Limit to 2 files to avoid too much context
+                for file_path in relevant_files[:2]:
                     try:
-                        file_check_cmd = f"test -f {file_path}"
-                        file_check = sandbox.exec("bash", "-c", file_check_cmd)
-                        file_check.wait()
+                        cat_result = sandbox.exec("bash", "-c", f"cat {file_path}")
+                        file_content = ""
+                        for line in cat_result.stdout:
+                            file_content += _to_str(line)
+                        cat_result.wait()
                         
-                        if file_check.returncode == 0:
-                            # It's a file, get its content
-                            cat_cmd = f"cat {file_path}"
-                            cat_result = sandbox.exec("bash", "-c", cat_cmd)
-                            file_content = ""
-                            for line in cat_result.stdout:
-                                file_content += _to_str(line)
-                            cat_result.wait()
-                            
-                            # Truncate if too long
-                            if len(file_content) > 1000:
-                                file_content = file_content[:1000] + "\n... (truncated)"
-                            
-                            file_context += f"\n--- {file_path} ---\n{file_content}\n"
-                        else:
-                            # It's a directory, list its contents
-                            ls_cmd = f"ls -la {file_path}"
-                            ls_dir_result = sandbox.exec("bash", "-c", ls_cmd)
-                            dir_content = ""
-                            for line in ls_dir_result.stdout:
-                                dir_content += _to_str(line)
-                            ls_dir_result.wait()
-                            
-                            file_context += f"\n--- Directory: {file_path} ---\n{dir_content}\n"
-                    except Exception as e:
-                        print(f"⚠️ Error getting content of {file_path}: {e}")
-                
-                # print(f"✅ Additional file context gathered from {len(relevant_files)} relevant files")
-            
-        except Exception as e:
-            print(f"⚠️ Error getting directory context: {e}")
+                        if len(file_content) > 1000:
+                            file_content = file_content[:1000] + "\n... (truncated)"
+                        
+                        file_context += f"\n--- {file_path} ---\n{file_content}\n"
+                    except Exception:
+                        continue
+        except Exception:
             directory_context = f"\nCurrent directory: {current_dir}\n"
     
-    # Prepare the API request
-    headers = {
-        "Content-Type": "application/json",
-        "Authorization": f"Bearer {api_key}"
-    }
+    return system_info, directory_context, file_context
 
-    stored_credentials = get_stored_credentials()
-    auth_context = generate_auth_context(stored_credentials)
-    
-    # Create a prompt for the LLM
-    print("\n" + "="*60)
-    print("DEBUG: ERROR_OUTPUT SENT TO LLM:")
-    print("="*60)
-    print(f"{error_output}")
-    print("="*60 + "\n")
-    
-    prompt = f"""
+
+def create_debug_prompt(command, error_output, system_info, directory_context, file_context, auth_context):
+    """Create the debugging prompt for LLM"""
+    return f"""
 I'm trying to run the following command in a Linux environment:
 
 ```
@@ -465,1193 +259,354 @@ IMPORTANT GUIDELINES:
    - Analyze the error to determine what type of authentication is needed
    - ALWAYS use the actual credential values from the AVAILABLE CREDENTIALS section above (NOT placeholders)
    - Look for the specific API key or token needed in the auth_context and use its exact value
-   - Common patterns:
-     * wandb errors: use wandb login with the actual WANDB_API_KEY value from auth_context
-     * huggingface errors: use huggingface-cli login with the actual HF_TOKEN or HUGGINGFACE_TOKEN value from auth_context
-     * github errors: configure git credentials with the actual GITHUB_TOKEN value from auth_context
-     * kaggle errors: create ~/.kaggle/kaggle.json with the actual KAGGLE_USERNAME and KAGGLE_KEY values from auth_context
-     * API errors: export the appropriate API key as environment variable using the actual value from auth_context
 
 5. Environment variable exports:
    - Use export commands for API keys that need to be in environment
    - ALWAYS use the actual credential values from auth_context, never use placeholders like "YOUR_API_KEY"
-   - Example: export OPENAI_API_KEY="sk-..." (using the actual key from auth_context)
-
-6. CRITICAL: When using any API key, token, or credential:
-   - Find the exact value in the AVAILABLE CREDENTIALS section
-   - Use that exact value in your command
-   - Do not use generic placeholders or dummy values
-   - The auth_context contains real, usable credentials
 
-7. For Git SSH authentication failures:
+6. For Git SSH authentication failures:
    - If the error contains "Host key verification failed" or "Could not read from remote repository"
    - ALWAYS convert SSH URLs to HTTPS URLs for public repositories
    - Replace git@github.com:username/repo.git with https://github.com/username/repo.git
-   - This works for public repositories without authentication
-   - Example: git clone https://github.com/xg-chu/ARTalk.git
 
 Do not provide any explanations, just the exact command to run.
 """
+
+
+def extract_command_from_response(response_text):
+    """Extract the actual command from LLM response"""
+    fix_command = response_text.strip()
     
-    # Prepare the API request payload
-    # print("🔍 DEBUG: Preparing API request...")
-    
-    # Try to use GPT-4 first, but fall back to other models if needed
-    models_to_try = [
-        "gpt-4.1-mini",        # First choice: GPT-4o (most widely available)
-    ]
-    
-    # Check if we have a preferred model in environment
-    preferred_model = os.environ.get("OPENAI_MODEL")
-    if preferred_model:
-        # Insert the preferred model at the beginning of the list
-        models_to_try.insert(0, preferred_model)
-        # print(f"✅ Using preferred model from environment: {preferred_model}")
-        
-    # Remove duplicates while preserving order
-    models_to_try = list(dict.fromkeys(models_to_try))
-    # print(f"🔍 DEBUG: Models to try: {models_to_try}")
+    # Extract from code blocks
+    if "```" in fix_command:
+        code_blocks = re.findall(r'```(?:bash|sh)?\s*(.*?)\s*```', fix_command, re.DOTALL)
+        if code_blocks:
+            fix_command = code_blocks[0].strip()
     
-    # Function to make the API call with a specific model
-    def try_api_call(model_name, retries=2, backoff_factor=1.5):
-        # print(f"🔍 DEBUG: Attempting API call with model: {model_name}")
-        # print(f"🔍 DEBUG: API key available: {'Yes' if api_key else 'No'}")
-        # if api_key:
-        #     print(f"🔍 DEBUG: API key length: {len(api_key)}")
-        #     print(f"🔍 DEBUG: API key starts with: {api_key[:10]}...")
-        
-        payload = {
-            "model": model_name,
-            "messages": [
-                {"role": "system", "content": "You are a debugging assistant. Provide only the terminal command to fix the issue. Analyze the issue first, understand why it's happening, then provide the command to fix it. For file not found errors, first search for the file using 'find . -name filename -type f' and navigate to the directory if found. For missing packages, use appropriate package managers (pip, apt-get, npm). For Git SSH authentication failures, always convert SSH URLs to HTTPS URLs (git@github.com:user/repo.git -> https://github.com/user/repo.git). For authentication, suggest login commands with placeholders."},
-                {"role": "user", "content": prompt}
-            ],
-            "temperature": 0.2,
-            "max_tokens": 300
-        }
+    # If multi-line, try to find the actual command
+    if len(fix_command.split('\n')) > 1:
+        command_prefixes = ['sudo', 'apt', 'pip', 'npm', 'yarn', 'git', 'cd', 'mv', 'cp', 'rm', 'mkdir', 'touch', 
+                          'chmod', 'chown', 'echo', 'cat', 'python', 'python3', 'node', 'export',
+                          'curl', 'wget', 'docker', 'make', 'conda', 'uv', 'poetry']
         
-        print(f"🔍 DEBUG: Payload prepared, prompt length: {len(prompt)}")
-        
-        # Add specific handling for common errors
-        last_error = None
-        for attempt in range(retries + 1):
-            try:
-                if attempt > 0:
-                    # Exponential backoff
-                    wait_time = backoff_factor * (2 ** (attempt - 1))
-                    print(f"⏱️ Retrying in {wait_time:.1f} seconds... (attempt {attempt+1}/{retries+1})")
-                    time.sleep(wait_time)
-                
-                print(f"🤖 Calling OpenAI with {model_name} model to debug the failed command...")
-                print(f"🔍 DEBUG: Making POST request to OpenAI API...")
-                response = requests.post(
-                    "https://api.openai.com/v1/chat/completions",
-                    headers=headers,
-                    json=payload,
-                    timeout=45  # Increased timeout for reliability
-                )
-                
-                print(f"🔍 DEBUG: Response received, status code: {response.status_code}")
-                
-                # Handle specific status codes
-                if response.status_code == 200:
-                    print(f"🔍 DEBUG: Success! Response length: {len(response.text)}")
-                    return response.json(), None
-                elif response.status_code == 401:
-                    error_msg = "Authentication error: Invalid API key"
-                    print(f"❌ {error_msg}")
-                    print(f"🔍 DEBUG: Response text: {response.text}")
-                    # Don't retry auth errors
-                    return None, error_msg
-                elif response.status_code == 429:
-                    error_msg = "Rate limit exceeded or quota reached"
-                    print(f"⚠️ {error_msg}")
-                    print(f"🔍 DEBUG: Response text: {response.text}")
-                    # Always retry rate limit errors with increasing backoff
-                    last_error = error_msg
-                    continue
-                elif response.status_code == 500:
-                    error_msg = "OpenAI server error"
-                    print(f"⚠️ {error_msg}")
-                    print(f"🔍 DEBUG: Response text: {response.text}")
-                    # Retry server errors
-                    last_error = error_msg
-                    continue
-                else:
-                    error_msg = f"Status code: {response.status_code}, Response: {response.text}"
-                    print(f"⚠️ OpenAI API error: {error_msg}")
-                    print(f"🔍 DEBUG: Full response text: {response.text}")
-                    last_error = error_msg
-                    # Only retry if we have attempts left
-                    if attempt < retries:
-                        continue
-                    return None, error_msg
-            except requests.exceptions.Timeout:
-                error_msg = "Request timed out"
-                # print(f"⚠️ {error_msg}")
-                # print(f"🔍 DEBUG: Timeout after 45 seconds")
-                last_error = error_msg
-                # Always retry timeouts
-                continue
-            except requests.exceptions.ConnectionError:
-                error_msg = "Connection error"
-                print(f"⚠️ {error_msg}")
-                print(f"🔍 DEBUG: Connection failed to api.openai.com")
-                last_error = error_msg
-                # Always retry connection errors
-                continue
-            except Exception as e:
-                error_msg = str(e)
-                print(f"⚠️ Unexpected error: {error_msg}")
-                print(f"🔍 DEBUG: Exception type: {type(e).__name__}")
-                print(f"🔍 DEBUG: Exception details: {str(e)}")
-                last_error = error_msg
-                # Only retry if we have attempts left
-                if attempt < retries:
-                    continue
-                return None, error_msg
+        command_lines = [line.strip() for line in fix_command.split('\n') 
+                       if any(line.strip().startswith(prefix) for prefix in command_prefixes)]
         
-        # If we get here, all retries failed
-        return None, last_error
-    
-    # Try each model in sequence until one works
-    result = None
-    last_error = None
-    
-    for model in models_to_try:
-        result, error = try_api_call(model)
-        if result:
-            # print(f"✅ Successfully got response from {model}")
-            break
+        if command_lines:
+            fix_command = command_lines[0]
         else:
-            print(f"⚠️ Failed to get response from {model}: {error}")
-            last_error = error
-    
-    if not result:
-        print(f"❌ All model attempts failed. Last error: {last_error}")
-        return None
-    
-    # Process the response
-    try:
-        print(f"🔍 DEBUG: Processing OpenAI response...")
-        # print(f"🔍 DEBUG: Response structure: {list(result.keys())}")
-        print(f"🔍 DEBUG: Choices count: {len(result.get('choices', []))}")
-        
-        fix_command = result["choices"][0]["message"]["content"].strip()
-        print(f"🔍 DEBUG: Raw response content: {fix_command}")
-        
-        # Save the original response for debugging
-        original_response = fix_command
-        
-        # Extract just the command if it's wrapped in backticks or explanation
-        if "```" in fix_command:
-            # Extract content between backticks
-            import re
-            code_blocks = re.findall(r'```(?:bash|sh)?\s*(.*?)\s*```', fix_command, re.DOTALL)
-            if code_blocks:
-                fix_command = code_blocks[0].strip()
-                print(f"✅ Extracted command from code block: {fix_command}")
-        
-        # If the response still has explanatory text, try to extract just the command
-        if len(fix_command.split('\n')) > 1:
-            # First try to find lines that look like commands (start with common command prefixes)
-            command_prefixes = ['sudo', 'apt', 'pip', 'npm', 'yarn', 'git', 'cd', 'mv', 'cp', 'rm', 'mkdir', 'touch', 
-                              'chmod', 'chown', 'echo', 'cat', 'python', 'python3', 'node', 'export',
-                              'curl', 'wget', 'docker', 'make', 'gcc', 'g++', 'javac', 'java',
-                              'conda', 'uv', 'poetry', 'nvm', 'rbenv', 'pyenv', 'rustup']
-            
-            # Check for lines that start with common command prefixes
+            # Try shell patterns
+            shell_patterns = [' | ', ' > ', ' >> ', ' && ', ' || ', ' ; ', '$(', '`', ' -y ', ' --yes ']
             command_lines = [line.strip() for line in fix_command.split('\n') 
-                           if any(line.strip().startswith(prefix) for prefix in command_prefixes)]
+                           if any(pattern in line for pattern in shell_patterns)]
             
             if command_lines:
-                # Use the first command line found
                 fix_command = command_lines[0]
-                print(f"✅ Identified command by prefix: {fix_command}")
             else:
-                # Try to find lines that look like commands (contain common shell patterns)
-                shell_patterns = [' | ', ' > ', ' >> ', ' && ', ' || ', ' ; ', '$(',  '`', ' -y ', ' --yes ']
-                command_lines = [line.strip() for line in fix_command.split('\n') 
-                              if any(pattern in line for pattern in shell_patterns)]
-                
-                if command_lines:
-                    # Use the first command line found
-                    fix_command = command_lines[0]
-                    print(f"✅ Identified command by shell pattern: {fix_command}")
-                else:
-                    # Fall back to the shortest non-empty line as it's likely the command
-                    lines = [line.strip() for line in fix_command.split('\n') if line.strip()]
-                    if lines:
-                        # Exclude very short lines that are likely not commands
-                        valid_lines = [line for line in lines if len(line) > 5]
-                        if valid_lines:
-                            fix_command = min(valid_lines, key=len)
-                        else:
-                            fix_command = min(lines, key=len)
-                        print(f"✅ Selected shortest line as command: {fix_command}")
-        
-        # Clean up the command - remove any trailing periods or quotes
-        fix_command = fix_command.rstrip('.;"\'')
-        
-        # Remove common prefixes that LLMs sometimes add
-        prefixes_to_remove = [
-            "Run: ", "Execute: ", "Try: ", "Command: ", "Fix: ", "Solution: ",
-            "You should run: ", "You can run: ", "You need to run: "
-        ]
-        for prefix in prefixes_to_remove:
-            if fix_command.startswith(prefix):
-                fix_command = fix_command[len(prefix):].strip()
-                print(f"✅ Removed prefix: {prefix}")
-                break
-        
-        # If the command is still multi-line or very long, it might not be a valid command
-        if len(fix_command.split('\n')) > 1 or len(fix_command) > 500:
-            print("⚠️ Extracted command appears invalid (multi-line or too long)")
-            print("🔍 Original response from LLM:")
-            print("-" * 60)
-            print(original_response)
-            print("-" * 60)
-            print("⚠️ Using best guess for command")
-        
-        print(f"🔧 Suggested fix: {fix_command}")
-        print(f"🔍 DEBUG: Returning fix command: {fix_command}")
-        return fix_command
-    except Exception as e:
-        print(f"❌ Error processing OpenAI response: {e}")
-        print(f"🔍 DEBUG: Exception type: {type(e).__name__}")
-        print(f"🔍 DEBUG: Exception details: {str(e)}")
-        return None
-
-def call_openai_for_batch_debug(failed_commands, api_key=None, current_dir=None, sandbox=None):
-    """Call OpenAI to debug multiple failed commands and suggest fixes for all of them at once"""
-    print("\n🔍 DEBUG: Starting batch LLM debugging...")
-    print(f"🔍 DEBUG: Analyzing {len(failed_commands)} failed commands")
-    
-    if not failed_commands:
-        print("⚠️ No failed commands to analyze")
-        return []
-    
-    if not api_key:
-        print("❌ No OpenAI API key provided for batch debugging")
-        return []
-    
-    # Prepare context for batch analysis
-    context_parts = []
-    context_parts.append(f"Current directory: {current_dir}")
-    context_parts.append(f"Sandbox available: {sandbox is not None}")
-    
-    # Add failed commands with their errors
-    for i, failed_cmd in enumerate(failed_commands, 1):
-        cmd_type = failed_cmd.get('type', 'main')
-        original_cmd = failed_cmd.get('original_command', '')
-        cmd_text = failed_cmd['command']
-        stderr = failed_cmd.get('stderr', '')
-        stdout = failed_cmd.get('stdout', '')
-        
-        context_parts.append(f"\n--- Failed Command {i} ({cmd_type}) ---")
-        context_parts.append(f"Command: {cmd_text}")
-        if original_cmd and original_cmd != cmd_text:
-            context_parts.append(f"Original Command: {original_cmd}")
-        if stderr:
-            context_parts.append(f"Error Output: {stderr}")
-        if stdout:
-            context_parts.append(f"Standard Output: {stdout}")
+                # Use shortest non-empty line
+                lines = [line.strip() for line in fix_command.split('\n') if line.strip()]
+                if lines:
+                    valid_lines = [line for line in lines if len(line) > 5]
+                    fix_command = min(valid_lines, key=len) if valid_lines else min(lines, key=len)
+    
+    # Clean up the command
+    fix_command = fix_command.rstrip('.;"\'')
+    
+    # Remove common prefixes
+    prefixes_to_remove = [
+        "Run: ", "Execute: ", "Try: ", "Command: ", "Fix: ", "Solution: ",
+        "You should run: ", "You can run: ", "You need to run: "
+    ]
+    for prefix in prefixes_to_remove:
+        if fix_command.startswith(prefix):
+            fix_command = fix_command[len(prefix):].strip()
+            break
     
-    # Create the prompt for batch analysis
-    prompt = f"""You are a debugging assistant analyzing multiple failed commands. 
+    return fix_command
 
-Context:
-{chr(10).join(context_parts)}
-
-Please analyze each failed command and provide a fix command for each one. For each failed command, respond with:
 
-FIX_COMMAND_{i}: <the fix command>
-REASON_{i}: <brief explanation of why the original command failed and how the fix addresses it>
-
-Guidelines:
-- For file not found errors, first search for the file using 'find . -name filename -type f'
-- For missing packages, use appropriate package managers (pip, apt-get, npm)
-- For Git SSH authentication failures, convert SSH URLs to HTTPS URLs
-- For permission errors, suggest commands with sudo if appropriate
-- For network issues, suggest retry commands or alternative URLs
-- Keep each fix command simple and focused on the specific error
+def make_api_request(provider, api_key, prompt, retries=2):
+    """Make API request to the specified provider"""
+    if provider == "openai":
+        return make_openai_request(api_key, prompt, retries)
+    elif provider == "anthropic":
+        return make_anthropic_request(api_key, prompt, retries)
+    elif provider == "openrouter":
+        return make_openrouter_request(api_key, prompt, retries)
+    elif provider == "groq":
+        return make_groq_request(api_key, prompt, retries)
+    else:
+        return None
 
-Provide fixes for all {len(failed_commands)} failed commands:"""
 
-    # Make the API call
+def make_openai_request(api_key, prompt, retries=2):
+    """Make request to OpenAI API"""
     headers = {
-        "Authorization": f"Bearer {api_key}",
-        "Content-Type": "application/json"
+        "Content-Type": "application/json",
+        "Authorization": f"Bearer {api_key}"
     }
     
     payload = {
-        "model": "gpt-4o-mini",  # Use a more capable model for batch analysis
+        "model": os.environ.get("OPENAI_MODEL", "gpt-5-mini"),
         "messages": [
-            {"role": "system", "content": "You are a debugging assistant. Analyze failed commands and provide specific fix commands. Return only the fix commands and reasons in the specified format."},
+            {"role": "system", "content": "You are a debugging assistant. Provide only the terminal command to fix the issue."},
             {"role": "user", "content": prompt}
         ],
-        "temperature": 0.1,
-        "max_tokens": 1000
+        "temperature": 0.2,
+        "max_tokens": 300
     }
     
-    try:
-        print(f"🤖 Calling OpenAI for batch debugging of {len(failed_commands)} commands...")
-        response = requests.post(
-            "https://api.openai.com/v1/chat/completions",
-            headers=headers,
-            json=payload,
-            timeout=60
-        )
-        
-        if response.status_code == 200:
-            result = response.json()
-            content = result['choices'][0]['message']['content']
-            print(f"✅ Batch analysis completed")
-            
-            # Parse the response to extract fix commands
-            fixes = []
-            for i in range(1, len(failed_commands) + 1):
-                fix_pattern = f"FIX_COMMAND_{i}: (.+)"
-                reason_pattern = f"REASON_{i}: (.+)"
-                
-                fix_match = re.search(fix_pattern, content, re.MULTILINE)
-                reason_match = re.search(reason_pattern, content, re.MULTILINE)
-                
-                if fix_match:
-                    fix_command = fix_match.group(1).strip()
-                    reason = reason_match.group(1).strip() if reason_match else "LLM suggested fix"
-                    
-                    # Clean up the fix command
-                    if fix_command.startswith('`') and fix_command.endswith('`'):
-                        fix_command = fix_command[1:-1]
-                    
-                    fixes.append({
-                        'original_command': failed_commands[i-1]['command'],
-                        'fix_command': fix_command,
-                        'reason': reason,
-                        'command_index': i-1
-                    })
-            
-            print(f"🔧 Generated {len(fixes)} fix commands from batch analysis")
-            return fixes
-        else:
-            print(f"❌ OpenAI API error: {response.status_code} - {response.text}")
-            return []
-            
-    except Exception as e:
-        print(f"❌ Error during batch debugging: {e}")
-        return []
-
-def call_anthropic_for_debug(command, error_output, api_key=None, current_dir=None, sandbox=None):
-    """Call Anthropic Claude to debug a failed command and suggest a fix"""
-    print("\n🔍 DEBUG: Starting Anthropic Claude debugging...")
-    print(f"🔍 DEBUG: Command: {command}")
-    print(f"🔍 DEBUG: Error output length: {len(error_output) if error_output else 0}")
-    print(f"🔍 DEBUG: Current directory: {current_dir}")
-    print(f"🔍 DEBUG: Sandbox available: {sandbox is not None}")
-    
-    # Define _to_str function locally to avoid NameError
-    def _to_str(maybe_bytes):
+    for attempt in range(retries + 1):
         try:
-            return (maybe_bytes.decode('utf-8') if isinstance(maybe_bytes, (bytes, bytearray)) else maybe_bytes)
-        except UnicodeDecodeError:
-            # Handle non-UTF-8 bytes by replacing invalid characters
-            if isinstance(maybe_bytes, (bytes, bytearray)):
-                return maybe_bytes.decode('utf-8', errors='replace')
+            if attempt > 0:
+                time.sleep(1.5 * (2 ** (attempt - 1)))
+            
+            response = requests.post(
+                "https://api.openai.com/v1/chat/completions",
+                headers=headers,
+                json=payload,
+                timeout=45
+            )
+            
+            if response.status_code == 200:
+                result = response.json()
+                return result["choices"][0]["message"]["content"]
+            elif response.status_code == 401:
+                print("❌ Invalid OpenAI API key")
+                return None
+            elif response.status_code in [429, 500]:
+                continue  # Retry
             else:
-                return str(maybe_bytes)
-        except Exception:
-            # Last resort fallback
-            return str(maybe_bytes)
-            
-    # Skip debugging for certain commands that commonly return non-zero exit codes
-    # but aren't actually errors (like test commands)
-    if command.strip().startswith("test "):
-        print("🔍 Skipping debugging for test command - non-zero exit code is expected behavior")
-        return None
-        
-    # Validate error_output - if it's empty, we can't debug effectively
-    if not error_output or not error_output.strip():
-        print("⚠️ Error output is empty. Cannot effectively debug the command.")
-        print("⚠️ Skipping Anthropic debugging due to lack of error information.")
-        return None
-    
-    # Try to get API key from multiple sources
-    if not api_key:
-        print("🔍 DEBUG: No Anthropic API key provided, searching for one...")
-        
-        # First try environment variable
-        api_key = os.environ.get("ANTHROPIC_API_KEY")
-        print(f"🔍 DEBUG: API key from environment: {'Found' if api_key else 'Not found'}")
-        if api_key:
-            print(f"🔍 DEBUG: Environment API key value: {api_key}")
-        
-        # If not in environment, try to fetch from server using fetch_modal_tokens
-        if not api_key:
-            try:
-                print("🔍 DEBUG: Trying to fetch API key from server...")
-                from fetch_modal_tokens import get_tokens
-                _, _, _, api_key = get_tokens()
-                if api_key:
-                    # Set in environment for this session
-                    os.environ["ANTHROPIC_API_KEY"] = api_key
-                else:
-                    print("⚠️ Could not fetch Anthropic API key from server")
-            except Exception as e:
-                print(f"⚠️ Error fetching API key from server: {e}")
-        
-        # Then try credentials manager
-        if not api_key:
-            print("🔍 DEBUG: Trying credentials manager...")
-            try:
-                from credentials_manager import CredentialsManager
-                credentials_manager = CredentialsManager()
-                api_key = credentials_manager.get_anthropic_api_key()
-                if api_key:
-                    print(f"🔍 DEBUG: API key from credentials manager: Found")
-                    print(f"🔍 DEBUG: Credentials manager API key value: {api_key}")
-                    # Set in environment for this session
-                    os.environ["ANTHROPIC_API_KEY"] = api_key
-                else:
-                    print("⚠️ Could not fetch Anthropic API key from credentials manager")
-            except Exception as e:
-                print(f"⚠️ Error fetching API key from credentials manager: {e}")
-        
-        # Store the API key in a persistent file if found
-        if api_key:
-            try:
-                os.makedirs(os.path.expanduser("~/.gitarsenal"), exist_ok=True)
-                with open(os.path.expanduser("~/.gitarsenal/anthropic_key"), "w") as f:
-                    f.write(api_key)
-                print("✅ Saved Anthropic API key for future use")
-            except Exception as e:
-                print(f"⚠️ Could not save API key: {e}")
-        
-        # Try to load from saved file if not in environment
-        if not api_key:
-            try:
-                key_file = os.path.expanduser("~/.gitarsenal/anthropic_key")
-                print(f"🔍 DEBUG: Checking for saved API key at: {key_file}")
-                if os.path.exists(key_file):
-                    with open(key_file, "r") as f:
-                        api_key = f.read().strip()
-                    if api_key:
-                        print("✅ Loaded Anthropic API key from saved file")
-                        print(f"🔍 DEBUG: API key from file: {api_key}")
-                        print(f"🔍 DEBUG: API key length: {len(api_key)}")
-                        # Also set in environment for this session
-                        os.environ["ANTHROPIC_API_KEY"] = api_key
-                    else:
-                        print("🔍 DEBUG: Saved file exists but is empty")
-                else:
-                    print("🔍 DEBUG: No saved API key file found")
-            except Exception as e:
-                print(f"⚠️ Could not load saved API key: {e}")
-    
-    if not api_key:
-        print("❌ No Anthropic API key available for debugging")
-        return None
+                print(f"⚠️ OpenAI API error: {response.status_code}")
+                return None
+                
+        except (requests.exceptions.Timeout, requests.exceptions.ConnectionError):
+            continue  # Retry
+        except Exception as e:
+            print(f"⚠️ OpenAI request error: {e}")
+            return None
     
-    # Prepare the prompt for debugging
-    error_str = _to_str(error_output)
-    prompt = f"""You are a debugging assistant. Provide only the terminal command to fix the issue. 
-
-Context:
-- Current directory: {current_dir}
-- Sandbox available: {sandbox is not None}
-- Failed command: {command}
-- Error output: {error_str}
-
-Analyze the issue first, understand why it's happening, then provide the command to fix it. 
-
-Guidelines:
-- For file not found errors, first search for the file using 'find . -name filename -type f' and navigate to the directory if found
-- For missing packages, use appropriate package managers (pip, apt-get, npm)
-- For Git SSH authentication failures, always convert SSH URLs to HTTPS URLs (git@github.com:user/repo.git -> https://github.com/user/repo.git)
-- For authentication, suggest login commands with placeholders
-- For permission errors, suggest commands with sudo if appropriate
-- For network issues, suggest retry commands or alternative URLs
+    return None
 
-Return only the command to fix the issue, nothing else."""
 
-    # Set up headers for Anthropic API
+def make_anthropic_request(api_key, prompt, retries=2):
+    """Make request to Anthropic API"""
     headers = {
         "x-api-key": api_key,
         "anthropic-version": "2023-06-01",
         "content-type": "application/json"
     }
     
-    # Models to try in order of preference
-    models_to_try = ["claude-sonnet-4-20250514"]
+    payload = {
+        "model": "claude-sonnet-4-20250514",
+        "max_tokens": 300,
+        "messages": [{"role": "user", "content": prompt}]
+    }
     
-    def try_api_call(model_name, retries=2, backoff_factor=1.5):
-        payload = {
-            "model": model_name,
-            "max_tokens": 300,
-            "messages": [
-                {"role": "user", "content": prompt}
-            ]
-        }
-        
-        print(f"🔍 DEBUG: Payload prepared, prompt length: {len(prompt)}")
-        
-        # Add specific handling for common errors
-        last_error = None
-        for attempt in range(retries + 1):
-            try:
-                if attempt > 0:
-                    # Exponential backoff
-                    wait_time = backoff_factor * (2 ** (attempt - 1))
-                    print(f"⏱️ Retrying in {wait_time:.1f} seconds... (attempt {attempt+1}/{retries+1})")
-                    time.sleep(wait_time)
-                
-                print(f"🤖 Calling Anthropic Claude with {model_name} model to debug the failed command...")
-                print(f"🔍 DEBUG: Making POST request to Anthropic API...")
-                response = requests.post(
-                    "https://api.anthropic.com/v1/messages",
-                    headers=headers,
-                    json=payload,
-                    timeout=45  # Increased timeout for reliability
-                )
-                
-                print(f"🔍 DEBUG: Response received, status code: {response.status_code}")
+    for attempt in range(retries + 1):
+        try:
+            if attempt > 0:
+                time.sleep(1.5 * (2 ** (attempt - 1)))
+            
+            response = requests.post(
+                "https://api.anthropic.com/v1/messages",
+                headers=headers,
+                json=payload,
+                timeout=45
+            )
+            
+            if response.status_code == 200:
+                result = response.json()
+                return result["content"][0]["text"]
+            elif response.status_code == 401:
+                print("❌ Invalid Anthropic API key")
+                return None
+            elif response.status_code in [429, 500]:
+                continue  # Retry
+            else:
+                print(f"⚠️ Anthropic API error: {response.status_code}")
+                return None
                 
-                # Handle specific status codes
-                if response.status_code == 200:
-                    print(f"🔍 DEBUG: Success! Response length: {len(response.text)}")
-                    return response.json(), None
-                elif response.status_code == 401:
-                    error_msg = "Authentication error: Invalid API key"
-                    print(f"❌ {error_msg}")
-                    print(f"🔍 DEBUG: Response text: {response.text}")
-                    # Don't retry auth errors
-                    return None, error_msg
-                elif response.status_code == 429:
-                    error_msg = "Rate limit exceeded or quota reached"
-                    print(f"⚠️ {error_msg}")
-                    print(f"🔍 DEBUG: Response text: {response.text}")
-                    # Always retry rate limit errors with increasing backoff
-                    last_error = error_msg
-                    continue
-                elif response.status_code == 500:
-                    error_msg = "Anthropic server error"
-                    print(f"⚠️ {error_msg}")
-                    print(f"🔍 DEBUG: Response text: {response.text}")
-                    # Retry server errors
-                    last_error = error_msg
-                    continue
-                else:
-                    error_msg = f"Status code: {response.status_code}, Response: {response.text}"
-                    print(f"⚠️ Anthropic API error: {error_msg}")
-                    print(f"🔍 DEBUG: Full response text: {response.text}")
-                    last_error = error_msg
-                    # Only retry if we have attempts left
-                    if attempt < retries:
-                        continue
-                    return None, error_msg
-            except requests.exceptions.Timeout:
-                error_msg = "Request timed out"
-                last_error = error_msg
-                # Always retry timeouts
-                continue
-            except requests.exceptions.ConnectionError:
-                error_msg = "Connection error"
-                print(f"⚠️ {error_msg}")
-                print(f"🔍 DEBUG: Connection failed to api.anthropic.com")
-                last_error = error_msg
-                # Always retry connection errors
-                continue
-            except Exception as e:
-                error_msg = str(e)
-                print(f"⚠️ Unexpected error: {error_msg}")
-                print(f"🔍 DEBUG: Exception type: {type(e).__name__}")
-                print(f"🔍 DEBUG: Exception details: {str(e)}")
-                last_error = error_msg
-                # Only retry if we have attempts left
-                if attempt < retries:
-                    continue
-                return None, error_msg
-        
-        # If we get here, all retries failed
-        return None, last_error
-    
-    # Try each model in sequence until one works
-    result = None
-    last_error = None
+        except (requests.exceptions.Timeout, requests.exceptions.ConnectionError):
+            continue  # Retry
+        except Exception as e:
+            print(f"⚠️ Anthropic request error: {e}")
+            return None
     
-    for model in models_to_try:
-        result, error = try_api_call(model)
-        if result:
-            break
-        else:
-            print(f"⚠️ Failed to get response from {model}: {error}")
-            last_error = error
+    return None
+
+
+def make_openrouter_request(api_key, prompt, retries=2):
+    """Make request to OpenRouter API"""
+    headers = {
+        "x-api-key": api_key,
+        "content-type": "application/json"
+    }
     
-    if not result:
-        print(f"❌ All model attempts failed. Last error: {last_error}")
-        return None
+    payload = {
+        "model": "openai/gpt-5-mini",
+        "max_tokens": 300,
+        "messages": [{"role": "user", "content": prompt}]
+    }
     
-    # Process the response
-    try:
-        print(f"🔍 DEBUG: Processing Anthropic response...")
-        print(f"🔍 DEBUG: Choices count: {len(result.get('content', []))}")
-        
-        fix_command = result["content"][0]["text"].strip()
-        print(f"🔍 DEBUG: Raw response content: {fix_command}")
-        
-        # Save the original response for debugging
-        original_response = fix_command
-        
-        # Extract just the command if it's wrapped in backticks or explanation
-        if "```" in fix_command:
-            # Extract content between backticks
-            import re
-            code_blocks = re.findall(r'```(?:bash|sh)?\s*(.*?)\s*```', fix_command, re.DOTALL)
-            if code_blocks:
-                fix_command = code_blocks[0].strip()
-                print(f"✅ Extracted command from code block: {fix_command}")
-        
-        # If the response still has explanatory text, try to extract just the command
-        if len(fix_command.split('\n')) > 1:
-            # First try to find lines that look like commands (start with common command prefixes)
-            command_prefixes = ['sudo', 'apt', 'pip', 'npm', 'yarn', 'git', 'cd', 'mv', 'cp', 'rm', 'mkdir', 'touch', 
-                              'chmod', 'chown', 'echo', 'cat', 'python', 'python3', 'node', 'export',
-                              'curl', 'wget', 'docker', 'make', 'gcc', 'g++', 'javac', 'java',
-                              'conda', 'uv', 'poetry', 'nvm', 'rbenv', 'pyenv', 'rustup']
-            
-            # Check for lines that start with common command prefixes
-            command_lines = [line.strip() for line in fix_command.split('\n') 
-                           if any(line.strip().startswith(prefix) for prefix in command_prefixes)]
-            
-            if command_lines:
-                # Use the first command line found
-                fix_command = command_lines[0]
-                print(f"✅ Identified command by prefix: {fix_command}")
+    for attempt in range(retries + 1):
+        try:
+            if attempt > 0:
+                time.sleep(1.5 * (2 ** (attempt - 1)))
+            
+            response = requests.post(
+                "https://openrouter.ai/api/v1/chat/completions",
+                headers=headers,
+                json=payload,
+                timeout=45
+            )
+            
+            if response.status_code == 200:
+                result = response.json()
+                return result["choices"][0]["message"]["content"]
+            elif response.status_code == 401:
+                print("❌ Invalid OpenRouter API key")
+                return None
+            elif response.status_code in [429, 500]:
+                continue  # Retry
             else:
-                # Try to find lines that look like commands (contain common shell patterns)
-                shell_patterns = [' | ', ' > ', ' >> ', ' && ', ' || ', ' ; ', '$(',  '`', ' -y ', ' --yes ']
-                command_lines = [line.strip() for line in fix_command.split('\n') 
-                              if any(pattern in line for pattern in shell_patterns)]
+                print(f"⚠️ OpenRouter API error: {response.status_code}")
+                return None
                 
-                if command_lines:
-                    # Use the first command line found
-                    fix_command = command_lines[0]
-                    print(f"✅ Identified command by shell pattern: {fix_command}")
-                else:
-                    # Fall back to the shortest non-empty line as it's likely the command
-                    lines = [line.strip() for line in fix_command.split('\n') if line.strip()]
-                    if lines:
-                        # Exclude very short lines that are likely not commands
-                        valid_lines = [line for line in lines if len(line) > 5]
-                        if valid_lines:
-                            fix_command = min(valid_lines, key=len)
-                        else:
-                            fix_command = min(lines, key=len)
-                        print(f"✅ Selected shortest line as command: {fix_command}")
-        
-        # Clean up the command - remove any trailing periods or quotes
-        fix_command = fix_command.rstrip('.;"\'')
-        
-        # Remove common prefixes that LLMs sometimes add
-        prefixes_to_remove = [
-            "Run: ", "Execute: ", "Try: ", "Command: ", "Fix: ", "Solution: ",
-            "You should run: ", "You can run: ", "You need to run: "
-        ]
-        for prefix in prefixes_to_remove:
-            if fix_command.startswith(prefix):
-                fix_command = fix_command[len(prefix):].strip()
-                print(f"✅ Removed prefix: {prefix}")
-                break
-        
-        # If the command is still multi-line or very long, it might not be a valid command
-        if len(fix_command.split('\n')) > 1 or len(fix_command) > 500:
-            print("⚠️ Extracted command appears invalid (multi-line or too long)")
-            print("🔍 Original response from LLM:")
-            print("-" * 60)
-            print(original_response)
-            print("-" * 60)
-            print("⚠️ Using best guess for command")
-        
-        print(f"🔧 Suggested fix: {fix_command}")
-        print(f"🔍 DEBUG: Returning fix command: {fix_command}")
-        return fix_command
-    except Exception as e:
-        print(f"❌ Error processing Anthropic response: {e}")
-        print(f"🔍 DEBUG: Exception type: {type(e).__name__}")
-        print(f"🔍 DEBUG: Exception details: {str(e)}")
-        return None
-
-def call_openrouter_for_debug(command, error_output, api_key=None, current_dir=None, sandbox=None):
-    """Call OpenRouter to debug a failed command and suggest a fix"""
-    print("\n🔍 DEBUG: Starting OpenRouter debugging...")
-    print(f"🔍 DEBUG: Command: {command}")
-    print(f"🔍 DEBUG: Error output length: {len(error_output) if error_output else 0}")
-    print(f"🔍 DEBUG: Current directory: {current_dir}")
-    print(f"🔍 DEBUG: Sandbox available: {sandbox is not None}")
+        except (requests.exceptions.Timeout, requests.exceptions.ConnectionError):
+            continue  # Retry
+        except Exception as e:
+            print(f"⚠️ OpenRouter request error: {e}")
+            return None
     
-    # Define _to_str function locally to avoid NameError
-    def _to_str(maybe_bytes):
+    return None
+
+
+def make_groq_request(api_key, prompt, retries=2):
+    """Make request to Groq API (OpenAI-compatible endpoint)"""
+    headers = {
+        "Content-Type": "application/json",
+        "Authorization": f"Bearer {api_key}"
+    }
+
+    payload = {
+        "model": os.environ.get("GROQ_MODEL", "openai/gpt-oss-20b"),
+        "messages": [
+            {"role": "system", "content": "You are a debugging assistant. Provide only the terminal command to fix the issue."},
+            {"role": "user", "content": prompt}
+        ],
+        "temperature": 0.2,
+        "max_tokens": 300
+    }
+
+    endpoint = os.environ.get("GROQ_BASE_URL", "https://api.groq.com/openai/v1/chat/completions")
+
+    for attempt in range(retries + 1):
         try:
-            return (maybe_bytes.decode('utf-8') if isinstance(maybe_bytes, (bytes, bytearray)) else maybe_bytes)
-        except UnicodeDecodeError:
-            # Handle non-UTF-8 bytes by replacing invalid characters
-            if isinstance(maybe_bytes, (bytes, bytearray)):
-                return maybe_bytes.decode('utf-8', errors='replace')
+            if attempt > 0:
+                time.sleep(1.5 * (2 ** (attempt - 1)))
+
+            response = requests.post(
+                endpoint,
+                headers=headers,
+                json=payload,
+                timeout=45
+            )
+
+            if response.status_code == 200:
+                result = response.json()
+                return result["choices"][0]["message"]["content"]
+            elif response.status_code == 401:
+                print("❌ Invalid Groq API key")
+                return None
+            elif response.status_code in [429, 500]:
+                continue  # Retry
             else:
-                return str(maybe_bytes)
-        except Exception:
-            # Last resort fallback
-            return str(maybe_bytes)
-            
-    # Skip debugging for certain commands that commonly return non-zero exit codes
-    # but aren't actually errors (like test commands)
+                print(f"⚠️ Groq API error: {response.status_code}")
+                return None
+
+        except (requests.exceptions.Timeout, requests.exceptions.ConnectionError):
+            continue  # Retry
+        except Exception as e:
+            print(f"⚠️ Groq request error: {e}")
+            return None
+
+    return None
+
+
+def call_llm_for_debug(command, error_output, api_key=None, current_dir=None, sandbox=None, use_web_search=False):
+    """Unified function to call LLM for debugging"""
+    # Skip debugging for test commands
     if command.strip().startswith("test "):
-        print("🔍 Skipping debugging for test command - non-zero exit code is expected behavior")
         return None
         
-    # Validate error_output - if it's empty, we can't debug effectively
+    # Validate error output
     if not error_output or not error_output.strip():
-        print("⚠️ Error output is empty. Cannot effectively debug the command.")
-        print("⚠️ Skipping OpenRouter debugging due to lack of error information.")
+        print("⚠️ Error output is empty. Cannot debug effectively.")
         return None
     
-    # Try to get API key from multiple sources
+    current_model = get_current_debug_model()
+    print(f"🔍 Using {current_model.upper()} for debugging...")
+    
+    # Get API key
     if not api_key:
-        print("🔍 DEBUG: No OpenRouter API key provided, searching for one...")
-        
-        # First try environment variable
-        api_key = os.environ.get("OPENROUTER_API_KEY")
-        print(f"🔍 DEBUG: API key from environment: {'Found' if api_key else 'Not found'}")
-        if api_key:
-            print(f"🔍 DEBUG: Environment API key value: {api_key}")
-        
-        # If not in environment, try to fetch from server using fetch_modal_tokens
-        if not api_key:
-            try:
-                print("🔍 DEBUG: Trying to fetch API key from server...")
-                from fetch_modal_tokens import get_tokens
-                # Assuming OpenRouter key is the 5th token in the tuple
-                tokens = get_tokens()
-                if len(tokens) >= 5:
-                    api_key = tokens[4]
-            except Exception as e:
-                print(f"⚠️ Error fetching OpenRouter API key from server: {e}")
-            
-            # Then try credentials manager
-            if not api_key:
-                try:
-                    from credentials_manager import CredentialsManager
-                    credentials_manager = CredentialsManager()
-                    api_key = credentials_manager.get_openrouter_api_key()
-                except Exception as e:
-                    print(f"⚠️ Error getting OpenRouter API key from credentials manager: {e}")
-        
-        # Store the API key in a persistent file if found
-        if api_key:
-            try:
-                os.makedirs(os.path.expanduser("~/.gitarsenal"), exist_ok=True)
-                with open(os.path.expanduser("~/.gitarsenal/openrouter_key"), "w") as f:
-                    f.write(api_key)
-                print("✅ Saved OpenRouter API key for future use")
-            except Exception as e:
-                print(f"⚠️ Could not save API key: {e}")
-        
-        # Try to load from saved file if not in environment
-        if not api_key:
-            try:
-                key_file = os.path.expanduser("~/.gitarsenal/openrouter_key")
-                print(f"🔍 DEBUG: Checking for saved API key at: {key_file}")
-                if os.path.exists(key_file):
-                    with open(key_file, "r") as f:
-                        api_key = f.read().strip()
-                    if api_key:
-                        print("✅ Loaded OpenRouter API key from saved file")
-                        print(f"🔍 DEBUG: API key from file: {api_key}")
-                        print(f"🔍 DEBUG: API key length: {len(api_key)}")
-                        # Also set in environment for this session
-                        os.environ["OPENROUTER_API_KEY"] = api_key
-                    else:
-                        print("🔍 DEBUG: Saved file exists but is empty")
-                else:
-                    print("🔍 DEBUG: No saved API key file found")
-            except Exception as e:
-                print(f"⚠️ Could not load saved API key: {e}")
+        api_key = get_api_key(current_model)
     
     if not api_key:
-        print("❌ No OpenRouter API key available for debugging")
+        print(f"❌ No {current_model} API key available. Cannot perform LLM debugging.")
         return None
     
-    # Prepare the prompt for debugging
-    error_str = _to_str(error_output)
-    prompt = f"""You are a debugging assistant. Provide only the terminal command to fix the issue. 
-
-Context:
-- Current directory: {current_dir}
-- Sandbox available: {sandbox is not None}
-- Failed command: {command}
-- Error output: {error_str}
-
-Analyze the issue first, understand why it's happening, then provide the command to fix it. 
-
-Guidelines:
-- For file not found errors, first search for the file using 'find . -name filename -type f' and navigate to the directory if found
-- For missing packages, use appropriate package managers (pip, apt-get, npm)
-- For Git SSH authentication failures, always convert SSH URLs to HTTPS URLs (git@github.com:user/repo.git -> https://github.com/user/repo.git)
-- For authentication, suggest login commands with placeholders
-- For permission errors, suggest commands with sudo if appropriate
-- For network issues, suggest retry commands or alternative URLs
-
-Return only the command to fix the issue, nothing else."""
-
-    # Set up headers for OpenRouter API
-    headers = {
-        "x-api-key": api_key,
-        "content-type": "application/json"
-    }
+    # Save API key for future use
+    save_api_key(current_model, api_key)
     
-    # Models to try in order of preference
-    models_to_try = ["openrouter/openai-gpt-4o-mini"]
+    # Gather context
+    system_info, directory_context, file_context = gather_context(sandbox, current_dir)
     
-    def try_api_call(model_name, retries=2, backoff_factor=1.5):
-        payload = {
-            "model": model_name,
-            "max_tokens": 300,
-            "messages": [
-                {"role": "user", "content": prompt}
-            ]
-        }
-        
-        print(f"🔍 DEBUG: Payload prepared, prompt length: {len(prompt)}")
-        
-        # Add specific handling for common errors
-        last_error = None
-        for attempt in range(retries + 1):
-            try:
-                if attempt > 0:
-                    # Exponential backoff
-                    wait_time = backoff_factor * (2 ** (attempt - 1))
-                    print(f"⏱️ Retrying in {wait_time:.1f} seconds... (attempt {attempt+1}/{retries+1})")
-                    time.sleep(wait_time)
-                
-                print(f"🤖 Calling OpenRouter with {model_name} model to debug the failed command...")
-                print(f"🔍 DEBUG: Making POST request to OpenRouter API...")
-                response = requests.post(
-                    "https://openrouter.ai/api/v1/chat/completions", # OpenRouter API endpoint
-                    headers=headers,
-                    json=payload,
-                    timeout=45  # Increased timeout for reliability
-                )
-                
-                print(f"🔍 DEBUG: Response received, status code: {response.status_code}")
-                
-                # Handle specific status codes
-                if response.status_code == 200:
-                    print(f"🔍 DEBUG: Success! Response length: {len(response.text)}")
-                    return response.json(), None
-                elif response.status_code == 401:
-                    error_msg = "Authentication error: Invalid API key"
-                    print(f"❌ {error_msg}")
-                    print(f"🔍 DEBUG: Response text: {response.text}")
-                    # Don't retry auth errors
-                    return None, error_msg
-                elif response.status_code == 429:
-                    error_msg = "Rate limit exceeded or quota reached"
-                    print(f"⚠️ {error_msg}")
-                    print(f"🔍 DEBUG: Response text: {response.text}")
-                    # Always retry rate limit errors with increasing backoff
-                    last_error = error_msg
-                    continue
-                elif response.status_code == 500:
-                    error_msg = "OpenRouter server error"
-                    print(f"⚠️ {error_msg}")
-                    print(f"🔍 DEBUG: Response text: {response.text}")
-                    # Retry server errors
-                    last_error = error_msg
-                    continue
-                else:
-                    error_msg = f"Status code: {response.status_code}, Response: {response.text}"
-                    print(f"⚠️ OpenRouter API error: {error_msg}")
-                    print(f"🔍 DEBUG: Full response text: {response.text}")
-                    last_error = error_msg
-                    # Only retry if we have attempts left
-                    if attempt < retries:
-                        continue
-                    return None, error_msg
-            except requests.exceptions.Timeout:
-                error_msg = "Request timed out"
-                last_error = error_msg
-                # Always retry timeouts
-                continue
-            except requests.exceptions.ConnectionError:
-                error_msg = "Connection error"
-                print(f"⚠️ {error_msg}")
-                print(f"🔍 DEBUG: Connection failed to openrouter.ai")
-                last_error = error_msg
-                # Always retry connection errors
-                continue
-            except Exception as e:
-                error_msg = str(e)
-                print(f"⚠️ Unexpected error: {error_msg}")
-                print(f"🔍 DEBUG: Exception type: {type(e).__name__}")
-                print(f"🔍 DEBUG: Exception details: {str(e)}")
-                last_error = error_msg
-                # Only retry if we have attempts left
-                if attempt < retries:
-                    continue
-                return None, error_msg
-        
-        # If we get here, all retries failed
-        return None, last_error
+    # Get credentials context
+    stored_credentials = get_stored_credentials()
+    auth_context = generate_auth_context(stored_credentials)
     
-    # Try each model in sequence until one works
-    result = None
-    last_error = None
+    # Create prompt
+    prompt = create_debug_prompt(command, error_output, system_info, directory_context, file_context, auth_context)
     
-    for model in models_to_try:
-        result, error = try_api_call(model)
-        if result:
-            break
-        else:
-            print(f"⚠️ Failed to get response from {model}: {error}")
-            last_error = error
+    print(f"\n{'='*60}")
+    print("DEBUG: ERROR_OUTPUT SENT TO LLM:")
+    print(f"{'='*60}")
+    print(f"{error_output}")
+    print(f"{'='*60}\n")
     
-    if not result:
-        print(f"❌ All model attempts failed. Last error: {last_error}")
-        return None
+    # Make API request
+    print(f"🤖 Calling {current_model} to debug the failed command...")
+    response_text = make_api_request(current_model, api_key, prompt)
     
-    # Process the response
-    try:
-        print(f"🔍 DEBUG: Processing OpenRouter response...")
-        print(f"🔍 DEBUG: Choices count: {len(result.get('choices', []))}")
-        
-        fix_command = result["choices"][0]["message"]["content"].strip()
-        print(f"🔍 DEBUG: Raw response content: {fix_command}")
-        
-        # Save the original response for debugging
-        original_response = fix_command
-        
-        # Extract just the command if it's wrapped in backticks or explanation
-        if "```" in fix_command:
-            # Extract content between backticks
-            import re
-            code_blocks = re.findall(r'```(?:bash|sh)?\s*(.*?)\s*```', fix_command, re.DOTALL)
-            if code_blocks:
-                fix_command = code_blocks[0].strip()
-                print(f"✅ Extracted command from code block: {fix_command}")
-        
-        # If the response still has explanatory text, try to extract just the command
-        if len(fix_command.split('\n')) > 1:
-            # First try to find lines that look like commands (start with common command prefixes)
-            command_prefixes = ['sudo', 'apt', 'pip', 'npm', 'yarn', 'git', 'cd', 'mv', 'cp', 'rm', 'mkdir', 'touch', 
-                              'chmod', 'chown', 'echo', 'cat', 'python', 'python3', 'node', 'export',
-                              'curl', 'wget', 'docker', 'make', 'gcc', 'g++', 'javac', 'java',
-                              'conda', 'uv', 'poetry', 'nvm', 'rbenv', 'pyenv', 'rustup']
-            
-            # Check for lines that start with common command prefixes
-            command_lines = [line.strip() for line in fix_command.split('\n') 
-                           if any(line.strip().startswith(prefix) for prefix in command_prefixes)]
-            
-            if command_lines:
-                # Use the first command line found
-                fix_command = command_lines[0]
-                print(f"✅ Identified command by prefix: {fix_command}")
-            else:
-                # Try to find lines that look like commands (contain common shell patterns)
-                shell_patterns = [' | ', ' > ', ' >> ', ' && ', ' || ', ' ; ', '$(',  '`', ' -y ', ' --yes ']
-                command_lines = [line.strip() for line in fix_command.split('\n') 
-                              if any(pattern in line for pattern in shell_patterns)]
-                
-                if command_lines:
-                    # Use the first command line found
-                    fix_command = command_lines[0]
-                    print(f"✅ Identified command by shell pattern: {fix_command}")
-                else:
-                    # Fall back to the shortest non-empty line as it's likely the command
-                    lines = [line.strip() for line in fix_command.split('\n') if line.strip()]
-                    if lines:
-                        # Exclude very short lines that are likely not commands
-                        valid_lines = [line for line in lines if len(line) > 5]
-                        if valid_lines:
-                            fix_command = min(valid_lines, key=len)
-                        else:
-                            fix_command = min(lines, key=len)
-                        print(f"✅ Selected shortest line as command: {fix_command}")
-        
-        # Clean up the command - remove any trailing periods or quotes
-        fix_command = fix_command.rstrip('.;"\'')
-        
-        # Remove common prefixes that LLMs sometimes add
-        prefixes_to_remove = [
-            "Run: ", "Execute: ", "Try: ", "Command: ", "Fix: ", "Solution: ",
-            "You should run: ", "You can run: ", "You need to run: "
-        ]
-        for prefix in prefixes_to_remove:
-            if fix_command.startswith(prefix):
-                fix_command = fix_command[len(prefix):].strip()
-                print(f"✅ Removed prefix: {prefix}")
-                break
-        
-        # If the command is still multi-line or very long, it might not be a valid command
-        if len(fix_command.split('\n')) > 1 or len(fix_command) > 500:
-            print("⚠️ Extracted command appears invalid (multi-line or too long)")
-            print("🔍 Original response from LLM:")
-            print("-" * 60)
-            print(original_response)
-            print("-" * 60)
-            print("⚠️ Using best guess for command")
-        
-        print(f"🔧 Suggested fix: {fix_command}")
-        print(f"🔍 DEBUG: Returning fix command: {fix_command}")
-        return fix_command
-    except Exception as e:
-        print(f"❌ Error processing OpenRouter response: {e}")
-        print(f"🔍 DEBUG: Exception type: {type(e).__name__}")
-        print(f"🔍 DEBUG: Exception details: {str(e)}")
+    if not response_text:
         return None
-
-
-def call_llm_for_batch_debug(failed_commands, api_key=None, current_dir=None, sandbox=None):
-    """Unified function to call LLM for batch debugging - routes to OpenAI or Anthropic based on configuration"""
-    current_model = get_current_debug_model()
     
-    print(f"🔍 DEBUG: Using {current_model.upper()} for batch debugging...")
+    # Extract command from response
+    fix_command = extract_command_from_response(response_text)
     
-    if current_model == "anthropic":
-        # Try to get Anthropic API key if not provided
-        if not api_key:
-            # First try environment variable
-            api_key = os.environ.get("ANTHROPIC_API_KEY")
-            
-            # If not in environment, try to fetch from server using fetch_modal_tokens
-            if not api_key:
-                try:
-                    from fetch_modal_tokens import get_tokens
-                    _, _, _, api_key = get_tokens()
-                except Exception as e:
-                    print(f"⚠️ Error fetching Anthropic API key from server: {e}")
-            
-            # Then try credentials manager
-            if not api_key:
-                try:
-                    from credentials_manager import CredentialsManager
-                    credentials_manager = CredentialsManager()
-                    api_key = credentials_manager.get_anthropic_api_key()
-                except Exception as e:
-                    print(f"⚠️ Error getting Anthropic API key from credentials manager: {e}")
-        
-        return call_anthropic_for_batch_debug(failed_commands, api_key, current_dir, sandbox)
-    elif current_model == "openrouter":
-        # Try to get OpenRouter API key if not provided
-        if not api_key:
-            # First try environment variable
-            api_key = os.environ.get("OPENROUTER_API_KEY")
-            
-            # If not in environment, try to fetch from server using fetch_modal_tokens
-            if not api_key:
-                try:
-                    from fetch_modal_tokens import get_tokens
-                    # Assuming OpenRouter key is the 5th token in the tuple
-                    tokens = get_tokens()
-                    if len(tokens) >= 5:
-                        api_key = tokens[4]
-                except Exception as e:
-                    print(f"⚠️ Error fetching OpenRouter API key from server: {e}")
-            
-            # Then try credentials manager
-            if not api_key:
-                try:
-                    from credentials_manager import CredentialsManager
-                    credentials_manager = CredentialsManager()
-                    api_key = credentials_manager.get_openrouter_api_key()
-                except Exception as e:
-                    print(f"⚠️ Error getting OpenRouter API key from credentials manager: {e}")
-        
-        return call_openrouter_for_batch_debug(failed_commands, api_key, current_dir, sandbox)
-    else:
-        # Default to OpenAI
-        # Try to get OpenAI API key if not provided
-        if not api_key:
-            # First try environment variable
-            api_key = os.environ.get("OPENAI_API_KEY")
-            
-            # If not in environment, try to fetch from server using fetch_modal_tokens
-            if not api_key:
-                try:
-                    from fetch_modal_tokens import get_tokens
-                    _, _, api_key, _ = get_tokens()
-                except Exception as e:
-                    print(f"⚠️ Error fetching OpenAI API key from server: {e}")
-            
-            # Then try credentials manager
-            if not api_key:
-                try:
-                    from credentials_manager import CredentialsManager
-                    credentials_manager = CredentialsManager()
-                    api_key = credentials_manager.get_openai_api_key()
-                except Exception as e:
-                    print(f"⚠️ Error getting OpenAI API key from credentials manager: {e}")
-        
-        return call_openai_for_batch_debug(failed_commands, api_key, current_dir, sandbox)
+    print(f"🔧 Suggested fix: {fix_command}")
+    return fix_command
 
-def call_anthropic_for_batch_debug(failed_commands, api_key=None, current_dir=None, sandbox=None):
-    """Call Anthropic Claude to debug multiple failed commands and suggest fixes for all of them at once"""
-    print("\n🔍 DEBUG: Starting batch Anthropic Claude debugging...")
-    print(f"🔍 DEBUG: Analyzing {len(failed_commands)} failed commands")
-    
+
+def call_llm_for_batch_debug(failed_commands, api_key=None, current_dir=None, sandbox=None, use_web_search=False):
+    """Call LLM for batch debugging of multiple failed commands"""
     if not failed_commands:
-        print("⚠️ No failed commands to analyze")
         return []
     
+    current_model = get_current_debug_model()
+    
+    # Get API key
     if not api_key:
-        print("🔍 DEBUG: No Anthropic API key provided, searching for one...")
-        
-        # First try environment variable
-        api_key = os.environ.get("ANTHROPIC_API_KEY")
-        print(f"🔍 DEBUG: API key from environment: {'Found' if api_key else 'Not found'}")
-        if api_key:
-            print(f"🔍 DEBUG: Environment API key value: {api_key}")
-        
-        # If not in environment, try to fetch from server using fetch_modal_tokens
-        if not api_key:
-            try:
-                print("🔍 DEBUG: Trying to fetch API key from server...")
-                from fetch_modal_tokens import get_tokens
-                _, _, _, api_key = get_tokens()
-                if api_key:
-                    # Set in environment for this session
-                    os.environ["ANTHROPIC_API_KEY"] = api_key
-                else:
-                    print("⚠️ Could not fetch Anthropic API key from server")
-            except Exception as e:
-                print(f"⚠️ Error fetching API key from server: {e}")
-        
-        # Then try credentials manager
-        if not api_key:
-            print("🔍 DEBUG: Trying credentials manager...")
-            try:
-                from credentials_manager import CredentialsManager
-                credentials_manager = CredentialsManager()
-                api_key = credentials_manager.get_anthropic_api_key()
-                if api_key:
-                    print(f"🔍 DEBUG: API key from credentials manager: Found")
-                    print(f"🔍 DEBUG: Credentials manager API key value: {api_key}")
-                    # Set in environment for this session
-                    os.environ["ANTHROPIC_API_KEY"] = api_key
-                else:
-                    print("⚠️ Could not fetch Anthropic API key from credentials manager")
-            except Exception as e:
-                print(f"⚠️ Error fetching API key from credentials manager: {e}")
-        
-        if not api_key:
-            print("❌ No Anthropic API key available for batch debugging")
-            return []
+        api_key = get_api_key(current_model)
+    
+    if not api_key:
+        print(f"❌ No {current_model} API key available for batch debugging")
+        return []
     
     # Prepare context for batch analysis
-    context_parts = []
-    context_parts.append(f"Current directory: {current_dir}")
-    context_parts.append(f"Sandbox available: {sandbox is not None}")
+    context_parts = [f"Current directory: {current_dir}", f"Sandbox available: {sandbox is not None}"]
     
-    # Add failed commands with their errors
     for i, failed_cmd in enumerate(failed_commands, 1):
         cmd_type = failed_cmd.get('type', 'main')
         original_cmd = failed_cmd.get('original_command', '')
@@ -1668,7 +623,7 @@ def call_anthropic_for_batch_debug(failed_commands, api_key=None, current_dir=No
         if stdout:
             context_parts.append(f"Standard Output: {stdout}")
     
-    # Create the prompt for batch analysis
+    # Create batch prompt
     prompt = f"""You are a debugging assistant analyzing multiple failed commands. 
 
 Context:
@@ -1676,257 +631,88 @@ Context:
 
 Please analyze each failed command and provide a fix command for each one. For each failed command, respond with:
 
-FIX_COMMAND_{i}: <the fix command>
-REASON_{i}: <brief explanation of why the original command failed and how the fix addresses it>
+FIX_COMMAND_{{i}}: <the fix command>
+REASON_{{i}}: <brief explanation of why the original command failed and how the fix addresses it>
 
 Guidelines:
 - For file not found errors, first search for the file using 'find . -name filename -type f'
 - For missing packages, use appropriate package managers (pip, apt-get, npm)
 - For Git SSH authentication failures, convert SSH URLs to HTTPS URLs
 - For permission errors, suggest commands with sudo if appropriate
-- For network issues, suggest retry commands or alternative URLs
 - Keep each fix command simple and focused on the specific error
 
 Provide fixes for all {len(failed_commands)} failed commands:"""
-
-    # Set up headers for Anthropic API
-    headers = {
-        "x-api-key": api_key,
-        "anthropic-version": "2023-06-01",
-        "content-type": "application/json"
-    }
     
-    payload = {
-        "model": "claude-3-5-sonnet-20241022",  # Use a more capable model for batch analysis
-        "max_tokens": 1000,
-        "messages": [
-            {"role": "user", "content": prompt}
-        ]
-    }
-    
-    try:
-        print(f"🤖 Calling Anthropic Claude for batch debugging of {len(failed_commands)} commands...")
-        response = requests.post(
-            "https://api.anthropic.com/v1/messages",
-            headers=headers,
-            json=payload,
-            timeout=60
-        )
-        
-        if response.status_code == 200:
-            result = response.json()
-            content = result['content'][0]['text']
-            print(f"✅ Batch analysis completed")
-            
-            # Parse the response to extract fix commands
-            fixes = []
-            for i in range(1, len(failed_commands) + 1):
-                fix_pattern = f"FIX_COMMAND_{i}: (.+)"
-                reason_pattern = f"REASON_{i}: (.+)"
-                
-                fix_match = re.search(fix_pattern, content, re.MULTILINE)
-                reason_match = re.search(reason_pattern, content, re.MULTILINE)
-                
-                if fix_match:
-                    fix_command = fix_match.group(1).strip()
-                    reason = reason_match.group(1).strip() if reason_match else "Anthropic Claude suggested fix"
-                    
-                    # Clean up the fix command
-                    if fix_command.startswith('`') and fix_command.endswith('`'):
-                        fix_command = fix_command[1:-1]
-                    
-                    fixes.append({
-                        'original_command': failed_commands[i-1]['command'],
-                        'fix_command': fix_command,
-                        'reason': reason,
-                        'command_index': i-1
-                    })
-            
-            print(f"🔧 Generated {len(fixes)} fix commands from batch analysis")
-            return fixes
-        else:
-            print(f"❌ Anthropic API error: {response.status_code} - {response.text}")
-            return []
-            
-    except Exception as e:
-        print(f"❌ Error during batch debugging: {e}")
-        return []
-
-def call_openrouter_for_batch_debug(failed_commands, api_key=None, current_dir=None, sandbox=None):
-    """Call OpenRouter to debug multiple failed commands and suggest fixes for all of them at once"""
-    print("\n🔍 DEBUG: Starting batch OpenRouter debugging...")
-    print(f"🔍 DEBUG: Analyzing {len(failed_commands)} failed commands")
+    print(f"🤖 Calling {current_model} for batch debugging of {len(failed_commands)} commands...")
+    response_text = make_api_request(current_model, api_key, prompt)
     
-    if not failed_commands:
-        print("⚠️ No failed commands to analyze")
+    if not response_text:
         return []
     
-    if not api_key:
-        print("🔍 DEBUG: No OpenRouter API key provided, searching for one...")
+    # Parse the response to extract fix commands
+    fixes = []
+    for i in range(1, len(failed_commands) + 1):
+        fix_pattern = f"FIX_COMMAND_{i}: (.+)"
+        reason_pattern = f"REASON_{i}: (.+)"
         
-        # First try environment variable
-        api_key = os.environ.get("OPENROUTER_API_KEY")
-        print(f"🔍 DEBUG: API key from environment: {'Found' if api_key else 'Not found'}")
-        if api_key:
-            print(f"🔍 DEBUG: Environment API key value: {api_key}")
+        fix_match = re.search(fix_pattern, response_text, re.MULTILINE)
+        reason_match = re.search(reason_pattern, response_text, re.MULTILINE)
         
-        # If not in environment, try to fetch from server using fetch_modal_tokens
-        if not api_key:
-            try:
-                print("🔍 DEBUG: Trying to fetch API key from server...")
-                from fetch_modal_tokens import get_tokens
-                # Assuming OpenRouter key is the 5th token in the tuple
-                tokens = get_tokens()
-                if len(tokens) >= 5:
-                    api_key = tokens[4]
-            except Exception as e:
-                print(f"⚠️ Error fetching OpenRouter API key from server: {e}")
+        if fix_match:
+            fix_command = fix_match.group(1).strip()
+            reason = reason_match.group(1).strip() if reason_match else "LLM suggested fix"
             
-            # Then try credentials manager
-            if not api_key:
-                try:
-                    from credentials_manager import CredentialsManager
-                    credentials_manager = CredentialsManager()
-                    api_key = credentials_manager.get_openrouter_api_key()
-                except Exception as e:
-                    print(f"⚠️ Error getting OpenRouter API key from credentials manager: {e}")
-        
-        # Store the API key in a persistent file if found
-        if api_key:
-            try:
-                os.makedirs(os.path.expanduser("~/.gitarsenal"), exist_ok=True)
-                with open(os.path.expanduser("~/.gitarsenal/openrouter_key"), "w") as f:
-                    f.write(api_key)
-                print("✅ Saved OpenRouter API key for future use")
-            except Exception as e:
-                print(f"⚠️ Could not save API key: {e}")
-        
-        # Try to load from saved file if not in environment
-        if not api_key:
-            try:
-                key_file = os.path.expanduser("~/.gitarsenal/openrouter_key")
-                print(f"🔍 DEBUG: Checking for saved API key at: {key_file}")
-                if os.path.exists(key_file):
-                    with open(key_file, "r") as f:
-                        api_key = f.read().strip()
-                    if api_key:
-                        print("✅ Loaded OpenRouter API key from saved file")
-                        print(f"🔍 DEBUG: API key from file: {api_key}")
-                        print(f"🔍 DEBUG: API key length: {len(api_key)}")
-                        # Also set in environment for this session
-                        os.environ["OPENROUTER_API_KEY"] = api_key
-                    else:
-                        print("🔍 DEBUG: Saved file exists but is empty")
-                else:
-                    print("🔍 DEBUG: No saved API key file found")
-            except Exception as e:
-                print(f"⚠️ Could not load saved API key: {e}")
-    
-    if not api_key:
-        print("❌ No OpenRouter API key available for batch debugging")
-        return []
-    
-    # Prepare context for batch analysis
-    context_parts = []
-    context_parts.append(f"Current directory: {current_dir}")
-    context_parts.append(f"Sandbox available: {sandbox is not None}")
-    
-    # Add failed commands with their errors
-    for i, failed_cmd in enumerate(failed_commands, 1):
-        cmd_type = failed_cmd.get('type', 'main')
-        original_cmd = failed_cmd.get('original_command', '')
-        cmd_text = failed_cmd['command']
-        stderr = failed_cmd.get('stderr', '')
-        stdout = failed_cmd.get('stdout', '')
-        
-        context_parts.append(f"\n--- Failed Command {i} ({cmd_type}) ---")
-        context_parts.append(f"Command: {cmd_text}")
-        if original_cmd and original_cmd != cmd_text:
-            context_parts.append(f"Original Command: {original_cmd}")
-        if stderr:
-            context_parts.append(f"Error Output: {stderr}")
-        if stdout:
-            context_parts.append(f"Standard Output: {stdout}")
+            # Clean up the fix command
+            if fix_command.startswith('`') and fix_command.endswith('`'):
+                fix_command = fix_command[1:-1]
+            
+            fixes.append({
+                'original_command': failed_commands[i-1]['command'],
+                'fix_command': fix_command,
+                'reason': reason,
+                'command_index': i-1
+            })
     
-    # Create the prompt for batch analysis
-    prompt = f"""You are a debugging assistant analyzing multiple failed commands. 
+    print(f"🔧 Generated {len(fixes)} fix commands from batch analysis")
+    return fixes
 
-Context:
-{chr(10).join(context_parts)}
 
-Please analyze each failed command and provide a fix command for each one. For each failed command, respond with:
+# Legacy function aliases for backward compatibility
+def call_openai_for_debug(command, error_output, api_key=None, current_dir=None, sandbox=None):
+    """Legacy OpenAI-specific function - now routes to unified function"""
+    return call_llm_for_debug(command, error_output, api_key, current_dir, sandbox)
 
-FIX_COMMAND_{i}: <the fix command>
-REASON_{i}: <brief explanation of why the original command failed and how the fix addresses it>
 
-Guidelines:
-- For file not found errors, first search for the file using 'find . -name filename -type f'
-- For missing packages, use appropriate package managers (pip, apt-get, npm)
-- For Git SSH authentication failures, convert SSH URLs to HTTPS URLs
-- For permission errors, suggest commands with sudo if appropriate
-- For network issues, suggest retry commands or alternative URLs
-- Keep each fix command simple and focused on the specific error
+def call_anthropic_for_debug(command, error_output, api_key=None, current_dir=None, sandbox=None):
+    """Legacy Anthropic-specific function - now routes to unified function"""
+    return call_llm_for_debug(command, error_output, api_key, current_dir, sandbox)
 
-Provide fixes for all {len(failed_commands)} failed commands:"""
 
-    # Set up headers for OpenRouter API
-    headers = {
-        "x-api-key": api_key,
-        "content-type": "application/json"
-    }
-    
-    payload = {
-        "model": "openrouter/openai-gpt-4o-mini", # Use a more capable model for batch analysis
-        "max_tokens": 1000,
-        "messages": [
-            {"role": "user", "content": prompt}
-        ]
-    }
-    
-    try:
-        print(f"🤖 Calling OpenRouter for batch debugging of {len(failed_commands)} commands...")
-        response = requests.post(
-            "https://openrouter.ai/api/v1/chat/completions", # OpenRouter API endpoint
-            headers=headers,
-            json=payload,
-            timeout=60
-        )
-        
-        if response.status_code == 200:
-            result = response.json()
-            content = result['choices'][0]['message']['content']
-            print(f"✅ Batch analysis completed")
-            
-            # Parse the response to extract fix commands
-            fixes = []
-            for i in range(1, len(failed_commands) + 1):
-                fix_pattern = f"FIX_COMMAND_{i}: (.+)"
-                reason_pattern = f"REASON_{i}: (.+)"
-                
-                fix_match = re.search(fix_pattern, content, re.MULTILINE)
-                reason_match = re.search(reason_pattern, content, re.MULTILINE)
-                
-                if fix_match:
-                    fix_command = fix_match.group(1).strip()
-                    reason = reason_match.group(1).strip() if reason_match else "OpenRouter suggested fix"
-                    
-                    # Clean up the fix command
-                    if fix_command.startswith('`') and fix_command.endswith('`'):
-                        fix_command = fix_command[1:-1]
-                    
-                    fixes.append({
-                        'original_command': failed_commands[i-1]['command'],
-                        'fix_command': fix_command,
-                        'reason': reason,
-                        'command_index': i-1
-                    })
-            
-            print(f"🔧 Generated {len(fixes)} fix commands from batch analysis")
-            return fixes
-        else:
-            print(f"❌ OpenRouter API error: {response.status_code} - {response.text}")
-            return []
-            
-    except Exception as e:
-        print(f"❌ Error during batch debugging: {e}")
-        return []
+def call_openrouter_for_debug(command, error_output, api_key=None, current_dir=None, sandbox=None):
+    """Legacy OpenRouter-specific function - now routes to unified function"""
+    return call_llm_for_debug(command, error_output, api_key, current_dir, sandbox)
+
+
+def call_openai_for_batch_debug(failed_commands, api_key=None, current_dir=None, sandbox=None):
+    """Legacy OpenAI batch function - now routes to unified function"""
+    return call_llm_for_batch_debug(failed_commands, api_key, current_dir, sandbox)
+
+
+def call_anthropic_for_batch_debug(failed_commands, api_key=None, current_dir=None, sandbox=None):
+    """Legacy Anthropic batch function - now routes to unified function"""
+    return call_llm_for_batch_debug(failed_commands, api_key, current_dir, sandbox)
+
+
+def call_openrouter_for_batch_debug(failed_commands, api_key=None, current_dir=None, sandbox=None):
+    """Legacy OpenRouter batch function - now routes to unified function"""
+    return call_llm_for_batch_debug(failed_commands, api_key, current_dir, sandbox)
+
+
+def call_groq_for_debug(command, error_output, api_key=None, current_dir=None, sandbox=None):
+    """Legacy Groq-specific function - now routes to unified function"""
+    return call_llm_for_debug(command, error_output, api_key, current_dir, sandbox)
+
+
+def call_groq_for_batch_debug(failed_commands, api_key=None, current_dir=None, sandbox=None):
+    """Legacy Groq batch function - now routes to unified function"""
+    return call_llm_for_batch_debug(failed_commands, api_key, current_dir, sandbox)