fix(anthropic): convert OpenAI tool messages to Anthropic content blocks

memorizz's core loop records tool calls/results in OpenAI's shape — an assistant
message with `tool_calls` and a follow-up `{"role": "tool", ...}` result. The
Anthropic provider passed these straight to the Messages API, which has no
`tool` role, so the second call (carrying tool output back to Claude) 400'd:
`Unexpected role "tool"`. Tool use was effectively broken on Anthropic.

New `_convert_messages` (run in both generate and generate_stream after
_split_system) rewrites them into Anthropic's format:
- assistant `tool_calls` -> `tool_use` content blocks (arguments JSON-parsed to
  the `input` dict; optional leading text block kept)
- `{"role": "tool", tool_call_id, content}` -> a `tool_result` block, with
  consecutive results (parallel tool calls) merged into one user message
- plain text messages pass through unchanged

Covered by tests/unit/test_anthropic_tool_messages.py (7 cases incl. round-trip,
parallel-call merge, malformed-args fallback). Full unit gate: 301 passed.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: RichmondAlake

src/memorizz/llms/anthropic.py

@@ -192,6 +192,7 @@ def generate(
         (``response.choices[0].message.tool_calls``).
         """
         system_text, api_messages = self._split_system(messages)
+        api_messages = self._convert_messages(api_messages)
 
         kwargs: Dict[str, Any] = {
             "model": self.model,
@@ -234,6 +235,7 @@ def generate_stream(
         - ``{"type": "done", "content": "<accumulated text>"}``
         """
         system_text, api_messages = self._split_system(messages)
+        api_messages = self._convert_messages(api_messages)
 
         kwargs: Dict[str, Any] = {
             "model": self.model,
@@ -387,6 +389,81 @@ def _split_system(messages: List[Dict[str, str]]):
                 remaining.append(msg)
         return ("\n\n".join(system_parts) if system_parts else None, remaining)
 
+    @staticmethod
+    def _convert_messages(messages: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+        """Convert OpenAI-style tool messages to Anthropic's content-block format.
+
+        memorizz's core loop records tool calls/results in OpenAI's shape::
+
+            {"role": "assistant", "content": ..., "tool_calls": [
+                {"id": ..., "function": {"name": ..., "arguments": "<json>"}}]}
+            {"role": "tool", "tool_call_id": ..., "content": "..."}
+
+        Anthropic has no ``tool`` role: a tool call is a ``tool_use`` block in the
+        assistant message, and its result is a ``tool_result`` block inside the
+        *following user* message. Without this, the follow-up request that carries
+        tool results back 400s with ``Unexpected role "tool"``.
+
+        Consecutive tool results (parallel tool calls) are merged into one user
+        message, as Anthropic requires. Plain text messages pass through.
+        """
+        converted: List[Dict[str, Any]] = []
+        pending_results: List[Dict[str, Any]] = []
+
+        def flush_results():
+            if pending_results:
+                converted.append({"role": "user", "content": list(pending_results)})
+                pending_results.clear()
+
+        for msg in messages:
+            role = msg.get("role")
+
+            if role == "tool":
+                content = msg.get("content")
+                pending_results.append(
+                    {
+                        "type": "tool_result",
+                        "tool_use_id": msg.get("tool_call_id", ""),
+                        "content": "" if content is None else str(content),
+                    }
+                )
+                continue
+
+            # A non-tool message closes any open run of tool results.
+            flush_results()
+
+            if role == "assistant" and msg.get("tool_calls"):
+                blocks: List[Dict[str, Any]] = []
+                text = msg.get("content")
+                if text:
+                    blocks.append({"type": "text", "text": text})
+                for tc in msg["tool_calls"]:
+                    fn = tc.get("function", {}) or {}
+                    raw_args = fn.get("arguments", "")
+                    if isinstance(raw_args, dict):
+                        parsed = raw_args
+                    else:
+                        try:
+                            parsed = json.loads(raw_args) if raw_args else {}
+                        except (json.JSONDecodeError, TypeError):
+                            parsed = {}
+                    if not isinstance(parsed, dict):
+                        parsed = {}
+                    blocks.append(
+                        {
+                            "type": "tool_use",
+                            "id": tc.get("id", ""),
+                            "name": fn.get("name", ""),
+                            "input": parsed,
+                        }
+                    )
+                converted.append({"role": "assistant", "content": blocks})
+            else:
+                converted.append(msg)
+
+        flush_results()
+        return converted
+
     @staticmethod
     def _convert_tools(
         tools: List[Dict[str, Any]],

tests/unit/test_anthropic_tool_messages.py

@@ -0,0 +1,128 @@
+# Copyright (c) 2024 Richmond Alake. All rights reserved.
+# Licensed under the PolyForm Noncommercial License 1.0.0.
+# See LICENSE file in the project root for full license information.
+
+"""Anthropic provider: OpenAI-style tool messages -> Anthropic content blocks.
+
+Regression tests for the bug where a follow-up request carrying tool results
+back to Claude 400'd with ``Unexpected role "tool"`` — memorizz records tool
+calls/results in OpenAI's shape, which Anthropic doesn't accept. The provider
+now converts them via the (SDK-free) staticmethod ``_convert_messages``.
+"""
+
+import pytest
+
+# The anthropic SDK is imported lazily in __init__, so the module + this
+# staticmethod import/run without the SDK installed.
+from memorizz.llms.anthropic import Anthropic  # noqa: E402
+
+convert = Anthropic._convert_messages
+
+
+@pytest.mark.unit
+def test_tool_round_trip_converts_roles_and_blocks():
+    msgs = [
+        {"role": "user", "content": "search for X"},
+        {
+            "role": "assistant",
+            "content": None,
+            "tool_calls": [
+                {
+                    "id": "call_1",
+                    "type": "function",
+                    "function": {"name": "search", "arguments": '{"q": "X"}'},
+                }
+            ],
+        },
+        {"role": "tool", "tool_call_id": "call_1", "name": "search", "content": "hits"},
+    ]
+    out = convert(msgs)
+
+    assert out[0] == {"role": "user", "content": "search for X"}
+    assert out[1]["role"] == "assistant"
+    assert out[1]["content"] == [
+        {"type": "tool_use", "id": "call_1", "name": "search", "input": {"q": "X"}}
+    ]
+    assert out[2]["role"] == "user"
+    assert out[2]["content"] == [
+        {"type": "tool_result", "tool_use_id": "call_1", "content": "hits"}
+    ]
+    # The whole point: no "tool" role survives.
+    assert all(m["role"] != "tool" for m in out)
+
+
+@pytest.mark.unit
+def test_assistant_text_and_tool_calls_emit_text_then_tool_use():
+    msgs = [
+        {
+            "role": "assistant",
+            "content": "let me check",
+            "tool_calls": [{"id": "c1", "function": {"name": "f", "arguments": "{}"}}],
+        }
+    ]
+    blocks = convert(msgs)[0]["content"]
+    assert blocks[0] == {"type": "text", "text": "let me check"}
+    assert blocks[1] == {"type": "tool_use", "id": "c1", "name": "f", "input": {}}
+
+
+@pytest.mark.unit
+def test_parallel_tool_results_merge_into_one_user_message():
+    msgs = [
+        {
+            "role": "assistant",
+            "content": None,
+            "tool_calls": [
+                {"id": "a", "function": {"name": "f", "arguments": "{}"}},
+                {"id": "b", "function": {"name": "g", "arguments": "{}"}},
+            ],
+        },
+        {"role": "tool", "tool_call_id": "a", "content": "ra"},
+        {"role": "tool", "tool_call_id": "b", "content": "rb"},
+    ]
+    out = convert(msgs)
+    assert len(out) == 2
+    assert out[0]["role"] == "assistant" and len(out[0]["content"]) == 2
+    assert out[1]["role"] == "user"
+    assert [b["tool_use_id"] for b in out[1]["content"]] == ["a", "b"]
+    assert [b["content"] for b in out[1]["content"]] == ["ra", "rb"]
+
+
+@pytest.mark.unit
+def test_malformed_arguments_fall_back_to_empty_input():
+    msgs = [
+        {
+            "role": "assistant",
+            "tool_calls": [
+                {"id": "c1", "function": {"name": "f", "arguments": "not-json"}}
+            ],
+        }
+    ]
+    assert convert(msgs)[0]["content"][0]["input"] == {}
+
+
+@pytest.mark.unit
+def test_dict_arguments_passed_through():
+    msgs = [
+        {
+            "role": "assistant",
+            "tool_calls": [
+                {"id": "c1", "function": {"name": "f", "arguments": {"q": "y"}}}
+            ],
+        }
+    ]
+    assert convert(msgs)[0]["content"][0]["input"] == {"q": "y"}
+
+
+@pytest.mark.unit
+def test_plain_messages_pass_through_unchanged():
+    msgs = [
+        {"role": "user", "content": "hi"},
+        {"role": "assistant", "content": "hello"},
+    ]
+    assert convert(msgs) == msgs
+
+
+@pytest.mark.unit
+def test_none_tool_content_becomes_empty_string():
+    out = convert([{"role": "tool", "tool_call_id": "c1", "content": None}])
+    assert out[0]["content"][0]["content"] == ""