claude-bug-fix-ag-2961 (#2720)

## Summary

Add a default message to the content if the tool calls do not include a
message to prevent the following error:

![image](https://github.com/user-attachments/assets/336b15bb-2307-4317-988f-54409d2b4228)


## Type of change

- [x] Bug fix (#2712)
- [ ] New feature
- [ ] Breaking change
- [ ] Improvement
- [ ] Model update
- [ ] Other: _____________________

---

## Checklist

- [ ] Code complies with style guidelines
- [ ] Ran format/validation scripts (`./scripts/format.sh` and
`./scripts/validate.sh`)
- [ ] Self-review completed
- [ ] Documentation updated (comments, docstrings)
- [ ] Examples and guides: Relevant cookbook examples have been included
or updated (if applicable)
- [ ] Tested in clean environment
- [ ] Tests added/updated (if applicable)

---

## Additional Notes

Add any important context (deployment instructions, screenshots,
security considerations, etc.)

Author: ysolanky

cookbook/models/anthropic/ThaiRecipes.pdf

@@ -2,14 +2,14 @@
 from collections.abc import AsyncIterator
 from dataclasses import dataclass
 from os import getenv
-from typing import Any, Dict, List, Optional, Tuple, Union
+from typing import Any, Dict, List, Optional, Union
 
 from agno.exceptions import ModelProviderError, ModelRateLimitError
-from agno.media import File, Image
 from agno.models.base import Model
 from agno.models.message import Citations, DocumentCitation, Message
 from agno.models.response import ModelResponse
 from agno.utils.log import log_error, log_warning
+from agno.utils.models.claude import format_messages
 
 try:
     from anthropic import Anthropic as AnthropicClient
@@ -21,245 +21,11 @@
         ContentBlockStopEvent,
         MessageDeltaEvent,
         MessageStopEvent,
-        TextBlock,
-        ToolUseBlock,
     )
     from anthropic.types import Message as AnthropicMessage
 except (ModuleNotFoundError, ImportError):
     raise ImportError("`anthropic` not installed. Please install using `pip install anthropic`")
 
-ROLE_MAP = {
-    "system": "system",
-    "user": "user",
-    "assistant": "assistant",
-    "tool": "user",
-}
-
-
-def _format_image_for_message(image: Image) -> Optional[Dict[str, Any]]:
-    """
-    Add an image to a message by converting it to base64 encoded format.
-    """
-    using_filetype = False
-
-    import base64
-
-    # 'imghdr' was deprecated in Python 3.11: https://docs.python.org/3/library/imghdr.html
-    # 'filetype' used as a fallback
-    try:
-        import imghdr
-    except (ModuleNotFoundError, ImportError):
-        try:
-            import filetype
-
-            using_filetype = True
-        except (ModuleNotFoundError, ImportError):
-            raise ImportError("`filetype` not installed. Please install using `pip install filetype`")
-
-    type_mapping = {
-        "jpeg": "image/jpeg",
-        "jpg": "image/jpeg",
-        "png": "image/png",
-        "gif": "image/gif",
-        "webp": "image/webp",
-    }
-
-    try:
-        # Case 1: Image is a URL
-        if image.url is not None:
-            return {"type": "image", "source": {"type": "url", "url": image.url}}
-
-        # Case 2: Image is a local file path
-        elif image.filepath is not None:
-            from pathlib import Path
-
-            path = Path(image.filepath) if isinstance(image.filepath, str) else image.filepath
-            if path.exists() and path.is_file():
-                with open(image.filepath, "rb") as f:
-                    content_bytes = f.read()
-            else:
-                log_error(f"Image file not found: {image}")
-                return None
-
-        # Case 3: Image is a bytes object
-        elif image.content is not None:
-            content_bytes = image.content
-
-        else:
-            log_error(f"Unsupported image type: {type(image)}")
-            return None
-
-        if using_filetype:
-            kind = filetype.guess(content_bytes)
-            if not kind:
-                log_error("Unable to determine image type")
-                return None
-
-            img_type = kind.extension
-        else:
-            img_type = imghdr.what(None, h=content_bytes)  # type: ignore
-
-        if not img_type:
-            log_error("Unable to determine image type")
-            return None
-
-        media_type = type_mapping.get(img_type)
-        if not media_type:
-            log_error(f"Unsupported image type: {img_type}")
-            return None
-
-        return {
-            "type": "image",
-            "source": {
-                "type": "base64",
-                "media_type": media_type,
-                "data": base64.b64encode(content_bytes).decode("utf-8"),  # type: ignore
-            },
-        }
-
-    except Exception as e:
-        log_error(f"Error processing image: {e}")
-        return None
-
-
-def _format_file_for_message(file: File) -> Optional[Dict[str, Any]]:
-    """
-    Add a document url or base64 encoded content to a message.
-    """
-
-    mime_mapping = {
-        "application/pdf": "base64",
-        "text/plain": "text",
-    }
-
-    # Case 1: Document is a URL
-    if file.url is not None:
-        return {
-            "type": "document",
-            "source": {
-                "type": "url",
-                "url": file.url,
-            },
-            "citations": {"enabled": True},
-        }
-    # Case 2: Document is a local file path
-    elif file.filepath is not None:
-        import base64
-        from pathlib import Path
-
-        path = Path(file.filepath) if isinstance(file.filepath, str) else file.filepath
-        if path.exists() and path.is_file():
-            file_data = base64.standard_b64encode(path.read_bytes()).decode("utf-8")
-
-            # Determine media type
-            media_type = file.mime_type
-            if media_type is None:
-                import mimetypes
-
-                media_type = mimetypes.guess_type(file.filepath)[0] or "application/pdf"
-
-            # Map media type to type, default to "base64" if no mapping exists
-            type = mime_mapping.get(media_type, "base64")
-
-            return {
-                "type": "document",
-                "source": {
-                    "type": type,
-                    "media_type": media_type,
-                    "data": file_data,
-                },
-                "citations": {"enabled": True},
-            }
-        else:
-            log_error(f"Document file not found: {file}")
-            return None
-    # Case 3: Document is bytes content
-    elif file.content is not None:
-        import base64
-
-        file_data = base64.standard_b64encode(file.content).decode("utf-8")
-        return {
-            "type": "document",
-            "source": {"type": "base64", "media_type": file.mime_type or "application/pdf", "data": file_data},
-            "citations": {"enabled": True},
-        }
-    return None
-
-
-def _format_messages(messages: List[Message]) -> Tuple[List[Dict[str, str]], str]:
-    """
-    Process the list of messages and separate them into API messages and system messages.
-
-    Args:
-        messages (List[Message]): The list of messages to process.
-
-    Returns:
-        Tuple[List[Dict[str, str]], str]: A tuple containing the list of API messages and the concatenated system messages.
-    """
-    chat_messages: List[Dict[str, str]] = []
-    system_messages: List[str] = []
-
-    for message in messages:
-        content = message.content or ""
-        if message.role == "system":
-            if content is not None:
-                system_messages.append(content)  # type: ignore
-            continue
-        elif message.role == "user":
-            if isinstance(content, str):
-                content = [{"type": "text", "text": content}]
-
-            if message.images is not None:
-                for image in message.images:
-                    image_content = _format_image_for_message(image)
-                    if image_content:
-                        content.append(image_content)
-
-            if message.files is not None:
-                for file in message.files:
-                    file_content = _format_file_for_message(file)
-                    if file_content:
-                        content.append(file_content)
-
-        # Handle tool calls from history
-        elif message.role == "assistant":
-            content = []
-
-            if message.thinking is not None and message.provider_data is not None:
-                from anthropic.types import RedactedThinkingBlock, ThinkingBlock
-
-                content.append(
-                    ThinkingBlock(
-                        thinking=message.thinking,
-                        signature=message.provider_data.get("signature"),
-                        type="thinking",
-                    )
-                )
-
-            if message.redacted_thinking is not None:
-                from anthropic.types import RedactedThinkingBlock
-
-                content.append(RedactedThinkingBlock(data=message.redacted_thinking, type="redacted_thinking"))
-
-            if isinstance(message.content, str) and message.content:
-                content.append(TextBlock(text=message.content, type="text"))
-
-            if message.tool_calls:
-                for tool_call in message.tool_calls:
-                    content.append(
-                        ToolUseBlock(
-                            id=tool_call["id"],
-                            input=json.loads(tool_call["function"]["arguments"])
-                            if "arguments" in tool_call["function"]
-                            else {},
-                            name=tool_call["function"]["name"],
-                            type="tool_use",
-                        )
-                    )
-
-        chat_messages.append({"role": ROLE_MAP[message.role], "content": content})  # type: ignore
-    return chat_messages, " ".join(system_messages)
-
 
 @dataclass
 class Claude(Model):
@@ -426,7 +192,7 @@ def invoke(self, messages: List[Message]) -> AnthropicMessage:
             APIStatusError: For other API-related errors
         """
         try:
-            chat_messages, system_message = _format_messages(messages)
+            chat_messages, system_message = format_messages(messages)
             request_kwargs = self._prepare_request_kwargs(system_message)
 
             return self.get_client().messages.create(
@@ -459,7 +225,7 @@ def invoke_stream(self, messages: List[Message]) -> Any:
         Returns:
             Any: The streamed response from the model.
         """
-        chat_messages, system_message = _format_messages(messages)
+        chat_messages, system_message = format_messages(messages)
         request_kwargs = self._prepare_request_kwargs(system_message)
 
         try:
@@ -503,7 +269,7 @@ async def ainvoke(self, messages: List[Message]) -> AnthropicMessage:
             APIStatusError: For other API-related errors
         """
         try:
-            chat_messages, system_message = _format_messages(messages)
+            chat_messages, system_message = format_messages(messages)
             request_kwargs = self._prepare_request_kwargs(system_message)
 
             return await self.get_async_client().messages.create(
@@ -537,7 +303,7 @@ async def ainvoke_stream(self, messages: List[Message]) -> AsyncIterator[Any]:
             Any: The streamed response from the model.
         """
         try:
-            chat_messages, system_message = _format_messages(messages)
+            chat_messages, system_message = format_messages(messages)
             request_kwargs = self._prepare_request_kwargs(system_message)
             async with self.get_async_client().messages.stream(
                 model=self.id,
@@ -561,7 +327,6 @@ async def ainvoke_stream(self, messages: List[Message]) -> AsyncIterator[Any]:
             log_error(f"Unexpected error calling Claude API: {str(e)}")
             raise ModelProviderError(message=str(e), model_name=self.name, model_id=self.id) from e
 
-    # Overwrite the default from the base model
     def format_function_call_results(
         self, messages: List[Message], function_call_results: List[Message], tool_ids: List[str]
     ) -> None:
@@ -585,7 +350,6 @@ def format_function_call_results(
                 )
             messages.append(Message(role="user", content=fc_responses))
 
-    # Overwrite the default from the base model
     def get_system_message_for_model(self) -> Optional[str]:
         if self._functions is not None and len(self._functions) > 0:
             tool_call_prompt = "Do not reflect on the quality of the returned search results in your response"