agno 1.8.1__py3-none-any.whl → 2.0.0__py3-none-any.whl

agno/utils/log.py

@@ -1,4 +1,5 @@
 import logging
+from functools import lru_cache
 from os import getenv
 from typing import Any, Literal, Optional
 
@@ -52,18 +53,23 @@ class AgnoLogger(logging.Logger):
     def __init__(self, name: str, level: int = logging.NOTSET):
         super().__init__(name, level)
 
-    def debug(self, msg: str, center: bool = False, symbol: str = "*", *args, **kwargs):
+    def debug(self, msg: str, center: bool = False, symbol: str = "*", *args, **kwargs):  # type: ignore
         if center:
             msg = center_header(str(msg), symbol)
         super().debug(msg, *args, **kwargs)
 
-    def info(self, msg: str, center: bool = False, symbol: str = "*", *args, **kwargs):
+    def info(self, msg: str, center: bool = False, symbol: str = "*", *args, **kwargs):  # type: ignore
         if center:
             msg = center_header(str(msg), symbol)
         super().info(msg, *args, **kwargs)
 
 
 def build_logger(logger_name: str, source_type: Optional[str] = None) -> Any:
+    # If a logger with the name "agno.{source_type}" is already set, we want to use that one
+    _logger = logging.getLogger(f"agno.{logger_name}")
+    if _logger.handlers or _logger.level != logging.NOTSET:
+        return _logger
+
     # Set the custom logger class as the default for this logger
     logging.setLoggerClass(AgnoLogger)
 
@@ -174,6 +180,12 @@ def use_workflow_logger():
     logger = workflow_logger
 
 
+@lru_cache(maxsize=128)
+def _using_default_logger(logger_instance: Any) -> bool:
+    """Return True if the currently active logger is our default AgnoLogger"""
+    return isinstance(logger_instance, AgnoLogger)
+
+
 def log_debug(msg, center: bool = False, symbol: str = "*", log_level: Literal[1, 2] = 1, *args, **kwargs):
     global logger
     global debug_on
@@ -181,12 +193,18 @@ def log_debug(msg, center: bool = False, symbol: str = "*", log_level: Literal[1
 
     if debug_on:
         if debug_level >= log_level:
-            logger.debug(msg, center, symbol, *args, **kwargs)
+            if _using_default_logger(logger):
+                logger.debug(msg, center, symbol, *args, **kwargs)
+            else:
+                logger.debug(msg, *args, **kwargs)
 
 
 def log_info(msg, center: bool = False, symbol: str = "*", *args, **kwargs):
     global logger
-    logger.info(msg, center, symbol, *args, **kwargs)
+    if _using_default_logger(logger):
+        logger.info(msg, center, symbol, *args, **kwargs)
+    else:
+        logger.info(msg, *args, **kwargs)
 
 
 def log_warning(msg, *args, **kwargs):
@@ -202,3 +220,35 @@ def log_error(msg, *args, **kwargs):
 def log_exception(msg, *args, **kwargs):
     global logger
     logger.exception(msg, *args, **kwargs)
+
+
+def configure_agno_logging(
+    custom_default_logger: Optional[Any] = None,
+    custom_agent_logger: Optional[Any] = None,
+    custom_team_logger: Optional[Any] = None,
+    custom_workflow_logger: Optional[Any] = None,
+) -> None:
+    """
+    Util to set custom loggers. These will be used everywhere across the Agno library.
+
+    Args:
+        custom_default_logger: Default logger to use (overrides agent_logger for default)
+        custom_agent_logger: Custom logger for agent operations
+        custom_team_logger: Custom logger for team operations
+        custom_workflow_logger: Custom logger for workflow operations
+    """
+    if custom_default_logger is not None:
+        global logger
+        logger = custom_default_logger
+
+    if custom_agent_logger is not None:
+        global agent_logger
+        agent_logger = custom_agent_logger
+
+    if custom_team_logger is not None:
+        global team_logger
+        team_logger = custom_team_logger
+
+    if custom_workflow_logger is not None:
+        global workflow_logger
+        workflow_logger = custom_workflow_logger

agno/utils/mcp.py

@@ -1,3 +1,4 @@
+import json
 from functools import partial
 from uuid import uuid4
 
@@ -11,7 +12,8 @@ except (ImportError, ModuleNotFoundError):
     raise ImportError("`mcp` not installed. Please install using `pip install mcp`")
 
 
-from agno.media import ImageArtifact
+from agno.media import Image
+from agno.tools.function import ToolResult
 
 
 def get_entrypoint_for_tool(tool: MCPTool, session: ClientSession):
@@ -27,29 +29,82 @@ def get_entrypoint_for_tool(tool: MCPTool, session: ClientSession):
     """
     from agno.agent import Agent
 
-    async def call_tool(agent: Agent, tool_name: str, **kwargs) -> str:
+    async def call_tool(agent: Agent, tool_name: str, **kwargs) -> ToolResult:
         try:
             log_debug(f"Calling MCP Tool '{tool_name}' with args: {kwargs}")
             result: CallToolResult = await session.call_tool(tool_name, kwargs)  # type: ignore
 
             # Return an error if the tool call failed
             if result.isError:
-                raise Exception(f"Error from MCP tool '{tool_name}': {result.content}")
+                return ToolResult(content=f"Error from MCP tool '{tool_name}': {result.content}")
 
             # Process the result content
             response_str = ""
+            images = []
+
             for content_item in result.content:
                 if isinstance(content_item, TextContent):
-                    response_str += content_item.text + "\n"
+                    text_content = content_item.text
+
+                    # Parse as JSON to check for custom image format
+                    try:
+                        parsed_json = json.loads(text_content)
+                        if (
+                            isinstance(parsed_json, dict)
+                            and parsed_json.get("type") == "image"
+                            and "data" in parsed_json
+                        ):
+                            log_debug("Found custom JSON image format in TextContent")
+
+                            # Extract image data
+                            image_data = parsed_json.get("data")
+                            mime_type = parsed_json.get("mimeType", "image/png")
+
+                            if image_data and isinstance(image_data, str):
+                                import base64
+
+                                try:
+                                    image_bytes = base64.b64decode(image_data)
+                                except Exception as e:
+                                    log_debug(f"Failed to decode base64 image data: {e}")
+                                    image_bytes = None
+
+                                if image_bytes:
+                                    img_artifact = Image(
+                                        id=str(uuid4()),
+                                        url=None,
+                                        content=image_bytes,
+                                        mime_type=mime_type,
+                                    )
+                                    images.append(img_artifact)
+                                    response_str += "Image has been generated and added to the response.\n"
+                                    continue
+
+                    except (json.JSONDecodeError, TypeError):
+                        pass
+
+                    response_str += text_content + "\n"
+
                 elif isinstance(content_item, ImageContent):
-                    # Handle image content if present
-                    img_artifact = ImageArtifact(
+                    # Handle standard MCP ImageContent
+                    image_data = getattr(content_item, "data", None)
+
+                    if image_data and isinstance(image_data, str):
+                        import base64
+
+                        try:
+                            image_data = base64.b64decode(image_data)
+                        except Exception as e:
+                            log_debug(f"Failed to decode base64 image data: {e}")
+                            image_data = None
+
+                    img_artifact = Image(
                         id=str(uuid4()),
                         url=getattr(content_item, "url", None),
-                        content=getattr(content_item, "data", None),
+                        content=image_data,
                         mime_type=getattr(content_item, "mimeType", "image/png"),
                     )
-                    agent.add_image(img_artifact)
+                    images.append(img_artifact)
                     response_str += "Image has been generated and added to the response.\n"
                 elif isinstance(content_item, EmbeddedResource):
                     # Handle embedded resources
@@ -58,9 +113,12 @@ def get_entrypoint_for_tool(tool: MCPTool, session: ClientSession):
                     # Handle other content types
                     response_str += f"[Unsupported content type: {content_item.type}]\n"
 
-            return response_str.strip()
+            return ToolResult(
+                content=response_str.strip(),
+                images=images if images else None,
+            )
         except Exception as e:
             log_exception(f"Failed to call MCP tool '{tool_name}': {e}")
-            return f"Error: {e}"
+            return ToolResult(content=f"Error: {e}")
 
     return partial(call_tool, tool_name=tool.name)

agno/utils/media.py

@@ -1,4 +1,5 @@
 import base64
+import time
 from enum import Enum
 from pathlib import Path
 from typing import List
@@ -114,6 +115,44 @@ def save_base64_data(base64_data: str, output_path: str) -> bool:
         raise Exception(f"An unexpected error occurred while saving data to '{output_path}': {e}")
 
 
+def wait_for_media_ready(url: str, timeout: int = 120, interval: int = 5, verbose: bool = True) -> bool:
+    """
+    Wait for media to be ready at URL by polling with HEAD requests.
+
+    Args:
+        url (str): The URL to check for media availability
+        timeout (int): Maximum time to wait in seconds (default: 120)
+        interval (int): Seconds between each check (default: 5)
+        verbose (bool): Whether to print progress messages (default: True)
+
+    Returns:
+        bool: True if media is ready, False if timeout reached
+    """
+    max_attempts = timeout // interval
+
+    if verbose:
+        print("Media generated! Waiting for upload to complete...")
+
+    for attempt in range(max_attempts):
+        try:
+            response = httpx.head(url, timeout=10)
+            response.raise_for_status()
+            if verbose:
+                print(f"Media ready: {url}")
+            return True
+        except httpx.HTTPError:
+            pass
+
+        if verbose and (attempt + 1) % 3 == 0:
+            print(f"Still processing... ({(attempt + 1) * interval}s elapsed)")
+
+        time.sleep(interval)
+
+    if verbose:
+        print(f"Timeout waiting for media. Try this URL later: {url}")
+    return False
+
+
 def download_knowledge_filters_sample_data(
     num_files: int = 5, file_extension: SampleDataFileExtension = SampleDataFileExtension.DOCX
 ) -> List[str]:

agno/utils/message.py

@@ -7,6 +7,7 @@ from agno.models.message import Message
 
 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
@@ -17,7 +18,15 @@ def get_text_from_message(message: Union[List, Dict, str, Message, BaseModel]) -
         if len(message) == 0:
             return ""
 
-        if "type" in message[0]:
+        # 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):
@@ -42,6 +51,8 @@ def get_text_from_message(message: Union[List, Dict, str, Message, BaseModel]) -
     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/aws_claude.py

@@ -53,7 +53,7 @@ def _format_image_for_message(image: Image) -> Optional[Dict[str, Any]]:
     try:
         # Case 1: Image is a URL
         if image.url is not None:
-            content_bytes = image.image_url_content
+            content_bytes = image.get_content_bytes()  # type: ignore
 
         # Case 2: Image is a local file path
         elif image.filepath is not None:

agno/utils/models/claude.py

@@ -246,21 +246,23 @@ def format_messages(messages: List[Message]) -> Tuple[List[Dict[str, str]], str]
         elif message.role == "assistant":
             content = []
 
-            if message.thinking is not None and message.provider_data is not None:
+            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.thinking,
+                        thinking=message.reasoning_content,
                         signature=message.provider_data.get("signature"),
                         type="thinking",
                     )
                 )
 
-            if message.redacted_thinking is not None:
+            if message.redacted_reasoning_content is not None:
                 from anthropic.types import RedactedThinkingBlock
 
-                content.append(RedactedThinkingBlock(data=message.redacted_thinking, type="redacted_thinking"))
+                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"))
@@ -284,3 +286,44 @@ def format_messages(messages: List[Message]) -> Tuple[List[Dict[str, str]], str]
 
         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

@@ -20,7 +20,7 @@ def _format_images_for_message(message: Message, images: Sequence[Image]) -> Lis
             if image.content is not None:
                 image_content = image.content
             elif image.url is not None:
-                image_content = image.image_url_content
+                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()

agno/utils/models/mistral.py

@@ -5,13 +5,14 @@ from agno.models.message import Message
 from agno.utils.log import log_error, log_warning
 
 try:
-    from mistralai.models import (
-        AssistantMessage,
-        ImageURLChunk,
-        SystemMessage,
-        TextChunk,
-        ToolMessage,
-        UserMessage,
+    # TODO: Adapt these imports to the new Mistral SDK versions
+    from mistralai.models import (  # type: ignore
+        AssistantMessage,  # type: ignore
+        ImageURLChunk,  # type: ignore
+        SystemMessage,  # type: ignore
+        TextChunk,  # type: ignore
+        ToolMessage,  # type: ignore
+        UserMessage,  # type: ignore
     )
 
     MistralMessage = Union[UserMessage, AssistantMessage, SystemMessage, ToolMessage]

agno/utils/models/schema_utils.py

@@ -135,19 +135,19 @@ def _normalize_generic(schema: Dict[str, Any]) -> Dict[str, Any]:
     return schema
 
 
-def get_response_schema_for_provider(response_model: Type[BaseModel], provider: str) -> Dict[str, Any]:
+def get_response_schema_for_provider(output_schema: Type[BaseModel], provider: str) -> Dict[str, Any]:
     """
     Get a properly formatted response schema for a specific model provider.
 
     Args:
-        response_model: Pydantic BaseModel class
+        output_schema: Pydantic BaseModel class
         provider: Model provider name
 
     Returns:
         Dict[str, Any]: Provider-specific schema
     """
     # Generate the base schema
-    base_schema = response_model.model_json_schema()
+    base_schema = output_schema.model_json_schema()
 
     # Normalize for the specific provider
     return normalize_schema_for_provider(base_schema, provider)

agno/utils/models/watsonx.py

@@ -19,7 +19,7 @@ def format_images_for_message(message: Message, images: Sequence[Image]) -> Mess
             if image.content is not None:
                 image_content = image.content
             elif image.url is not None:
-                image_content = image.image_url_content
+                image_content = image.get_content_bytes()  # type: ignore
             else:
                 log_warning(f"Unsupported image format: {image}")
                 continue

agno/utils/openai.py

@@ -39,7 +39,7 @@ def audio_to_message(audio: Sequence[Audio]) -> List[Dict[str, Any]]:
 
         # The audio is a URL
         elif audio_snippet.url:
-            audio_bytes = audio_snippet.audio_url_content
+            audio_bytes = audio_snippet.get_content_bytes()
             if audio_bytes is not None:
                 encoded_string = base64.b64encode(audio_bytes).decode("utf-8")
                 if not audio_format:

agno/utils/pprint.py

@@ -3,39 +3,40 @@ from typing import AsyncIterable, Iterable, Union, get_args
 
 from pydantic import BaseModel
 
-from agno.run.response import RunResponse, RunResponseEvent
-from agno.run.team import TeamRunResponse, TeamRunResponseEvent
-from agno.run.v2.workflow import WorkflowRunResponse, WorkflowRunResponseEvent
+from agno.run.agent import RunOutput, RunOutputEvent
+from agno.run.team import TeamRunOutput, TeamRunOutputEvent
+from agno.run.workflow import WorkflowRunOutput, WorkflowRunOutputEvent
 from agno.utils.log import logger
 from agno.utils.timer import Timer
 
 
 def pprint_run_response(
     run_response: Union[
-        RunResponse,
-        Iterable[RunResponseEvent],
-        TeamRunResponse,
-        Iterable[TeamRunResponseEvent],
-        WorkflowRunResponse,
-        Iterable[WorkflowRunResponseEvent],
+        RunOutput,
+        Iterable[RunOutputEvent],
+        TeamRunOutput,
+        Iterable[TeamRunOutputEvent],
+        WorkflowRunOutput,
+        Iterable[WorkflowRunOutputEvent],
     ],
     markdown: bool = False,
     show_time: bool = False,
 ) -> None:
     from rich.box import ROUNDED
+    from rich.console import Console
     from rich.json import JSON
     from rich.live import Live
     from rich.markdown import Markdown
     from rich.status import Status
     from rich.table import Table
 
-    from agno.cli.console import console
+    console = Console()
 
-    # If run_response is a single RunResponse, wrap it in a list to make it iterable
+    # If run_response is a single RunOutput, wrap it in a list to make it iterable
     if (
-        isinstance(run_response, RunResponse)
-        or isinstance(run_response, TeamRunResponse)
-        or isinstance(run_response, WorkflowRunResponse)
+        isinstance(run_response, RunOutput)
+        or isinstance(run_response, TeamRunOutput)
+        or isinstance(run_response, WorkflowRunOutput)
     ):
         single_response_content: Union[str, JSON, Markdown] = ""
         if isinstance(run_response.content, str):
@@ -66,9 +67,9 @@ def pprint_run_response(
             for resp in run_response:
                 if (
                     (
-                        isinstance(resp, tuple(get_args(RunResponseEvent)))
-                        or isinstance(resp, tuple(get_args(TeamRunResponseEvent)))
-                        or isinstance(resp, tuple(get_args(WorkflowRunResponseEvent)))
+                        isinstance(resp, tuple(get_args(RunOutputEvent)))
+                        or isinstance(resp, tuple(get_args(TeamRunOutputEvent)))
+                        or isinstance(resp, tuple(get_args(WorkflowRunOutputEvent)))
                     )
                     and hasattr(resp, "content")
                     and resp.content is not None
@@ -95,30 +96,30 @@ def pprint_run_response(
 
 async def apprint_run_response(
     run_response: Union[
-        RunResponse,
-        AsyncIterable[RunResponse],
-        TeamRunResponse,
-        AsyncIterable[TeamRunResponse],
-        WorkflowRunResponse,
-        AsyncIterable[WorkflowRunResponseEvent],
+        RunOutput,
+        AsyncIterable[RunOutput],
+        TeamRunOutput,
+        AsyncIterable[TeamRunOutput],
+        WorkflowRunOutput,
+        AsyncIterable[WorkflowRunOutputEvent],
     ],
     markdown: bool = False,
     show_time: bool = False,
 ) -> None:
     from rich.box import ROUNDED
+    from rich.console import Console
     from rich.json import JSON
     from rich.live import Live
     from rich.markdown import Markdown
     from rich.status import Status
     from rich.table import Table
 
-    from agno.cli.console import console
-
-    # If run_response is a single RunResponse, wrap it in a list to make it iterable
+    console = Console()
+    # If run_response is a single RunOutput, wrap it in a list to make it iterable
     if (
-        isinstance(run_response, RunResponse)
-        or isinstance(run_response, TeamRunResponse)
-        or isinstance(run_response, WorkflowRunResponse)
+        isinstance(run_response, RunOutput)
+        or isinstance(run_response, TeamRunOutput)
+        or isinstance(run_response, WorkflowRunOutput)
     ):
         single_response_content: Union[str, JSON, Markdown] = ""
         if isinstance(run_response.content, str):
@@ -150,9 +151,9 @@ async def apprint_run_response(
             async for resp in run_response:
                 if (
                     (
-                        isinstance(resp, tuple(get_args(RunResponseEvent)))
-                        or isinstance(resp, tuple(get_args(TeamRunResponseEvent)))
-                        or isinstance(resp, tuple(get_args(WorkflowRunResponseEvent)))
+                        isinstance(resp, tuple(get_args(RunOutputEvent)))
+                        or isinstance(resp, tuple(get_args(TeamRunOutputEvent)))
+                        or isinstance(resp, tuple(get_args(WorkflowRunOutputEvent)))
                     )
                     and hasattr(resp, "content")
                     and resp.content is not None