gitarsenal-cli 1.9.24 → 1.9.25

package/.venv_status.json

@@ -1 +1 @@
-{"created":"2025-08-07T09:48:26.761Z","packages":["modal","gitingest","requests","anthropic"],"uv_version":"uv 0.8.4 (Homebrew 2025-07-30)"}
+{"created":"2025-08-07T10:49:35.026Z","packages":["modal","gitingest","requests","anthropic"],"uv_version":"uv 0.8.4 (Homebrew 2025-07-30)"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitarsenal-cli",
-  "version": "1.9.24",
+  "version": "1.9.25",
   "description": "CLI tool for creating Modal sandboxes with GitHub repositories",
   "main": "index.js",
   "bin": {

package/python/llm_debugging.py

@@ -4,6 +4,8 @@ import json
 import requests
 import openai
 import anthropic
+import time
+import getpass
 
 
 def get_stored_credentials():
@@ -39,10 +41,10 @@ def generate_auth_context(stored_credentials):
 
 def get_current_debug_model():
     """Get the currently configured debugging model preference"""
-    return os.environ.get("GITARSENAL_DEBUG_MODEL", "openai")
+    return os.environ.get("GITARSENAL_DEBUG_MODEL", "anthropic")
 
 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 or Anthropic based on configuration"""
+    """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...")
@@ -71,6 +73,33 @@ def call_llm_for_debug(command, error_output, api_key=None, current_dir=None, sa
                     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
@@ -469,7 +498,7 @@ Do not provide any explanations, just the exact command to run.
     
     # Try to use GPT-4 first, but fall back to other models if needed
     models_to_try = [
-        "gpt-4o-mini",        # First choice: GPT-4o (most widely available)
+        "gpt-4.1-mini",        # First choice: GPT-4o (most widely available)
     ]
     
     # Check if we have a preferred model in environment
@@ -953,7 +982,7 @@ Return only the command to fix the issue, nothing else."""
     }
     
     # Models to try in order of preference
-    models_to_try = ["claude-4-sonnet"]
+    models_to_try = ["claude-sonnet-4-20250514"]
     
     def try_api_call(model_name, retries=2, backoff_factor=1.5):
         payload = {
@@ -1152,6 +1181,334 @@ Return only the command to fix the issue, nothing else."""
         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}")
+    
+    # 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 OpenRouter debugging due to lack of error information.")
+        return None
+    
+    # Try to get API key from multiple sources
+    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}")
+    
+    if not api_key:
+        print("❌ No OpenRouter API key available for 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"
+    }
+    
+    # Models to try in order of preference
+    models_to_try = ["openrouter/openai-gpt-4o-mini"]
+    
+    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
+    
+    # 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:
+            break
+        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 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)}")
+        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"""
@@ -1183,6 +1540,33 @@ def call_llm_for_batch_debug(failed_commands, api_key=None, current_dir=None, sa
                     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
@@ -1364,6 +1748,185 @@ Provide fixes for all {len(failed_commands)} failed commands:"""
             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")
+    
+    if not failed_commands:
+        print("⚠️ No failed commands to analyze")
+        return []
+    
+    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}")
+    
+    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}")
+    
+    # Create the prompt for batch analysis
+    prompt = f"""You are a debugging assistant analyzing multiple failed commands. 
+
+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
+
+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 []

package/python/test_modalSandboxScript.py

@@ -381,7 +381,7 @@ def create_modal_ssh_container(gpu_type, repo_url=None, repo_name=None, setup_co
         try:
             from command_manager import CommandListManager
             from shell import PersistentShell
-            from llm_debugging import get_stored_credentials, generate_auth_context, call_llm_for_debug, call_llm_for_batch_debug, call_anthropic_for_debug, call_openai_for_debug, call_openai_for_batch_debug, call_anthropic_for_batch_debug, get_current_debug_model
+            from llm_debugging import get_stored_credentials, generate_auth_context, call_llm_for_debug, call_llm_for_batch_debug, call_anthropic_for_debug, call_openai_for_debug, call_openai_for_batch_debug, call_anthropic_for_batch_debug, call_openrouter_for_debug, call_openrouter_for_batch_debug, get_current_debug_model
             
             print("✅ Successfully imported CommandListManager, PersistentShell, and all llm_debugging functions from mounted modules")
         except ImportError as e:
@@ -1867,7 +1867,7 @@ Return only the JSON array, no other text.
         client = openai.OpenAI(api_key=api_key)
         
         response = client.chat.completions.create(
-            model="gpt-3.5-turbo",
+            model="gpt-4.1-mini",
             messages=[
                 {"role": "system", "content": "You are a command preprocessing assistant that modifies setup commands to use available credentials and make them non-interactive."},
                 {"role": "user", "content": prompt}