todo-agent 0.2.9__py3-none-any.whl → 0.3.2__py3-none-any.whl

todo_agent/infrastructure/openrouter_client.py

@@ -2,67 +2,54 @@
 LLM client for OpenRouter API communication.
 """
 
-import json
-import time
 from typing import Any, Dict, List
 
-import requests
-
-try:
-    from todo_agent.infrastructure.config import Config
-    from todo_agent.infrastructure.llm_client import LLMClient
-    from todo_agent.infrastructure.logger import Logger
-    from todo_agent.infrastructure.token_counter import get_token_counter
-except ImportError:
-    from infrastructure.config import Config  # type: ignore[no-redef]
-    from infrastructure.llm_client import LLMClient  # type: ignore[no-redef]
-    from infrastructure.logger import Logger  # type: ignore[no-redef]
-    from infrastructure.token_counter import get_token_counter  # type: ignore[no-redef]
+from todo_agent.infrastructure.llm_client import LLMClient
 
 
 class OpenRouterClient(LLMClient):
     """LLM API communication and response handling."""
 
-    def __init__(self, config: Config):
-        self.config = config
-        self.api_key = config.openrouter_api_key
-        self.model = config.model
-        self.base_url = "https://openrouter.ai/api/v1"
-        self.logger = Logger("openrouter_client")
-        self.token_counter = get_token_counter(self.model)
-
-    def _estimate_tokens(self, text: str) -> int:
+    def __init__(self, config):
         """
-        Estimate token count for text using accurate tokenization.
+        Initialize OpenRouter client.
 
         Args:
-            text: Text to count tokens for
-
-        Returns:
-            Number of tokens
+            config: Configuration object
         """
-        return self.token_counter.count_tokens(text)
+        super().__init__(config, config.model, "openrouter_client")
+        self.api_key = config.openrouter_api_key
+        self.base_url = "https://openrouter.ai/api/v1"
 
-    def _log_request_details(self, payload: Dict[str, Any], start_time: float) -> None:
-        """Log request details including accurate token count."""
-        # Count tokens for messages
-        messages = payload.get("messages", [])
-        tools = payload.get("tools", [])
+    def _get_request_headers(self) -> Dict[str, str]:
+        """Get request headers for OpenRouter API."""
+        return {
+            "Authorization": f"Bearer {self.api_key}",
+            "Content-Type": "application/json",
+        }
 
-        total_tokens = self.token_counter.count_request_tokens(messages, tools)
+    def _get_request_payload(self, messages: List[Dict[str, str]], tools: List[Dict[str, Any]]) -> Dict[str, Any]:
+        """Get request payload for OpenRouter API."""
+        return {
+            "model": self.model,
+            "messages": messages,
+            "tools": tools,
+            "tool_choice": "auto",
+        }
 
-        self.logger.info(f"Request sent - Token count: {total_tokens}")
-        # self.logger.debug(f"Raw request payload: {json.dumps(payload, indent=2)}")
+    def _get_api_endpoint(self) -> str:
+        """Get OpenRouter API endpoint."""
+        return f"{self.base_url}/chat/completions"
 
-    def _log_response_details(
-        self, response: Dict[str, Any], start_time: float
-    ) -> None:
-        """Log response details including token count and latency."""
+    def _process_response(self, response_data: Dict[str, Any], start_time: float) -> None:
+        """Process and log OpenRouter response details."""
+        import time
+        
         end_time = time.time()
         latency_ms = (end_time - start_time) * 1000
 
         # Extract token usage from response if available
-        usage = response.get("usage", {})
+        usage = response_data.get("usage", {})
         prompt_tokens = usage.get("prompt_tokens", "unknown")
         completion_tokens = usage.get("completion_tokens", "unknown")
         total_tokens = usage.get("total_tokens", "unknown")
@@ -73,33 +60,33 @@ class OpenRouterClient(LLMClient):
         )
 
         # Extract and log choice details
-        choices = response.get("choices", [])
+        choices = response_data.get("choices", [])
         if not choices:
             return
-            
+
         choice = choices[0]
         message = choice.get("message", {})
-        
+
         # Always log reasoning and content if present
         reasoning = message.get("reasoning", "")
         if reasoning:
             self.logger.info(f"LLM reasoning: {reasoning}")
-            
+
         content = message.get("content", "")
         if content:
             self.logger.info(f"LLM content: {content}")
-        
+
         # Handle tool calls
         tool_calls = message.get("tool_calls", [])
         if tool_calls:
             self.logger.info(f"Response contains {len(tool_calls)} tool calls")
-            
+
             # Log each tool call
             for i, tool_call in enumerate(tool_calls, 1):
                 tool_name = tool_call.get("function", {}).get("name", "unknown")
                 self.logger.info(f"  Tool call {i}: {tool_name}")
 
-        self.logger.debug(f"Raw response: {json.dumps(response, indent=2)}")
+        self.logger.debug(f"Raw response: {response_data}")
 
     def chat_with_tools(
         self, messages: List[Dict[str, str]], tools: List[Dict[str, Any]]
@@ -114,33 +101,7 @@ class OpenRouterClient(LLMClient):
         Returns:
             API response dictionary
         """
-        headers = {
-            "Authorization": f"Bearer {self.api_key}",
-            "Content-Type": "application/json",
-        }
-
-        payload = {
-            "model": self.model,
-            "messages": messages,
-            "tools": tools,
-            "tool_choice": "auto",
-        }
-
-        start_time = time.time()
-        self._log_request_details(payload, start_time)
-
-        response = requests.post(  # nosec B113
-            f"{self.base_url}/chat/completions", headers=headers, json=payload
-        )
-
-        if response.status_code != 200:
-            self.logger.error(f"OpenRouter API error: {response.text}")
-            raise Exception(f"OpenRouter API error: {response.text}")
-
-        response_data: Dict[str, Any] = response.json()
-        self._log_response_details(response_data, start_time)
-
-        return response_data
+        return self._make_http_request(messages, tools)
 
     def continue_with_tool_result(self, tool_result: Dict[str, Any]) -> Dict[str, Any]:
         """
@@ -157,13 +118,24 @@ class OpenRouterClient(LLMClient):
 
     def extract_tool_calls(self, response: Dict[str, Any]) -> List[Dict[str, Any]]:
         """Extract tool calls from API response."""
+        # Check for provider errors first
+        if response.get("error", False):
+            self.logger.warning(f"Cannot extract tool calls from error response: {response.get('error_type')}")
+            return []
+            
         tool_calls = []
         if response.get("choices"):
             choice = response["choices"][0]
             if "message" in choice and "tool_calls" in choice["message"]:
-                tool_calls = choice["message"]["tool_calls"]
+                raw_tool_calls = choice["message"]["tool_calls"]
+                
+                # Validate each tool call using common validation
+                for i, tool_call in enumerate(raw_tool_calls):
+                    if self._validate_tool_call(tool_call, i):
+                        tool_calls.append(tool_call)
+                
                 self.logger.debug(
-                    f"Extracted {len(tool_calls)} tool calls from response"
+                    f"Extracted {len(tool_calls)} valid tool calls from {len(raw_tool_calls)} total"
                 )
                 for i, tool_call in enumerate(tool_calls):
                     tool_name = tool_call.get("function", {}).get("name", "unknown")
@@ -179,6 +151,11 @@ class OpenRouterClient(LLMClient):
 
     def extract_content(self, response: Dict[str, Any]) -> str:
         """Extract content from API response."""
+        # Check for provider errors first
+        if response.get("error", False):
+            self.logger.warning(f"Cannot extract content from error response: {response.get('error_type')}")
+            return ""
+            
         if response.get("choices"):
             choice = response["choices"][0]
             if "message" in choice and "content" in choice["message"]:
@@ -194,3 +171,23 @@ class OpenRouterClient(LLMClient):
             Model name string
         """
         return self.model
+
+    def get_provider_name(self) -> str:
+        """
+        Get the provider name for this client.
+
+        Returns:
+            Provider name string
+        """
+        return "openrouter"
+
+    def get_request_timeout(self) -> int:
+        """
+        Get the request timeout in seconds for OpenRouter.
+        
+        Cloud APIs typically respond quickly, so we use a 30-second timeout.
+        
+        Returns:
+            Timeout value in seconds (30)
+        """
+        return 30