agno 2.0.0rc1__py3-none-any.whl → 2.0.1__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
 
@@ -64,6 +65,11 @@ class AgnoLogger(logging.Logger):
 
 
 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,7 @@ 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
 
 
@@ -43,13 +44,64 @@ def get_entrypoint_for_tool(tool: MCPTool, session: ClientSession):
 
             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"),
                     )
                     images.append(img_artifact)

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

@@ -307,14 +307,6 @@ def format_tools_for_model(tools: Optional[List[Dict[str, Any]]] = None) -> Opti
         required: List[str] = parameters.get("required", [])
         required_params: List[str] = required
 
-        if not required_params:
-            for param_name, param_info in properties.items():
-                param_type = param_info.get("type", "")
-                param_type_list: List[str] = [param_type] if isinstance(param_type, str) else param_type or []
-
-                if "null" not in param_type_list:
-                    required_params.append(param_name)
-
         input_properties: Dict[str, Any] = {}
         for param_name, param_info in properties.items():
             # Preserve the complete schema structure for complex types

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/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/print_response/team.py

@@ -6,7 +6,7 @@ from agno.media import Audio, File, Image, Video
 from agno.models.message import Message
 from agno.models.response import ToolExecution
 from agno.reasoning.step import ReasoningStep
-from agno.run.agent import RunEvent, RunOutput, ToolCallCompletedEvent
+from agno.run.agent import RunOutput
 from agno.run.team import TeamRunEvent, TeamRunOutput, TeamRunOutputEvent
 from agno.utils.log import log_warning
 from agno.utils.message import get_text_from_message
@@ -184,7 +184,7 @@ def print_response(
                         elif isinstance(member_response, TeamRunOutput) and member_response.team_id is not None:
                             show_markdown = member_markdown.get(member_response.team_id, False)
 
-                    member_response_content: Union[str, JSON, Markdown] = team._parse_response_content(  # type: ignore
+                    member_response_content: Union[str, JSON, Markdown] = _parse_response_content(  # type: ignore
                         member_response,
                         tags_to_include_in_markdown,
                         show_markdown=show_markdown,
@@ -247,7 +247,7 @@ def print_response(
                     panels.append(team_tool_calls_panel)
                     live_console.update(Group(*panels))
 
-            response_content_batch: Union[str, JSON, Markdown] = team._parse_response_content(  # type: ignore
+            response_content_batch: Union[str, JSON, Markdown] = _parse_response_content(  # type: ignore
                 run_response, tags_to_include_in_markdown, show_markdown=team_markdown
             )
 
@@ -388,6 +388,7 @@ def print_response_stream(
             dependencies=dependencies,
             metadata=metadata,
             debug_mode=debug_mode,
+            yield_run_response=True,
             **kwargs,
         )
 
@@ -397,9 +398,8 @@ def print_response_stream(
         # Dict to track member response panels by member_id
         member_response_panels = {}
 
-        run_id = None
+        final_run_response = None
         for resp in stream_resp:
-            run_id = resp.run_id
             if team_markdown is None:
                 if markdown:
                     team_markdown = True
@@ -409,6 +409,10 @@ def print_response_stream(
                 if team.output_schema is not None:
                     team_markdown = False
 
+            if isinstance(resp, TeamRunOutput):
+                final_run_response = resp
+                continue
+
             if isinstance(resp, tuple(get_args(TeamRunOutputEvent))):
                 if resp.event == TeamRunEvent.run_content:
                     if isinstance(resp.content, str):
@@ -424,8 +428,8 @@ def print_response_stream(
                     reasoning_steps = resp.reasoning_steps  # type: ignore
 
                 # Collect team tool calls, avoiding duplicates
-                if isinstance(resp, ToolCallCompletedEvent) and resp.tool:
-                    tool = resp.tool
+                if resp.event == TeamRunEvent.tool_call_completed and resp.tool:  # type: ignore
+                    tool = resp.tool  # type: ignore
                     # Generate a unique ID for this tool call
                     if tool.tool_call_id:
                         tool_id = tool.tool_call_id
@@ -537,7 +541,7 @@ def print_response_stream(
                     if markdown:
                         show_markdown = True
 
-                    member_response_content = team._parse_response_content(
+                    member_response_content = _parse_response_content(
                         member_response,
                         tags_to_include_in_markdown,
                         show_markdown=show_markdown,
@@ -597,7 +601,7 @@ def print_response_stream(
                 live_console.update(Group(*panels))
 
         response_timer.stop()
-        run_response = team.get_run_output(run_id=run_id)  # type: ignore
+        run_response = final_run_response
 
         # Add citations
         if hasattr(resp, "citations") and resp.citations is not None and resp.citations.urls is not None:
@@ -725,7 +729,7 @@ def print_response_stream(
                 elif isinstance(member_response, TeamRunOutput) and member_response.team_id is not None:
                     show_markdown = member_markdown.get(member_response.team_id, False)
 
-                member_response_content = team._parse_response_content(  # type: ignore
+                member_response_content = _parse_response_content(  # type: ignore
                     member_response,
                     tags_to_include_in_markdown,
                     show_markdown=show_markdown,
@@ -985,7 +989,7 @@ async def aprint_response(
                     elif isinstance(member_response, TeamRunOutput) and member_response.team_id is not None:
                         show_markdown = member_markdown.get(member_response.team_id, False)
 
-                    member_response_content: Union[str, JSON, Markdown] = team._parse_response_content(  # type: ignore
+                    member_response_content: Union[str, JSON, Markdown] = _parse_response_content(  # type: ignore
                         member_response,
                         tags_to_include_in_markdown,
                         show_markdown=show_markdown,
@@ -1046,7 +1050,7 @@ async def aprint_response(
                     panels.append(team_tool_calls_panel)
                     live_console.update(Group(*panels))
 
-            response_content_batch: Union[str, JSON, Markdown] = team._parse_response_content(  # type: ignore
+            response_content_batch: Union[str, JSON, Markdown] = _parse_response_content(  # type: ignore
                 run_response, tags_to_include_in_markdown, show_markdown=team_markdown
             )
 
@@ -1175,7 +1179,10 @@ async def aprint_response_stream(
         team_markdown = None
         member_markdown = {}
 
-        run_id = None
+        # Dict to track member response panels by member_id
+        member_response_panels = {}
+
+        final_run_response = None
         async for resp in team.arun(  # type: ignore
             input=input,
             audio=audio,
@@ -1192,9 +1199,9 @@ async def aprint_response_stream(
             dependencies=dependencies,
             metadata=metadata,
             debug_mode=debug_mode,
+            yield_run_response=True,
             **kwargs,
         ):
-            run_id = resp.run_id
             if team_markdown is None:
                 if markdown:
                     team_markdown = True
@@ -1204,6 +1211,10 @@ async def aprint_response_stream(
                 if team.output_schema is not None:
                     team_markdown = False
 
+            if isinstance(resp, TeamRunOutput):
+                final_run_response = resp
+                continue
+
             if isinstance(resp, tuple(get_args(TeamRunOutputEvent))):
                 if resp.event == TeamRunEvent.run_content:
                     if isinstance(resp.content, str):
@@ -1219,8 +1230,8 @@ async def aprint_response_stream(
                     reasoning_steps = resp.reasoning_steps  # type: ignore
 
                 # Collect team tool calls, avoiding duplicates
-                if isinstance(resp, ToolCallCompletedEvent) and resp.tool:
-                    tool = resp.tool
+                if resp.event == TeamRunEvent.tool_call_completed and resp.tool:  # type: ignore
+                    tool = resp.tool  # type: ignore
                     # Generate a unique ID for this tool call
                     if tool.tool_call_id is not None:
                         tool_id = tool.tool_call_id
@@ -1259,7 +1270,7 @@ async def aprint_response_stream(
                 response_content_stream = Markdown(escaped_content)
 
             # Create new panels for each chunk
-            panels = [status]
+            panels = []
 
             if input and show_message:
                 render = True
@@ -1271,8 +1282,6 @@ async def aprint_response_stream(
                     border_style="cyan",
                 )
                 panels.append(message_panel)
-            if render:
-                live_console.update(Group(*panels))
 
             if len(reasoning_steps) > 0 and show_reasoning:
                 render = True
@@ -1280,8 +1289,6 @@ async def aprint_response_stream(
                 for i, step in enumerate(reasoning_steps, 1):
                     reasoning_panel = build_reasoning_step_panel(i, step, show_full_reasoning)
                     panels.append(reasoning_panel)
-            if render:
-                live_console.update(Group(*panels))
 
             if len(_response_reasoning_content) > 0:
                 render = True
@@ -1292,29 +1299,95 @@ async def aprint_response_stream(
                     border_style="green",
                 )
                 panels.append(thinking_panel)
-            if render:
-                live_console.update(Group(*panels))
+            elif _response_content == "":
+                # Keep showing status if no content yet
+                panels.append(status)
 
-            # Add tool calls panel if available
-            if (
-                resp is not None
-                and hasattr(resp, "tool")
-                and resp.tool is not None
-                and resp.event == RunEvent.tool_call_started
-            ):
-                render = True
-                # Create bullet points for each tool call
-                tool_calls_content = Text()
-                formatted_tool_call = format_tool_calls([resp.tool])
-                tool_calls_content.append(f"• {formatted_tool_call}\n")
-
-                tool_calls_panel = create_panel(
-                    content=tool_calls_content.plain.rstrip(),
-                    title="Tool Calls",
-                    border_style="yellow",
-                )
-                panels.append(tool_calls_panel)
+            # Process member responses and their tool calls
+            for member_response in resp.member_responses if hasattr(resp, "member_responses") else []:
+                member_id = None
+                member_name = "Team Member"
+                if isinstance(member_response, RunOutput) and member_response.agent_id is not None:
+                    member_id = member_response.agent_id
+                    member_name = team._get_member_name(member_id)
+                elif isinstance(member_response, TeamRunOutput) and member_response.team_id is not None:
+                    member_id = member_response.team_id
+
+                    member_name = team._get_member_name(member_id)
+
+                # If we have tool calls for this member, display them
+                if member_id in member_tool_calls and member_tool_calls[member_id]:
+                    formatted_calls = format_tool_calls(member_tool_calls[member_id])
+                    if formatted_calls:
+                        console_width = console.width if console else 80
+                        panel_width = console_width + 30
+
+                        lines = []
+                        for call in formatted_calls:
+                            wrapped_call = textwrap.fill(f"• {call}", width=panel_width, subsequent_indent="  ")
+                            lines.append(wrapped_call)
+
+                        tool_calls_text = "\n\n".join(lines)
+
+                        member_tool_calls_panel = create_panel(
+                            content=tool_calls_text,
+                            title=f"{member_name} Tool Calls",
+                            border_style="yellow",
+                        )
+                        panels.append(member_tool_calls_panel)
+
+                # Process member response content
+                if team.show_members_responses and member_id is not None:
+                    show_markdown = False
+                    if markdown:
+                        show_markdown = True
+
+                    member_response_content = _parse_response_content(
+                        member_response,
+                        tags_to_include_in_markdown,
+                        show_markdown=show_markdown,
+                    )
+
+                    member_response_panel = create_panel(
+                        content=member_response_content,
+                        title=f"{member_name} Response",
+                        border_style="magenta",
+                    )
+
+                    panels.append(member_response_panel)
+
+                    # Store for reference
+                    if member_id is not None:
+                        member_response_panels[member_id] = member_response_panel
+
+            # Add team tool calls panel if available (before the team response)
+            if team_tool_calls:
+                formatted_calls = format_tool_calls(team_tool_calls)
+                if formatted_calls:
+                    console_width = console.width if console else 80
+                    panel_width = console_width + 30
+
+                    lines = []
+                    # Create a set to track already added calls by their string representation
+                    added_calls = set()
+                    for call in formatted_calls:
+                        if call not in added_calls:
+                            added_calls.add(call)
+                            # Wrap the call text to fit within the panel
+                            wrapped_call = textwrap.fill(f"• {call}", width=panel_width, subsequent_indent="  ")
+                            lines.append(wrapped_call)
+
+                    # Join with blank lines between items
+                    tool_calls_text = "\n\n".join(lines)
+
+                    team_tool_calls_panel = create_panel(
+                        content=tool_calls_text,
+                        title="Team Tool Calls",
+                        border_style="yellow",
+                    )
+                    panels.append(team_tool_calls_panel)
 
+            # Add the team response panel at the end
             if response_content_stream:
                 render = True
                 # Create panel for response
@@ -1324,11 +1397,13 @@ async def aprint_response_stream(
                     border_style="blue",
                 )
                 panels.append(response_panel)
-            if render:
+
+            if render or len(panels) > 0:
                 live_console.update(Group(*panels))
+
         response_timer.stop()
 
-        run_response = team.get_run_output(run_id=run_id)  # type: ignore
+        run_response = final_run_response
 
         # Add citations
         if hasattr(resp, "citations") and resp.citations is not None and resp.citations.urls is not None:
@@ -1415,6 +1490,7 @@ async def aprint_response_stream(
                 elif isinstance(member_response, TeamRunOutput) and member_response.team_id is not None:
                     member_id = member_response.team_id
 
+                # Print tool calls
                 if member_id:
                     # First add tool calls if any
                     if member_id in member_tool_calls and member_tool_calls[member_id]:
@@ -1472,39 +1548,39 @@ async def aprint_response_stream(
                 elif isinstance(member_response, TeamRunOutput) and member_response.team_id is not None:
                     show_markdown = member_markdown.get(member_response.team_id, False)
 
-                    member_response_content = team._parse_response_content(  # type: ignore
-                        member_response,
-                        tags_to_include_in_markdown,
-                        show_markdown=show_markdown,
-                    )
+                member_response_content = _parse_response_content(  # type: ignore
+                    member_response,
+                    tags_to_include_in_markdown,
+                    show_markdown=show_markdown,
+                )
 
-                    member_name = "Team Member"
-                    if isinstance(member_response, RunOutput) and member_response.agent_id is not None:
-                        member_name = team._get_member_name(member_response.agent_id)
-                    elif isinstance(member_response, TeamRunOutput) and member_response.team_id is not None:
-                        member_name = team._get_member_name(member_response.team_id)
+                member_name = "Team Member"
+                if isinstance(member_response, RunOutput) and member_response.agent_id is not None:
+                    member_name = team._get_member_name(member_response.agent_id)
+                elif isinstance(member_response, TeamRunOutput) and member_response.team_id is not None:
+                    member_name = team._get_member_name(member_response.team_id)
 
-                    member_response_panel = create_panel(
-                        content=member_response_content,
-                        title=f"{member_name} Response",
-                        border_style="magenta",
-                    )
-                    final_panels.append(member_response_panel)
+                member_response_panel = create_panel(
+                    content=member_response_content,
+                    title=f"{member_name} Response",
+                    border_style="magenta",
+                )
+                final_panels.append(member_response_panel)
 
-                    # Add citations if any
-                    if member_response.citations is not None and member_response.citations.urls is not None:
-                        md_content = "\n".join(
-                            f"{i + 1}. [{citation.title or citation.url}]({citation.url})"
-                            for i, citation in enumerate(member_response.citations.urls)
-                            if citation.url  # Only include citations with valid URLs
+                # Add citations if any
+                if member_response.citations is not None and member_response.citations.urls is not None:
+                    md_content = "\n".join(
+                        f"{i + 1}. [{citation.title or citation.url}]({citation.url})"
+                        for i, citation in enumerate(member_response.citations.urls)
+                        if citation.url  # Only include citations with valid URLs
+                    )
+                    if md_content:  # Only create panel if there are citations
+                        citations_panel = create_panel(
+                            content=Markdown(md_content),
+                            title="Citations",
+                            border_style="magenta",
                         )
-                        if md_content:  # Only create panel if there are citations
-                            citations_panel = create_panel(
-                                content=Markdown(md_content),
-                                title="Citations",
-                                border_style="magenta",
-                            )
-                            final_panels.append(citations_panel)
+                        final_panels.append(citations_panel)
 
         # Add team tool calls before team response
         if team_tool_calls:
@@ -1563,3 +1639,31 @@ async def aprint_response_stream(
 
         # Final update with correctly ordered panels
         live_console.update(Group(*final_panels))
+
+
+def _parse_response_content(
+    run_response: Union[TeamRunOutput, RunOutput],
+    tags_to_include_in_markdown: Set[str],
+    show_markdown: bool = True,
+) -> Any:
+    from rich.json import JSON
+    from rich.markdown import Markdown
+
+    if isinstance(run_response.content, str):
+        if show_markdown:
+            escaped_content = escape_markdown_tags(run_response.content, tags_to_include_in_markdown)
+            return Markdown(escaped_content)
+        else:
+            return run_response.get_content_as_string(indent=4)
+    elif isinstance(run_response.content, BaseModel):
+        try:
+            return JSON(run_response.content.model_dump_json(exclude_none=True), indent=2)
+        except Exception as e:
+            log_warning(f"Failed to convert response to JSON: {e}")
+    else:
+        import json
+
+        try:
+            return JSON(json.dumps(run_response.content), indent=4)
+        except Exception as e:
+            log_warning(f"Failed to convert response to JSON: {e}")