agno 2.2.13__py3-none-any.whl → 2.4.3__py3-none-any.whl

agno/utils/http.py

@@ -1,5 +1,6 @@
 import asyncio
 import logging
+import threading
 from time import sleep
 from typing import Optional
 
@@ -10,6 +11,164 @@ logger = logging.getLogger(__name__)
 DEFAULT_MAX_RETRIES = 3
 DEFAULT_BACKOFF_FACTOR = 2  # Exponential backoff: 1, 2, 4, 8...
 
+# Global httpx clients for resource efficiency
+# These are shared across all models to reuse connection pools and avoid resource leaks.
+# Consumers can override these at application startup using set_default_sync_client()
+# and set_default_async_client() to customize limits, timeouts, proxies, etc.
+_global_sync_client: Optional[httpx.Client] = None
+_global_async_client: Optional[httpx.AsyncClient] = None
+
+# Locks for thread-safe lazy initialization
+_sync_client_lock = threading.Lock()
+_async_client_lock = threading.Lock()
+
+
+def get_default_sync_client() -> httpx.Client:
+    """Get or create the global synchronous httpx client.
+
+    Thread-safe lazy initialization using double-checked locking.
+
+    Note: HTTP/2 is disabled for the sync client because HTTP/2's stream
+    multiplexing is not thread-safe when sharing a client across threads
+    (e.g., when using ThreadPoolExecutor). HTTP/1.1 uses connection pooling
+    where each connection handles one request at a time, which is thread-safe.
+
+    Returns:
+        A singleton httpx.Client instance with default limits.
+    """
+    global _global_sync_client
+
+    if _global_sync_client is not None and not _global_sync_client.is_closed:
+        return _global_sync_client
+
+    with _sync_client_lock:
+        if _global_sync_client is None or _global_sync_client.is_closed:
+            _global_sync_client = httpx.Client(
+                limits=httpx.Limits(max_connections=1000, max_keepalive_connections=200),
+                http2=False,  # Disabled for thread safety in multi-threaded contexts
+                follow_redirects=True,
+            )
+    return _global_sync_client
+
+
+def get_default_async_client() -> httpx.AsyncClient:
+    """Get or create the global asynchronous httpx client.
+
+    Thread-safe lazy initialization using double-checked locking.
+
+    Note: HTTP/2 is enabled for the async client because asyncio runs in a
+    single-threaded event loop where HTTP/2 stream multiplexing is safe.
+
+    Returns:
+        A singleton httpx.AsyncClient instance with default limits.
+    """
+    global _global_async_client
+
+    if _global_async_client is not None and not _global_async_client.is_closed:
+        return _global_async_client
+
+    with _async_client_lock:
+        if _global_async_client is None or _global_async_client.is_closed:
+            _global_async_client = httpx.AsyncClient(
+                limits=httpx.Limits(max_connections=1000, max_keepalive_connections=200),
+                http2=True,  # Safe in async context (single-threaded event loop)
+                follow_redirects=True,
+            )
+    return _global_async_client
+
+
+def close_sync_client() -> None:
+    """Closes the global sync httpx client.
+
+    Thread-safe. Should be called during application shutdown.
+    """
+    global _global_sync_client
+    with _sync_client_lock:
+        if _global_sync_client is not None and not _global_sync_client.is_closed:
+            _global_sync_client.close()
+            _global_sync_client = None
+
+
+async def aclose_default_clients() -> None:
+    """Asynchronously close the global httpx clients.
+
+    Thread-safe. Should be called during application shutdown in async contexts.
+    """
+    global _global_sync_client, _global_async_client
+
+    with _sync_client_lock:
+        if _global_sync_client is not None and not _global_sync_client.is_closed:
+            _global_sync_client.close()
+            _global_sync_client = None
+
+    with _async_client_lock:
+        if _global_async_client is not None and not _global_async_client.is_closed:
+            await _global_async_client.aclose()
+            _global_async_client = None
+
+
+def set_default_sync_client(client: httpx.Client) -> None:
+    """Set the global synchronous httpx client.
+
+    Thread-safe. Call before creating any model instances for best results,
+    though this can be called at any time.
+
+    Allows consumers to override the default httpx client with custom configuration
+    (e.g., custom limits, timeouts, proxies, SSL verification, etc.).
+    This is useful at application startup to customize how all models connect.
+
+    Warning: If using this client in multi-threaded contexts (e.g., ThreadPoolExecutor),
+    consider disabling HTTP/2 (http2=False) to avoid thread-safety issues with
+    HTTP/2 stream multiplexing.
+
+    Example:
+        >>> import httpx
+        >>> from agno.utils.http import set_default_sync_client
+        >>> custom_client = httpx.Client(
+        ...     limits=httpx.Limits(max_connections=500),
+        ...     timeout=httpx.Timeout(30.0),
+        ...     http2=False,  # Recommended for multi-threaded use
+        ...     verify=False  # for dev environments
+        ... )
+        >>> set_default_sync_client(custom_client)
+        >>> # All models will now use this custom client
+
+    Args:
+        client: An httpx.Client instance to use as the global sync client.
+    """
+    global _global_sync_client
+    with _sync_client_lock:
+        _global_sync_client = client
+
+
+def set_default_async_client(client: httpx.AsyncClient) -> None:
+    """Set the global asynchronous httpx client.
+
+    Thread-safe. Call before creating any model instances for best results,
+    though this can be called at any time.
+
+    Allows consumers to override the default async httpx client with custom configuration
+    (e.g., custom limits, timeouts, proxies, SSL verification, etc.).
+    This is useful at application startup to customize how all models connect.
+
+    Example:
+        >>> import httpx
+        >>> from agno.utils.http import set_default_async_client
+        >>> custom_client = httpx.AsyncClient(
+        ...     limits=httpx.Limits(max_connections=500),
+        ...     timeout=httpx.Timeout(30.0),
+        ...     verify=False  # for dev environments
+        ... )
+        >>> set_default_async_client(custom_client)
+        >>> # All models will now use this custom client
+
+    Args:
+        client: An httpx.AsyncClient instance to use as the global async client.
+    """
+    global _global_async_client
+    with _async_client_lock:
+        _global_async_client = client
+
 
 def fetch_with_retry(
     url: str,
@@ -29,7 +188,7 @@ def fetch_with_retry(
                 logger.error(f"Failed to fetch {url} after {max_retries} attempts: {e}")
                 raise
             wait_time = backoff_factor**attempt
-            logger.warning(f"Request failed (attempt {attempt + 1}), retrying in {wait_time} seconds...")
+            logger.warning("Connection error.")
             sleep(wait_time)
         except httpx.HTTPStatusError as e:
             logger.error(f"HTTP error for {url}: {e.response.status_code} - {e.response.text}")
@@ -65,7 +224,7 @@ async def async_fetch_with_retry(
                 logger.error(f"Failed to fetch {url} after {max_retries} attempts: {e}")
                 raise
             wait_time = backoff_factor**attempt
-            logger.warning(f"Request failed (attempt {attempt + 1}), retrying in {wait_time} seconds...")
+            logger.warning("Connection error.")
             await asyncio.sleep(wait_time)
         except httpx.HTTPStatusError as e:
             logger.error(f"HTTP error for {url}: {e.response.status_code} - {e.response.text}")

agno/utils/mcp.py

@@ -1,5 +1,6 @@
 import json
 from functools import partial
+from typing import TYPE_CHECKING, Optional, Union
 from uuid import uuid4
 
 from agno.utils.log import log_debug, log_exception
@@ -15,28 +16,68 @@ except (ImportError, ModuleNotFoundError):
 from agno.media import Image
 from agno.tools.function import ToolResult
 
+if TYPE_CHECKING:
+    from agno.agent import Agent
+    from agno.run import RunContext
+    from agno.team.team import Team
+    from agno.tools.mcp.mcp import MCPTools
+    from agno.tools.mcp.multi_mcp import MultiMCPTools
 
-def get_entrypoint_for_tool(tool: MCPTool, session: ClientSession):
+
+def get_entrypoint_for_tool(
+    tool: MCPTool,
+    session: ClientSession,
+    mcp_tools_instance: Optional[Union["MCPTools", "MultiMCPTools"]] = None,
+    server_idx: int = 0,
+):
     """
     Return an entrypoint for an MCP tool.
 
     Args:
         tool: The MCP tool to create an entrypoint for
-        session: The session to use
+        session: The MCP ClientSession to use
+        mcp_tools_instance: Optional MCPTools or MultiMCPTools instance
+        server_idx: Index of the server (for MultiMCPTools)
 
     Returns:
         Callable: The entrypoint function for the tool
     """
 
-    async def call_tool(tool_name: str, **kwargs) -> ToolResult:
+    async def call_tool(
+        tool_name: str,
+        run_context: Optional["RunContext"] = None,
+        agent: Optional["Agent"] = None,
+        team: Optional["Team"] = None,
+        **kwargs,
+    ) -> ToolResult:
+        # Execute the MCP tool call
         try:
-            await session.send_ping()
-        except Exception as e:
-            print(e)
+            # Get the appropriate session for this run
+            # If mcp_tools_instance has header_provider and run_context is provided,
+            # this will create/reuse a session with dynamic headers
+            if mcp_tools_instance and hasattr(mcp_tools_instance, "get_session_for_run"):
+                # Import here to avoid circular imports
+                from agno.tools.mcp.multi_mcp import MultiMCPTools
+
+                # For MultiMCPTools, pass server_idx; for MCPTools, only pass run_context
+                if isinstance(mcp_tools_instance, MultiMCPTools):
+                    active_session = await mcp_tools_instance.get_session_for_run(
+                        run_context=run_context, server_idx=server_idx, agent=agent, team=team
+                    )
+                else:
+                    active_session = await mcp_tools_instance.get_session_for_run(
+                        run_context=run_context, agent=agent, team=team
+                    )
+            else:
+                active_session = session
+
+            try:
+                await active_session.send_ping()
+            except Exception as e:
+                log_exception(e)
 
-        try:
             log_debug(f"Calling MCP Tool '{tool_name}' with args: {kwargs}")
-            result: CallToolResult = await session.call_tool(tool_name, kwargs)  # type: ignore
+            result: CallToolResult = await active_session.call_tool(tool_name, kwargs)  # type: ignore
 
             # Return an error if the tool call failed
             if result.isError:

agno/utils/media.py

@@ -56,6 +56,17 @@ def download_image(url: str, output_path: str) -> bool:
         return False
 
 
+def download_audio(url: str, output_path: str) -> str:
+    """Download audio from URL"""
+    response = httpx.get(url)
+    response.raise_for_status()
+
+    with open(output_path, "wb") as f:
+        for chunk in response.iter_bytes(chunk_size=8192):
+            f.write(chunk)
+    return output_path
+
+
 def download_video(url: str, output_path: str) -> str:
     """Download video from URL"""
     response = httpx.get(url)
@@ -280,7 +291,7 @@ def reconstruct_file_from_dict(file_data):
         if isinstance(file_data, dict):
             # If content is base64 string, decode it back to bytes
             if "content" in file_data and isinstance(file_data["content"], str):
-                return File.from_base64(
+                file_obj = File.from_base64(
                     file_data["content"],
                     id=file_data.get("id"),
                     mime_type=file_data.get("mime_type"),
@@ -288,6 +299,16 @@ def reconstruct_file_from_dict(file_data):
                     name=file_data.get("name"),
                     format=file_data.get("format"),
                 )
+                # Preserve additional fields that from_base64 doesn't handle
+                if file_data.get("size") is not None:
+                    file_obj.size = file_data.get("size")
+                if file_data.get("file_type") is not None:
+                    file_obj.file_type = file_data.get("file_type")
+                if file_data.get("filepath") is not None:
+                    file_obj.filepath = file_data.get("filepath")
+                if file_data.get("url") is not None:
+                    file_obj.url = file_data.get("url")
+                return file_obj
             else:
                 # Regular file (filepath/url)
                 return File(**file_data)

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),
                 }
             )
 
@@ -320,6 +327,7 @@ def format_messages(messages: List[Message]) -> Tuple[List[Dict[str, str]], str]
 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.
+    Now supports strict mode for structured outputs.
     """
     if not tools:
         return None
@@ -352,7 +360,14 @@ def format_tools_for_model(tools: Optional[List[Dict[str, Any]]] = None) -> Opti
                 "type": parameters.get("type", "object"),
                 "properties": input_properties,
                 "required": required_params,
+                "additionalProperties": False,
             },
         }
+
+        # Add strict mode if specified (check both function dict and tool_def top level)
+        strict_mode = func_def.get("strict") or tool_def.get("strict")
+        if strict_mode is True:
+            tool["strict"] = True
+
         parsed_tools.append(tool)
     return parsed_tools

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}")