agno 2.1.2__py3-none-any.whl → 2.3.13__py3-none-any.whl

agno/utils/cryptography.py

@@ -0,0 +1,22 @@
+from cryptography.hazmat.primitives import serialization
+from cryptography.hazmat.primitives.asymmetric import rsa
+
+
+def generate_rsa_keys():
+    """Generate RSA key pair for RS256 JWT signing/verification."""
+    private_key = rsa.generate_private_key(public_exponent=65537, key_size=2048)
+
+    # Private key PEM (used by auth server to sign tokens)
+    private_pem = private_key.private_bytes(
+        encoding=serialization.Encoding.PEM,
+        format=serialization.PrivateFormat.PKCS8,
+        encryption_algorithm=serialization.NoEncryption(),
+    )
+
+    # Public key PEM (used by AgentOS to verify tokens)
+    public_pem = private_key.public_key().public_bytes(
+        encoding=serialization.Encoding.PEM,
+        format=serialization.PublicFormat.SubjectPublicKeyInfo,
+    )
+
+    return private_pem.decode("utf-8"), public_pem.decode("utf-8")

agno/utils/dttm.py

@@ -1,4 +1,5 @@
 from datetime import datetime, timezone
+from typing import Union
 
 
 def current_datetime() -> datetime:
@@ -11,3 +12,35 @@ def current_datetime_utc() -> datetime:
 
 def current_datetime_utc_str() -> str:
     return current_datetime_utc().strftime("%Y-%m-%dT%H:%M:%S")
+
+
+def now_epoch_s() -> int:
+    return int(datetime.now(timezone.utc).timestamp())
+
+
+def to_epoch_s(value: Union[int, float, str, datetime]) -> int:
+    """Normalize various datetime representations to epoch seconds (UTC)."""
+
+    if isinstance(value, (int, float)):
+        # assume value is already in seconds
+        return int(value)
+
+    if isinstance(value, datetime):
+        dt = value
+        if dt.tzinfo is None:
+            dt = dt.replace(tzinfo=timezone.utc)
+        return int(dt.timestamp())
+
+    if isinstance(value, str):
+        s = value.strip()
+        if s.endswith("Z"):
+            s = s[:-1] + "+00:00"
+        try:
+            dt = datetime.fromisoformat(s)
+        except ValueError as e:
+            raise ValueError(f"Unsupported datetime string: {value!r}") from e
+        if dt.tzinfo is None:
+            dt = dt.replace(tzinfo=timezone.utc)
+        return int(dt.timestamp())
+
+    raise TypeError(f"Unsupported datetime value: {type(value)}")

agno/utils/events.py

@@ -1,4 +1,4 @@
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, List, Optional, Union
 
 from agno.media import Audio, Image
 from agno.models.message import Citations
@@ -11,6 +11,8 @@ from agno.run.agent import (
     OutputModelResponseStartedEvent,
     ParserModelResponseCompletedEvent,
     ParserModelResponseStartedEvent,
+    PostHookCompletedEvent,
+    PostHookStartedEvent,
     PreHookCompletedEvent,
     PreHookStartedEvent,
     ReasoningCompletedEvent,
@@ -18,22 +20,30 @@ from agno.run.agent import (
     ReasoningStepEvent,
     RunCancelledEvent,
     RunCompletedEvent,
+    RunContentCompletedEvent,
     RunContentEvent,
     RunContinuedEvent,
     RunErrorEvent,
+    RunEvent,
     RunInput,
     RunOutput,
+    RunOutputEvent,
     RunPausedEvent,
     RunStartedEvent,
+    SessionSummaryCompletedEvent,
+    SessionSummaryStartedEvent,
     ToolCallCompletedEvent,
     ToolCallStartedEvent,
 )
+from agno.run.requirement import RunRequirement
 from agno.run.team import MemoryUpdateCompletedEvent as TeamMemoryUpdateCompletedEvent
 from agno.run.team import MemoryUpdateStartedEvent as TeamMemoryUpdateStartedEvent
 from agno.run.team import OutputModelResponseCompletedEvent as TeamOutputModelResponseCompletedEvent
 from agno.run.team import OutputModelResponseStartedEvent as TeamOutputModelResponseStartedEvent
 from agno.run.team import ParserModelResponseCompletedEvent as TeamParserModelResponseCompletedEvent
 from agno.run.team import ParserModelResponseStartedEvent as TeamParserModelResponseStartedEvent
+from agno.run.team import PostHookCompletedEvent as TeamPostHookCompletedEvent
+from agno.run.team import PostHookStartedEvent as TeamPostHookStartedEvent
 from agno.run.team import PreHookCompletedEvent as TeamPreHookCompletedEvent
 from agno.run.team import PreHookStartedEvent as TeamPreHookStartedEvent
 from agno.run.team import ReasoningCompletedEvent as TeamReasoningCompletedEvent
@@ -41,12 +51,16 @@ from agno.run.team import ReasoningStartedEvent as TeamReasoningStartedEvent
 from agno.run.team import ReasoningStepEvent as TeamReasoningStepEvent
 from agno.run.team import RunCancelledEvent as TeamRunCancelledEvent
 from agno.run.team import RunCompletedEvent as TeamRunCompletedEvent
+from agno.run.team import RunContentCompletedEvent as TeamRunContentCompletedEvent
 from agno.run.team import RunContentEvent as TeamRunContentEvent
 from agno.run.team import RunErrorEvent as TeamRunErrorEvent
 from agno.run.team import RunStartedEvent as TeamRunStartedEvent
-from agno.run.team import TeamRunInput, TeamRunOutput
+from agno.run.team import SessionSummaryCompletedEvent as TeamSessionSummaryCompletedEvent
+from agno.run.team import SessionSummaryStartedEvent as TeamSessionSummaryStartedEvent
+from agno.run.team import TeamRunEvent, TeamRunInput, TeamRunOutput, TeamRunOutputEvent
 from agno.run.team import ToolCallCompletedEvent as TeamToolCallCompletedEvent
 from agno.run.team import ToolCallStartedEvent as TeamToolCallStartedEvent
+from agno.session.summary import SessionSummary
 
 
 def create_team_run_started_event(from_run_response: TeamRunOutput) -> TeamRunStartedEvent:
@@ -93,6 +107,7 @@ def create_team_run_completed_event(from_run_response: TeamRunOutput) -> TeamRun
         member_responses=from_run_response.member_responses,  # type: ignore
         metadata=from_run_response.metadata,  # type: ignore
         metrics=from_run_response.metrics,  # type: ignore
+        session_state=from_run_response.session_state,  # type: ignore
     )
 
 
@@ -117,11 +132,14 @@ def create_run_completed_event(from_run_response: RunOutput) -> RunCompletedEven
         reasoning_messages=from_run_response.reasoning_messages,  # type: ignore
         metadata=from_run_response.metadata,  # type: ignore
         metrics=from_run_response.metrics,  # type: ignore
+        session_state=from_run_response.session_state,  # type: ignore
     )
 
 
 def create_run_paused_event(
-    from_run_response: RunOutput, tools: Optional[List[ToolExecution]] = None
+    from_run_response: RunOutput,
+    tools: Optional[List[ToolExecution]] = None,
+    requirements: Optional[List[RunRequirement]] = None,
 ) -> RunPausedEvent:
     return RunPausedEvent(
         session_id=from_run_response.session_id,
@@ -129,6 +147,7 @@ def create_run_paused_event(
         agent_name=from_run_response.agent_name,  # type: ignore
         run_id=from_run_response.run_id,
         tools=tools,
+        requirements=requirements,
         content=from_run_response.content,
     )
 
@@ -242,6 +261,54 @@ def create_team_pre_hook_completed_event(
     )
 
 
+def create_post_hook_started_event(
+    from_run_response: RunOutput, post_hook_name: Optional[str] = None
+) -> PostHookStartedEvent:
+    return PostHookStartedEvent(
+        session_id=from_run_response.session_id,
+        agent_id=from_run_response.agent_id,  # type: ignore
+        agent_name=from_run_response.agent_name,  # type: ignore
+        run_id=from_run_response.run_id,
+        post_hook_name=post_hook_name,
+    )
+
+
+def create_team_post_hook_started_event(
+    from_run_response: TeamRunOutput, post_hook_name: Optional[str] = None
+) -> TeamPostHookStartedEvent:
+    return TeamPostHookStartedEvent(
+        session_id=from_run_response.session_id,
+        team_id=from_run_response.team_id,  # type: ignore
+        team_name=from_run_response.team_name,  # type: ignore
+        run_id=from_run_response.run_id,
+        post_hook_name=post_hook_name,
+    )
+
+
+def create_post_hook_completed_event(
+    from_run_response: RunOutput, post_hook_name: Optional[str] = None
+) -> PostHookCompletedEvent:
+    return PostHookCompletedEvent(
+        session_id=from_run_response.session_id,
+        agent_id=from_run_response.agent_id,  # type: ignore
+        agent_name=from_run_response.agent_name,  # type: ignore
+        run_id=from_run_response.run_id,
+        post_hook_name=post_hook_name,
+    )
+
+
+def create_team_post_hook_completed_event(
+    from_run_response: TeamRunOutput, post_hook_name: Optional[str] = None
+) -> TeamPostHookCompletedEvent:
+    return TeamPostHookCompletedEvent(
+        session_id=from_run_response.session_id,
+        team_id=from_run_response.team_id,  # type: ignore
+        team_name=from_run_response.team_name,  # type: ignore
+        run_id=from_run_response.run_id,
+        post_hook_name=post_hook_name,
+    )
+
+
 def create_memory_update_started_event(from_run_response: RunOutput) -> MemoryUpdateStartedEvent:
     return MemoryUpdateStartedEvent(
         session_id=from_run_response.session_id,
@@ -278,6 +345,50 @@ def create_team_memory_update_completed_event(from_run_response: TeamRunOutput)
     )
 
 
+def create_team_session_summary_started_event(
+    from_run_response: TeamRunOutput,
+) -> TeamSessionSummaryStartedEvent:
+    return TeamSessionSummaryStartedEvent(
+        session_id=from_run_response.session_id,
+        team_id=from_run_response.team_id,  # type: ignore
+        team_name=from_run_response.team_name,  # type: ignore
+        run_id=from_run_response.run_id,
+    )
+
+
+def create_team_session_summary_completed_event(
+    from_run_response: TeamRunOutput, session_summary: Optional[SessionSummary] = None
+) -> TeamSessionSummaryCompletedEvent:
+    return TeamSessionSummaryCompletedEvent(
+        session_id=from_run_response.session_id,
+        team_id=from_run_response.team_id,  # type: ignore
+        team_name=from_run_response.team_name,  # type: ignore
+        run_id=from_run_response.run_id,
+        session_summary=session_summary,
+    )
+
+
+def create_session_summary_started_event(from_run_response: RunOutput) -> SessionSummaryStartedEvent:
+    return SessionSummaryStartedEvent(
+        session_id=from_run_response.session_id,
+        agent_id=from_run_response.agent_id,  # type: ignore
+        agent_name=from_run_response.agent_name,  # type: ignore
+        run_id=from_run_response.run_id,
+    )
+
+
+def create_session_summary_completed_event(
+    from_run_response: RunOutput, session_summary: Optional[SessionSummary] = None
+) -> SessionSummaryCompletedEvent:
+    return SessionSummaryCompletedEvent(
+        session_id=from_run_response.session_id,
+        agent_id=from_run_response.agent_id,  # type: ignore
+        agent_name=from_run_response.agent_name,  # type: ignore
+        run_id=from_run_response.run_id,
+        session_summary=session_summary,
+    )
+
+
 def create_reasoning_started_event(from_run_response: RunOutput) -> ReasoningStartedEvent:
     return ReasoningStartedEvent(
         session_id=from_run_response.session_id,
@@ -468,6 +579,28 @@ def create_team_run_output_content_event(
     )
 
 
+def create_run_content_completed_event(
+    from_run_response: RunOutput,
+) -> RunContentCompletedEvent:
+    return RunContentCompletedEvent(
+        session_id=from_run_response.session_id,
+        agent_id=from_run_response.agent_id,  # type: ignore
+        agent_name=from_run_response.agent_name,  # type: ignore
+        run_id=from_run_response.run_id,
+    )
+
+
+def create_team_run_content_completed_event(
+    from_run_response: TeamRunOutput,
+) -> TeamRunContentCompletedEvent:
+    return TeamRunContentCompletedEvent(
+        session_id=from_run_response.session_id,
+        team_id=from_run_response.team_id,  # type: ignore
+        team_name=from_run_response.team_name,  # type: ignore
+        run_id=from_run_response.run_id,
+    )
+
+
 def create_parser_model_response_started_event(
     from_run_response: RunOutput,
 ) -> ParserModelResponseStartedEvent:
@@ -550,3 +683,18 @@ def create_team_output_model_response_completed_event(
         team_name=from_run_response.team_name,  # type: ignore
         run_id=from_run_response.run_id,
     )
+
+
+def handle_event(
+    event: Union[RunOutputEvent, TeamRunOutputEvent],
+    run_response: Union[RunOutput, TeamRunOutput],
+    events_to_skip: Optional[List[Union[RunEvent, TeamRunEvent]]] = None,
+    store_events: bool = False,
+) -> Union[RunOutputEvent, TeamRunOutputEvent]:
+    # We only store events that are not run_response_content events
+    events_to_skip = [event.value for event in events_to_skip] if events_to_skip else []
+    if store_events and event.event not in events_to_skip:
+        if run_response.events is None:
+            run_response.events = []
+        run_response.events.append(event)  # type: ignore
+    return event

agno/utils/gemini.py

@@ -225,12 +225,13 @@ def convert_schema(
     if schema_type is None or schema_type == "null":
         return None
     description = schema_dict.get("description", None)
+    title = schema_dict.get("title", None)
     default = schema_dict.get("default", None)
 
     # Handle enum types
     if "enum" in schema_dict:
         enum_values = schema_dict["enum"]
-        return Schema(type=GeminiType.STRING, enum=enum_values, description=description, default=default)
+        return Schema(type=GeminiType.STRING, enum=enum_values, description=description, default=default, title=title)
 
     if schema_type == "object":
         # Handle regular objects with properties
@@ -250,6 +251,10 @@ def convert_schema(
                     if is_nullable:
                         converted_schema.nullable = True
                     properties[key] = converted_schema
+                else:
+                    properties[key] = Schema(
+                        title=prop_def.get("title", None), description=prop_def.get("description", None)
+                    )
 
             required = schema_dict.get("required", [])
 
@@ -260,9 +265,10 @@ def convert_schema(
                     required=required,
                     description=description,
                     default=default,
+                    title=title,
                 )
             else:
-                return Schema(type=GeminiType.OBJECT, description=description, default=default)
+                return Schema(type=GeminiType.OBJECT, description=description, default=default, title=title)
 
         # Handle Dict types (objects with additionalProperties but no properties)
         elif "additionalProperties" in schema_dict:
@@ -305,11 +311,11 @@ def convert_schema(
                 )
             else:
                 # additionalProperties is false or true
-                return Schema(type=GeminiType.OBJECT, description=description, default=default)
+                return Schema(type=GeminiType.OBJECT, description=description, default=default, title=title)
 
         # Handle empty objects
         else:
-            return Schema(type=GeminiType.OBJECT, description=description, default=default)
+            return Schema(type=GeminiType.OBJECT, description=description, default=default, title=title)
 
     elif schema_type == "array" and "items" in schema_dict:
         if not schema_dict["items"]:  # Handle empty {}
@@ -325,6 +331,7 @@ def convert_schema(
             items=items,
             min_items=min_items,
             max_items=max_items,
+            title=title,
         )
 
     elif schema_type == "string":
@@ -332,6 +339,7 @@ def convert_schema(
             "type": GeminiType.STRING,
             "description": description,
             "default": default,
+            "title": title,
         }
         if "format" in schema_dict:
             schema_kwargs["format"] = schema_dict["format"]
@@ -342,6 +350,7 @@ def convert_schema(
             "type": schema_type.upper(),
             "description": description,
             "default": default,
+            "title": title,
         }
         if "maximum" in schema_dict:
             schema_kwargs["maximum"] = schema_dict["maximum"]
@@ -373,6 +382,7 @@ def convert_schema(
                 any_of=any_of,
                 description=description,
                 default=default,
+                title=title,
             )
     else:
         if isinstance(schema_type, list):
@@ -384,7 +394,7 @@ def convert_schema(
         # Only convert to uppercase if schema_type is not empty
         if schema_type:
             schema_type = schema_type.upper()
-            return Schema(type=schema_type, description=description, default=default)
+            return Schema(type=schema_type, description=description, default=default, title=title)
         else:
             # If we get here with an empty type and no other handlers matched,
             # something is wrong with the schema

agno/utils/hooks.py

@@ -1,14 +1,73 @@
-from typing import Any, Callable, Dict, List, Optional, Union
+from copy import deepcopy
+from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional, Union
+
+if TYPE_CHECKING:
+    from agno.eval.base import BaseEval
 
 from agno.guardrails.base import BaseGuardrail
+from agno.hooks.decorator import HOOK_RUN_IN_BACKGROUND_ATTR
 from agno.utils.log import log_warning
 
+# Keys that should be deep copied for background hooks to prevent race conditions
+BACKGROUND_HOOK_COPY_KEYS = frozenset(
+    {"run_input", "run_context", "run_output", "session_state", "dependencies", "metadata"}
+)
+
+
+def copy_args_for_background(args: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Create a copy of hook arguments for background execution.
+
+    This deep copies run_input, run_context, run_output, session_state, dependencies,
+    and metadata to prevent race conditions when hooks run in the background.
+
+    Args:
+        args: The original arguments dictionary
+
+    Returns:
+        A new dictionary with copied values for sensitive keys
+    """
+    copied_args = {}
+    for key, value in args.items():
+        if key in BACKGROUND_HOOK_COPY_KEYS and value is not None:
+            try:
+                copied_args[key] = deepcopy(value)
+            except Exception:
+                # If deepcopy fails (e.g., for non-copyable objects), use the original
+                log_warning(f"Could not deepcopy {key} for background hook, using original reference")
+                copied_args[key] = value
+        else:
+            copied_args[key] = value
+    return copied_args
+
+
+def should_run_hook_in_background(hook: Callable[..., Any]) -> bool:
+    """
+    Check if a hook function should run in background.
+
+    This checks for the _agno_run_in_background attribute set by the @hook decorator.
+
+    Args:
+        hook: The hook function to check
+
+    Returns:
+        True if the hook is decorated with @hook(run_in_background=True)
+    """
+    return getattr(hook, HOOK_RUN_IN_BACKGROUND_ATTR, False)
+
 
-def normalize_hooks(
-    hooks: Optional[Union[List[Callable[..., Any]], List[BaseGuardrail]]],
+def normalize_pre_hooks(
+    hooks: Optional[List[Union[Callable[..., Any], BaseGuardrail, "BaseEval"]]],
     async_mode: bool = False,
 ) -> Optional[List[Callable[..., Any]]]:
-    """Normalize hooks to a list format"""
+    """Normalize pre-hooks to a list format.
+
+    Args:
+        hooks: List of hook functions, guardrails, or eval instances
+        async_mode: Whether to use async versions of methods
+    """
+    from agno.eval.base import BaseEval
+
     result_hooks: List[Callable[..., Any]] = []
 
     if hooks is not None:
@@ -18,6 +77,61 @@ def normalize_hooks(
                     result_hooks.append(hook.async_check)
                 else:
                     result_hooks.append(hook.check)
+            elif isinstance(hook, BaseEval):
+                # Extract pre_check method
+                method = hook.async_pre_check if async_mode else hook.pre_check
+
+                from functools import partial
+
+                wrapped = partial(method)
+                wrapped.__name__ = method.__name__  # type: ignore
+                setattr(wrapped, HOOK_RUN_IN_BACKGROUND_ATTR, getattr(hook, "run_in_background", False))
+                result_hooks.append(wrapped)
+            else:
+                # Check if the hook is async and used within sync methods
+                if not async_mode:
+                    import asyncio
+
+                    if asyncio.iscoroutinefunction(hook):
+                        raise ValueError(
+                            f"Cannot use {hook.__name__} (an async hook) with `run()`. Use `arun()` instead."
+                        )
+
+                result_hooks.append(hook)
+    return result_hooks if result_hooks else None
+
+
+def normalize_post_hooks(
+    hooks: Optional[List[Union[Callable[..., Any], BaseGuardrail, "BaseEval"]]],
+    async_mode: bool = False,
+) -> Optional[List[Callable[..., Any]]]:
+    """Normalize post-hooks to a list format.
+
+    Args:
+        hooks: List of hook functions, guardrails, or eval instances
+        async_mode: Whether to use async versions of methods
+    """
+    from agno.eval.base import BaseEval
+
+    result_hooks: List[Callable[..., Any]] = []
+
+    if hooks is not None:
+        for hook in hooks:
+            if isinstance(hook, BaseGuardrail):
+                if async_mode:
+                    result_hooks.append(hook.async_check)
+                else:
+                    result_hooks.append(hook.check)
+            elif isinstance(hook, BaseEval):
+                # Extract post_check method
+                method = hook.async_post_check if async_mode else hook.post_check  # type: ignore[assignment]
+
+                from functools import partial
+
+                wrapped = partial(method)
+                wrapped.__name__ = method.__name__  # type: ignore
+                setattr(wrapped, HOOK_RUN_IN_BACKGROUND_ATTR, getattr(hook, "run_in_background", False))
+                result_hooks.append(wrapped)
             else:
                 # Check if the hook is async and used within sync methods
                 if not async_mode:

agno/utils/http.py

@@ -10,6 +10,117 @@ 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
+
+
+def get_default_sync_client() -> httpx.Client:
+    """Get or create the global synchronous httpx client.
+
+    Returns:
+        A singleton httpx.Client instance with default limits.
+    """
+    global _global_sync_client
+    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=True, follow_redirects=True
+        )
+    return _global_sync_client
+
+
+def get_default_async_client() -> httpx.AsyncClient:
+    """Get or create the global asynchronous httpx client.
+
+    Returns:
+        A singleton httpx.AsyncClient instance with default limits.
+    """
+    global _global_async_client
+    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, follow_redirects=True
+        )
+    return _global_async_client
+
+
+def close_sync_client() -> None:
+    """Closes the global sync httpx client.
+
+    Should be called during application shutdown.
+    """
+    global _global_sync_client
+    if _global_sync_client is not None and not _global_sync_client.is_closed:
+        _global_sync_client.close()
+
+
+async def aclose_default_clients() -> None:
+    """Asynchronously close the global httpx clients.
+
+    Should be called during application shutdown in async contexts.
+    """
+    global _global_sync_client, _global_async_client
+    if _global_sync_client is not None and not _global_sync_client.is_closed:
+        _global_sync_client.close()
+    if _global_async_client is not None and not _global_async_client.is_closed:
+        await _global_async_client.aclose()
+
+
+def set_default_sync_client(client: httpx.Client) -> None:
+    """Set the global synchronous httpx client.
+
+    IMPORTANT: Call before creating any model instances. Models cache clients on first use.
+
+    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.
+
+    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),
+        ...     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
+    _global_sync_client = client
+
+
+def set_default_async_client(client: httpx.AsyncClient) -> None:
+    """Set the global asynchronous httpx client.
+
+    IMPORTANT: Call before creating any model instances. Models cache clients on first use.
+
+    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
+    _global_async_client = client
+
 
 def fetch_with_retry(
     url: str,
@@ -29,7 +140,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 +176,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}")