gitarsenal-cli 1.9.26 → 1.9.27

package/.venv_status.json

@@ -1 +1 @@
-{"created":"2025-08-07T11:45:36.545Z","packages":["modal","gitingest","requests","anthropic"],"uv_version":"uv 0.8.4 (Homebrew 2025-07-30)"}
+{"created":"2025-08-08T04:25:52.914Z","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.26",
+  "version": "1.9.27",
   "description": "CLI tool for creating Modal sandboxes with GitHub repositories",
   "main": "index.js",
   "bin": {

package/python/command_manager.py

@@ -255,7 +255,7 @@ class CommandListManager:
         
         return all_commands
     
-    def analyze_failed_commands_with_llm(self, api_key=None, current_dir=None, sandbox=None):
+    def analyze_failed_commands_with_llm(self, api_key=None, current_dir=None, sandbox=None, use_web_search=False):
         """Analyze all failed commands using LLM and add suggested fixes."""
         failed_commands = self.get_failed_commands_for_llm()
         
@@ -266,7 +266,7 @@ class CommandListManager:
         print(f"🔍 Analyzing {len(failed_commands)} failed commands with LLM...")
         
         # Use unified batch debugging for efficiency
-        fixes = call_llm_for_batch_debug(failed_commands, api_key, current_dir, sandbox)
+        fixes = call_llm_for_batch_debug(failed_commands, api_key, current_dir, sandbox, use_web_search)
         
         # Add the fixes to the command list
         added_fixes = []
@@ -296,18 +296,17 @@ class CommandListManager:
             tuple: (should_skip, reason)
         """
         try:
+            # Import required helpers once for this function scope
+            from llm_debugging import get_current_debug_model, get_api_key, make_api_request
+            
             # Get API key if not provided
             if not api_key:
-                api_key = os.environ.get("OPENAI_API_KEY")
-                if not api_key:
-                    # Try to load from saved file
-                    key_file = os.path.expanduser("~/.gitarsenal/openai_key")
-                    if os.path.exists(key_file):
-                        with open(key_file, "r") as f:
-                            api_key = f.read().strip()
+                # Use the same API key retrieval logic as the debugging functions
+                current_model = get_current_debug_model()
+                api_key = get_api_key(current_model)
             
             if not api_key:
-                print("⚠️ No OpenAI API key available for command list analysis")
+                print(f"⚠️ No {current_model} API key available for command list analysis")
                 return False, "No API key available"
             
             # Get all commands for context
@@ -342,23 +341,15 @@ class CommandListManager:
             RUN: <reason>
             """
             
-            # Call OpenAI API
-            import openai
-            client = openai.OpenAI(api_key=api_key)
+            current_model = get_current_debug_model()
             
-            print("🔍 Analyzing if original command should be skipped...")
+            print(f"🔍 Analyzing if original command should be skipped using {current_model}...")
             
-            response = client.chat.completions.create(
-                model="gpt-3.5-turbo",
-                messages=[
-                    {"role": "system", "content": "You are a helpful assistant that analyzes command execution."},
-                    {"role": "user", "content": prompt}
-                ],
-                max_tokens=100,
-                temperature=0.3
-            )
+            response_text = make_api_request(current_model, api_key, prompt)
             
-            response_text = response.choices[0].message.content.strip()
+            if not response_text:
+                print(f"⚠️ Failed to get response from {current_model}")
+                return False, f"Failed to get response from {current_model}"
             
             # Parse the response
             if response_text.startswith("SKIP:"):
@@ -421,18 +412,16 @@ class CommandListManager:
             bool: True if the list was updated, False otherwise
         """
         try:
+            from llm_debugging import get_current_debug_model, get_api_key, make_api_request
             # Get API key if not provided
             if not api_key:
-                api_key = os.environ.get("OPENAI_API_KEY")
-                if not api_key:
-                    # Try to load from saved file
-                    key_file = os.path.expanduser("~/.gitarsenal/openai_key")
-                    if os.path.exists(key_file):
-                        with open(key_file, "r") as f:
-                            api_key = f.read().strip()
+                # Use the same API key retrieval logic as the debugging functions
+                from llm_debugging import get_current_debug_model, get_api_key
+                current_model = get_current_debug_model()
+                api_key = get_api_key(current_model)
             
             if not api_key:
-                print("⚠️ No OpenAI API key available for command list analysis")
+                print(f"⚠️ No {current_model} API key available for command list analysis")
                 return False
             
             # Get all commands for context
@@ -486,24 +475,18 @@ class CommandListManager:
             Only include commands that need changes (SKIP, MODIFY, ADD_AFTER), not KEEP actions.
             """
             
-            # Call OpenAI API
-            import openai
+            # Use the unified LLM API call
+            from llm_debugging import make_api_request
             import json
-            client = openai.OpenAI(api_key=api_key)
-            
-            print("🔍 Analyzing command list for optimizations...")
-            
-            response = client.chat.completions.create(
-                model="gpt-4o-mini",  # Use a more capable model for this complex task
-                messages=[
-                    {"role": "system", "content": "You are a helpful assistant that analyzes and optimizes command lists."},
-                    {"role": "user", "content": prompt}
-                ],
-                max_tokens=1000,
-                temperature=0.2
-            )
+            current_model = get_current_debug_model()
             
-            response_text = response.choices[0].message.content.strip()
+            print(f"🔍 Analyzing command list for optimizations using {current_model}...")
+            
+            response_text = make_api_request(current_model, api_key, prompt)
+            
+            if not response_text:
+                print(f"⚠️ Failed to get response from {current_model}")
+                return False
             
             # Extract JSON from the response
             try:

package/python/credentials_manager.py

@@ -145,7 +145,7 @@ class CredentialsManager:
         # First try to fetch from server using fetch_modal_tokens (GitArsenal's key)
         try:
             from fetch_modal_tokens import get_tokens
-            _, _, api_key, _ = get_tokens()
+            _, _, api_key, _, _ = get_tokens()
             if api_key and validate_openai_key(api_key):
                 # Set in environment for future use
                 os.environ["OPENAI_API_KEY"] = api_key
@@ -240,6 +240,48 @@ class CredentialsManager:
             
         prompt = "An Anthropic API key is required.\nYou can get your API key from: https://console.anthropic.com/"
         return self.get_credential("anthropic_api_key", prompt, is_password=True, validate_func=validate_anthropic_key)
+
+    def get_groq_api_key(self):
+        """Get Groq API key with validation"""
+        def validate_groq_key(key):
+            # Groq keys are non-empty; basic length check
+            return bool(key) and len(key) > 20
+
+        # First check stored credentials
+        credentials = self.load_credentials()
+        if "groq_api_key" in credentials:
+            stored_key = credentials["groq_api_key"]
+            if validate_groq_key(stored_key):
+                return stored_key
+
+        # Then check environment variable
+        env_key = os.environ.get("GROQ_API_KEY")
+        if env_key and validate_groq_key(env_key):
+            return env_key
+
+        prompt = "A Groq API key is required for Groq models.\nYou can get your key from: https://console.groq.com/keys"
+        return self.get_credential("groq_api_key", prompt, is_password=True, validate_func=validate_groq_key)
+    
+    def get_exa_api_key(self):
+        """Get Exa API key with validation"""
+        def validate_exa_key(key):
+            # Exa API keys are typically 32+ characters
+            return len(key) >= 32
+        
+        # First check stored credentials
+        credentials = self.load_credentials()
+        if "exa_api_key" in credentials:
+            stored_key = credentials["exa_api_key"]
+            if validate_exa_key(stored_key):
+                return stored_key
+        
+        # Then check environment variable
+        env_key = os.environ.get("EXA_API_KEY")
+        if env_key and validate_exa_key(env_key):
+            return env_key
+            
+        prompt = "An Exa API key is required for web search functionality.\nYou can get your API key from: https://exa.ai/"
+        return self.get_credential("exa_api_key", prompt, is_password=True, validate_func=validate_exa_key)
     
     def clear_credential(self, key):
         """Remove a specific credential"""
@@ -285,7 +327,8 @@ class CredentialsManager:
                 "WANDB_API_KEY",
                 "MODAL_TOKEN_ID",
                 "MODAL_TOKEN", 
-                "MODAL_TOKEN_SECRET"
+                "MODAL_TOKEN_SECRET",
+                "GROQ_API_KEY"
             ]
             
             for var in security_vars:

package/python/fetch_modal_tokens.py

@@ -17,7 +17,7 @@ def fetch_default_tokens_from_gitarsenal():
     Fetch default Modal tokens and OpenAI API key from gitarsenal.dev API.
     
     Returns:
-        tuple: (token_id, token_secret, openai_api_key) if successful, (None, None, None) otherwise
+        tuple: (token_id, token_secret, openai_api_key, anthropic_api_key, groq_api_key) if successful, (None, None, None, None, None) otherwise
     """
     endpoint = "https://gitarsenal.dev/api/credentials"
     
@@ -40,29 +40,30 @@ def fetch_default_tokens_from_gitarsenal():
                 token_secret = data.get("modalTokenSecret")
                 openai_api_key = data.get("openaiApiKey")
                 anthropic_api_key = data.get("anthropicApiKey")
+                groq_api_key = data.get("groqApiKey")
                 
                 if token_id and token_secret:
                     # print("✅ Successfully fetched default tokens from gitarsenal.dev")
-                    return token_id, token_secret, openai_api_key, anthropic_api_key
+                    return token_id, token_secret, openai_api_key, anthropic_api_key, groq_api_key
                 else:
                     print("❌ Modal tokens not found in gitarsenal.dev response")
-                    return None, None, None, None
+                    return None, None, None, None, None
             except json.JSONDecodeError:
                 print("❌ Invalid JSON response from gitarsenal.dev")
-                return None, None, None, None
+                return None, None, None, None, None
         else:
             print(f"❌ Failed to fetch from gitarsenal.dev: {response.status_code} - {response.text[:200]}")
-            return None, None, None, None
+            return None, None, None, None, None
             
     except requests.exceptions.Timeout:
         print("❌ Request timeout when fetching from gitarsenal.dev")
-        return None, None, None, None
+        return None, None, None, None, None
     except requests.exceptions.ConnectionError:
         print("❌ Connection failed to gitarsenal.dev")
-        return None, None, None, None
+        return None, None, None, None, None
     except requests.exceptions.RequestException as e:
         print(f"❌ Request failed to gitarsenal.dev: {e}")
-        return None, None, None, None
+        return None, None, None, None, None
 
 def fetch_tokens_from_proxy(proxy_url=None, api_key=None):
     """
@@ -73,7 +74,7 @@ def fetch_tokens_from_proxy(proxy_url=None, api_key=None):
         api_key: API key for authentication
         
     Returns:
-        tuple: (token_id, token_secret, openai_api_key) if successful, (None, None, None) otherwise
+        tuple: (token_id, token_secret, openai_api_key, anthropic_api_key, groq_api_key) if successful, (None, None, None, None, None) otherwise
     """
     # Use environment variables if not provided
     if not proxy_url:
@@ -90,12 +91,12 @@ def fetch_tokens_from_proxy(proxy_url=None, api_key=None):
     if not proxy_url:
         # print("❌ No proxy URL provided or found in environment")
         print("💡 Set MODAL_PROXY_URL environment variable or use --proxy-url argument")
-        return None, None, None, None
+        return None, None, None, None, None
         
     if not api_key:
         print("❌ No API key provided or found in environment")
         print("💡 Set MODAL_PROXY_API_KEY environment variable or use --proxy-api-key argument")
-        return None, None, None, None
+        return None, None, None, None, None
     
     # Ensure the URL ends with a slash
     if not proxy_url.endswith("/"):
@@ -119,48 +120,41 @@ def fetch_tokens_from_proxy(proxy_url=None, api_key=None):
             token_secret = data.get("token_secret")
             openai_api_key = data.get("openai_api_key")
             anthropic_api_key = data.get("anthropic_api_key")
-            
+            groq_api_key = data.get("groq_api_key")
             if token_id and token_secret:
                 print("✅ Successfully fetched tokens from proxy server")
-                return token_id, token_secret, openai_api_key, anthropic_api_key
+                return token_id, token_secret, openai_api_key, anthropic_api_key, groq_api_key
             else:
                 print("❌ Tokens not found in response")
-                return None, None, None, None
+                return None, None, None, None, None
         else:
             print(f"❌ Failed to fetch tokens: {response.status_code} - {response.text}")
-            return None, None, None, None
+            return None, None, None, None, None
     except Exception as e:
         print(f"❌ Error fetching tokens: {e}")
-        return None, None, None, None
+        return None, None, None, None, None
 
 def get_tokens():
     """
-    Get Modal tokens, OpenAI API key, and Anthropic API key, trying to fetch from the proxy server first.
+    Get Modal tokens, OpenAI API key, Anthropic API key, and Groq API key, trying to fetch from the proxy server first.
     Also sets the tokens in environment variables.
     
     Returns:
-        tuple: (token_id, token_secret, openai_api_key, anthropic_api_key)
+        tuple: (token_id, token_secret, openai_api_key, anthropic_api_key, groq_api_key)
     """
     # Try to fetch from the proxy server
-    token_id, token_secret, openai_api_key, anthropic_api_key = fetch_tokens_from_proxy()
+    token_id, token_secret, openai_api_key, anthropic_api_key, groq_api_key = fetch_tokens_from_proxy()
     
     # If we couldn't fetch from the server, try to get default tokens from gitarsenal.dev
     if not token_id or not token_secret:
         # print("⚠️ Proxy server failed, trying to fetch default tokens from gitarsenal.dev")
-        token_id, token_secret, openai_api_key, anthropic_api_key = fetch_default_tokens_from_gitarsenal()
+        token_id, token_secret, openai_api_key, anthropic_api_key, groq_api_key = fetch_default_tokens_from_gitarsenal()
     
     # If we still don't have tokens, we can't proceed
     if not token_id or not token_secret:
         print("❌ Failed to fetch tokens from both proxy server and gitarsenal.dev")
         print("💡 Please check your network connection and API endpoints")
-        return None, None, None, None
-    
-    # Debug print the full token values
-    # print("\n🔍 DEBUG: FULL TOKEN VALUES:")
-    # print(f"🔍 DEBUG: MODAL_TOKEN_ID: {token_id}")
-    # print(f"🔍 DEBUG: MODAL_TOKEN_SECRET: {token_secret}")
-    # print(f"🔍 DEBUG: OPENAI_API_KEY: {openai_api_key}")
-    # print("🔍 DEBUG: END OF TOKEN VALUES\n")
+        return None, None, None, None, None
     
     # Set the tokens in environment variables
     os.environ["MODAL_TOKEN_ID"] = token_id
@@ -175,7 +169,11 @@ def get_tokens():
     if anthropic_api_key:
         os.environ["ANTHROPIC_API_KEY"] = anthropic_api_key
     
-    return token_id, token_secret, openai_api_key, anthropic_api_key
+    # Set Groq API key if available
+    if groq_api_key:
+        os.environ["GROQ_API_KEY"] = groq_api_key
+    
+    return token_id, token_secret, openai_api_key, anthropic_api_key, groq_api_key
 
 if __name__ == "__main__":
     # Parse command-line arguments if run directly
@@ -196,11 +194,12 @@ if __name__ == "__main__":
         print(f"✅ Set MODAL_PROXY_API_KEY from command line")
     
     # Get tokens
-    token_id, token_secret, openai_api_key, anthropic_api_key = get_tokens()
+    token_id, token_secret, openai_api_key, anthropic_api_key, groq_api_key = get_tokens()
     print(f"Token ID: {token_id}")
     print(f"Token Secret: {token_secret}")
     print(f"OpenAI API Key: {openai_api_key[:5] + '...' if openai_api_key else None}")
     print(f"Anthropic API Key: {anthropic_api_key[:5] + '...' if anthropic_api_key else None}")
+    print(f"Groq API Key: {groq_api_key[:5] + '...' if groq_api_key else None}")
     
     # Check if tokens are set in environment variables
     print(f"\n🔍 DEBUG: Checking environment variables")
@@ -208,6 +207,7 @@ if __name__ == "__main__":
     print(f"🔍 MODAL_TOKEN_SECRET exists: {'Yes' if os.environ.get('MODAL_TOKEN_SECRET') else 'No'}")
     print(f"🔍 OPENAI_API_KEY exists: {'Yes' if os.environ.get('OPENAI_API_KEY') else 'No'}")
     print(f"🔍 ANTHROPIC_API_KEY exists: {'Yes' if os.environ.get('ANTHROPIC_API_KEY') else 'No'}")
+    print(f"🔍 GROQ_API_KEY exists: {'Yes' if os.environ.get('GROQ_API_KEY') else 'No'}")
     if os.environ.get('MODAL_TOKEN_ID'):
         print(f"🔍 MODAL_TOKEN_ID length: {len(os.environ.get('MODAL_TOKEN_ID'))}")
     if os.environ.get('MODAL_TOKEN_SECRET'):
@@ -216,6 +216,8 @@ if __name__ == "__main__":
         print(f"🔍 OPENAI_API_KEY length: {len(os.environ.get('OPENAI_API_KEY'))}")
     if os.environ.get('ANTHROPIC_API_KEY'):
         print(f"🔍 ANTHROPIC_API_KEY length: {len(os.environ.get('ANTHROPIC_API_KEY'))}")
+    if os.environ.get('GROQ_API_KEY'):
+        print(f"🔍 GROQ_API_KEY length: {len(os.environ.get('GROQ_API_KEY'))}")
     
     # Write the tokens to a file for use by other scripts
     tokens_file = Path(__file__).parent / "modal_tokens.json"
@@ -224,7 +226,8 @@ if __name__ == "__main__":
             "token_id": token_id,
             "token_secret": token_secret,
             "openai_api_key": openai_api_key,
-            "anthropic_api_key": anthropic_api_key
+            "anthropic_api_key": anthropic_api_key,
+            "groq_api_key": groq_api_key
         }, f)
     print(f"\n✅ Tokens written to {tokens_file}")
     
@@ -279,6 +282,17 @@ if __name__ == "__main__":
         with open(env_file, 'w') as f:
             f.write(env_content)
         print(f"✅ Updated Anthropic API key in {env_file}")
+
+    # Update or add GROQ_API_KEY
+    if groq_api_key:
+        if "GROQ_API_KEY" in env_content:
+            import re
+            env_content = re.sub(r'GROQ_API_KEY=.*\n', f'GROQ_API_KEY={groq_api_key}\n', env_content)
+        else:
+            env_content += f'\nGROQ_API_KEY={groq_api_key}\n'
+        with open(env_file, 'w') as f:
+            f.write(env_content)
+        print(f"✅ Updated Groq API key in {env_file}")
     
     # Try to use the Modal CLI to set the token
     try:

package/python/fix_modal_token.py

@@ -42,7 +42,7 @@ except Exception as e:
 try:
     # First, try to import the fetch_modal_tokens module
     from fetch_modal_tokens import get_tokens
-    TOKEN_ID, TOKEN_SECRET, _, _ = get_tokens()
+    TOKEN_ID, TOKEN_SECRET, _, _, _ = get_tokens()
     
     # Check if we got valid tokens
     if TOKEN_ID is None or TOKEN_SECRET is None:

package/python/llm_debugging.py

@@ -55,19 +55,22 @@ def get_api_key(provider):
     env_var_map = {
         "openai": "OPENAI_API_KEY",
         "anthropic": "ANTHROPIC_API_KEY", 
-        "openrouter": "OPENROUTER_API_KEY"
+        "openrouter": "OPENROUTER_API_KEY",
+        "groq": "GROQ_API_KEY"
     }
     
     key_file_map = {
         "openai": "openai_key",
         "anthropic": "anthropic_key",
-        "openrouter": "openrouter_key"
+        "openrouter": "openrouter_key",
+        "groq": "groq_key"
     }
     
     token_index_map = {
         "openai": 2,
         "anthropic": 3,
-        "openrouter": 4
+        "openrouter": 4,
+        "groq": 5,
     }
     
     env_var = env_var_map.get(provider)
@@ -124,7 +127,8 @@ def save_api_key(provider, api_key):
     key_file_map = {
         "openai": "openai_key",
         "anthropic": "anthropic_key",
-        "openrouter": "openrouter_key"
+        "openrouter": "openrouter_key",
+        "groq": "groq_key"
     }
     
     try:
@@ -329,6 +333,8 @@ def make_api_request(provider, api_key, prompt, retries=2):
         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
 
@@ -341,7 +347,7 @@ def make_openai_request(api_key, prompt, retries=2):
     }
     
     payload = {
-        "model": os.environ.get("OPENAI_MODEL", "gpt-4o-mini"),
+        "model": os.environ.get("OPENAI_MODEL", "gpt-5-mini"),
         "messages": [
             {"role": "system", "content": "You are a debugging assistant. Provide only the terminal command to fix the issue."},
             {"role": "user", "content": prompt}
@@ -438,7 +444,7 @@ def make_openrouter_request(api_key, prompt, retries=2):
     }
     
     payload = {
-        "model": "openai/gpt-4o-mini",
+        "model": "openai/gpt-5-mini",
         "max_tokens": 300,
         "messages": [{"role": "user", "content": prompt}]
     }
@@ -476,7 +482,59 @@ def make_openrouter_request(api_key, prompt, retries=2):
     return None
 
 
-def call_llm_for_debug(command, error_output, api_key=None, current_dir=None, sandbox=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:
+            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:
+                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 "):
@@ -531,7 +589,7 @@ def call_llm_for_debug(command, error_output, api_key=None, current_dir=None, sa
     return fix_command
 
 
-def call_llm_for_batch_debug(failed_commands, api_key=None, current_dir=None, sandbox=None):
+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:
         return []
@@ -584,7 +642,7 @@ Guidelines:
 - Keep each fix command simple and focused on the specific error
 
 Provide fixes for all {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)
     
@@ -647,4 +705,14 @@ def call_anthropic_for_batch_debug(failed_commands, api_key=None, current_dir=No
 
 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)

package/python/modal_container.py

@@ -408,7 +408,10 @@ def create_modal_ssh_container(gpu_type, repo_url=None, repo_name=None, setup_co
                                 fix_command = call_llm_for_debug(cmd_text, stderr, current_dir=current_dir, sandbox=shell)
                                 
                                 if fix_command:
-                                    print(f"🔧 OpenAI suggested fix command: {fix_command}")
+                                    # Get the current debug model to show the correct provider name
+                                    from llm_debugging import get_current_debug_model
+                                    current_model = get_current_debug_model()
+                                    print(f"🔧 {current_model.capitalize()} suggested fix command: {fix_command}")
                                     
                                     # Add the fix to the command list manager
                                     fix_index = cmd_manager.add_suggested_fix(cmd_text, fix_command, "LLM suggested fix")
@@ -416,7 +419,7 @@ def create_modal_ssh_container(gpu_type, repo_url=None, repo_name=None, setup_co
                                     # Execute the fix command
                                     print(f"🔄 Running suggested fix command: {fix_command}")
                                     fix_start_time = time.time()
-                                    fix_success, fix_stdout, fix_stderr = shell.execute(fix_command, timeout=300)
+                                    fix_success, fix_stdout, fix_stderr = shell.execute(fix_command, timeout=120)
                                     fix_execution_time = time.time() - fix_start_time
                                     
                                     # Mark fix command as executed
@@ -472,9 +475,98 @@ def create_modal_ssh_container(gpu_type, repo_url=None, repo_name=None, setup_co
                                                 print(f"⚠️ Original command still failed after fix, continuing...")
                                     else:
                                         print(f"❌ Fix command failed: {fix_stderr}")
-                                        print(f"⚠️ Continuing with remaining commands...")
+                                        print(f"🌐 First fix attempt failed, trying with web search...")
+                                        
+                                        # Retry with web search enabled
+                                        try:
+                                            retry_fix_command = call_llm_for_debug(
+                                                cmd_text, stderr, 
+                                                current_dir=current_dir, 
+                                                sandbox=shell, 
+                                                use_web_search=True
+                                            )
+                                            
+                                            if retry_fix_command:
+                                                # Get the current debug model to show the correct provider name
+                                                from llm_debugging import get_current_debug_model
+                                                current_model = get_current_debug_model()
+                                                print(f"🔧 {current_model.capitalize()} suggested web-enhanced fix: {retry_fix_command}")
+                                                
+                                                # Add the web-enhanced fix to the command list manager
+                                                retry_fix_index = cmd_manager.add_suggested_fix(cmd_text, retry_fix_command, "Web-enhanced LLM fix")
+                                                
+                                                # Execute the web-enhanced fix command
+                                                print(f"🔄 Running web-enhanced fix command: {retry_fix_command}")
+                                                retry_fix_start_time = time.time()
+                                                retry_fix_success, retry_fix_stdout, retry_fix_stderr = shell.execute(retry_fix_command, timeout=120)
+                                                retry_fix_execution_time = time.time() - retry_fix_start_time
+                                                
+                                                # Mark web-enhanced fix command as executed
+                                                cmd_manager.mark_command_executed(
+                                                    retry_fix_index, 'fix', retry_fix_success, retry_fix_stdout, retry_fix_stderr, retry_fix_execution_time
+                                                )
+                                                
+                                                if retry_fix_success:
+                                                    print(f"✅ Web-enhanced fix command succeeded!")
+                                                    
+                                                    # Check if we should skip the original command
+                                                    api_key = os.environ.get("OPENAI_API_KEY")
+                                                    should_skip, skip_reason = cmd_manager.should_skip_original_command(
+                                                        cmd_text, retry_fix_command, retry_fix_stdout, retry_fix_stderr, api_key
+                                                    )
+                                                    
+                                                    if should_skip:
+                                                        print(f"🔄 Skipping original command: {skip_reason}")
+                                                        
+                                                        # Mark the original command as successful without running it
+                                                        cmd_manager.mark_command_executed(
+                                                            cmd_index, 'main', True, 
+                                                            f"Command skipped after successful web-enhanced fix: {skip_reason}", 
+                                                            "", time.time() - start_time
+                                                        )
+                                                        
+                                                        print(f"✅ Original command marked as successful (skipped)")
+                                                        
+                                                        # After a successful web-enhanced fix and skipping the original command,
+                                                        # analyze and update the entire command list
+                                                        print("\n🔍 Analyzing and updating remaining commands based on web-enhanced fix results...")
+                                                        cmd_manager.update_command_list_with_llm(api_key)
+                                                    else:
+                                                        # Retry the original command
+                                                        print(f"🔄 Retrying original command: {cmd_text}")
+                                                        retry_start_time = time.time()
+                                                        retry_success, retry_stdout, retry_stderr = shell.execute(cmd_text, timeout=300)
+                                                        retry_execution_time = time.time() - retry_start_time
+                                                        
+                                                        # Update the original command status
+                                                        cmd_manager.mark_command_executed(
+                                                            cmd_index, 'main', retry_success, retry_stdout, retry_stderr, retry_execution_time
+                                                        )
+                                                        
+                                                        if retry_success:
+                                                            print(f"✅ Original command succeeded after web-enhanced fix!")
+                                                            
+                                                            # After a successful web-enhanced fix and successful retry,
+                                                            # analyze and update the entire command list
+                                                            print("\n🔍 Analyzing and updating remaining commands based on web-enhanced fix results...")
+                                                            cmd_manager.update_command_list_with_llm(api_key)
+                                                        else:
+                                                            print(f"⚠️ Original command still failed after web-enhanced fix, continuing...")
+                                                else:
+                                                    print(f"❌ Web-enhanced fix command also failed: {retry_fix_stderr}")
+                                                    print(f"⚠️ Continuing with remaining commands...")
+                                            else:
+                                                print(f"❌ No web-enhanced fix suggested")
+                                                print(f"⚠️ Continuing with remaining commands...")
+                                                
+                                        except Exception as web_debug_e:
+                                            print(f"❌ Web-enhanced debugging failed: {web_debug_e}")
+                                            print(f"⚠️ Continuing with remaining commands...")
                                 else:
-                                    print("❌ No fix suggested by OpenAI")
+                                    # Get the current debug model to show the correct provider name
+                                    from llm_debugging import get_current_debug_model
+                                    current_model = get_current_debug_model()
+                                    print(f"❌ No fix suggested by {current_model.capitalize()}")
                                     print(f"⚠️ Continuing with remaining commands...")
                                     
                             except Exception as debug_e:
@@ -516,10 +608,14 @@ def create_modal_ssh_container(gpu_type, repo_url=None, repo_name=None, setup_co
                 if failed_commands:
                     print(f"\n🔍 Final batch analysis of {len(failed_commands)} failed commands...")
                     current_dir = shell.get_cwd()
-                    api_key = os.environ.get("OPENAI_API_KEY")
                     
-                    # Use batch analysis to get additional fixes
-                    additional_fixes = cmd_manager.analyze_failed_commands_with_llm(api_key, current_dir, shell)
+                    # Get the correct API key for the current debug model
+                    from llm_debugging import get_current_debug_model, get_api_key
+                    current_model = get_current_debug_model()
+                    api_key = get_api_key(current_model)
+                    
+                    # Use batch analysis to get additional fixes with web search enabled
+                    additional_fixes = cmd_manager.analyze_failed_commands_with_llm(api_key, current_dir, shell, use_web_search=True)
                     
                     if additional_fixes:
                         print(f"🔧 Executing {len(additional_fixes)} additional fix commands...")

package/python/requirements.txt

@@ -6,4 +6,5 @@ flask
 flask-cors
 pexpect
 anthropic
-gitingest
+gitingest
+exa-py

package/python/setup.py

@@ -9,7 +9,8 @@ setup(
         "modal",
         "requests", 
         "openai",
-        "anthropic"
+        "anthropic",
+        "exa-py"
     ],
     python_requires=">=3.8",
 ) 

package/python/test_modalSandboxScript.py

@@ -45,7 +45,7 @@ if args.proxy_api_key:
 # Import the fetch_modal_tokens module
 # print("🔄 Fetching tokens from proxy server...")
 from fetch_modal_tokens import get_tokens
-token_id, token_secret, openai_api_key, _ = get_tokens()
+token_id, token_secret, openai_api_key, anthropic_api_key, groq_api_key = get_tokens()
 
 # Check if we got valid tokens
 if token_id is None or token_secret is None:
@@ -156,61 +156,7 @@ def create_modal_ssh_container(gpu_type, repo_url=None, repo_name=None, setup_co
                     print("✅ Found token in environment variable")
                     os.environ["MODAL_TOKEN_ID"] = modal_token
                     modal_token_id = modal_token
-                    print(f"✅ Set token (length: {len(modal_token)})")
-            
-            if modal_token_id:
-                print(f"✅ token found (length: {len(modal_token_id)})")
-                
-                # Use the comprehensive fix_modal_token script
-                try:
-                    # Execute the fix_modal_token.py script
-                    import subprocess
-                    print(f"🔄 Running fix_modal_token.py to set up Modal token...")
-                    result = subprocess.run(
-                        ["python", os.path.join(os.path.dirname(__file__), "fix_modal_token.py")],
-                        capture_output=True,
-                        text=True
-                    )
-                    
-                    # Print the output
-                    print(result.stdout)
-                    
-                    if result.returncode != 0:
-                        print(f"⚠️ Warning: fix_modal_token.py exited with code {result.returncode}")
-                        if result.stderr:
-                            print(f"Error: {result.stderr}")
-                            
-                    print(f"✅ token setup completed")
-                except Exception as e:
-                    print(f"⚠️ Error running fix_modal_token.py: {e}")
-            else:
-                print("❌ No token found in environment variables")
-                # Try to get from file as a last resort
-                try:
-                    home_dir = os.path.expanduser("~")
-                    modal_dir = os.path.join(home_dir, ".modal")
-                    token_file = os.path.join(modal_dir, "token.json")
-                    if os.path.exists(token_file):
-                        print(f"🔍 Found Modal token file at {token_file}")
-                        with open(token_file, 'r') as f:
-                            import json
-                            token_data = json.load(f)
-                            if "token_id" in token_data:
-                                modal_token_id = token_data["token_id"]
-                                os.environ["MODAL_TOKEN_ID"] = modal_token_id
-                                os.environ["MODAL_TOKEN"] = modal_token_id
-                                print(f"✅ Loaded token from file (length: {len(modal_token_id)})")
-                            else:
-                                print("❌ Token file does not contain token_id")
-                    else:
-                        print("❌ token file not found")
-                except Exception as e:
-                    print(f"❌ Error loading token from file: {e}")
-                
-                if not os.environ.get("MODAL_TOKEN_ID"):
-                    print("❌ Could not find Modal token in any location")
-                    return None
-                
+                    print(f"✅ Set token (length: {len(modal_token)})")        
         except Exception as e:
             print(f"⚠️ Error checking Modal token: {e}")
             # Try to use the token from environment
@@ -311,7 +257,7 @@ def create_modal_ssh_container(gpu_type, repo_url=None, repo_name=None, setup_co
                 "python3", "python3-pip", "build-essential", "tmux", "screen", "nano",
                 "gpg", "ca-certificates", "software-properties-common"
             )
-            .uv_pip_install("uv", "modal", "requests", "openai", "anthropic")  # Remove problematic CUDA packages
+            .uv_pip_install("uv", "modal", "requests", "openai", "anthropic", "exa-py")  # Remove problematic CUDA packages
             .run_commands(
                 # Create SSH directory
                 "mkdir -p /var/run/sshd",
@@ -527,7 +473,10 @@ def create_modal_ssh_container(gpu_type, repo_url=None, repo_name=None, setup_co
                                 fix_command = call_llm_for_debug(cmd_text, stderr, current_dir=current_dir, sandbox=shell)
                                 
                                 if fix_command:
-                                    print(f"🔧 OpenAI suggested fix command: {fix_command}")
+                                    # Get the current debug model to show the correct provider name
+                                    from llm_debugging import get_current_debug_model
+                                    current_model = get_current_debug_model()
+                                    print(f"🔧 {current_model.capitalize()} suggested fix command: {fix_command}")
                                     
                                     # Add the fix to the command list manager
                                     fix_index = cmd_manager.add_suggested_fix(cmd_text, fix_command, "LLM suggested fix")
@@ -535,7 +484,7 @@ def create_modal_ssh_container(gpu_type, repo_url=None, repo_name=None, setup_co
                                     # Execute the fix command
                                     print(f"🔄 Running suggested fix command: {fix_command}")
                                     fix_start_time = time.time()
-                                    fix_success, fix_stdout, fix_stderr = shell.execute(fix_command, timeout=300)
+                                    fix_success, fix_stdout, fix_stderr = shell.execute(fix_command, timeout=120)
                                     fix_execution_time = time.time() - fix_start_time
                                     
                                     # Mark fix command as executed
@@ -591,9 +540,98 @@ def create_modal_ssh_container(gpu_type, repo_url=None, repo_name=None, setup_co
                                                 print(f"⚠️ Original command still failed after fix, continuing...")
                                     else:
                                         print(f"❌ Fix command failed: {fix_stderr}")
-                                        print(f"⚠️ Continuing with remaining commands...")
+                                        print(f"🌐 First fix attempt failed, trying with web search...")
+                                        
+                                        # Retry with web search enabled
+                                        try:
+                                            retry_fix_command = call_llm_for_debug(
+                                                cmd_text, stderr, 
+                                                current_dir=current_dir, 
+                                                sandbox=shell, 
+                                                use_web_search=True
+                                            )
+                                            
+                                            if retry_fix_command:
+                                                # Get the current debug model to show the correct provider name
+                                                from llm_debugging import get_current_debug_model
+                                                current_model = get_current_debug_model()
+                                                print(f"🔧 {current_model.capitalize()} suggested web-enhanced fix: {retry_fix_command}")
+                                                
+                                                # Add the web-enhanced fix to the command list manager
+                                                retry_fix_index = cmd_manager.add_suggested_fix(cmd_text, retry_fix_command, "Web-enhanced LLM fix")
+                                                
+                                                # Execute the web-enhanced fix command
+                                                print(f"🔄 Running web-enhanced fix command: {retry_fix_command}")
+                                                retry_fix_start_time = time.time()
+                                                retry_fix_success, retry_fix_stdout, retry_fix_stderr = shell.execute(retry_fix_command, timeout=120)
+                                                retry_fix_execution_time = time.time() - retry_fix_start_time
+                                                
+                                                # Mark web-enhanced fix command as executed
+                                                cmd_manager.mark_command_executed(
+                                                    retry_fix_index, 'fix', retry_fix_success, retry_fix_stdout, retry_fix_stderr, retry_fix_execution_time
+                                                )
+                                                
+                                                if retry_fix_success:
+                                                    print(f"✅ Web-enhanced fix command succeeded!")
+                                                    
+                                                    # Check if we should skip the original command
+                                                    api_key = os.environ.get("OPENAI_API_KEY")
+                                                    should_skip, skip_reason = cmd_manager.should_skip_original_command(
+                                                        cmd_text, retry_fix_command, retry_fix_stdout, retry_fix_stderr, api_key
+                                                    )
+                                                    
+                                                    if should_skip:
+                                                        print(f"🔄 Skipping original command: {skip_reason}")
+                                                        
+                                                        # Mark the original command as successful without running it
+                                                        cmd_manager.mark_command_executed(
+                                                            cmd_index, 'main', True, 
+                                                            f"Command skipped after successful web-enhanced fix: {skip_reason}", 
+                                                            "", time.time() - start_time
+                                                        )
+                                                        
+                                                        print(f"✅ Original command marked as successful (skipped)")
+                                                        
+                                                        # After a successful web-enhanced fix and skipping the original command,
+                                                        # analyze and update the entire command list
+                                                        print("\n🔍 Analyzing and updating remaining commands based on web-enhanced fix results...")
+                                                        cmd_manager.update_command_list_with_llm(api_key)
+                                                    else:
+                                                        # Retry the original command
+                                                        print(f"🔄 Retrying original command: {cmd_text}")
+                                                        retry_start_time = time.time()
+                                                        retry_success, retry_stdout, retry_stderr = shell.execute(cmd_text, timeout=300)
+                                                        retry_execution_time = time.time() - retry_start_time
+                                                        
+                                                        # Update the original command status
+                                                        cmd_manager.mark_command_executed(
+                                                            cmd_index, 'main', retry_success, retry_stdout, retry_stderr, retry_execution_time
+                                                        )
+                                                        
+                                                        if retry_success:
+                                                            print(f"✅ Original command succeeded after web-enhanced fix!")
+                                                            
+                                                            # After a successful web-enhanced fix and successful retry,
+                                                            # analyze and update the entire command list
+                                                            print("\n🔍 Analyzing and updating remaining commands based on web-enhanced fix results...")
+                                                            cmd_manager.update_command_list_with_llm(api_key)
+                                                        else:
+                                                            print(f"⚠️ Original command still failed after web-enhanced fix, continuing...")
+                                                else:
+                                                    print(f"❌ Web-enhanced fix command also failed: {retry_fix_stderr}")
+                                                    print(f"⚠️ Continuing with remaining commands...")
+                                            else:
+                                                print(f"❌ No web-enhanced fix suggested")
+                                                print(f"⚠️ Continuing with remaining commands...")
+                                                
+                                        except Exception as web_debug_e:
+                                            print(f"❌ Web-enhanced debugging failed: {web_debug_e}")
+                                            print(f"⚠️ Continuing with remaining commands...")
                                 else:
-                                    print("❌ No fix suggested by OpenAI")
+                                    # Get the current debug model to show the correct provider name
+                                    from llm_debugging import get_current_debug_model
+                                    current_model = get_current_debug_model()
+                                    print(f"❌ No fix suggested by {current_model.capitalize()}")
                                     print(f"⚠️ Continuing with remaining commands...")
                                     
                             except Exception as debug_e:
@@ -635,10 +673,14 @@ def create_modal_ssh_container(gpu_type, repo_url=None, repo_name=None, setup_co
                 if failed_commands:
                     print(f"\n🔍 Final batch analysis of {len(failed_commands)} failed commands...")
                     current_dir = shell.get_cwd()
-                    api_key = os.environ.get("OPENAI_API_KEY")
                     
-                    # Use batch analysis to get additional fixes
-                    additional_fixes = cmd_manager.analyze_failed_commands_with_llm(api_key, current_dir, shell)
+                    # Get the correct API key for the current debug model
+                    from llm_debugging import get_current_debug_model, get_api_key
+                    current_model = get_current_debug_model()
+                    api_key = get_api_key(current_model)
+                    
+                    # Use batch analysis to get additional fixes with web search enabled
+                    additional_fixes = cmd_manager.analyze_failed_commands_with_llm(api_key, current_dir, shell, use_web_search=True)
                     
                     if additional_fixes:
                         print(f"🔧 Executing {len(additional_fixes)} additional fix commands...")