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

todo_agent/infrastructure/inference.py

@@ -12,8 +12,11 @@ try:
     from todo_agent.infrastructure.config import Config
     from todo_agent.infrastructure.llm_client_factory import LLMClientFactory
     from todo_agent.infrastructure.logger import Logger
+    from todo_agent.interface.formatters import (
+        get_provider_error_message as _get_error_msg,
+    )
+    from todo_agent.interface.progress import NoOpProgress, ToolCallProgress
     from todo_agent.interface.tools import ToolCallHandler
-    from todo_agent.interface.progress import ToolCallProgress, NoOpProgress
 except ImportError:
     from core.conversation_manager import (  # type: ignore[no-redef]
         ConversationManager,
@@ -24,8 +27,14 @@ except ImportError:
         LLMClientFactory,
     )
     from infrastructure.logger import Logger  # type: ignore[no-redef]
+    from interface.formatters import (  # type: ignore[no-redef]
+        get_provider_error_message as _get_error_msg,
+    )
+    from interface.progress import (  # type: ignore[no-redef]
+        NoOpProgress,
+        ToolCallProgress,
+    )
     from interface.tools import ToolCallHandler  # type: ignore[no-redef]
-    from interface.progress import ToolCallProgress, NoOpProgress  # type: ignore[no-redef]
 
 
 class Inference:
@@ -68,6 +77,27 @@ class Inference:
         self.conversation_manager.set_system_prompt(system_prompt)
         self.logger.debug("System prompt loaded and set")
 
+    def current_tasks(self) -> str:
+        """
+        Get current tasks from the todo manager.
+
+        Returns:
+            Formatted string of current tasks or error message
+        """
+        try:
+            # Use the todo manager from the tool handler to get current tasks
+            tasks = self.tool_handler.todo_manager.list_tasks(suppress_color=True)
+
+            # If no tasks found, return a clear message
+            if not tasks.strip() or tasks == "No tasks found.":
+                return "No current tasks found."
+
+            return tasks
+
+        except Exception as e:
+            self.logger.warning(f"Failed to get current tasks: {e!s}")
+            return f"Error retrieving current tasks: {e!s}"
+
     def _load_system_prompt(self) -> str:
         """Load and format the system prompt from file."""
         # Get current datetime for interpolation
@@ -84,6 +114,9 @@ class Inference:
             self.logger.warning(f"Failed to get calendar output: {e!s}")
             calendar_output = "Calendar unavailable"
 
+        # Get current tasks
+        current_tasks = self.current_tasks()
+
         # Load system prompt from file
         prompt_file_path = os.path.join(
             os.path.dirname(__file__), "prompts", "system_prompt.txt"
@@ -93,10 +126,11 @@ class Inference:
             with open(prompt_file_path, encoding="utf-8") as f:
                 system_prompt_template = f.read()
 
-            # Format the template with current datetime and calendar
+            # Format the template with current datetime, calendar, and current tasks
             return system_prompt_template.format(
                 current_datetime=current_datetime,
                 calendar_output=calendar_output,
+                current_tasks=current_tasks,
             )
 
         except FileNotFoundError:
@@ -106,9 +140,9 @@ class Inference:
             self.logger.error(f"Error loading system prompt: {e!s}")
             raise
 
-
-
-    def process_request(self, user_input: str, progress_callback: Optional[ToolCallProgress] = None) -> tuple[str, float]:
+    def process_request(
+        self, user_input: str, progress_callback: Optional[ToolCallProgress] = None
+    ) -> tuple[str, float]:
         """
         Process a user request through the LLM with tool orchestration.
 
@@ -121,11 +155,11 @@ class Inference:
         """
         # Start timing the request
         start_time = time.time()
-        
+
         # Initialize progress callback if not provided
         if progress_callback is None:
             progress_callback = NoOpProgress()
-        
+
         # Notify progress callback that thinking has started
         progress_callback.on_thinking_start()
 
@@ -155,23 +189,19 @@ class Inference:
                 error_type = response.get("error_type", "general_error")
                 provider = response.get("provider", "unknown")
                 self.logger.error(f"Provider error from {provider}: {error_type}")
-                
-                # Import here to avoid circular imports
-                try:
-                    from todo_agent.interface.formatters import get_provider_error_message
-                    error_message = get_provider_error_message(error_type)
-                except ImportError:
-                    from interface.formatters import get_provider_error_message
-                    error_message = get_provider_error_message(error_type)
-                
+
+                error_message = _get_error_msg(error_type)
+
                 # Add error message to conversation
-                self.conversation_manager.add_message(MessageRole.ASSISTANT, error_message)
-                
+                self.conversation_manager.add_message(
+                    MessageRole.ASSISTANT, error_message
+                )
+
                 # Calculate thinking time and return
                 end_time = time.time()
                 thinking_time = end_time - start_time
                 progress_callback.on_thinking_complete(thinking_time)
-                
+
                 return error_message, thinking_time
 
             # Extract actual token usage from API response
@@ -188,8 +218,7 @@ class Inference:
 
             # Handle multiple tool calls in sequence
             tool_call_count = 0
-            total_sequences = 0  # We'll track this as we go
-            
+
             while True:
                 tool_calls = self.llm_client.extract_tool_calls(response)
 
@@ -200,9 +229,11 @@ class Inference:
                 self.logger.debug(
                     f"Executing tool call sequence #{tool_call_count} with {len(tool_calls)} tools"
                 )
-                
+
                 # Notify progress callback of sequence start
-                progress_callback.on_sequence_complete(tool_call_count, 0)  # We don't know total yet
+                progress_callback.on_sequence_complete(
+                    tool_call_count, 0
+                )  # We don't know total yet
 
                 # Execute all tool calls and collect results
                 tool_results = []
@@ -217,13 +248,18 @@ class Inference:
                     self.logger.debug(f"Raw tool call: {tool_call}")
 
                     # Get progress description for the tool
-                    progress_description = self._get_tool_progress_description(tool_name)
-                    
+                    progress_description = self._get_tool_progress_description(
+                        tool_name, tool_call
+                    )
+
                     # Notify progress callback of tool call start
                     progress_callback.on_tool_call_start(
-                        tool_name, progress_description, tool_call_count, 0  # We don't know total yet
+                        tool_name,
+                        progress_description,
+                        tool_call_count,
+                        0,  # We don't know total yet
                     )
-                    
+
                     result = self.tool_handler.execute_tool(tool_call)
 
                     # Log tool execution result (success or error)
@@ -253,24 +289,22 @@ class Inference:
                 if response.get("error", False):
                     error_type = response.get("error_type", "general_error")
                     provider = response.get("provider", "unknown")
-                    self.logger.error(f"Provider error in continuation from {provider}: {error_type}")
-                    
-                    # Import here to avoid circular imports
-                    try:
-                        from todo_agent.interface.formatters import get_provider_error_message
-                        error_message = get_provider_error_message(error_type)
-                    except ImportError:
-                        from interface.formatters import get_provider_error_message
-                        error_message = get_provider_error_message(error_type)
-                    
+                    self.logger.error(
+                        f"Provider error in continuation from {provider}: {error_type}"
+                    )
+
+                    error_message = _get_error_msg(error_type)
+
                     # Add error message to conversation
-                    self.conversation_manager.add_message(MessageRole.ASSISTANT, error_message)
-                    
+                    self.conversation_manager.add_message(
+                        MessageRole.ASSISTANT, error_message
+                    )
+
                     # Calculate thinking time and return
                     end_time = time.time()
                     thinking_time = end_time - start_time
                     progress_callback.on_thinking_complete(thinking_time)
-                    
+
                     return error_message, thinking_time
 
                 # Update with actual tokens from subsequent API calls
@@ -284,7 +318,7 @@ class Inference:
             # Calculate and log total thinking time
             end_time = time.time()
             thinking_time = end_time - start_time
-            
+
             # Notify progress callback that thinking is complete
             progress_callback.on_thinking_complete(thinking_time)
 
@@ -321,22 +355,56 @@ class Inference:
             self.tool_handler.tools
         )
 
-    def _get_tool_progress_description(self, tool_name: str) -> str:
+    def _get_tool_progress_description(
+        self, tool_name: str, tool_call: Dict[str, Any]
+    ) -> str:
         """
-        Get user-friendly progress description for a tool.
-        
+        Get user-friendly progress description for a tool with parameter interpolation.
+
         Args:
             tool_name: Name of the tool
-            
+            tool_call: The tool call dictionary containing parameters
+
         Returns:
-            Progress description string
+            Progress description string with interpolated parameters
         """
-        tool_def = next((t for t in self.tool_handler.tools 
-                         if t.get("function", {}).get("name") == tool_name), None)
-        
+        tool_def = next(
+            (
+                t
+                for t in self.tool_handler.tools
+                if t.get("function", {}).get("name") == tool_name
+            ),
+            None,
+        )
+
         if tool_def and "progress_description" in tool_def:
-            return tool_def["progress_description"]
-        
+            template = tool_def["progress_description"]
+
+            # Extract arguments from tool call
+            arguments = tool_call.get("function", {}).get("arguments", {})
+            if isinstance(arguments, str):
+                import json
+
+                try:
+                    arguments = json.loads(arguments)
+                except json.JSONDecodeError:
+                    arguments = {}
+
+            # Use .format() like the system prompt does
+            try:
+                return template.format(**arguments)
+            except KeyError as e:
+                # If a required parameter is missing, fall back to template
+                self.logger.warning(
+                    f"Missing parameter {e} for progress description of {tool_name}"
+                )
+                return template
+            except Exception as e:
+                self.logger.warning(
+                    f"Failed to interpolate progress description for {tool_name}: {e}"
+                )
+                return template
+
         # Fallback to generic description
         return f"🔧 Executing {tool_name}..."
 

todo_agent/infrastructure/llm_client.py

@@ -2,7 +2,6 @@
 Abstract LLM client interface for todo.sh agent.
 """
 
-import json
 import time
 from abc import ABC, abstractmethod
 from typing import Any, Dict, List
@@ -93,7 +92,9 @@ class LLMClient(ABC):
         pass
 
     @abstractmethod
-    def _get_request_payload(self, messages: List[Dict[str, str]], tools: List[Dict[str, Any]]) -> Dict[str, Any]:
+    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.
 
@@ -117,7 +118,9 @@ class LLMClient(ABC):
         pass
 
     @abstractmethod
-    def _process_response(self, response_data: Dict[str, Any], start_time: float) -> None:
+    def _process_response(
+        self, response_data: Dict[str, Any], start_time: float
+    ) -> None:
         """
         Process and log response details.
 
@@ -135,7 +138,9 @@ class LLMClient(ABC):
         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]:
+    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.
 
@@ -155,7 +160,10 @@ class LLMClient(ABC):
 
         try:
             response = requests.post(  # nosec B113
-                endpoint, headers=headers, json=payload, timeout=self.get_request_timeout()
+                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")
@@ -169,19 +177,29 @@ class LLMClient(ABC):
 
         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)
+            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.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]:
+    def _create_error_response(
+        self, error_type: str, raw_error: str, status_code: int = 0
+    ) -> Dict[str, Any]:
         """
         Create standardized error response.
 
@@ -198,7 +216,7 @@ class LLMClient(ABC):
             "error_type": error_type,
             "provider": self.get_provider_name(),
             "status_code": status_code,
-            "raw_error": raw_error
+            "raw_error": raw_error,
         }
 
     def _validate_tool_call(self, tool_call: Any, index: int) -> bool:
@@ -214,47 +232,63 @@ class LLMClient(ABC):
         """
         try:
             if not isinstance(tool_call, dict):
-                self.logger.warning(f"Tool call {index+1} is not a dictionary: {tool_call}")
+                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}")
+                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}")
+                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}")
+                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}")
+            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:
+        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:
+        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"
@@ -278,7 +312,7 @@ class LLMClient(ABC):
     def get_request_timeout(self) -> int:
         """
         Get the request timeout in seconds for this provider.
-        
+
         Returns:
             Timeout value in seconds (default: 30)
         """

todo_agent/infrastructure/ollama_client.py

@@ -10,7 +10,7 @@ from todo_agent.infrastructure.llm_client import LLMClient
 class OllamaClient(LLMClient):
     """Ollama API client implementation."""
 
-    def __init__(self, config):
+    def __init__(self, config: Any) -> None:
         """
         Initialize Ollama client.
 
@@ -26,7 +26,9 @@ class OllamaClient(LLMClient):
             "Content-Type": "application/json",
         }
 
-    def _get_request_payload(self, messages: List[Dict[str, str]], tools: List[Dict[str, Any]]) -> Dict[str, Any]:
+    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,
@@ -39,10 +41,12 @@ class OllamaClient(LLMClient):
         """Get Ollama API endpoint."""
         return f"{self.base_url}/api/chat"
 
-    def _process_response(self, response_data: Dict[str, Any], start_time: float) -> None:
+    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
 
@@ -88,21 +92,25 @@ class OllamaClient(LLMClient):
         """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')}")
+            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"]:
             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")
+
+            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")
@@ -118,9 +126,11 @@ class OllamaClient(LLMClient):
         """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')}")
+            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)
@@ -147,9 +157,9 @@ class OllamaClient(LLMClient):
     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)
         """

todo_agent/infrastructure/openrouter_client.py

@@ -10,7 +10,7 @@ from todo_agent.infrastructure.llm_client import LLMClient
 class OpenRouterClient(LLMClient):
     """LLM API communication and response handling."""
 
-    def __init__(self, config):
+    def __init__(self, config: Any) -> None:
         """
         Initialize OpenRouter client.
 
@@ -28,7 +28,9 @@ class OpenRouterClient(LLMClient):
             "Content-Type": "application/json",
         }
 
-    def _get_request_payload(self, messages: List[Dict[str, str]], tools: List[Dict[str, Any]]) -> Dict[str, Any]:
+    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,
@@ -41,10 +43,12 @@ class OpenRouterClient(LLMClient):
         """Get OpenRouter API endpoint."""
         return f"{self.base_url}/chat/completions"
 
-    def _process_response(self, response_data: Dict[str, Any], start_time: float) -> None:
+    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
 
@@ -120,20 +124,22 @@ class OpenRouterClient(LLMClient):
         """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')}")
+            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"]:
                 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)} valid tool calls from {len(raw_tool_calls)} total"
                 )
@@ -153,9 +159,11 @@ class OpenRouterClient(LLMClient):
         """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')}")
+            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"]:
@@ -184,9 +192,9 @@ class OpenRouterClient(LLMClient):
     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)
         """