agno 2.2.13__py3-none-any.whl

agno/utils/message.py

@@ -0,0 +1,118 @@
+from copy import deepcopy
+from typing import Dict, List, Union
+
+from pydantic import BaseModel
+
+from agno.models.message import Message
+from agno.utils.log import log_debug
+
+
+def filter_tool_calls(messages: List[Message], max_tool_calls: int) -> None:
+    """
+    Filter messages (in-place) to keep only the most recent N tool calls.
+
+    Args:
+        messages: List of messages to filter (modified in-place)
+        max_tool_calls: Number of recent tool calls to keep
+    """
+    # Count total tool calls
+    tool_call_count = sum(1 for m in messages if m.role == "tool")
+
+    # No filtering needed
+    if tool_call_count <= max_tool_calls:
+        return
+
+    # Collect tool_call_ids to keep (most recent N)
+    tool_call_ids_list: List[str] = []
+    for msg in reversed(messages):
+        if msg.role == "tool" and len(tool_call_ids_list) < max_tool_calls:
+            if msg.tool_call_id:
+                tool_call_ids_list.append(msg.tool_call_id)
+
+    tool_call_ids_to_keep: set[str] = set(tool_call_ids_list)
+
+    # Filter messages in-place
+    filtered_messages = []
+    for msg in messages:
+        if msg.role == "tool":
+            # Keep only tool results in our window
+            if msg.tool_call_id in tool_call_ids_to_keep:
+                filtered_messages.append(msg)
+        elif msg.role == "assistant" and msg.tool_calls:
+            # Filter tool_calls within the assistant message
+            # Use deepcopy to ensure complete isolation of the filtered message
+            filtered_msg = deepcopy(msg)
+            # Filter tool_calls
+            if filtered_msg.tool_calls is not None:
+                filtered_msg.tool_calls = [
+                    tc for tc in filtered_msg.tool_calls if tc.get("id") in tool_call_ids_to_keep
+                ]
+
+            if filtered_msg.tool_calls:
+                # Has tool_calls remaining, keep it
+                filtered_messages.append(filtered_msg)
+            # skip empty messages
+            elif filtered_msg.content:
+                filtered_msg.tool_calls = None
+                filtered_messages.append(filtered_msg)
+        else:
+            filtered_messages.append(msg)
+
+    messages[:] = filtered_messages
+
+    # Log filtering information
+    num_filtered = tool_call_count - len(tool_call_ids_to_keep)
+    log_debug(f"Filtered {num_filtered} tool calls, kept {len(tool_call_ids_to_keep)}")
+
+
+def get_text_from_message(message: Union[List, Dict, str, Message, BaseModel]) -> str:
+    """Return the user texts from the message"""
+    import json
+
+    if isinstance(message, str):
+        return message
+    if isinstance(message, BaseModel):
+        return message.model_dump_json(indent=2, exclude_none=True)
+    if isinstance(message, list):
+        text_messages = []
+        if len(message) == 0:
+            return ""
+
+        # Check if it's a list of Message objects
+        if isinstance(message[0], Message):
+            for m in message:
+                if isinstance(m, Message) and m.role == "user" and m.content is not None:
+                    # Recursively extract text from the message content
+                    content_text = get_text_from_message(m.content)
+                    if content_text:
+                        text_messages.append(content_text)
+        elif "type" in message[0]:
+            for m in message:
+                m_type = m.get("type")
+                if m_type is not None and isinstance(m_type, str):
+                    m_value = m.get(m_type)
+                    if m_value is not None and isinstance(m_value, str):
+                        if m_type == "text":
+                            text_messages.append(m_value)
+                        # if m_type == "image_url":
+                        #     text_messages.append(f"Image: {m_value}")
+                        # else:
+                        #     text_messages.append(f"{m_type}: {m_value}")
+        elif "role" in message[0]:
+            for m in message:
+                m_role = m.get("role")
+                if m_role is not None and isinstance(m_role, str):
+                    m_content = m.get("content")
+                    if m_content is not None and isinstance(m_content, str):
+                        if m_role == "user":
+                            text_messages.append(m_content)
+        if len(text_messages) > 0:
+            return "\n".join(text_messages)
+    if isinstance(message, dict):
+        if "content" in message:
+            return get_text_from_message(message["content"])
+        else:
+            return json.dumps(message, indent=2)
+    if isinstance(message, Message) and message.content is not None:
+        return get_text_from_message(message.content)
+    return ""

agno/utils/models/ai_foundry.py

@@ -0,0 +1,43 @@
+from typing import Any, Dict
+
+from agno.models.message import Message
+from agno.utils.log import log_warning
+from agno.utils.openai import images_to_message
+
+
+def format_message(message: Message) -> Dict[str, Any]:
+    """
+    Format a message into the format expected by OpenAI.
+
+    Args:
+        message (Message): The message to format.
+
+    Returns:
+        Dict[str, Any]: The formatted message.
+    """
+    message_dict: Dict[str, Any] = {
+        "role": message.role,
+        "content": message.content,
+        "name": message.name,
+        "tool_call_id": message.tool_call_id,
+        "tool_calls": message.tool_calls,
+    }
+    message_dict = {k: v for k, v in message_dict.items() if v is not None}
+
+    if message.images is not None and len(message.images) > 0:
+        # Ignore non-string message content
+        # because we assume that the images/audio are already added to the message
+        if isinstance(message.content, str):
+            message_dict["content"] = [{"type": "text", "text": message.content}]
+            message_dict["content"].extend(images_to_message(images=message.images))
+
+    if message.audio is not None and len(message.audio) > 0:
+        log_warning("Audio input is currently unsupported.")
+
+    if message.files is not None and len(message.files) > 0:
+        log_warning("File input is currently unsupported.")
+
+    if message.videos is not None and len(message.videos) > 0:
+        log_warning("Video input is currently unsupported.")
+
+    return message_dict

agno/utils/models/claude.py

@@ -0,0 +1,358 @@
+import json
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Optional, Tuple
+
+from agno.media import File, Image
+from agno.models.message import Message
+from agno.utils.log import log_error, log_warning
+
+try:
+    from anthropic.types import (
+        TextBlock,
+        ToolUseBlock,
+    )
+except ImportError:
+    raise ImportError("`anthropic` not installed. Please install using `pip install anthropic`")
+
+
+@dataclass
+class MCPToolConfiguration:
+    enabled: bool = True
+    allowed_tools: List[str] = field(default_factory=list)
+
+
+@dataclass
+class MCPServerConfiguration:
+    type: str
+    url: str
+    name: str
+    tool_configuration: Optional[MCPToolConfiguration] = None
+    authorization_token: Optional[str] = None
+
+
+ROLE_MAP = {
+    "system": "system",
+    "developer": "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 ImportError:
+        try:
+            import filetype
+
+            using_filetype = True
+        except 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:
+        img_type = None
+
+        # Case 0: Image is an Anthropic uploaded file
+        if image.content is not None and hasattr(image.content, "id"):
+            content_bytes = image.content
+
+        # Case 1: Image is a URL
+        if image.url is not None:
+            content_bytes = image.get_content_bytes()  # type: ignore
+
+            # If image URL has a suffix, use it as the type (without dot)
+            import os
+            from urllib.parse import urlparse
+
+            if image.url:
+                parsed_url = urlparse(image.url)
+                _, ext = os.path.splitext(parsed_url.path)
+                if ext:
+                    img_type = ext.lstrip(".").lower()
+
+        # 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()
+
+                # If image file path has a suffix, use it as the type (without dot)
+                path_ext = path.suffix.lstrip(".")
+                if path_ext:
+                    img_type = path_ext.lower()
+            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 not img_type:
+            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 0: File is an Anthropic uploaded file
+    if file.external is not None and hasattr(file.external, "id"):
+        return {
+            "type": "document",
+            "source": {
+                "type": "file",
+                "file_id": file.external.id,
+            },
+        }
+
+    # 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 ""
+        # Both "system" and "developer" roles should be extracted as system messages
+        if message.role in ("system", "developer"):
+            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)
+
+            if message.audio is not None and len(message.audio) > 0:
+                log_warning("Audio input is currently unsupported.")
+
+            if message.videos is not None and len(message.videos) > 0:
+                log_warning("Video input is currently unsupported.")
+
+        elif message.role == "assistant":
+            content = []
+
+            if message.reasoning_content is not None and message.provider_data is not None:
+                from anthropic.types import RedactedThinkingBlock, ThinkingBlock
+
+                content.append(
+                    ThinkingBlock(
+                        thinking=message.reasoning_content,
+                        signature=message.provider_data.get("signature"),
+                        type="thinking",
+                    )
+                )
+
+            if message.redacted_reasoning_content is not None:
+                from anthropic.types import RedactedThinkingBlock
+
+                content.append(
+                    RedactedThinkingBlock(data=message.redacted_reasoning_content, type="redacted_reasoning_content")
+                )
+
+            if isinstance(message.content, str) and message.content and len(message.content.strip()) > 0:
+                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",
+                        )
+                    )
+        elif message.role == "tool":
+            content = []
+            content.append(
+                {
+                    "type": "tool_result",
+                    "tool_use_id": message.tool_call_id,
+                    "content": str(message.content),
+                }
+            )
+
+        # Skip empty assistant responses
+        if message.role == "assistant" and not content:
+            continue
+
+        chat_messages.append({"role": ROLE_MAP[message.role], "content": content})  # type: ignore
+    return chat_messages, " ".join(system_messages)
+
+
+def format_tools_for_model(tools: Optional[List[Dict[str, Any]]] = None) -> Optional[List[Dict[str, Any]]]:
+    """
+    Transforms function definitions into a format accepted by the Anthropic API.
+    """
+    if not tools:
+        return None
+
+    parsed_tools: List[Dict[str, Any]] = []
+    for tool_def in tools:
+        if tool_def.get("type", "") != "function":
+            parsed_tools.append(tool_def)
+            continue
+
+        func_def = tool_def.get("function", {})
+        parameters: Dict[str, Any] = func_def.get("parameters", {})
+        properties: Dict[str, Any] = parameters.get("properties", {})
+        required: List[str] = parameters.get("required", [])
+        required_params: List[str] = required
+
+        input_properties: Dict[str, Any] = {}
+        for param_name, param_info in properties.items():
+            # Preserve the complete schema structure for complex types
+            input_properties[param_name] = param_info.copy()
+
+            # Ensure description is present (default to empty if missing)
+            if "description" not in input_properties[param_name]:
+                input_properties[param_name]["description"] = ""
+
+        tool = {
+            "name": func_def.get("name") or "",
+            "description": func_def.get("description") or "",
+            "input_schema": {
+                "type": parameters.get("type", "object"),
+                "properties": input_properties,
+                "required": required_params,
+            },
+        }
+        parsed_tools.append(tool)
+    return parsed_tools

agno/utils/models/cohere.py

@@ -0,0 +1,87 @@
+from pathlib import Path
+from typing import Any, Dict, List, Sequence
+
+from agno.media import Image
+from agno.models.message import Message
+from agno.utils.log import log_error, log_warning
+
+
+def _format_images_for_message(message: Message, images: Sequence[Image]) -> List[Dict[str, Any]]:
+    """
+    Format an image into the format expected by WatsonX.
+    """
+
+    # Create a default message content with text
+    message_content_with_image: List[Dict[str, Any]] = [{"type": "text", "text": message.content}]
+
+    # Add images to the message content
+    for image in images:
+        try:
+            if image.content is not None:
+                image_content = image.content
+            elif image.url is not None:
+                image_content = image.get_content_bytes()  # type: ignore
+            elif image.filepath is not None:
+                if isinstance(image.filepath, Path):
+                    image_content = image.filepath.read_bytes()
+                else:
+                    with open(image.filepath, "rb") as f:
+                        image_content = f.read()
+            else:
+                log_warning(f"Unsupported image format: {image}")
+                continue
+
+            if image_content is not None:
+                import base64
+
+                base64_image = base64.b64encode(image_content).decode("utf-8")
+                image_url = f"data:image/jpeg;base64,{base64_image}"
+                image_payload = {"type": "image_url", "image_url": {"url": image_url}}
+                message_content_with_image.append(image_payload)
+
+        except Exception as e:
+            log_error(f"Failed to process image: {str(e)}")
+
+    # Update the message content with the images
+    return message_content_with_image
+
+
+def format_messages(messages: List[Message]) -> List[Dict[str, Any]]:
+    """
+    Format messages for the Cohere API.
+
+    Args:
+        messages (List[Message]): The list of messages.
+
+    Returns:
+        List[Dict[str, Any]]: The formatted messages.
+    """
+    formatted_messages = []
+    for message in messages:
+        message_dict = {
+            "role": message.role,
+            "content": message.content,
+            "name": message.name,
+            "tool_call_id": message.tool_call_id,
+            "tool_calls": message.tool_calls,
+        }
+
+        if message.images is not None and len(message.images) > 0:
+            # Ignore non-string message content
+            if isinstance(message.content, str):
+                message_content_with_image = _format_images_for_message(message=message, images=message.images)
+                if len(message_content_with_image) > 1:
+                    message_dict["content"] = message_content_with_image
+
+        if message.videos is not None and len(message.videos) > 0:
+            log_warning("Video input is currently unsupported.")
+
+        if message.audio is not None and len(message.audio) > 0:
+            log_warning("Audio input is currently unsupported.")
+
+        if message.files is not None and len(message.files) > 0:
+            log_warning("File input is currently unsupported.")
+
+        message_dict = {k: v for k, v in message_dict.items() if v is not None}
+        formatted_messages.append(message_dict)
+    return formatted_messages

agno/utils/models/llama.py

@@ -0,0 +1,78 @@
+from typing import Any, Dict
+
+from agno.agent import Message
+from agno.utils.log import log_warning
+from agno.utils.openai import process_image
+
+ROLE_MAP = {
+    "user": "user",
+    "assistant": "assistant",
+    "system": "system",
+    "tool": "tool",
+}
+
+TOOL_CALL_ROLE_MAP = {
+    "user": "user",
+    "assistant": "assistant",
+    "system": "user",
+    "tool": "tool",
+}
+
+
+def format_message(message: Message, openai_like: bool = False, tool_calls: bool = False) -> Dict[str, Any]:
+    """
+    Format a message into the format expected by Llama API.
+
+    Args:
+        message (Message): The message to format.
+        openai_like (bool): Whether to format the message as an OpenAI-like message.
+
+    Returns:
+        Dict[str, Any]: The formatted message.
+    """
+    message_dict: Dict[str, Any] = {
+        "role": ROLE_MAP[message.role] if not tool_calls else TOOL_CALL_ROLE_MAP[message.role],
+        "content": [{"type": "text", "text": message.content or " "}],
+        "name": message.name,
+        "tool_call_id": message.tool_call_id,
+        "tool_calls": message.tool_calls,
+    }
+    message_dict = {k: v for k, v in message_dict.items() if v is not None}
+
+    if message.images is not None and len(message.images) > 0:
+        for image in message.images:
+            image_payload = process_image(image)
+            if image_payload:
+                message_dict["content"].append(image_payload)
+
+    if message.videos is not None and len(message.videos) > 0:
+        log_warning("Video input is currently unsupported.")
+
+    if message.audio is not None and len(message.audio) > 0:
+        log_warning("Audio input is currently unsupported.")
+
+    if message.role == "tool":
+        message_dict = {
+            "role": "tool",
+            "tool_call_id": message.tool_call_id,
+            "content": message.content,
+        }
+
+    if message.role == "assistant":
+        text_content = {"type": "text", "text": message.content or " "}
+
+        if message.tool_calls is not None and len(message.tool_calls) > 0:
+            message_dict = {
+                "content": [text_content] if openai_like else text_content,
+                "role": "assistant",
+                "tool_calls": message.tool_calls,
+                "stop_reason": "tool_calls",
+            }
+        else:
+            message_dict = {
+                "role": "assistant",
+                "content": [text_content] if openai_like else text_content,
+                "stop_reason": "stop",
+            }
+
+    return message_dict