agno 2.3.2__py3-none-any.whl → 2.3.3__py3-none-any.whl

agno/tools/mcp/mcp.py

@@ -43,7 +43,7 @@ class MCPTools(Toolkit):
         include_tools: Optional[list[str]] = None,
         exclude_tools: Optional[list[str]] = None,
         refresh_connection: bool = False,
-        tool_name_prefix: Optional[str] = "",
+        tool_name_prefix: Optional[str] = None,
         **kwargs,
     ):
         """

agno/utils/agent.py

@@ -1,10 +1,11 @@
 from asyncio import Future, Task
-from typing import TYPE_CHECKING, Any, AsyncIterator, Dict, Iterator, List, Optional, Sequence, Union
+from typing import TYPE_CHECKING, Any, AsyncIterator, Callable, Dict, Iterator, List, Optional, Sequence, Union
 
 from agno.media import Audio, File, Image, Video
 from agno.models.message import Message
 from agno.models.metrics import Metrics
 from agno.models.response import ModelResponse
+from agno.run import RunContext
 from agno.run.agent import RunEvent, RunInput, RunOutput, RunOutputEvent
 from agno.run.team import RunOutputEvent as TeamRunOutputEvent
 from agno.run.team import TeamRunOutput
@@ -818,3 +819,120 @@ async def aget_chat_history_util(entity: Union["Agent", "Team"], session_id: str
         raise Exception("Session not found")
 
     return session.get_chat_history()  # type: ignore
+
+
+def execute_instructions(
+    instructions: Callable,
+    agent: Optional[Union["Agent", "Team"]] = None,
+    team: Optional["Team"] = None,
+    session_state: Optional[Dict[str, Any]] = None,
+    run_context: Optional[RunContext] = None,
+) -> Union[str, List[str]]:
+    """Execute the instructions function."""
+    import inspect
+
+    signature = inspect.signature(instructions)
+    instruction_args: Dict[str, Any] = {}
+
+    # Check for agent parameter
+    if "agent" in signature.parameters:
+        instruction_args["agent"] = agent
+
+    if "team" in signature.parameters:
+        instruction_args["team"] = team
+
+    # Check for session_state parameter
+    if "session_state" in signature.parameters:
+        instruction_args["session_state"] = session_state or {}
+
+    # Check for run_context parameter
+    if "run_context" in signature.parameters:
+        instruction_args["run_context"] = run_context or None
+
+    # Run the instructions function, await if it's awaitable, otherwise run directly (in thread)
+    if inspect.iscoroutinefunction(instructions):
+        raise Exception("Instructions function is async, use `agent.arun()` instead")
+
+    # Run the instructions function
+    return instructions(**instruction_args)
+
+
+def execute_system_message(
+    system_message: Callable,
+    agent: Optional[Union["Agent", "Team"]] = None,
+    team: Optional["Team"] = None,
+    session_state: Optional[Dict[str, Any]] = None,
+    run_context: Optional[RunContext] = None,
+) -> str:
+    """Execute the system message function."""
+    import inspect
+
+    signature = inspect.signature(system_message)
+    system_message_args: Dict[str, Any] = {}
+
+    # Check for agent parameter
+    if "agent" in signature.parameters:
+        system_message_args["agent"] = agent
+    if "team" in signature.parameters:
+        system_message_args["team"] = team
+    if inspect.iscoroutinefunction(system_message):
+        raise ValueError("System message function is async, use `agent.arun()` instead")
+
+    return system_message(**system_message_args)
+
+
+async def aexecute_instructions(
+    instructions: Callable,
+    agent: Optional[Union["Agent", "Team"]] = None,
+    team: Optional["Team"] = None,
+    session_state: Optional[Dict[str, Any]] = None,
+    run_context: Optional[RunContext] = None,
+) -> Union[str, List[str]]:
+    """Execute the instructions function."""
+    import inspect
+
+    signature = inspect.signature(instructions)
+    instruction_args: Dict[str, Any] = {}
+
+    # Check for agent parameter
+    if "agent" in signature.parameters:
+        instruction_args["agent"] = agent
+    if "team" in signature.parameters:
+        instruction_args["team"] = team
+
+    # Check for session_state parameter
+    if "session_state" in signature.parameters:
+        instruction_args["session_state"] = session_state or {}
+
+    # Check for run_context parameter
+    if "run_context" in signature.parameters:
+        instruction_args["run_context"] = run_context or None
+
+    if inspect.iscoroutinefunction(instructions):
+        return await instructions(**instruction_args)
+    else:
+        return instructions(**instruction_args)
+
+
+async def aexecute_system_message(
+    system_message: Callable,
+    agent: Optional[Union["Agent", "Team"]] = None,
+    team: Optional["Team"] = None,
+    session_state: Optional[Dict[str, Any]] = None,
+    run_context: Optional[RunContext] = None,
+) -> str:
+    import inspect
+
+    signature = inspect.signature(system_message)
+    system_message_args: Dict[str, Any] = {}
+
+    # Check for agent parameter
+    if "agent" in signature.parameters:
+        system_message_args["agent"] = agent
+    if "team" in signature.parameters:
+        system_message_args["team"] = team
+
+    if inspect.iscoroutinefunction(system_message):
+        return await system_message(**system_message_args)
+    else:
+        return system_message(**system_message_args)

agno/utils/models/ai_foundry.py

@@ -5,19 +5,26 @@ from agno.utils.log import log_warning
 from agno.utils.openai import images_to_message
 
 
-def format_message(message: Message) -> Dict[str, Any]:
+def format_message(message: Message, compress_tool_results: bool = False) -> Dict[str, Any]:
     """
     Format a message into the format expected by OpenAI.
 
     Args:
         message (Message): The message to format.
+        compress_tool_results: Whether to compress tool results.
 
     Returns:
         Dict[str, Any]: The formatted message.
     """
+    # Use compressed content for tool messages if compression is active
+    content = message.content
+
+    if message.role == "tool":
+        content = message.get_content(use_compressed_content=compress_tool_results)
+
     message_dict: Dict[str, Any] = {
         "role": message.role,
-        "content": message.content,
+        "content": content,
         "name": message.name,
         "tool_call_id": message.tool_call_id,
         "tool_calls": message.tool_calls,

agno/utils/models/claude.py

@@ -1,6 +1,6 @@
 import json
 from dataclasses import dataclass, field
-from typing import Any, Dict, List, Optional, Tuple
+from typing import Any, Dict, List, Optional, Tuple, Union
 
 from agno.media import File, Image
 from agno.models.message import Message
@@ -221,17 +221,20 @@ def _format_file_for_message(file: File) -> Optional[Dict[str, Any]]:
     return None
 
 
-def format_messages(messages: List[Message]) -> Tuple[List[Dict[str, str]], str]:
+def format_messages(
+    messages: List[Message], compress_tool_results: bool = False
+) -> Tuple[List[Dict[str, Union[str, list]]], 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.
+        compress_tool_results: Whether to compress tool results.
 
     Returns:
-        Tuple[List[Dict[str, str]], str]: A tuple containing the list of API messages and the concatenated system messages.
+        Tuple[List[Dict[str, Union[str, list]]], str]: A tuple containing the list of API messages and the concatenated system messages.
     """
-    chat_messages: List[Dict[str, str]] = []
+    chat_messages: List[Dict[str, Union[str, list]]] = []
     system_messages: List[str] = []
 
     for message in messages:
@@ -301,11 +304,15 @@ def format_messages(messages: List[Message]) -> Tuple[List[Dict[str, str]], str]
                     )
         elif message.role == "tool":
             content = []
+
+            # Use compressed content for tool messages if compression is active
+            tool_result = message.get_content(use_compressed_content=compress_tool_results)
+
             content.append(
                 {
                     "type": "tool_result",
                     "tool_use_id": message.tool_call_id,
-                    "content": str(message.content),
+                    "content": str(tool_result),
                 }
             )
 

agno/utils/models/cohere.py

@@ -46,21 +46,28 @@ def _format_images_for_message(message: Message, images: Sequence[Image]) -> Lis
     return message_content_with_image
 
 
-def format_messages(messages: List[Message]) -> List[Dict[str, Any]]:
+def format_messages(messages: List[Message], compress_tool_results: bool = False) -> List[Dict[str, Any]]:
     """
     Format messages for the Cohere API.
 
     Args:
         messages (List[Message]): The list of messages.
+        compress_tool_results: Whether to compress tool results.
 
     Returns:
         List[Dict[str, Any]]: The formatted messages.
     """
     formatted_messages = []
     for message in messages:
+        # Use compressed content for tool messages if compression is active
+        content = message.content
+
+        if message.role == "tool":
+            content = message.get_content(use_compressed_content=compress_tool_results)
+
         message_dict = {
             "role": message.role,
-            "content": message.content,
+            "content": content,
             "name": message.name,
             "tool_call_id": message.tool_call_id,
             "tool_calls": message.tool_calls,

agno/utils/models/llama.py

@@ -19,13 +19,17 @@ TOOL_CALL_ROLE_MAP = {
 }
 
 
-def format_message(message: Message, openai_like: bool = False, tool_calls: bool = False) -> Dict[str, Any]:
+def format_message(
+    message: Message, openai_like: bool = False, tool_calls: bool = False, compress_tool_results: 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.
+        tool_calls (bool): Whether tool calls are present.
+        compress_tool_results: Whether to compress tool results.
 
     Returns:
         Dict[str, Any]: The formatted message.
@@ -52,10 +56,13 @@ def format_message(message: Message, openai_like: bool = False, tool_calls: bool
         log_warning("Audio input is currently unsupported.")
 
     if message.role == "tool":
+        # Use compressed content if compression is active
+        content = message.get_content(use_compressed_content=compress_tool_results)
+
         message_dict = {
             "role": "tool",
             "tool_call_id": message.tool_call_id,
-            "content": message.content,
+            "content": content,
         }
 
     if message.role == "assistant":

agno/utils/models/mistral.py

@@ -48,7 +48,7 @@ def _format_image_for_message(image: Image) -> Optional[ImageURLChunk]:
     return None
 
 
-def format_messages(messages: List[Message]) -> List[MistralMessage]:
+def format_messages(messages: List[Message], compress_tool_results: bool = False) -> List[MistralMessage]:
     mistral_messages: List[MistralMessage] = []
 
     for message in messages:
@@ -84,7 +84,9 @@ def format_messages(messages: List[Message]) -> List[MistralMessage]:
         elif message.role == "system":
             mistral_message = SystemMessage(role="system", content=message.content)
         elif message.role == "tool":
-            mistral_message = ToolMessage(name="tool", content=message.content, tool_call_id=message.tool_call_id)
+            # Get compressed content if compression is active
+            tool_content = message.get_content(use_compressed_content=compress_tool_results)
+            mistral_message = ToolMessage(name="tool", content=tool_content, tool_call_id=message.tool_call_id)
         else:
             raise ValueError(f"Unknown role: {message.role}")
 

agno/utils/print_response/agent.py

@@ -179,6 +179,7 @@ def print_response_stream(
                 show_reasoning=show_reasoning,
                 show_full_reasoning=show_full_reasoning,
                 accumulated_tool_calls=accumulated_tool_calls,
+                compression_manager=agent.compression_manager,
             )
             panels.extend(additional_panels)
             if panels:
@@ -204,6 +205,10 @@ def print_response_stream(
             live_log.update(Group(*panels))
             agent.session_summary_manager.summaries_updated = False
 
+        # Clear compression stats after final display
+        if agent.compression_manager is not None:
+            agent.compression_manager.stats.clear()
+
         response_timer.stop()
 
         # Final update to remove the "Thinking..." status
@@ -366,6 +371,7 @@ async def aprint_response_stream(
                 show_reasoning=show_reasoning,
                 show_full_reasoning=show_full_reasoning,
                 accumulated_tool_calls=accumulated_tool_calls,
+                compression_manager=agent.compression_manager,
             )
             panels.extend(additional_panels)
             if panels:
@@ -391,6 +397,10 @@ async def aprint_response_stream(
             live_log.update(Group(*panels))
             agent.session_summary_manager.summaries_updated = False
 
+        # Clear compression stats after final display
+        if agent.compression_manager is not None:
+            agent.compression_manager.stats.clear()
+
         response_timer.stop()
 
         # Final update to remove the "Thinking..." status
@@ -407,6 +417,7 @@ def build_panels_stream(
     show_reasoning: bool = True,
     show_full_reasoning: bool = False,
     accumulated_tool_calls: Optional[List] = None,
+    compression_manager: Optional[Any] = None,
 ):
     panels = []
 
@@ -447,8 +458,18 @@ def build_panels_stream(
         for formatted_tool_call in formatted_tool_calls:
             tool_calls_content.append(f"• {formatted_tool_call}\n")
 
+        tool_calls_text = tool_calls_content.plain.rstrip()
+
+        # Add compression stats if available (don't clear - caller will clear after final display)
+        if compression_manager is not None and compression_manager.stats:
+            stats = compression_manager.stats
+            saved = stats.get("original_size", 0) - stats.get("compressed_size", 0)
+            orig = stats.get("original_size", 1)
+            if stats.get("messages_compressed", 0) > 0:
+                tool_calls_text += f"\n\nTool results compressed: {stats.get('messages_compressed', 0)} | Saved: {saved:,} chars ({saved / orig * 100:.0f}%)"
+
         tool_calls_panel = create_panel(
-            content=tool_calls_content.plain.rstrip(),
+            content=tool_calls_text,
             title="Tool Calls",
             border_style="yellow",
         )
@@ -589,6 +610,7 @@ def print_response(
             show_full_reasoning=show_full_reasoning,
             tags_to_include_in_markdown=tags_to_include_in_markdown,
             markdown=markdown,
+            compression_manager=agent.compression_manager,
         )
         panels.extend(additional_panels)
 
@@ -721,6 +743,7 @@ async def aprint_response(
             show_full_reasoning=show_full_reasoning,
             tags_to_include_in_markdown=tags_to_include_in_markdown,
             markdown=markdown,
+            compression_manager=agent.compression_manager,
         )
         panels.extend(additional_panels)
 
@@ -757,6 +780,7 @@ def build_panels(
     show_full_reasoning: bool = False,
     tags_to_include_in_markdown: Optional[Set[str]] = None,
     markdown: bool = False,
+    compression_manager: Optional[Any] = None,
 ):
     panels = []
 
@@ -808,8 +832,19 @@ def build_panels(
         for formatted_tool_call in formatted_tool_calls:
             tool_calls_content.append(f"• {formatted_tool_call}\n")
 
+        tool_calls_text = tool_calls_content.plain.rstrip()
+
+        # Add compression stats if available
+        if compression_manager is not None and compression_manager.stats:
+            stats = compression_manager.stats
+            saved = stats.get("original_size", 0) - stats.get("compressed_size", 0)
+            orig = stats.get("original_size", 1)
+            if stats.get("messages_compressed", 0) > 0:
+                tool_calls_text += f"\n\nTool results compressed: {stats.get('messages_compressed', 0)} | Saved: {saved:,} chars ({saved / orig * 100:.0f}%)"
+            compression_manager.stats.clear()
+
         tool_calls_panel = create_panel(
-            content=tool_calls_content.plain.rstrip(),
+            content=tool_calls_text,
             title="Tool Calls",
             border_style="yellow",
         )

agno/utils/print_response/team.py

@@ -260,6 +260,15 @@ def print_response(
                     # Join with blank lines between items
                     tool_calls_text = "\n\n".join(lines)
 
+                    # Add compression stats at end of tool calls
+                    if team.compression_manager is not None and team.compression_manager.stats:
+                        stats = team.compression_manager.stats
+                        saved = stats.get("original_size", 0) - stats.get("compressed_size", 0)
+                        orig = stats.get("original_size", 1)
+                        if stats.get("messages_compressed", 0) > 0:
+                            tool_calls_text += f"\n\nTool results compressed: {stats.get('messages_compressed', 0)} | Saved: {saved:,} chars ({saved / orig * 100:.0f}%)"
+                        team.compression_manager.stats.clear()
+
                     team_tool_calls_panel = create_panel(
                         content=tool_calls_text,
                         title="Team Tool Calls",
@@ -613,6 +622,14 @@ def print_response_stream(
                     # Join with blank lines between items
                     tool_calls_text = "\n\n".join(lines)
 
+                    # Add compression stats if available (don't clear - will be cleared in final_panels)
+                    if team.compression_manager is not None and team.compression_manager.stats:
+                        stats = team.compression_manager.stats
+                        saved = stats.get("original_size", 0) - stats.get("compressed_size", 0)
+                        orig = stats.get("original_size", 1)
+                        if stats.get("messages_compressed", 0) > 0:
+                            tool_calls_text += f"\n\nTool results compressed: {stats.get('messages_compressed', 0)} | Saved: {saved:,} chars ({saved / orig * 100:.0f}%)"
+
                     team_tool_calls_panel = create_panel(
                         content=tool_calls_text,
                         title="Team Tool Calls",
@@ -815,6 +832,15 @@ def print_response_stream(
 
                 tool_calls_text = "\n\n".join(lines)
 
+                # Add compression stats at end of tool calls
+                if team.compression_manager is not None and team.compression_manager.stats:
+                    stats = team.compression_manager.stats
+                    saved = stats.get("original_size", 0) - stats.get("compressed_size", 0)
+                    orig = stats.get("original_size", 1)
+                    if stats.get("messages_compressed", 0) > 0:
+                        tool_calls_text += f"\n\nTool results compressed: {stats.get('messages_compressed', 0)} | Saved: {saved:,} chars ({saved / orig * 100:.0f}%)"
+                    team.compression_manager.stats.clear()
+
                 team_tool_calls_panel = create_panel(
                     content=tool_calls_text,
                     title="Team Tool Calls",
@@ -1095,6 +1121,15 @@ async def aprint_response(
 
                     tool_calls_text = "\n\n".join(lines)
 
+                    # Add compression stats at end of tool calls
+                    if team.compression_manager is not None and team.compression_manager.stats:
+                        stats = team.compression_manager.stats
+                        saved = stats.get("original_size", 0) - stats.get("compressed_size", 0)
+                        orig = stats.get("original_size", 1)
+                        if stats.get("messages_compressed", 0) > 0:
+                            tool_calls_text += f"\n\nTool results compressed: {stats.get('messages_compressed', 0)} | Saved: {saved:,} chars ({saved / orig * 100:.0f}%)"
+                        team.compression_manager.stats.clear()
+
                     team_tool_calls_panel = create_panel(
                         content=tool_calls_text,
                         title="Team Tool Calls",
@@ -1446,6 +1481,14 @@ async def aprint_response_stream(
                     # Join with blank lines between items
                     tool_calls_text = "\n\n".join(lines)
 
+                    # Add compression stats if available (don't clear - will be cleared in final_panels)
+                    if team.compression_manager is not None and team.compression_manager.stats:
+                        stats = team.compression_manager.stats
+                        saved = stats.get("original_size", 0) - stats.get("compressed_size", 0)
+                        orig = stats.get("original_size", 1)
+                        if stats.get("messages_compressed", 0) > 0:
+                            tool_calls_text += f"\n\nTool results compressed: {stats.get('messages_compressed', 0)} | Saved: {saved:,} chars ({saved / orig * 100:.0f}%)"
+
                     team_tool_calls_panel = create_panel(
                         content=tool_calls_text,
                         title="Team Tool Calls",
@@ -1666,6 +1709,15 @@ async def aprint_response_stream(
 
                 tool_calls_text = "\n\n".join(lines)
 
+                # Add compression stats at end of tool calls
+                if team.compression_manager is not None and team.compression_manager.stats:
+                    stats = team.compression_manager.stats
+                    saved = stats.get("original_size", 0) - stats.get("compressed_size", 0)
+                    orig = stats.get("original_size", 1)
+                    if stats.get("messages_compressed", 0) > 0:
+                        tool_calls_text += f"\n\nTool results compressed: {stats.get('messages_compressed', 0)} | Saved: {saved:,} chars ({saved / orig * 100:.0f}%)"
+                    team.compression_manager.stats.clear()
+
                 team_tool_calls_panel = create_panel(
                     content=tool_calls_text,
                     title="Team Tool Calls",

agno/utils/tokens.py

@@ -0,0 +1,41 @@
+"""Token counting utilities for text processing."""
+
+
+def count_tokens(text: str) -> int:
+    """Count tokens in text using tiktoken.
+
+    Uses cl100k_base encoding (compatible with GPT-4, GPT-4o, GPT-3.5-turbo).
+    Falls back to character-based estimation if tiktoken is not available.
+
+    Args:
+        text: The text string to count tokens for.
+
+    Returns:
+        Total token count for the text.
+
+    Examples:
+        >>> count_tokens("Hello world")
+        2
+        >>> count_tokens("")
+        0
+    """
+    try:
+        import tiktoken
+
+        # Use cl100k_base encoding (GPT-4, GPT-4o, GPT-3.5-turbo)
+        encoding = tiktoken.get_encoding("cl100k_base")
+        tokens = encoding.encode(text)
+        return len(tokens)
+    except ImportError:
+        from agno.utils.log import log_warning
+
+        log_warning(
+            "tiktoken not installed. You can install with `pip install -U tiktoken`. Using character-based estimation."
+        )
+        # Fallback: rough estimation (1 token H 4 characters)
+        return len(text) // 4
+    except Exception as e:
+        from agno.utils.log import log_warning
+
+        log_warning(f"Error counting tokens: {e}. Using character-based estimation.")
+        return len(text) // 4

agno/workflow/types.py

@@ -209,7 +209,7 @@ class StepInput:
         input_dict: Optional[Union[str, Dict[str, Any], List[Any]]] = None
         if self.input is not None:
             if isinstance(self.input, BaseModel):
-                input_dict = self.input.model_dump(exclude_none=True)
+                input_dict = self.input.model_dump(exclude_none=True, mode="json")
             elif isinstance(self.input, (dict, list)):
                 input_dict = self.input
             else:
@@ -281,7 +281,7 @@ class StepOutput:
         content_dict: Optional[Union[str, Dict[str, Any], List[Any]]] = None
         if self.content is not None:
             if isinstance(self.content, BaseModel):
-                content_dict = self.content.model_dump(exclude_none=True)
+                content_dict = self.content.model_dump(exclude_none=True, mode="json")
             elif isinstance(self.content, (dict, list)):
                 content_dict = self.content
             else: