Skip to content

:hedgehog: PostHog is the leading platform for building self-driving products. Our developer tools – AI observability, analytics, session replay, flags, experiments, error tracking, logs, and more – capture all the context agents need to diagnose problems, uncover opportunities, and ship fixes. Steer it all from Slack, web, desktop, or the MCP.

8.1 KB
Raw Blame
from django.test import SimpleTestCase

from langchain_core.messages import AIMessage, HumanMessage
from parameterized import parameterized

from posthog.schema import (
    AssistantForm,
    AssistantFormOption,
    AssistantMessage,
    AssistantMessageMetadata,
    AssistantToolCall,
    AssistantToolCallMessage,
    HumanMessage as SchemaHumanMessage,
)

from ee.hogai.utils.anthropic import (
    add_cache_control,
    convert_assistant_message_to_anthropic_message,
    convert_to_anthropic_messages,
    get_anthropic_thinking_from_assistant_message,
)


class TestAnthropicUtils(SimpleTestCase):
    @parameterized.expand(
        [
            (None, []),
            (AssistantMessageMetadata(thinking=None), []),
            (AssistantMessageMetadata(thinking=[]), []),
            (
                AssistantMessageMetadata(thinking=[{"type": "thinking", "content": "test"}]),
                [{"type": "thinking", "content": "test"}],
            ),
            (
                AssistantMessageMetadata(
                    thinking=[
                        {"type": "thinking", "content": "first"},
                        {"type": "redacted_thinking", "content": "second"},
                    ]
                ),
                [{"type": "thinking", "content": "first"}, {"type": "redacted_thinking", "content": "second"}],
            ),
        ]
    )
    def test_get_thinking_from_assistant_message(self, meta, expected):
        """Test extracting thinking from AssistantMessage"""
        message = AssistantMessage(content="test", meta=meta)

        result = get_anthropic_thinking_from_assistant_message(message)

        self.assertEqual(result, expected)

        # Verify it returns a copy, not the original
        if expected:
            self.assertIsNot(result, meta.thinking)

    def test_add_cache_control_string_content(self):
        """Test adding cache control to message with string content"""
        message = HumanMessage(content="Test message")

        result = add_cache_control(message)

        self.assertIs(result, message)  # Should modify in place
        assert isinstance(message.content, list)
        self.assertEqual(len(message.content), 1)
        assert isinstance(message.content[0], dict)
        self.assertEqual(message.content[0]["type"], "text")
        self.assertEqual(message.content[0]["text"], "Test message")
        self.assertEqual(message.content[0]["cache_control"], {"type": "ephemeral", "ttl": "5m"})

    def test_add_cache_control_list_content_with_string_last(self):
        """Test adding cache control to message with list content ending in string"""
        message = HumanMessage(
            content=[
                {"type": "text", "text": "First part"},
                "Second part as string",
            ]
        )

        result = add_cache_control(message)

        self.assertIs(result, message)
        assert isinstance(message.content, list)
        self.assertEqual(len(message.content), 2)
        # First part unchanged
        assert isinstance(message.content[0], dict)
        self.assertEqual(message.content[0]["type"], "text")
        self.assertEqual(message.content[0]["text"], "First part")
        self.assertNotIn("cache_control", message.content[0])

        # Last part converted and cache control added
        assert isinstance(message.content[1], dict)
        self.assertEqual(message.content[1]["type"], "text")
        self.assertEqual(message.content[1]["text"], "Second part as string")
        self.assertEqual(message.content[1]["cache_control"], {"type": "ephemeral", "ttl": "5m"})

    def test_add_cache_control_list_content_with_dict_last(self):
        """Test adding cache control to message with list content ending in dict"""
        message = HumanMessage(
            content=[
                {"type": "text", "text": "First part"},
                {"type": "image", "url": "http://example.com/image.jpg"},
            ]
        )

        result = add_cache_control(message)

        self.assertIs(result, message)
        assert isinstance(message.content, list)
        self.assertEqual(len(message.content), 2)
        # First part unchanged
        assert isinstance(message.content[0], dict)
        self.assertNotIn("cache_control", message.content[0])

        # Last part gets cache control added
        assert isinstance(message.content[1], dict)
        self.assertEqual(message.content[1]["type"], "image")
        self.assertEqual(message.content[1]["url"], "http://example.com/image.jpg")
        self.assertEqual(message.content[1]["cache_control"], {"type": "ephemeral", "ttl": "5m"})

    @parameterized.expand(
        [
            ("no_source", None, "Original content", None),
            ("slash_command_usage", "slash_command:usage", "Current conversation: 5 credits", "usage"),
            ("slash_command_remember", "slash_command:remember", "Saved memory", "remember"),
            ("unknown_source", "unknown_source", "Original content", None),
        ]
    )
    def test_convert_assistant_message_provenance_note(self, _name, source, content_text, expected_command):
        meta = AssistantMessageMetadata(source=source) if source else None
        message = AssistantMessage(content=content_text, id="1", meta=meta)
        result = convert_assistant_message_to_anthropic_message(message, {})

        # Assistant text is never modified — only a follow-up HumanMessage is appended when there's a slash-command source.
        ai_message = result[0]
        ai_content = ai_message.content
        assert isinstance(ai_content, list)
        assert isinstance(ai_content[0], dict)
        self.assertEqual(ai_content[0], {"type": "text", "text": content_text})

        if expected_command is not None:
            self.assertEqual(len(result), 2)
            provenance_message = result[1]
            self.assertIsInstance(provenance_message, HumanMessage)
            provenance_content = provenance_message.content
            assert isinstance(provenance_content, list)
            assert isinstance(provenance_content[0], dict)
            provenance_text = provenance_content[0]["text"]
            self.assertIn(f"/{expected_command} slash command", provenance_text)
            self.assertIn("deterministic PostHog code", provenance_text)
        else:
            self.assertEqual(len(result), 1)

    @parameterized.expand(
        [
            # Legacy summarize_sessions appended its "Open report" message after the tool result,
            # leaving the conversation on an assistant turn.
            ["legacy_form_message_last", True, 1],
            ["human_message_last", False, 3],
        ]
    )
    def test_conversation_never_ends_on_an_assistant_turn(self, _name, ends_with_assistant, expected_length):
        conversation: list = [
            SchemaHumanMessage(content="Summarize my sessions"),
            AssistantMessage(
                content="Report complete: Sessions summary",
                id="report",
                meta=AssistantMessageMetadata(
                    form=AssistantForm(
                        options=[AssistantFormOption(value="Open report", href="/session-summaries/abc")]
                    )
                ),
            ),
        ]
        if not ends_with_assistant:
            conversation.append(SchemaHumanMessage(content="Thanks"))

        result = convert_to_anthropic_messages(conversation, {})

        self.assertEqual(len(result), expected_length)
        self.assertNotIsInstance(result[-1], AIMessage)

    def test_assistant_message_with_tool_calls_is_not_dropped(self):
        conversation: list = [
            SchemaHumanMessage(content="Run it"),
            AssistantMessage(
                content="Running",
                id="call",
                tool_calls=[AssistantToolCall(id="t1", name="read_data", args={})],
            ),
        ]
        tool_results = {"t1": AssistantToolCallMessage(content="done", tool_call_id="t1", id="result")}

        result = convert_to_anthropic_messages(conversation, tool_results)

        # The assistant turn stays because dropping it would orphan its tool result, which follows it.
        self.assertIsInstance(result[1], AIMessage)
        self.assertEqual(len(result), 3)