todo-agent 0.3.1__tar.gz → 0.3.3__tar.gz

{todo_agent-0.3.1 → todo_agent-0.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: todo-agent
-Version: 0.3.1
+Version: 0.3.3
 Summary: A natural language interface for todo.sh task management
 Author: codeprimate
 Maintainer: codeprimate
@@ -68,7 +68,7 @@ todo-agent "show my work tasks"
 
 **Get intelligent insights** beyond basic task lists. It organizes tasks strategically, suggests priorities, and recommends optimal timing based on your patterns.
 
-**Work smarter** with automatic duplicate detection, recurring task handling, and calendar-aware scheduling.
+**Work smarter** with automatic duplicate detection and calendar-aware scheduling.
 
 **Choose your privacy** - use cloud AI (OpenRouter) or run locally (Ollama).
 
@@ -163,7 +163,7 @@ todo-agent "what tasks are blocking other work?"
 ### Natural Language Intelligence
 ```bash
 todo-agent "add dentist appointment next Monday"
-todo-agent "set up recurring daily vitamin reminder"
+
 todo-agent "move all completed tasks to archive"
 todo-agent "show me tasks I can do from home"
 ```

{todo_agent-0.3.1 → todo_agent-0.3.3}/README.md

@@ -21,7 +21,7 @@ todo-agent "show my work tasks"
 
 **Get intelligent insights** beyond basic task lists. It organizes tasks strategically, suggests priorities, and recommends optimal timing based on your patterns.
 
-**Work smarter** with automatic duplicate detection, recurring task handling, and calendar-aware scheduling.
+**Work smarter** with automatic duplicate detection and calendar-aware scheduling.
 
 **Choose your privacy** - use cloud AI (OpenRouter) or run locally (Ollama).
 
@@ -116,7 +116,7 @@ todo-agent "what tasks are blocking other work?"
 ### Natural Language Intelligence
 ```bash
 todo-agent "add dentist appointment next Monday"
-todo-agent "set up recurring daily vitamin reminder"
+
 todo-agent "move all completed tasks to archive"
 todo-agent "show me tasks I can do from home"
 ```

{todo_agent-0.3.1 → todo_agent-0.3.3}/tests/test_core/test_conversation_manager.py

@@ -14,8 +14,8 @@ class TestConversationManager:
         """Test ConversationManager initialization."""
         manager = ConversationManager()
         assert len(manager.history) == 0
-        assert manager.max_tokens == 32000
-        assert manager.max_messages == 50
+        assert manager.max_tokens == 64000
+        assert manager.max_messages == 100
         assert manager.system_prompt is None
 
     def test_add_message(self):

{todo_agent-0.3.1 → todo_agent-0.3.3}/tests/test_core/test_todo_manager.py

@@ -148,44 +148,6 @@ class TestTodoManager(unittest.TestCase):
             self.todo_manager.set_due_date(1, "2025/1/5")
         self.assertIn("Invalid due date format", str(context.exception))
 
-    def test_add_task_with_valid_recurring_daily(self):
-        """Test adding a task with valid daily recurring format."""
-        self.todo_shell.add.return_value = "Test task"
-        result = self.todo_manager.add_task("Test task", recurring="rec:daily")
-        self.assertEqual(result, "Added task: Test task rec:daily")
-        self.todo_shell.add.assert_called_once_with("Test task rec:daily")
-
-    def test_add_task_with_valid_recurring_weekly_interval(self):
-        """Test adding a task with valid weekly recurring format with interval."""
-        self.todo_shell.add.return_value = "Test task"
-        result = self.todo_manager.add_task("Test task", recurring="rec:weekly:2")
-        self.assertEqual(result, "Added task: Test task rec:weekly:2")
-        self.todo_shell.add.assert_called_once_with("Test task rec:weekly:2")
-
-    def test_add_task_with_invalid_recurring_format(self):
-        """Test adding a task with invalid recurring format raises ValueError."""
-        with self.assertRaises(ValueError) as context:
-            self.todo_manager.add_task("Test task", recurring="invalid")
-        self.assertIn("Invalid recurring format", str(context.exception))
-
-    def test_add_task_with_invalid_recurring_frequency(self):
-        """Test adding a task with invalid recurring frequency raises ValueError."""
-        with self.assertRaises(ValueError) as context:
-            self.todo_manager.add_task("Test task", recurring="rec:invalid")
-        self.assertIn("Invalid frequency", str(context.exception))
-
-    def test_add_task_with_invalid_recurring_interval(self):
-        """Test adding a task with invalid recurring interval raises ValueError."""
-        with self.assertRaises(ValueError) as context:
-            self.todo_manager.add_task("Test task", recurring="rec:weekly:invalid")
-        self.assertIn("Invalid interval", str(context.exception))
-
-    def test_add_task_with_zero_recurring_interval(self):
-        """Test adding a task with zero recurring interval raises ValueError."""
-        with self.assertRaises(ValueError) as context:
-            self.todo_manager.add_task("Test task", recurring="rec:weekly:0")
-        self.assertIn("Must be a positive integer", str(context.exception))
-
     def test_add_task_with_invalid_duration_format(self):
         """Test adding a task with invalid duration format raises ValueError."""
         with self.assertRaises(ValueError) as context:
@@ -216,24 +178,6 @@ class TestTodoManager(unittest.TestCase):
             self.todo_manager.add_task("Test task", duration="")
         self.assertIn("Duration must be a non-empty string", str(context.exception))
 
-    def test_add_task_with_all_parameters_including_recurring(self):
-        """Test adding a task with all parameters including recurring."""
-        self.todo_shell.add.return_value = "Test task"
-        result = self.todo_manager.add_task(
-            "Test task",
-            priority="A",
-            project="work",
-            context="office",
-            due="2024-01-15",
-            recurring="rec:daily",
-        )
-        self.assertEqual(
-            result, "Added task: (A) Test task +work @office due:2024-01-15 rec:daily"
-        )
-        self.todo_shell.add.assert_called_once_with(
-            "(A) Test task +work @office due:2024-01-15 rec:daily"
-        )
-
     def test_add_task_with_duration(self):
         """Test adding a task with duration parameter."""
         self.todo_shell.add.return_value = "Test task"
@@ -253,15 +197,14 @@ class TestTodoManager(unittest.TestCase):
             project="work",
             context="office",
             due="2024-01-15",
-            recurring="rec:daily",
             duration="2h",
         )
         self.assertEqual(
             result,
-            "Added task: (A) Test task +work @office due:2024-01-15 rec:daily duration:2h",
+            "Added task: (A) Test task +work @office due:2024-01-15 duration:2h",
         )
         self.todo_shell.add.assert_called_once_with(
-            "(A) Test task +work @office due:2024-01-15 rec:daily duration:2h"
+            "(A) Test task +work @office due:2024-01-15 duration:2h"
         )
 
     def test_list_tasks(self):
@@ -269,7 +212,7 @@ class TestTodoManager(unittest.TestCase):
         self.todo_shell.list_tasks.return_value = "1. Task 1\n2. Task 2"
         result = self.todo_manager.list_tasks()
         self.assertEqual(result, "1. Task 1\n2. Task 2")
-        self.todo_shell.list_tasks.assert_called_once_with(None)
+        self.todo_shell.list_tasks.assert_called_once_with(None, suppress_color=True)
 
     def test_complete_task(self):
         """Test completing a task."""
@@ -285,28 +228,36 @@ class TestTodoManager(unittest.TestCase):
         )
         result = self.todo_manager.list_completed_tasks()
         self.assertEqual(result, "1. Completed task 1\n2. Completed task 2")
-        self.todo_shell.list_completed.assert_called_once_with(None)
+        self.todo_shell.list_completed.assert_called_once_with(
+            None, suppress_color=True
+        )
 
     def test_list_completed_tasks_with_project_filter(self):
         """Test listing completed tasks with project filter."""
         self.todo_shell.list_completed.return_value = "1. Work task completed"
         result = self.todo_manager.list_completed_tasks(project="work")
         self.assertEqual(result, "1. Work task completed")
-        self.todo_shell.list_completed.assert_called_once_with("+work")
+        self.todo_shell.list_completed.assert_called_once_with(
+            "+work", suppress_color=True
+        )
 
     def test_list_completed_tasks_with_context_filter(self):
         """Test listing completed tasks with context filter."""
         self.todo_shell.list_completed.return_value = "1. Office task completed"
         result = self.todo_manager.list_completed_tasks(context="office")
         self.assertEqual(result, "1. Office task completed")
-        self.todo_shell.list_completed.assert_called_once_with("@office")
+        self.todo_shell.list_completed.assert_called_once_with(
+            "@office", suppress_color=True
+        )
 
     def test_list_completed_tasks_with_text_search(self):
         """Test listing completed tasks with text search."""
         self.todo_shell.list_completed.return_value = "1. Review task completed"
         result = self.todo_manager.list_completed_tasks(text_search="review")
         self.assertEqual(result, "1. Review task completed")
-        self.todo_shell.list_completed.assert_called_once_with("review")
+        self.todo_shell.list_completed.assert_called_once_with(
+            "review", suppress_color=True
+        )
 
     def test_list_completed_tasks_with_date_filters(self):
         """Test listing completed tasks with date filters."""
@@ -316,14 +267,18 @@ class TestTodoManager(unittest.TestCase):
         )
         self.assertEqual(result, "1. Task completed in date range")
         # With both date_from and date_to, we use the year-month pattern from date_from
-        self.todo_shell.list_completed.assert_called_once_with("2025-08")
+        self.todo_shell.list_completed.assert_called_once_with(
+            "2025-08", suppress_color=True
+        )
 
     def test_list_completed_tasks_with_date_from_only(self):
         """Test listing completed tasks with only date_from filter."""
         self.todo_shell.list_completed.return_value = "1. Task completed from date"
         result = self.todo_manager.list_completed_tasks(date_from="2025-08-01")
         self.assertEqual(result, "1. Task completed from date")
-        self.todo_shell.list_completed.assert_called_once_with("2025-08-01")
+        self.todo_shell.list_completed.assert_called_once_with(
+            "2025-08-01", suppress_color=True
+        )
 
     def test_list_completed_tasks_with_date_to_only(self):
         """Test listing completed tasks with only date_to filter."""
@@ -331,7 +286,9 @@ class TestTodoManager(unittest.TestCase):
         result = self.todo_manager.list_completed_tasks(date_to="2025-08-31")
         self.assertEqual(result, "1. Task completed in month")
         # With only date_to, we use the year-month pattern
-        self.todo_shell.list_completed.assert_called_once_with("2025-08")
+        self.todo_shell.list_completed.assert_called_once_with(
+            "2025-08", suppress_color=True
+        )
 
     def test_list_completed_tasks_with_multiple_filters(self):
         """Test listing completed tasks with multiple filters."""
@@ -342,21 +299,27 @@ class TestTodoManager(unittest.TestCase):
             project="work", context="office", text_search="review"
         )
         self.assertEqual(result, "1. Work task from office completed")
-        self.todo_shell.list_completed.assert_called_once_with("+work @office review")
+        self.todo_shell.list_completed.assert_called_once_with(
+            "+work @office review", suppress_color=True
+        )
 
     def test_list_completed_tasks_with_raw_filter(self):
         """Test listing completed tasks with raw filter string."""
         self.todo_shell.list_completed.return_value = "1. Custom filtered task"
         result = self.todo_manager.list_completed_tasks(filter="+urgent @home")
         self.assertEqual(result, "1. Custom filtered task")
-        self.todo_shell.list_completed.assert_called_once_with("+urgent @home")
+        self.todo_shell.list_completed.assert_called_once_with(
+            "+urgent @home", suppress_color=True
+        )
 
     def test_list_completed_tasks_no_results(self):
         """Test listing completed tasks when no results found."""
         self.todo_shell.list_completed.return_value = ""
         result = self.todo_manager.list_completed_tasks(project="nonexistent")
         self.assertEqual(result, "No completed tasks found matching the criteria.")
-        self.todo_shell.list_completed.assert_called_once_with("+nonexistent")
+        self.todo_shell.list_completed.assert_called_once_with(
+            "+nonexistent", suppress_color=True
+        )
 
     def test_add_task_sanitizes_inputs(self):
         """Test that add_task sanitizes inputs to prevent duplicates."""
@@ -421,7 +384,6 @@ class TestTodoManager(unittest.TestCase):
             "projects": ["+project1", "+project1", "+project2"],  # Duplicate project1
             "contexts": ["@context1", "@context1", "@context2"],  # Duplicate context1
             "due": "2024-01-01",
-            "recurring": None,
             "other_tags": [],
         }
 
@@ -599,6 +561,111 @@ class TestTodoManager(unittest.TestCase):
         assert components["contexts"].count("@context1") == 1
         assert components["contexts"].count("@context2") == 1
 
+    def test_get_current_datetime(self):
+        """Test getting current date and time."""
+        with patch("todo_agent.core.todo_manager.datetime") as mock_datetime:
+            mock_now = Mock()
+            mock_now.strftime.side_effect = lambda fmt: {
+                "%Y-%m-%d %H:%M:%S": "2025-01-15 10:30:00",
+                "%A, %B %d, %Y at %I:%M %p": "Wednesday, January 15, 2025 at 10:30 AM",
+            }[fmt]
+            mock_now.isocalendar.return_value = (2025, 3, 3)
+            mock_now.astimezone.return_value.tzinfo = Mock()
+            mock_datetime.now.return_value = mock_now
+
+            result = self.todo_manager.get_current_datetime()
+            self.assertIn("2025-01-15 10:30:00", result)
+            self.assertIn("Week 3", result)
+
+    def test_created_completed_task_basic(self):
+        """Test creating and immediately completing a task."""
+        # Mock the todo_shell methods
+        self.todo_shell.add.return_value = "Task added"
+        self.todo_shell.list_tasks.return_value = "1 Test task\n2 Another task"
+        self.todo_shell.complete.return_value = "Task completed"
+
+        result = self.todo_manager.created_completed_task("Test task")
+
+        # Verify the task was added
+        self.todo_shell.add.assert_called_once_with("Test task")
+        # Verify the task was completed (should find task number 1 since it contains "Test task")
+        self.todo_shell.complete.assert_called_once_with(1)
+        # Verify the result message
+        self.assertIn("Created and completed task: Test task", result)
+
+    def test_created_completed_task_with_project_and_context(self):
+        """Test creating and completing a task with project and context."""
+        self.todo_shell.add.return_value = "Task added"
+        self.todo_shell.list_tasks.return_value = "1 Test task\n2 Another task"
+        self.todo_shell.complete.return_value = "Task completed"
+
+        result = self.todo_manager.created_completed_task(
+            "Test task", project="work", context="office"
+        )
+
+        # Verify the task was added with project and context
+        self.todo_shell.add.assert_called_once_with("Test task +work @office")
+        # Verify the task was completed (should find task number 1 since it contains "Test task")
+        self.todo_shell.complete.assert_called_once_with(1)
+        self.assertIn("+work @office", result)
+
+    def test_created_completed_task_with_custom_date(self):
+        """Test creating and completing a task with a custom completion date."""
+        self.todo_shell.add.return_value = "Task added"
+        self.todo_shell.list_tasks.return_value = "1 Test task"
+        self.todo_shell.complete.return_value = "Task completed"
+
+        result = self.todo_manager.created_completed_task(
+            "Test task", completion_date="2025-01-10"
+        )
+
+        # Verify the task was completed (should find task number 1 since it contains "Test task")
+        self.todo_shell.complete.assert_called_once_with(1)
+        self.assertIn("completed on 2025-01-10", result)
+
+    def test_created_completed_task_with_invalid_date(self):
+        """Test that invalid completion date raises ValueError."""
+        with self.assertRaises(ValueError) as context:
+            self.todo_manager.created_completed_task(
+                "Test task", completion_date="invalid-date"
+            )
+        self.assertIn("Invalid completion date format", str(context.exception))
+
+    def test_created_completed_task_sanitizes_project_and_context(self):
+        """Test that project and context with existing symbols are properly sanitized."""
+        self.todo_shell.add.return_value = "Task added"
+        self.todo_shell.list_tasks.return_value = "1 Test task"
+        self.todo_shell.complete.return_value = "Task completed"
+
+        result = self.todo_manager.created_completed_task(
+            "Test task", project="+work", context="@office"
+        )
+
+        # Verify the task was added with properly sanitized project and context
+        self.todo_shell.add.assert_called_once_with("Test task +work @office")
+        self.assertIn("+work @office", result)
+
+    def test_created_completed_task_with_empty_project_after_sanitization(self):
+        """Test that empty project after sanitization raises ValueError."""
+        with self.assertRaises(ValueError) as context:
+            self.todo_manager.created_completed_task("Test task", project="+")
+        self.assertIn("Project name cannot be empty", str(context.exception))
+
+    def test_created_completed_task_with_empty_context_after_sanitization(self):
+        """Test that empty context after sanitization raises ValueError."""
+        with self.assertRaises(ValueError) as context:
+            self.todo_manager.created_completed_task("Test task", context="@")
+        self.assertIn("Context name cannot be empty", str(context.exception))
+
+    def test_created_completed_task_no_tasks_after_addition(self):
+        """Test that RuntimeError is raised when no tasks are found after addition."""
+        self.todo_shell.add.return_value = "Task added"
+        self.todo_shell.list_tasks.return_value = ""  # No tasks found
+
+        with self.assertRaises(RuntimeError) as context:
+            self.todo_manager.created_completed_task("Test task")
+        self.assertIn("Failed to add task", str(context.exception))
+
 
 if __name__ == "__main__":
     unittest.main()

{todo_agent-0.3.1 → todo_agent-0.3.3}/tests/test_infrastructure/test_calendar_utils.py

@@ -17,7 +17,7 @@ class TestCalendarUtils:
 
     def test_get_calendar_output_success(self):
         """Test successful calendar output generation."""
-        mock_output = "Calendar output from cal -3"
+        mock_output = "Calendar output from cal"
 
         with patch("subprocess.run") as mock_run:
             mock_result = Mock()
@@ -29,7 +29,7 @@ class TestCalendarUtils:
             assert result == mock_output
             assert len(result) > 0
             mock_run.assert_called_once_with(
-                ["cal", "-3"], capture_output=True, text=True, check=True
+                ["cal"], capture_output=True, text=True, check=True
             )
 
     def test_get_calendar_output_fallback(self):

{todo_agent-0.3.1 → todo_agent-0.3.3}/tests/test_infrastructure/test_inference.py

@@ -104,7 +104,9 @@ class TestInference:
     def test_system_prompt_datetime_interpolation(self):
         """Test that current datetime is properly interpolated into system prompt."""
         # Mock the file reading
-        mock_prompt_content = "CURRENT DATE/TIME: {current_datetime}\n{tools_section}"
+        mock_prompt_content = (
+            "CURRENT DATE/TIME: {current_datetime}\nCALENDAR: {calendar_output}"
+        )
 
         with patch("builtins.open", mock_open(read_data=mock_prompt_content)):
             # Call the method that loads the system prompt
@@ -122,9 +124,9 @@ class TestInference:
                 "System prompt should contain properly formatted datetime"
             )
 
-            # Verify that tools_section is also interpolated
-            assert "{tools_section}" not in result
-            assert "list_tasks" in result  # Should contain tool information
+            # Verify that calendar_output is also interpolated
+            assert "{calendar_output}" not in result
+            assert "September" in result  # Should contain calendar month information
 
     def test_process_request_with_tool_calls(self):
         """Test request processing with tool calls."""

todo_agent-0.3.3/tests/test_infrastructure/test_ollama_client.py

@@ -0,0 +1,198 @@
+"""
+Tests for OllamaClient.
+"""
+
+import json
+from unittest.mock import Mock, mock_open, patch
+
+import pytest
+
+from todo_agent.infrastructure.config import Config
+from todo_agent.infrastructure.ollama_client import OllamaClient
+
+
+class TestOllamaClient:
+    """Test OllamaClient functionality."""
+
+    def setup_method(self):
+        """Set up test fixtures."""
+        self.config = Config()
+        self.config.provider = "ollama"
+        self.config.ollama_base_url = "http://localhost:11434"
+        self.config.ollama_model = "llama3.2"
+
+        # Patch the dependencies that are now initialized in the parent class
+        with patch("todo_agent.infrastructure.llm_client.Logger") as mock_logger, patch(
+            "todo_agent.infrastructure.llm_client.get_token_counter"
+        ) as mock_token_counter:
+            mock_logger.return_value = Mock()
+            mock_token_counter.return_value = Mock()
+
+            self.client = OllamaClient(self.config)
+
+    def test_initialization(self):
+        """Test client initialization."""
+        assert self.client.config == self.config
+        assert self.client.base_url == "http://localhost:11434"
+        assert self.client.model == "llama3.2"
+        assert self.client.logger is not None
+        assert self.client.token_counter is not None
+
+    def test_get_model_name(self):
+        """Test getting model name."""
+        assert self.client.get_model_name() == "llama3.2"
+
+    def test_get_provider_name(self):
+        """Test getting provider name."""
+        assert self.client.get_provider_name() == "ollama"
+
+    def test_get_request_timeout(self):
+        """Test getting request timeout."""
+        assert self.client.get_request_timeout() == 120  # 2 minutes for Ollama
+
+    def test_get_request_headers(self):
+        """Test request headers generation."""
+        headers = self.client._get_request_headers()
+        assert headers == {"Content-Type": "application/json"}
+
+    def test_get_request_payload(self):
+        """Test request payload generation."""
+        messages = [{"role": "user", "content": "Hello"}]
+        tools = [{"name": "test_tool", "description": "A test tool"}]
+
+        payload = self.client._get_request_payload(messages, tools)
+        expected = {
+            "model": "llama3.2",
+            "messages": messages,
+            "tools": tools,
+            "stream": False,
+        }
+        assert payload == expected
+
+    def test_get_api_endpoint(self):
+        """Test API endpoint generation."""
+        endpoint = self.client._get_api_endpoint()
+        assert endpoint == "http://localhost:11434/api/chat"
+
+    @patch("todo_agent.infrastructure.ollama_client.OllamaClient._make_http_request")
+    def test_chat_with_tools_success(self, mock_make_request):
+        """Test successful chat with tools."""
+        # Mock the common HTTP request method
+        expected_response = {
+            "message": {"content": "Here are your tasks", "tool_calls": []}
+        }
+        mock_make_request.return_value = expected_response
+
+        messages = [{"role": "user", "content": "List my tasks"}]
+        tools = [{"function": {"name": "list_tasks", "description": "List tasks"}}]
+
+        response = self.client.chat_with_tools(messages, tools)
+
+        assert response == expected_response
+        mock_make_request.assert_called_once_with(messages, tools)
+
+    @patch("todo_agent.infrastructure.ollama_client.OllamaClient._make_http_request")
+    def test_chat_with_tools_api_error(self, mock_make_request):
+        """Test chat with tools when API returns error."""
+        # Mock error response from the common method
+        error_response = {
+            "error": True,
+            "error_type": "general_error",
+            "provider": "ollama",
+            "status_code": 500,
+            "raw_error": "Internal Server Error",
+        }
+        mock_make_request.return_value = error_response
+
+        messages = [{"role": "user", "content": "List my tasks"}]
+        tools = [{"function": {"name": "list_tasks", "description": "List tasks"}}]
+
+        response = self.client.chat_with_tools(messages, tools)
+        assert response == error_response
+
+    def test_extract_tool_calls_with_tools(self):
+        """Test extracting tool calls from response with tools."""
+        response = {
+            "message": {
+                "content": "I'll help you with that",
+                "tool_calls": [
+                    {
+                        "id": "call_1",
+                        "function": {"name": "list_tasks", "arguments": "{}"},
+                    }
+                ],
+            }
+        }
+
+        tool_calls = self.client.extract_tool_calls(response)
+        assert len(tool_calls) == 1
+        assert tool_calls[0]["id"] == "call_1"
+        assert tool_calls[0]["function"]["name"] == "list_tasks"
+
+    def test_extract_tool_calls_without_tools(self):
+        """Test extracting tool calls from response without tools."""
+        response = {
+            "message": {
+                "content": "I'll help you with that",
+            }
+        }
+
+        tool_calls = self.client.extract_tool_calls(response)
+        assert len(tool_calls) == 0
+
+    def test_extract_tool_calls_with_error_response(self):
+        """Test extracting tool calls from error response."""
+        error_response = {"error": True, "error_type": "timeout", "provider": "ollama"}
+
+        tool_calls = self.client.extract_tool_calls(error_response)
+        assert len(tool_calls) == 0
+
+    def test_extract_content_with_content(self):
+        """Test extracting content from response with content."""
+        response = {
+            "message": {
+                "content": "Here are your tasks",
+            }
+        }
+
+        content = self.client.extract_content(response)
+        assert content == "Here are your tasks"
+
+    def test_extract_content_without_content(self):
+        """Test extracting content from response without content."""
+        response = {"message": {}}
+
+        content = self.client.extract_content(response)
+        assert content == ""
+
+    def test_extract_content_empty_response(self):
+        """Test extracting content from empty response."""
+        response = {}
+
+        content = self.client.extract_content(response)
+        assert content == ""
+
+    def test_extract_content_with_error_response(self):
+        """Test extracting content from error response."""
+        error_response = {"error": True, "error_type": "timeout", "provider": "ollama"}
+
+        content = self.client.extract_content(error_response)
+        assert content == ""
+
+    def test_process_response(self):
+        """Test response processing and logging."""
+        response_data = {
+            "message": {
+                "content": "Hello",
+                "tool_calls": [{"id": "call_1", "function": {"name": "test_tool"}}],
+            }
+        }
+
+        with patch.object(self.client.logger, "info") as mock_info, patch.object(
+            self.client.logger, "debug"
+        ) as mock_debug:
+            self.client._process_response(response_data, 0.0)
+
+            # Should log response details
+            assert mock_info.call_count >= 1
+            assert mock_debug.call_count >= 1