Disable OpenRouter; only Anthropic/OpenAI providers remain

agent/llm_client.py

@@ -42,7 +42,6 @@ class LLMClient:
         # Support both standard and MCP hackathon naming conventions
         self.openai_key = _get_env(["OPENAI_API_KEY", "OPENAI_MCP_1ST_BDAY"])
         self.anthropic_key = _get_env(["ANTHROPIC_API_KEY", "ANTHROPIC_MCP_1ST_BDAY"])
-        self.openrouter_key = _get_env(["OPENROUTER_API_KEY"])
         
         # Determine which provider to use
         self.provider = self._detect_provider()
@@ -68,15 +67,12 @@ class LLMClient:
         status = {
             "openai_key": "present" if _present(["OPENAI_API_KEY", "OPENAI_MCP_1ST_BDAY"]) else "missing",
             "anthropic_key": "present" if _present(["ANTHROPIC_API_KEY", "ANTHROPIC_MCP_1ST_BDAY"]) else "missing",
-            "openrouter_key": "present" if _present(["OPENROUTER_API_KEY"]) else "missing",
             "provider": "unknown",
         }
         if status["anthropic_key"] == "present":
             status["provider"] = "anthropic"
         elif status["openai_key"] == "present":
             status["provider"] = "openai"
-        elif status["openrouter_key"] == "present":
-            status["provider"] = "openrouter"
         return status
     
     def _detect_provider(self) -> Optional[str]:
@@ -85,8 +81,6 @@ class LLMClient:
             return "anthropic"
         elif self.openai_key:
             return "openai"
-        elif self.openrouter_key:
-            return "openrouter"
         return None
     
     def chat(
@@ -103,9 +97,7 @@ class LLMClient:
         if not self.provider:
             raise RuntimeError("No LLM provider configured. Set ANTHROPIC_MCP_1ST_BDAY or OPENAI_MCP_1ST_BDAY.")
         
-        if self.provider == "openrouter":
-            return self._call_openrouter(messages, temperature, max_tokens, stream)
-        elif self.provider == "openai":
+        if self.provider == "openai":
             return self._call_openai(messages, temperature, max_tokens, stream)
         elif self.provider == "anthropic":
             return self._call_anthropic(messages, temperature, max_tokens, stream)
@@ -120,117 +112,18 @@ class LLMClient:
         if not self.provider:
             raise RuntimeError("No LLM provider configured. Set ANTHROPIC_MCP_1ST_BDAY or OPENAI_MCP_1ST_BDAY.")
         
-        if self.provider == "openrouter":
-            yield from self._stream_openrouter(messages, temperature, max_tokens)
-        elif self.provider == "openai":
+        if self.provider == "openai":
             yield from self._stream_openai(messages, temperature, max_tokens)
         elif self.provider == "anthropic":
             yield from self._stream_anthropic(messages, temperature, max_tokens)
     
     def _call_openrouter(self, messages, temperature, max_tokens, stream):
         """Call OpenRouter API"""
-        call_id = str(uuid.uuid4())
-        model = "anthropic/claude-3.5-sonnet"
-        
-        if monitor:
-            monitor.start_call(call_id, "llm", "openrouter", model, temperature=temperature)
-        
-        try:
-            import requests
-            
-            url = "https://openrouter.ai/api/v1/chat/completions"
-            headers = {
-                "Authorization": f"Bearer {self.openrouter_key}",
-                "Content-Type": "application/json"
-            }
-            
-            data = {
-                "model": model,  # Good balance of cost/quality
-                "messages": [{"role": m.role, "content": m.content} for m in messages],
-                "temperature": temperature,
-                "max_tokens": max_tokens
-            }
-            
-            response = requests.post(url, headers=headers, json=data, timeout=60)
-            response.raise_for_status()
-            
-            result = response.json()
-            content = result['choices'][0]['message']['content']
-            usage = result.get('usage', {})
-            
-            if monitor:
-                monitor.complete_call(
-                    call_id,
-                    success=True,
-                    input_tokens=usage.get('prompt_tokens', 0),
-                    output_tokens=usage.get('completion_tokens', 0)
-                )
-            
-            return content
-            
-        except Exception as e:
-            logger.error(f"OpenRouter API error: {e}")
-            if monitor:
-                monitor.complete_call(call_id, success=False, error_message=str(e))
-            raise
+        raise RuntimeError("OpenRouter is disabled for this Space.")
     
     def _stream_openrouter(self, messages, temperature, max_tokens):
         """Stream from OpenRouter"""
-        call_id = str(uuid.uuid4())
-        model = "anthropic/claude-3.5-sonnet"
-        
-        if monitor:
-            monitor.start_call(call_id, "llm", "openrouter", model, temperature=temperature)
-        
-        total_tokens_est = 0
-        
-        try:
-            import requests
-            
-            url = "https://openrouter.ai/api/v1/chat/completions"
-            headers = {
-                "Authorization": f"Bearer {self.openrouter_key}",
-                "Content-Type": "application/json"
-            }
-            
-            data = {
-                "model": model,
-                "messages": [{"role": m.role, "content": m.content} for m in messages],
-                "temperature": temperature,
-                "max_tokens": max_tokens,
-                "stream": True
-            }
-            
-            with requests.post(url, headers=headers, json=data, stream=True, timeout=60) as response:
-                response.raise_for_status()
-                for line in response.iter_lines():
-                    if line:
-                        line = line.decode('utf-8')
-                        if line.startswith('data: '):
-                            line = line[6:]
-                            if line == '[DONE]':
-                                # Estimate tokens (rough approximation: 4 chars = 1 token)
-                                if monitor:
-                                    monitor.complete_call(call_id, success=True, 
-                                        input_tokens=total_tokens_est // 2,
-                                        output_tokens=total_tokens_est // 2)
-                                break
-                            try:
-                                chunk = json.loads(line)
-                                if 'choices' in chunk and len(chunk['choices']) > 0:
-                                    delta = chunk['choices'][0].get('delta', {})
-                                    if 'content' in delta:
-                                        content = delta['content']
-                                        total_tokens_est += len(content) // 4
-                                        yield content
-                            except json.JSONDecodeError:
-                                continue
-                                
-        except Exception as e:
-            logger.error(f"OpenRouter streaming error: {e}")
-            if monitor:
-                monitor.complete_call(call_id, success=False, error_message=str(e))
-            raise
+        raise RuntimeError("OpenRouter is disabled for this Space.")
     
     def _call_openai(self, messages, temperature, max_tokens, stream):
         """Call OpenAI API"""