mito-ai 0.1.44__py3-none-any.whl → 0.1.46__py3-none-any.whl

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/deploy_app/test_app_deploy_utils.py

@@ -0,0 +1,71 @@
+# Copyright (c) Saga Inc.
+# Distributed under the terms of the GNU Affero General Public License v3.0 License.
+
+import zipfile
+import logging
+from mito_ai.app_deploy.app_deploy_utils import add_files_to_zip
+
+class TestAddFilesToZip:
+    """Test cases for add_files_to_zip helper function"""
+
+    def test_files_added_correctly(self, tmp_path):
+        """Ensure individual files are added correctly to the zip"""
+        # Create files
+        f1 = tmp_path / "file1.txt"
+        f1.write_text("file1 content")
+        f2 = tmp_path / "file2.txt"
+        f2.write_text("file2 content")
+
+        zip_path = tmp_path / "test.zip"
+        add_files_to_zip(str(zip_path), str(tmp_path), ["file1.txt", "file2.txt"])
+
+        with zipfile.ZipFile(zip_path, "r") as zf:
+            names = zf.namelist()
+            assert "file1.txt" in names
+            assert "file2.txt" in names
+            assert len(names) == 2
+
+    def test_directories_added_recursively(self, tmp_path):
+        """Ensure directories are added recursively with correct relative paths"""
+        nested = tmp_path / "folder"
+        nested.mkdir()
+        (nested / "nested1.txt").write_text("nested1 content")
+        subfolder = nested / "sub"
+        subfolder.mkdir()
+        (subfolder / "nested2.txt").write_text("nested2 content")
+
+        zip_path = tmp_path / "test.zip"
+        add_files_to_zip(str(zip_path), str(tmp_path), ["folder"])
+
+        with zipfile.ZipFile(zip_path, "r") as zf:
+            names = zf.namelist()
+            assert "folder/nested1.txt" in names
+            assert "folder/sub/nested2.txt" in names
+
+    def test_missing_files_skipped(self, tmp_path, caplog):
+        """Ensure missing files do not break the function and warning is logged"""
+        caplog.set_level(logging.WARNING)
+        zip_path = tmp_path / "test.zip"
+        add_files_to_zip(str(zip_path), str(tmp_path), ["does_not_exist.txt"], logger=logging.getLogger())
+
+        # Zip should exist but be empty
+        with zipfile.ZipFile(zip_path, "r") as zf:
+            assert zf.namelist() == []
+
+        # Check warning was logged
+        assert any("Skipping missing file" in record.message for record in caplog.records)
+
+    def test_arcname_paths_correct(self, tmp_path):
+        """Ensure arcname paths inside zip preserve relative paths to base_path"""
+        (tmp_path / "file.txt").write_text("content")
+        folder = tmp_path / "folder"
+        folder.mkdir()
+        (folder / "nested.txt").write_text("nested content")
+
+        zip_path = tmp_path / "test.zip"
+        add_files_to_zip(str(zip_path), str(tmp_path), ["file.txt", "folder"])
+
+        with zipfile.ZipFile(zip_path, "r") as zf:
+            names = zf.namelist()
+            assert "file.txt" in names
+            assert "folder/nested.txt" in names

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:

mito_ai/tests/providers/test_anthropic_client.py

@@ -2,14 +2,14 @@
 # Distributed under the terms of the GNU Affero General Public License v3.0 License.
 
 import pytest
-from mito_ai.anthropic_client import get_anthropic_system_prompt_and_messages, extract_and_parse_anthropic_json_response, AnthropicClient
-from mito_ai.utils.anthropic_utils import get_anthropic_completion_function_params, FAST_ANTHROPIC_MODEL
+from mito_ai.anthropic_client import get_anthropic_system_prompt_and_messages, get_anthropic_system_prompt_and_messages_with_caching, add_cache_control_to_message, extract_and_parse_anthropic_json_response, AnthropicClient
+from mito_ai.utils.anthropic_utils import FAST_ANTHROPIC_MODEL
 from anthropic.types import Message, TextBlock, ToolUseBlock, Usage, ToolUseBlock, Message, Usage, TextBlock
 from openai.types.chat import ChatCompletionMessageParam, ChatCompletionUserMessageParam, ChatCompletionAssistantMessageParam, ChatCompletionSystemMessageParam
-from mito_ai.completions.models import MessageType, ResponseFormatInfo, AgentResponse
-from unittest.mock import MagicMock, patch
+from mito_ai.completions.models import MessageType
+from unittest.mock import patch
 import anthropic
-from typing import List, Dict, Any, cast, Union
+from typing import List, Dict, cast
 
 
 # Dummy base64 image (1x1 PNG)
@@ -53,7 +53,7 @@ def test_no_system_instructions_only_content():
     ]
     system_prompt, anthropic_messages = get_anthropic_system_prompt_and_messages(messages)
     
-    assert isinstance(system_prompt, anthropic.NotGiven)
+    assert isinstance(system_prompt, anthropic.Omit)
     assert len(anthropic_messages) == 2
     assert anthropic_messages[0]["role"] == "user"
     assert anthropic_messages[0]["content"] == "Hello!"
@@ -93,7 +93,7 @@ def test_empty_message_content():
     ]
     system_prompt, anthropic_messages = get_anthropic_system_prompt_and_messages(messages)
     
-    assert isinstance(system_prompt, anthropic.NotGiven)
+    assert isinstance(system_prompt, anthropic.Omit)
     assert len(anthropic_messages) == 1  # Should skip the message with missing content
     assert anthropic_messages[0]["role"] == "assistant"
     assert anthropic_messages[0]["content"] == "Hi!"
@@ -272,4 +272,176 @@ async def test_model_selection_based_on_message_type(message_type, expected_mode
         # Verify that create was called with the expected model
         mock_create.assert_called_once()
         call_args = mock_create.call_args
-        assert call_args[1]['model'] == expected_model 
+        assert call_args[1]['model'] == expected_model
+
+
+# Caching Tests
+
+@pytest.mark.parametrize("message,expected_role,expected_content_type,expected_content_length,expected_cache_control", [
+    # String content message
+    (
+        {"role": "user", "content": "Hello world"},
+        "user",
+        list,
+        1,
+        True
+    ),
+    # List content message
+    (
+        {
+            "role": "user", 
+            "content": [
+                {"type": "text", "text": "First part"},
+                {"type": "text", "text": "Second part"}
+            ]
+        },
+        "user",
+        list,
+        2,
+        True
+    ),
+    # Empty content message
+    (
+        {"role": "user", "content": []},
+        "user",
+        list,
+        0,
+        False
+    ),
+    # Assistant message with string content
+    (
+        {"role": "assistant", "content": "I can help you with that."},
+        "assistant",
+        list,
+        1,
+        True
+    ),
+])
+def test_add_cache_control_to_message(message, expected_role, expected_content_type, expected_content_length, expected_cache_control):
+    """Test adding cache control to different types of messages."""
+    result = add_cache_control_to_message(message)
+    
+    assert result["role"] == expected_role
+    assert isinstance(result["content"], expected_content_type)
+    assert len(result["content"]) == expected_content_length
+    
+    if expected_cache_control and expected_content_length > 0:
+        # Should have cache_control on the last content block
+        last_block = result["content"][-1]
+        assert last_block["cache_control"] == {"type": "ephemeral"}
+        
+        # If there are multiple blocks, earlier blocks should not have cache_control
+        if expected_content_length > 1:
+            for i in range(expected_content_length - 1):
+                assert "cache_control" not in result["content"][i]
+    elif expected_content_length == 0:
+        # Empty content should return unchanged
+        assert result == message
+
+
+@pytest.mark.parametrize("messages,expected_system_type,expected_system_content", [
+    # With system prompt
+    (
+        [
+            ChatCompletionSystemMessageParam(role="system", content="You are a helpful assistant."),
+            ChatCompletionUserMessageParam(role="user", content="Hello!")
+        ],
+        list,
+        "You are a helpful assistant.",
+    ),
+    # Without system prompt
+    (
+        [
+            ChatCompletionUserMessageParam(role="user", content="Hello!"),
+            ChatCompletionAssistantMessageParam(role="assistant", content="Hi there!")
+        ],
+        anthropic.Omit,
+        None,
+    ),
+    # Multiple system messages (should take last one)
+    (
+        [
+            ChatCompletionSystemMessageParam(role="system", content="First system message."),
+            ChatCompletionSystemMessageParam(role="system", content="Second system message."),
+            ChatCompletionUserMessageParam(role="user", content="Hello!"),
+            ChatCompletionUserMessageParam(role="user", content="Hello!"),
+            ChatCompletionUserMessageParam(role="user", content="Hello!")
+        ],
+        list,
+        "Second system message.",
+    ),
+])
+def test_caching_system_prompt_scenarios(messages, expected_system_type, expected_system_content):
+    """Test caching with different system prompt scenarios."""
+    system_prompt, anthropic_messages = get_anthropic_system_prompt_and_messages_with_caching(messages)
+    
+    # Check system prompt
+    assert isinstance(system_prompt, expected_system_type)
+    if expected_system_content:
+        assert system_prompt[0]["text"] == expected_system_content
+        assert system_prompt[0]["cache_control"] == {"type": "ephemeral"}
+
+
+@pytest.mark.parametrize("message_count,expected_cache_boundary", [
+    (1, None),  # 1 message, No cache boundary
+    (3, None),  # 3 messages, No cache boundary
+    (5, 1),  # 5 messages, cache at index 2
+    (10, 6),  # 10 messages, cache at index 6
+])
+def test_caching_conversation_history(message_count, expected_cache_boundary):
+    """Test that conversation history is cached at the keep_recent boundary for different message counts."""
+    
+    # Create messages based on the parameter
+    messages: List[ChatCompletionMessageParam] = [
+        ChatCompletionSystemMessageParam(role="system", content="You are helpful.")
+    ]
+    
+    # Add message pairs
+    for i in range(message_count):
+        messages.append(ChatCompletionUserMessageParam(role="user", content=f"Message {i+1}"))
+    
+    system_prompt, anthropic_messages = get_anthropic_system_prompt_and_messages_with_caching(messages)
+    
+    # System prompt should have cache control
+    assert isinstance(system_prompt, list)
+    assert system_prompt[0]["cache_control"] == {"type": "ephemeral"}
+    
+    print(anthropic_messages)
+
+    if expected_cache_boundary is None:
+        # Verify no cache boundry 
+        assert all("cache_control" not in str(message) for message in anthropic_messages)
+    else:
+        # Other messages should not have cache control
+        for i, message in enumerate(anthropic_messages):
+            if i == expected_cache_boundary:
+                assert anthropic_messages[expected_cache_boundary]["content"][0]["cache_control"] == {"type": "ephemeral"}
+            else:
+                assert "cache_control" not in str(message)
+
+def test_caching_with_mixed_content():
+    """Test caching with mixed text and image content."""
+    messages: List[ChatCompletionMessageParam] = [
+        ChatCompletionSystemMessageParam(role="system", content="You are a helpful assistant."),
+        ChatCompletionUserMessageParam(role="user", content=[
+            {"type": "text", "text": "Here is an image:"},
+            {"type": "image_url", "image_url": {"url": DUMMY_IMAGE_DATA_URL}}
+        ])
+    ]
+    system_prompt, anthropic_messages = get_anthropic_system_prompt_and_messages_with_caching(messages)
+    
+    # System prompt should have cache control
+    assert isinstance(system_prompt, list)
+    assert system_prompt[0]["cache_control"] == {"type": "ephemeral"}
+    
+    # User message should NOT have cache control (only 1 message, so boundary is invalid)
+    user_message = anthropic_messages[0]
+    assert user_message["role"] == "user"
+    assert isinstance(user_message["content"], list)
+    assert len(user_message["content"]) == 2
+    
+    # No content blocks should have cache control (too few messages to cache)
+    assert user_message["content"][0]["type"] == "text"
+    assert "cache_control" not in user_message["content"][0]
+    assert user_message["content"][1]["type"] == "image"
+    assert "cache_control" not in user_message["content"][1]