mito-ai 0.1.45__py3-none-any.whl → 0.1.47__py3-none-any.whl

mito_ai/streamlit_preview/handlers.py

@@ -2,17 +2,17 @@
 # Distributed under the terms of the GNU Affero General Public License v3.0 License.
 
 import os
-import tempfile
+from typing import Literal, TypedDict
 import uuid
-from mito_ai.streamlit_conversion.streamlit_utils import get_app_path
 from mito_ai.streamlit_preview.utils import ensure_app_exists, validate_request_body
 import tornado
 from jupyter_server.base.handlers import APIHandler
-from mito_ai.streamlit_conversion.streamlit_agent_handler import streamlit_handler
 from mito_ai.streamlit_preview.manager import get_preview_manager
-from mito_ai.utils.create import initialize_user
-from typing import Tuple, Optional
-
+from mito_ai.path_utils import  AbsoluteNotebookPath, get_absolute_notebook_dir_path, get_absolute_notebook_path
+from mito_ai.utils.telemetry_utils import log_streamlit_app_conversion_error, log_streamlit_app_preview_failure, log_streamlit_app_preview_success
+from mito_ai.completions.models import MessageType
+from mito_ai.utils.error_classes import StreamlitConversionError, StreamlitPreviewError
+import traceback
 
 
 class StreamlitPreviewHandler(APIHandler):
@@ -22,103 +22,62 @@ class StreamlitPreviewHandler(APIHandler):
         """Initialize the handler."""
         self.preview_manager = get_preview_manager()
 
-    def _resolve_notebook_path(self, notebook_path: str) -> str:
-        """
-        Resolve the notebook path to an absolute path that can be found by the backend.
-
-        This method handles path resolution issues that can occur in different environments:
-
-        1. **Test Environment**: Playwright tests create temporary directories with complex
-           paths like 'mitoai_ui_tests-app_builde-ab3a5-n-Test-Preview-as-Streamlit-chromium/'
-           that the backend can't directly access.
-
-        2. **JupyterHub/Cloud Deployments**: In cloud environments, users may have notebooks
-           in subdirectories that aren't immediately accessible from the server root.
-
-        3. **Docker Containers**: When running in containers, the working directory and
-           file paths may not align with what the frontend reports.
-
-        4. **Multi-user Environments**: In enterprise deployments, users may have notebooks
-           in user-specific directories that require path resolution.
-
-        The method tries multiple strategies:
-        1. If the path is already absolute, return it as-is
-        2. Try to resolve relative to the Jupyter server's root directory
-        3. Search recursively through subdirectories for a file with the same name
-        4. Return the original path if not found (will cause a clear error message)
-
-        Args:
-            notebook_path (str): The notebook path from the frontend (may be relative or absolute)
-
-        Returns:
-            str: The resolved absolute path to the notebook file
-        """
-        # If the path is already absolute, return it
-        if os.path.isabs(notebook_path):
-            return notebook_path
-
-        # Get the Jupyter server's root directory
-        server_root = self.settings.get("server_root_dir", os.getcwd())
-
-        # Try to find the notebook file in the server root
-        resolved_path = os.path.join(server_root, notebook_path)
-        if os.path.exists(resolved_path):
-            return resolved_path
-
-        # If not found, try to find it in subdirectories
-        # This handles cases where the notebook is in a subdirectory that the frontend
-        # doesn't know about, or where the path structure differs between frontend and backend
-        for root, dirs, files in os.walk(server_root):
-            if os.path.basename(notebook_path) in files:
-                return os.path.join(root, os.path.basename(notebook_path))
-
-        # If still not found, return the original path (will cause a clear error)
-        # This ensures we get a meaningful error message rather than a generic "file not found"
-        return os.path.join(os.getcwd(), notebook_path)
-
     @tornado.web.authenticated
     async def post(self) -> None:
         """Start a new streamlit preview."""
         try:
             # Parse and validate request
             body = self.get_json_body()
-            is_valid, error_msg, notebook_path, force_recreate = validate_request_body(body)
-            if not is_valid or notebook_path is None:
-                self.set_status(400)
-                self.finish({"error": error_msg})
-                return
-
+            notebook_path, force_recreate, edit_prompt = validate_request_body(body)
 
             # Ensure app exists
-            resolved_notebook_path = self._resolve_notebook_path(notebook_path)
-
-            success, error_msg = await ensure_app_exists(resolved_notebook_path, force_recreate)
-
-            if not success:
-                self.set_status(500)
-                self.finish({"error": error_msg})
-                return
+            absolute_notebook_path = get_absolute_notebook_path(notebook_path)
+            await ensure_app_exists(absolute_notebook_path, force_recreate, edit_prompt)
 
             # Start preview
             # TODO: There's a bug here where when the user rebuilds and already running app. Instead of 
             # creating a new process, we should update the existing process. The app displayed to the user 
             # does update, but that's just because of hot reloading when we overwrite the app.py file. 
             preview_id = str(uuid.uuid4())
-            resolved_app_directory = os.path.dirname(resolved_notebook_path)
-            success, message, port = self.preview_manager.start_streamlit_preview(resolved_app_directory, preview_id)
-
-            if not success:
-                self.set_status(500)
-                self.finish({"error": f"Failed to start preview: {message}"})
-                return
+            absolute_app_directory = get_absolute_notebook_dir_path(absolute_notebook_path)
+            port = self.preview_manager.start_streamlit_preview(absolute_app_directory, preview_id)
 
             # Return success response
-            self.finish({"id": preview_id, "port": port, "url": f"http://localhost:{port}"})
-
+            self.finish({
+                "type": 'success',
+                "id": preview_id, 
+                "port": port, 
+                "url": f"http://localhost:{port}"
+            })
+            log_streamlit_app_preview_success('mito_server_key', MessageType.STREAMLIT_CONVERSION, edit_prompt)
+
+        except StreamlitConversionError as e:
+            print(e)
+            self.set_status(e.error_code)
+            error_message = str(e)
+            formatted_traceback = traceback.format_exc()
+            self.finish({"error": error_message})
+            log_streamlit_app_conversion_error(
+                'mito_server_key', 
+                MessageType.STREAMLIT_CONVERSION, 
+                error_message, 
+                formatted_traceback,
+                edit_prompt,
+            )
+        except StreamlitPreviewError as e:
+            print(e)
+            error_message = str(e)
+            formatted_traceback = traceback.format_exc()
+            self.set_status(e.error_code)
+            self.finish({"error": error_message})
+            log_streamlit_app_preview_failure('mito_server_key', MessageType.STREAMLIT_CONVERSION, error_message, formatted_traceback, edit_prompt)
         except Exception as e:
-            print(f"Error in streamlit preview handler: {e}")
+            print(f"Exception in streamlit preview handler: {e}")
             self.set_status(500)
-            self.finish({"error": str(e)})
+            error_message = str(e)
+            formatted_traceback = traceback.format_exc()
+            self.finish({"error": error_message})
+            log_streamlit_app_preview_failure('mito_server_key', MessageType.STREAMLIT_CONVERSION, error_message, formatted_traceback, "")
 
     @tornado.web.authenticated
     def delete(self, preview_id: str) -> None:

mito_ai/streamlit_preview/manager.py

@@ -11,6 +11,7 @@ import requests
 from typing import Dict, Optional, Tuple
 from dataclasses import dataclass
 from mito_ai.logger import get_logger
+from mito_ai.utils.error_classes import StreamlitPreviewError
 
 
 @dataclass
@@ -37,7 +38,7 @@ class StreamlitPreviewManager:
         
         return port
     
-    def start_streamlit_preview(self, app_directory: str, preview_id: str) -> Tuple[bool, str, Optional[int]]:
+    def start_streamlit_preview(self, app_directory: str, preview_id: str) -> int:
         """Start a streamlit preview process.
         
         Args:
@@ -80,7 +81,7 @@ class StreamlitPreviewManager:
             if not ready:
                 proc.terminate()
                 proc.wait()
-                return False, "Streamlit app failed to start", None
+                raise StreamlitPreviewError("Streamlit app failed to start as app is not ready", 500)
             
             # Register the process
             with self._lock:
@@ -90,11 +91,11 @@ class StreamlitPreviewManager:
                 )
             
             self.log.info(f"Started streamlit preview {preview_id} on port {port}")
-            return True, "Preview started successfully", port
+            return port
             
         except Exception as e:
             self.log.error(f"Error starting streamlit preview: {e}")
-            return False, f"Failed to start preview: {str(e)}", None
+            raise StreamlitPreviewError(f"Failed to start preview: {str(e)}", 500)
     
     def _wait_for_app_ready(self, port: int, timeout: int = 30) -> bool:
         """Wait for streamlit app to be ready on the given port."""
@@ -106,7 +107,7 @@ class StreamlitPreviewManager:
                 if response.status_code == 200:
                     return True
             except requests.exceptions.RequestException as e:
-                print(f"Error waiting for app to be ready: {e}")
+                print(f"Waiting for app to be ready...")
                 pass
             
             time.sleep(1)
@@ -153,7 +154,6 @@ class StreamlitPreviewManager:
 # Global instance
 _preview_manager = StreamlitPreviewManager()
 
-
 def get_preview_manager() -> StreamlitPreviewManager:
     """Get the global preview manager instance."""
     return _preview_manager 

mito_ai/streamlit_preview/utils.py

@@ -2,40 +2,41 @@
 # Distributed under the terms of the GNU Affero General Public License v3.0 License.
 
 from typing import Tuple, Optional
-import os
-from mito_ai.streamlit_conversion.streamlit_utils import get_app_path
 from mito_ai.streamlit_conversion.streamlit_agent_handler import streamlit_handler
+from mito_ai.path_utils import AbsoluteNotebookPath, does_app_path_exists, get_absolute_app_path, get_absolute_notebook_dir_path
+from mito_ai.utils.error_classes import StreamlitPreviewError
 
 
-def validate_request_body(body: Optional[dict]) -> Tuple[bool, str, Optional[str], bool]:
+def validate_request_body(body: Optional[dict]) -> Tuple[str, bool, str]:
     """Validate the request body and extract notebook_path and force_recreate."""
     if body is None:
-        return False, "Invalid or missing JSON body", None, False
+        raise StreamlitPreviewError("Invalid or missing JSON body", 400)
 
     notebook_path = body.get("notebook_path")
     if not notebook_path:
-        return False, "Missing notebook_path parameter", None, False
+        raise StreamlitPreviewError("Missing notebook_path parameter", 400)
 
     force_recreate = body.get("force_recreate", False)
     if not isinstance(force_recreate, bool):
-        return False, "force_recreate must be a boolean", None, False
+        raise StreamlitPreviewError("force_recreate must be a boolean", 400)
+    
+    edit_prompt = body.get("edit_prompt", "")
+    if not isinstance(edit_prompt, str):
+        raise StreamlitPreviewError("edit_prompt must be a string", 400)
 
-    return True, "", notebook_path, force_recreate
+    return notebook_path, force_recreate, edit_prompt
 
-async def ensure_app_exists(resolved_notebook_path: str, force_recreate: bool = False) -> Tuple[bool, str]:
+async def ensure_app_exists(absolute_notebook_path: AbsoluteNotebookPath, force_recreate: bool = False, edit_prompt: str = "") -> None:
     """Ensure app.py exists, generating it if necessary or if force_recreate is True."""
-    # Check if the app already exists
-    app_path = get_app_path(os.path.dirname(resolved_notebook_path))
+
+    absolute_notebook_dir_path = get_absolute_notebook_dir_path(absolute_notebook_path)
+    absolute_app_path = get_absolute_app_path(absolute_notebook_dir_path)
+    app_path_exists = does_app_path_exists(absolute_app_path)
     
-    if app_path is None or force_recreate:
-        if app_path is None:
+    if not app_path_exists or force_recreate:
+        if not app_path_exists:
             print("[Mito AI] App path not found, generating streamlit code")
         else:
             print("[Mito AI] Force recreating streamlit app")
         
-        success, app_path, message = await streamlit_handler(resolved_notebook_path)
-
-        if not success or app_path is None:
-            return False, f"Failed to generate streamlit code: {message}"
-
-    return True, ""
+        await streamlit_handler(absolute_notebook_path, edit_prompt)

mito_ai/tests/chat_history/test_chat_history.py

@@ -0,0 +1,211 @@
+# Copyright (c) Saga Inc.
+# Distributed under the terms of the GNU Affero General Public License v3.0 License.
+
+import pytest
+import requests
+import time
+from unittest.mock import patch, MagicMock
+from mito_ai.tests.conftest import TOKEN
+from mito_ai.completions.message_history import GlobalMessageHistory, ChatThread
+from mito_ai.completions.models import ThreadID
+
+
+@pytest.fixture
+def mock_chat_threads():
+    """Fixture that creates mock chat threads for testing"""
+    thread_id_1 = ThreadID("test-thread-1")
+    thread_id_2 = ThreadID("test-thread-2")
+
+    # Create mock threads with different timestamps
+    thread_1 = ChatThread(
+        thread_id=thread_id_1,
+        creation_ts=time.time() - 3600,  # 1 hour ago
+        last_interaction_ts=time.time() - 1800,  # 30 minutes ago
+        name="Test Chat 1",
+        ai_optimized_history=[
+            {"role": "user", "content": "Hello"},
+            {"role": "assistant", "content": "Hi there!"},
+        ],
+        display_history=[
+            {"role": "user", "content": "Hello"},
+            {"role": "assistant", "content": "Hi there!"},
+        ],
+    )
+
+    thread_2 = ChatThread(
+        thread_id=thread_id_2,
+        creation_ts=time.time() - 7200,  # 2 hours ago
+        last_interaction_ts=time.time() - 900,  # 15 minutes ago (more recent)
+        name="Test Chat 2",
+        ai_optimized_history=[
+            {"role": "user", "content": "How are you?"},
+            {"role": "assistant", "content": "I'm doing well, thanks!"},
+        ],
+        display_history=[
+            {"role": "user", "content": "How are you?"},
+            {"role": "assistant", "content": "I'm doing well, thanks!"},
+        ],
+    )
+
+    return {thread_id_1: thread_1, thread_id_2: thread_2}
+
+
+@pytest.fixture
+def mock_message_history(mock_chat_threads):
+    """Fixture that mocks the GlobalMessageHistory with test data"""
+    mock_history = MagicMock(spec=GlobalMessageHistory)
+    mock_history._chat_threads = mock_chat_threads
+
+    # Mock the get_threads method to return sorted threads
+    def mock_get_threads():
+        from mito_ai.completions.models import ChatThreadMetadata
+
+        threads = []
+        for thread in mock_chat_threads.values():
+            threads.append(
+                ChatThreadMetadata(
+                    thread_id=thread.thread_id,
+                    name=thread.name,
+                    creation_ts=thread.creation_ts,
+                    last_interaction_ts=thread.last_interaction_ts,
+                )
+            )
+        # Sort by last_interaction_ts (newest first)
+        threads.sort(key=lambda x: x.last_interaction_ts, reverse=True)
+        return threads
+
+    mock_history.get_threads = mock_get_threads
+    return mock_history
+
+
+# --- GET ALL THREADS ---
+
+
+def test_get_all_threads_success(jp_base_url: str, mock_message_history):
+    """Test successful GET all threads endpoint"""
+    # Since the server extension is already loaded, we need to work with the actual instance
+    # Let's just test that the endpoint works and returns the expected structure
+    response = requests.get(
+        jp_base_url + "/mito-ai/chat-history/threads",
+        headers={"Authorization": f"token {TOKEN}"},
+    )
+    assert response.status_code == 200
+
+    response_json = response.json()
+    assert "threads" in response_json
+    # The actual number of threads will depend on what's in the .mito/ai-chats directory
+    # So we'll just check that it's a list
+    assert isinstance(response_json["threads"], list)
+
+    # Check thread structure for any threads that exist
+    for thread in response_json["threads"]:
+        assert "thread_id" in thread
+        assert "name" in thread
+        assert "creation_ts" in thread
+        assert "last_interaction_ts" in thread
+
+
+def test_get_all_threads_empty(jp_base_url: str):
+    """Test GET all threads endpoint when no threads exist"""
+    # This test will work with whatever threads exist in the actual .mito/ai-chats directory
+    # We'll just verify the endpoint works and returns the expected structure
+    response = requests.get(
+        jp_base_url + "/mito-ai/chat-history/threads",
+        headers={"Authorization": f"token {TOKEN}"},
+    )
+    assert response.status_code == 200
+
+    response_json = response.json()
+    assert "threads" in response_json
+    assert isinstance(response_json["threads"], list)
+
+
+def test_get_all_threads_with_no_auth(jp_base_url: str):
+    """Test GET all threads endpoint without authentication"""
+    response = requests.get(
+        jp_base_url + "/mito-ai/chat-history/threads",
+    )
+    assert response.status_code == 403  # Forbidden
+
+
+def test_get_all_threads_with_incorrect_auth(jp_base_url: str):
+    """Test GET all threads endpoint with incorrect authentication"""
+    response = requests.get(
+        jp_base_url + "/mito-ai/chat-history/threads",
+        headers={"Authorization": f"token incorrect-token"},
+    )
+    assert response.status_code == 403  # Forbidden
+
+
+# --- GET SPECIFIC THREAD ---
+
+
+def test_get_specific_thread_success(jp_base_url: str, mock_message_history):
+    """Test successful GET specific thread endpoint"""
+    # First, get all threads to see what's available
+    response = requests.get(
+        jp_base_url + "/mito-ai/chat-history/threads",
+        headers={"Authorization": f"token {TOKEN}"},
+    )
+    assert response.status_code == 200
+
+    threads = response.json()["threads"]
+    if not threads:
+        # If no threads exist, skip this test
+        pytest.skip("No threads available for testing")
+
+    # Use the first available thread
+    thread_id = threads[0]["thread_id"]
+
+    response = requests.get(
+        jp_base_url + f"/mito-ai/chat-history/threads/{thread_id}",
+        headers={"Authorization": f"token {TOKEN}"},
+    )
+    assert response.status_code == 200
+
+    response_json = response.json()
+    assert response_json["thread_id"] == thread_id
+    assert "name" in response_json
+    assert "creation_ts" in response_json
+    assert "last_interaction_ts" in response_json
+    assert "display_history" in response_json
+    assert "ai_optimized_history" in response_json
+
+    # Check message history structure
+    display_history = response_json["display_history"]
+    assert isinstance(display_history, list)
+    ai_optimized_history = response_json["ai_optimized_history"]
+    assert isinstance(ai_optimized_history, list)
+
+
+def test_get_specific_thread_not_found(jp_base_url: str, mock_message_history):
+    """Test GET specific thread endpoint with non-existent thread ID"""
+    # Use a clearly non-existent thread ID
+    fake_thread_id = "non-existent-thread-12345"
+
+    response = requests.get(
+        jp_base_url + f"/mito-ai/chat-history/threads/{fake_thread_id}",
+        headers={"Authorization": f"token {TOKEN}"},
+    )
+    assert response.status_code == 404
+
+    response_json = response.json()
+    assert "error" in response_json
+    assert fake_thread_id in response_json["error"]
+
+
+def test_get_specific_thread_with_no_auth(jp_base_url: str):
+    """Test GET specific thread endpoint without authentication"""
+    response = requests.get(
+        jp_base_url + "/mito-ai/chat-history/threads/test-thread-1",
+    )
+    assert response.status_code == 403  # Forbidden
+
+
+def test_get_specific_thread_with_incorrect_auth(jp_base_url: str):
+    """Test GET specific thread endpoint with incorrect authentication"""
+    response = requests.get(
+        jp_base_url + "/mito-ai/chat-history/threads/test-thread-1",
+        headers={"Authorization": f"token incorrect-token"},
+    )
+    assert response.status_code == 403  # Forbidden

mito_ai/tests/message_history/test_message_history_utils.py

@@ -233,16 +233,17 @@ file1.csv
 file2.txt
 """
     
-    # Create test messages with proper typing
+    # Create test messages with proper typing 
     messages: List[ChatCompletionMessageParam] = [
         {"role": "system", "content": system_message_with_sections},
         {"role": "user", "content": user_message_with_sections},
         {"role": "assistant", "content": assistant_message_with_sections},
-        {"role": "user", "content": "Recent user message"},
+        {"role": "user", "content": "Recent user message 1"},
+        {"role": "user", "content": "Recent user message 2"},
+        {"role": "user", "content": "Recent user message 3"},
     ]
     
-    # Keep only the most recent message
-    result = trim_old_messages(messages, keep_recent=1)
+    result = trim_old_messages(messages)
     
     # System message should remain unchanged even though it's old
     system_content = result[0].get("content")
@@ -265,14 +266,22 @@ file2.txt
     assert FILES_SECTION_HEADING in assistant_content
     assert "file1.csv" in assistant_content
     
-    # Recent user message should remain unchanged
-    recent_content = result[3].get("content")
-    assert isinstance(recent_content, str)
-    assert recent_content == "Recent user message"
+    # Recent user messages should remain unchanged
+    recent_content_1 = result[3].get("content")
+    assert isinstance(recent_content_1, str)
+    assert recent_content_1 == "Recent user message 1"
+    
+    recent_content_2 = result[4].get("content")
+    assert isinstance(recent_content_2, str)
+    assert recent_content_2 == "Recent user message 2"
+    
+    recent_content_3 = result[5].get("content")
+    assert isinstance(recent_content_3, str)
+    assert recent_content_3 == "Recent user message 3"
 
 
 def test_trim_old_messages_preserves_recent_messages() -> None:
-    """Test that trim_old_messages preserves the most recent messages based on keep_recent parameter."""
+    """Test that trim_old_messages preserves the most recent messages based on MESSAGE_HISTORY_TRIM_THRESHOLD."""
     # Create test messages
     old_message_1 = f"""Old message 1.
 {FILES_SECTION_HEADING}
@@ -289,6 +298,10 @@ file3.csv
     recent_message_2 = f"""Recent message 2.
 {FILES_SECTION_HEADING}
 file4.csv
+"""
+    recent_message_3 = f"""Recent message 3.
+{FILES_SECTION_HEADING}
+file5.csv
 """
     
     # Create test messages with proper typing
@@ -297,10 +310,11 @@ file4.csv
         {"role": "user", "content": old_message_2},
         {"role": "user", "content": recent_message_1},
         {"role": "user", "content": recent_message_2},
+        {"role": "user", "content": recent_message_3},
     ]
     
-    # Keep the 2 most recent messages
-    result = trim_old_messages(messages, keep_recent=2)
+    # Test with MESSAGE_HISTORY_TRIM_THRESHOLD (3) - only the first 2 messages should be trimmed
+    result = trim_old_messages(messages)
     
     # Old messages should be trimmed
     old_content_1 = result[0].get("content")
@@ -325,24 +339,30 @@ file4.csv
     assert recent_content_2 == recent_message_2
     assert FILES_SECTION_HEADING in recent_content_2
     assert "file4.csv" in recent_content_2
+    
+    recent_content_3 = result[4].get("content")
+    assert isinstance(recent_content_3, str)
+    assert recent_content_3 == recent_message_3
+    assert FILES_SECTION_HEADING in recent_content_3
+    assert "file5.csv" in recent_content_3
 
 def test_trim_old_messages_empty_list() -> None:
     """Test that trim_old_messages handles empty message lists correctly."""
     messages: List[ChatCompletionMessageParam] = []
-    result = trim_old_messages(messages, keep_recent=2)
+    result = trim_old_messages(messages)
     assert result == []
 
 
-def test_trim_old_messages_fewer_than_keep_recent() -> None:
-    """Test that trim_old_messages doesn't modify messages if there are fewer than keep_recent."""
+def test_trim_old_messages_fewer_than_threshold() -> None:
+    """Test that trim_old_messages doesn't modify messages if there are fewer than MESSAGE_HISTORY_TRIM_THRESHOLD."""
     messages: List[ChatCompletionMessageParam] = [
         {"role": "user", "content": "User message 1"},
         {"role": "assistant", "content": "Assistant message 1"},
     ]
     
-    result = trim_old_messages(messages, keep_recent=3)
+    result = trim_old_messages(messages)
     
-    # Messages should remain unchanged
+    # Messages should remain unchanged since we have fewer than MESSAGE_HISTORY_TRIM_THRESHOLD (3) messages
     user_content = result[0].get("content")
     assert isinstance(user_content, str)
     assert user_content == "User message 1"
@@ -373,15 +393,17 @@ def test_trim_mixed_content_messages() -> None:
     })
     
     # Create sample message list with one old message (the mixed content)
-    # and one recent message (to not be trimmed)
+    # and enough recent messages to exceed MESSAGE_HISTORY_TRIM_THRESHOLD (3)
     message_list: List[ChatCompletionMessageParam] = [
         mixed_content_message,  # This should get trimmed
         {"role": "assistant", "content": "That's a chart showing data trends"},
-        {"role": "user", "content": "Can you explain more?"}  # Recent message, should not be trimmed
+        {"role": "user", "content": "Can you explain more?"},  # Recent message, should not be trimmed
+        {"role": "user", "content": "Another recent message"},  # Recent message, should not be trimmed
+        {"role": "user", "content": "Yet another recent message"}  # Recent message, should not be trimmed
     ]
     
     # Apply the trimming function
-    trimmed_messages = trim_old_messages(message_list, keep_recent=2)
+    trimmed_messages = trim_old_messages(message_list)
     
     # Verify that the first message has been trimmed properly
     assert trimmed_messages[0]["role"] == "user"
@@ -390,6 +412,8 @@ def test_trim_mixed_content_messages() -> None:
     # Verify that the recent messages are untouched
     assert trimmed_messages[1] == message_list[1]
     assert trimmed_messages[2] == message_list[2]
+    assert trimmed_messages[3] == message_list[3]
+    assert trimmed_messages[4] == message_list[4]
 
 
 def test_get_display_history_calls_update_last_interaction() -> None: