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

todo_agent/infrastructure/llm_client.py

@@ -2,12 +2,33 @@
 Abstract LLM client interface for todo.sh agent.
 """
 
+import json
+import time
 from abc import ABC, abstractmethod
 from typing import Any, Dict, List
 
+import requests
+
+from todo_agent.infrastructure.logger import Logger
+from todo_agent.infrastructure.token_counter import get_token_counter
+
 
 class LLMClient(ABC):
-    """Abstract interface for LLM clients."""
+    """Abstract interface for LLM clients with common functionality."""
+
+    def __init__(self, config: Any, model: str, logger_name: str = "llm_client"):
+        """
+        Initialize common LLM client functionality.
+
+        Args:
+            config: Configuration object
+            model: Model name for token counting
+            logger_name: Logger name for this client
+        """
+        self.config = config
+        self.model = model
+        self.logger = Logger(logger_name)
+        self.token_counter = get_token_counter(model)
 
     @abstractmethod
     def chat_with_tools(
@@ -60,3 +81,205 @@ class LLMClient(ABC):
             Model name string
         """
         pass
+
+    @abstractmethod
+    def _get_request_headers(self) -> Dict[str, str]:
+        """
+        Get request headers for the API call.
+
+        Returns:
+            Dictionary of headers
+        """
+        pass
+
+    @abstractmethod
+    def _get_request_payload(self, messages: List[Dict[str, str]], tools: List[Dict[str, Any]]) -> Dict[str, Any]:
+        """
+        Get request payload for the API call.
+
+        Args:
+            messages: List of message dictionaries
+            tools: List of tool definitions
+
+        Returns:
+            Request payload dictionary
+        """
+        pass
+
+    @abstractmethod
+    def _get_api_endpoint(self) -> str:
+        """
+        Get the API endpoint for requests.
+
+        Returns:
+            API endpoint URL
+        """
+        pass
+
+    @abstractmethod
+    def _process_response(self, response_data: Dict[str, Any], start_time: float) -> None:
+        """
+        Process and log response details.
+
+        Args:
+            response_data: Response data from API
+            start_time: Request start time for latency calculation
+        """
+        pass
+
+    def _log_request_details(self, payload: Dict[str, Any], start_time: float) -> None:
+        """Log request details including accurate token count."""
+        messages = payload.get("messages", [])
+        tools = payload.get("tools", [])
+
+        total_tokens = self.token_counter.count_request_tokens(messages, tools)
+        self.logger.info(f"Request sent - Token count: {total_tokens}")
+
+    def _make_http_request(self, messages: List[Dict[str, str]], tools: List[Dict[str, Any]]) -> Dict[str, Any]:
+        """
+        Make HTTP request to the LLM API with common error handling.
+
+        Args:
+            messages: List of message dictionaries
+            tools: List of tool definitions
+
+        Returns:
+            API response dictionary
+        """
+        headers = self._get_request_headers()
+        payload = self._get_request_payload(messages, tools)
+        endpoint = self._get_api_endpoint()
+
+        start_time = time.time()
+        self._log_request_details(payload, start_time)
+
+        try:
+            response = requests.post(  # nosec B113
+                endpoint, headers=headers, json=payload, timeout=self.get_request_timeout()
+            )
+        except requests.exceptions.Timeout:
+            self.logger.error(f"{self.get_provider_name()} API request timed out")
+            return self._create_error_response("timeout", "Request timed out")
+        except requests.exceptions.ConnectionError as e:
+            self.logger.error(f"{self.get_provider_name()} API connection error: {e}")
+            return self._create_error_response("timeout", f"Connection error: {e}")
+        except requests.exceptions.RequestException as e:
+            self.logger.error(f"{self.get_provider_name()} API request error: {e}")
+            return self._create_error_response("general_error", f"Request error: {e}")
+
+        if response.status_code != 200:
+            self.logger.error(f"{self.get_provider_name()} API error: {response.text}")
+            error_type = self.classify_error(Exception(response.text), self.get_provider_name())
+            return self._create_error_response(error_type, response.text, response.status_code)
+
+        try:
+            response_data: Dict[str, Any] = response.json()
+        except Exception as e:
+            self.logger.error(f"Failed to parse {self.get_provider_name()} response JSON: {e}")
+            return self._create_error_response("malformed_response", f"JSON parsing failed: {e}", response.status_code)
+
+        self._process_response(response_data, start_time)
+        return response_data
+
+    def _create_error_response(self, error_type: str, raw_error: str, status_code: int = 0) -> Dict[str, Any]:
+        """
+        Create standardized error response.
+
+        Args:
+            error_type: Type of error
+            raw_error: Raw error message
+            status_code: HTTP status code if available
+
+        Returns:
+            Standardized error response dictionary
+        """
+        return {
+            "error": True,
+            "error_type": error_type,
+            "provider": self.get_provider_name(),
+            "status_code": status_code,
+            "raw_error": raw_error
+        }
+
+    def _validate_tool_call(self, tool_call: Any, index: int) -> bool:
+        """
+        Validate a tool call structure.
+
+        Args:
+            tool_call: Tool call to validate
+            index: Index of the tool call for logging
+
+        Returns:
+            True if valid, False otherwise
+        """
+        try:
+            if not isinstance(tool_call, dict):
+                self.logger.warning(f"Tool call {index+1} is not a dictionary: {tool_call}")
+                return False
+
+            function = tool_call.get("function", {})
+            if not isinstance(function, dict):
+                self.logger.warning(f"Tool call {index+1} function is not a dictionary: {function}")
+                return False
+
+            tool_name = function.get("name")
+            if not tool_name:
+                self.logger.warning(f"Tool call {index+1} missing function name: {tool_call}")
+                return False
+
+            arguments = function.get("arguments", "{}")
+            if arguments and not isinstance(arguments, str):
+                self.logger.warning(f"Tool call {index+1} arguments not a string: {arguments}")
+                return False
+
+            return True
+        except Exception as e:
+            self.logger.warning(f"Error validating tool call {index+1}: {e}")
+            return False
+
+    def classify_error(self, error: Exception, provider: str) -> str:
+        """
+        Classify provider errors using simple string matching.
+        
+        Args:
+            error: The exception that occurred
+            provider: The provider name (e.g., 'openrouter', 'ollama')
+            
+        Returns:
+            Error type string for message lookup
+        """
+        error_str = str(error).lower()
+        
+        if "malformed" in error_str or "invalid" in error_str or "parse" in error_str:
+            return "malformed_response"
+        elif "rate limit" in error_str or "429" in error_str or "too many requests" in error_str:
+            return "rate_limit"
+        elif "unauthorized" in error_str or "401" in error_str or "authentication" in error_str:
+            return "auth_error"
+        elif "timeout" in error_str or "timed out" in error_str:
+            return "timeout"
+        elif "connection" in error_str or "network" in error_str or "dns" in error_str:
+            return "timeout"  # Treat connection issues as timeouts for user messaging
+        elif "refused" in error_str or "unreachable" in error_str:
+            return "timeout"  # Connection refused is similar to timeout for users
+        else:
+            return "general_error"
+
+    @abstractmethod
+    def get_provider_name(self) -> str:
+        """
+        Get the provider name for this client.
+
+        Returns:
+            Provider name string
+        """
+        pass
+
+    def get_request_timeout(self) -> int:
+        """
+        Get the request timeout in seconds for this provider.
+        
+        Returns:
+            Timeout value in seconds (default: 30)
+        """
+        return 30

todo_agent/infrastructure/ollama_client.py

@@ -2,92 +2,72 @@
 LLM client for Ollama 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 OllamaClient(LLMClient):
     """Ollama API client implementation."""
 
-    def __init__(self, config: Config):
+    def __init__(self, config):
         """
         Initialize Ollama client.
 
         Args:
             config: Configuration object
         """
-        self.config = config
+        super().__init__(config, config.ollama_model, "ollama_client")
         self.base_url = config.ollama_base_url
-        self.model = config.ollama_model
-        self.logger = Logger("ollama_client")
-        self.token_counter = get_token_counter(self.model)
-
-    def _estimate_tokens(self, text: str) -> int:
-        """
-        Estimate token count for text using accurate tokenization.
-
-        Args:
-            text: Text to count tokens for
 
-        Returns:
-            Number of tokens
-        """
-        return self.token_counter.count_tokens(text)
-
-    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 Ollama API."""
+        return {
+            "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 Ollama API."""
+        return {
+            "model": self.model,
+            "messages": messages,
+            "tools": tools,
+            "stream": False,
+        }
 
-        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 Ollama API endpoint."""
+        return f"{self.base_url}/api/chat"
 
-    def _log_response_details(
-        self, response: Dict[str, Any], start_time: float
-    ) -> None:
-        """Log response details including latency."""
+    def _process_response(self, response_data: Dict[str, Any], start_time: float) -> None:
+        """Process and log Ollama response details."""
+        import time
+        
         end_time = time.time()
         latency_ms = (end_time - start_time) * 1000
 
         self.logger.info(f"Response received - Latency: {latency_ms:.2f}ms")
 
         # Log tool call details if present
-        if "message" in response and "tool_calls" in response["message"]:
-            tool_calls = response["message"]["tool_calls"]
+        if "message" in response_data and "tool_calls" in response_data["message"]:
+            tool_calls = response_data["message"]["tool_calls"]
             self.logger.info(f"Response contains {len(tool_calls)} tool calls")
 
             # Log thinking content (response body) if present
-            content = response["message"].get("content", "")
+            content = response_data["message"].get("content", "")
             if content and content.strip():
                 self.logger.info(f"LLM thinking before tool calls: {content}")
 
             for i, tool_call in enumerate(tool_calls):
                 tool_name = tool_call.get("function", {}).get("name", "unknown")
                 self.logger.info(f"  Tool call {i + 1}: {tool_name}")
-        elif "message" in response and "content" in response["message"]:
-            content = response["message"]["content"]
+        elif "message" in response_data and "content" in response_data["message"]:
+            content = response_data["message"]["content"]
             self.logger.debug(
                 f"Response contains content: {content[:100]}{'...' if len(content) > 100 else ''}"
             )
 
-        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]]
@@ -102,41 +82,27 @@ class OllamaClient(LLMClient):
         Returns:
             API response dictionary
         """
-        headers = {
-            "Content-Type": "application/json",
-        }
-
-        payload = {
-            "model": self.model,
-            "messages": messages,
-            "tools": tools,
-            "stream": False,
-        }
-
-        start_time = time.time()
-        self._log_request_details(payload, start_time)
-
-        response = requests.post(  # nosec B113
-            f"{self.base_url}/api/chat", headers=headers, json=payload
-        )
-
-        if response.status_code != 200:
-            self.logger.error(f"Ollama API error: {response.text}")
-            raise Exception(f"Ollama 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 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 = []
 
         # Ollama response format is different from OpenRouter
         if "message" in response and "tool_calls" in response["message"]:
-            tool_calls = response["message"]["tool_calls"]
-            self.logger.debug(f"Extracted {len(tool_calls)} tool calls from response")
+            raw_tool_calls = response["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)} 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")
                 tool_call_id = tool_call.get("id", "unknown")
@@ -150,6 +116,11 @@ class OllamaClient(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 "message" in response and "content" in response["message"]:
             content = response["message"]["content"]
             return content if isinstance(content, str) else str(content)
@@ -163,3 +134,23 @@ class OllamaClient(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 "ollama"
+
+    def get_request_timeout(self) -> int:
+        """
+        Get the request timeout in seconds for Ollama.
+        
+        Ollama can be slower than cloud providers, so we use a 2-minute timeout.
+        
+        Returns:
+            Timeout value in seconds (120)
+        """
+        return 120

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,7 +60,7 @@ class OpenRouterClient(LLMClient):
         )
 
         # Extract and log choice details
-        choices = response.get("choices", [])
+        choices = response_data.get("choices", [])
         if not choices:
             return
 
@@ -99,7 +86,7 @@ class OpenRouterClient(LLMClient):
                 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