agno 2.2.13__py3-none-any.whl

agno/utils/http.py

@@ -0,0 +1,74 @@
+import asyncio
+import logging
+from time import sleep
+from typing import Optional
+
+import httpx
+
+logger = logging.getLogger(__name__)
+
+DEFAULT_MAX_RETRIES = 3
+DEFAULT_BACKOFF_FACTOR = 2  # Exponential backoff: 1, 2, 4, 8...
+
+
+def fetch_with_retry(
+    url: str,
+    max_retries: int = DEFAULT_MAX_RETRIES,
+    backoff_factor: int = DEFAULT_BACKOFF_FACTOR,
+    proxy: Optional[str] = None,
+) -> httpx.Response:
+    """Synchronous HTTP GET with retry logic."""
+
+    for attempt in range(max_retries):
+        try:
+            response = httpx.get(url, proxy=proxy) if proxy else httpx.get(url)
+            response.raise_for_status()
+            return response
+        except httpx.RequestError as e:
+            if attempt == max_retries - 1:
+                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...")
+            sleep(wait_time)
+        except httpx.HTTPStatusError as e:
+            logger.error(f"HTTP error for {url}: {e.response.status_code} - {e.response.text}")
+            raise
+
+    raise httpx.RequestError(f"Failed to fetch {url} after {max_retries} attempts")
+
+
+async def async_fetch_with_retry(
+    url: str,
+    client: Optional[httpx.AsyncClient] = None,
+    max_retries: int = DEFAULT_MAX_RETRIES,
+    backoff_factor: int = DEFAULT_BACKOFF_FACTOR,
+    proxy: Optional[str] = None,
+) -> httpx.Response:
+    """Asynchronous HTTP GET with retry logic."""
+
+    async def _fetch():
+        if client is None:
+            client_args = {"proxy": proxy} if proxy else {}
+            async with httpx.AsyncClient(**client_args) as local_client:  # type: ignore
+                return await local_client.get(url)
+        else:
+            return await client.get(url)
+
+    for attempt in range(max_retries):
+        try:
+            response = await _fetch()
+            response.raise_for_status()
+            return response
+        except httpx.RequestError as e:
+            if attempt == max_retries - 1:
+                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...")
+            await asyncio.sleep(wait_time)
+        except httpx.HTTPStatusError as e:
+            logger.error(f"HTTP error for {url}: {e.response.status_code} - {e.response.text}")
+            raise
+
+    raise httpx.RequestError(f"Failed to fetch {url} after {max_retries} attempts")

agno/utils/json_schema.py

@@ -0,0 +1,234 @@
+from enum import Enum
+from typing import Any, Dict, Optional, Union, get_args, get_origin
+
+from pydantic import BaseModel
+
+from agno.utils.log import logger
+
+
+def is_origin_union_type(origin: Any) -> bool:
+    import sys
+
+    if sys.version_info.minor >= 10:
+        from types import UnionType  # type: ignore
+
+        return origin in [Union, UnionType]
+
+    return origin is Union
+
+
+def get_json_type_for_py_type(arg: str) -> str:
+    """
+    Get the JSON schema type for a given type.
+    :param arg: The type to get the JSON schema type for.
+    :return: The JSON schema type.
+    """
+    # log_info(f"Getting JSON type for: {arg}")
+    if arg in ("int", "float", "complex", "Decimal"):
+        return "number"
+    elif arg in ("str", "string"):
+        return "string"
+    elif arg in ("bool", "boolean"):
+        return "boolean"
+    elif arg in ("NoneType", "None"):
+        return "null"
+    elif arg in ("list", "tuple", "set", "frozenset"):
+        return "array"
+    elif arg in ("dict", "mapping"):
+        return "object"
+
+    # If the type is not recognized, return "object"
+    return "object"
+
+
+def inline_pydantic_schema(schema: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Recursively inline Pydantic model schemas by replacing $ref with actual schema.
+    """
+    if not isinstance(schema, dict):
+        return schema
+
+    def resolve_ref(ref: str, defs: Dict[str, Any]) -> Dict[str, Any]:
+        """Resolve a $ref to its actual schema."""
+        if not ref.startswith("#/$defs/"):
+            return {"type": "object"}  # Fallback for external refs
+
+        def_name = ref.split("/")[-1]
+        if def_name in defs:
+            return defs[def_name]
+        return {"type": "object"}  # Fallback if definition not found
+
+    def process_schema(s: Dict[str, Any], defs: Dict[str, Any]) -> Dict[str, Any]:
+        """Process a schema dictionary, resolving all references."""
+        if not isinstance(s, dict):
+            return s
+
+        # Handle $ref
+        if "$ref" in s:
+            return resolve_ref(s["$ref"], defs)
+
+        # Create a new dict to avoid modifying the input
+        result = s.copy()
+
+        # Handle arrays
+        if "items" in result:
+            result["items"] = process_schema(result["items"], defs)
+
+        # Handle object properties
+        if "properties" in result:
+            for prop_name, prop_schema in result["properties"].items():
+                result["properties"][prop_name] = process_schema(prop_schema, defs)
+
+        # Handle anyOf (for Union types)
+        if "anyOf" in result:
+            result["anyOf"] = [process_schema(sub_schema, defs) for sub_schema in result["anyOf"]]
+
+        # Handle allOf (for inheritance)
+        if "allOf" in result:
+            result["allOf"] = [process_schema(sub_schema, defs) for sub_schema in result["allOf"]]
+
+        # Handle additionalProperties
+        if "additionalProperties" in result:
+            result["additionalProperties"] = process_schema(result["additionalProperties"], defs)
+
+        # Handle propertyNames
+        if "propertyNames" in result:
+            result["propertyNames"] = process_schema(result["propertyNames"], defs)
+
+        return result
+
+    # Store definitions for later use
+    definitions = schema.pop("$defs", {})
+
+    # First, resolve any nested references in definitions
+    resolved_definitions = {}
+    for def_name, def_schema in definitions.items():
+        resolved_definitions[def_name] = process_schema(def_schema, definitions)
+
+    # Process the main schema with resolved definitions
+    result = process_schema(schema, resolved_definitions)
+
+    # Remove any remaining definitions
+    if "$defs" in result:
+        del result["$defs"]
+
+    return result
+
+
+def get_json_schema_for_arg(type_hint: Any) -> Optional[Dict[str, Any]]:
+    # log_info(f"Getting JSON schema for arg: {t}")
+    type_args = get_args(type_hint)
+    # log_info(f"Type args: {type_args}")
+    type_origin = get_origin(type_hint)
+    # log_info(f"Type origin: {type_origin}")
+    if type_origin is not None:
+        if type_origin in (list, tuple, set, frozenset):
+            json_schema_for_items = get_json_schema_for_arg(type_args[0]) if type_args else {"type": "string"}
+            return {"type": "array", "items": json_schema_for_items}
+        elif type_origin is dict:
+            # Handle both key and value types for dictionaries
+            key_schema = get_json_schema_for_arg(type_args[0]) if type_args else {"type": "string"}
+            value_schema = get_json_schema_for_arg(type_args[1]) if len(type_args) > 1 else {"type": "string"}
+            return {"type": "object", "propertyNames": key_schema, "additionalProperties": value_schema}
+        elif is_origin_union_type(type_origin):
+            types = []
+            for arg in type_args:
+                try:
+                    schema = get_json_schema_for_arg(arg)
+                    if schema:
+                        types.append(schema)
+                except Exception:
+                    continue
+            return {"anyOf": types} if types else None
+
+    if isinstance(type_hint, type) and issubclass(type_hint, Enum):
+        enum_values = [member.value for member in type_hint]
+        return {"type": "string", "enum": enum_values}
+
+    if isinstance(type_hint, type) and issubclass(type_hint, BaseModel):
+        # Get the schema and inline it
+        schema = type_hint.model_json_schema()
+        return inline_pydantic_schema(schema)  # type: ignore
+
+    if hasattr(type_hint, "__dataclass_fields__"):
+        # Convert dataclass to JSON schema
+        properties = {}
+        required = []
+
+        for field_name, field in type_hint.__dataclass_fields__.items():
+            field_type = field.type
+            field_schema = get_json_schema_for_arg(field_type)
+
+            if (
+                field_schema
+                and "anyOf" in field_schema
+                and any(schema["type"] == "null" for schema in field_schema["anyOf"])
+            ):
+                field_schema["type"] = next(
+                    schema["type"] for schema in field_schema["anyOf"] if schema["type"] != "null"
+                )
+                field_schema.pop("anyOf")
+            else:
+                required.append(field_name)
+
+            if field_schema:
+                properties[field_name] = field_schema
+
+        arg_json_schema = {"type": "object", "properties": properties, "additionalProperties": False}
+
+        if required:
+            arg_json_schema["required"] = required
+        return arg_json_schema
+
+    json_schema: Dict[str, Any] = {"type": get_json_type_for_py_type(type_hint.__name__)}
+    if json_schema["type"] == "object":
+        json_schema["properties"] = {}
+        json_schema["additionalProperties"] = False
+    return json_schema
+
+
+def get_json_schema(
+    type_hints: Dict[str, Any], param_descriptions: Optional[Dict[str, str]] = None, strict: bool = False
+) -> Dict[str, Any]:
+    json_schema: Dict[str, Any] = {
+        "type": "object",
+        "properties": {},
+    }
+    if strict:
+        json_schema["additionalProperties"] = False
+
+    # We only include the fields in the type_hints dict
+    for parameter_name, type_hint in type_hints.items():
+        # log_info(f"Parsing arg: {k} | {v}")
+        if parameter_name == "return":
+            continue
+
+        try:
+            # Check if type is Optional (Union with NoneType)
+            type_origin = get_origin(type_hint)
+            type_args = get_args(type_hint)
+            is_optional = type_origin is Union and len(type_args) == 2 and any(arg is type(None) for arg in type_args)
+
+            # Get the actual type if it's Optional
+            if is_optional:
+                type_hint = next(arg for arg in type_args if arg is not type(None))
+
+            if type_hint:
+                arg_json_schema = get_json_schema_for_arg(type_hint)
+            else:
+                arg_json_schema = {}
+
+            if arg_json_schema is not None:
+                # Add description
+                if param_descriptions and parameter_name in param_descriptions and param_descriptions[parameter_name]:
+                    arg_json_schema["description"] = param_descriptions[parameter_name]
+
+                json_schema["properties"][parameter_name] = arg_json_schema
+
+            else:
+                logger.warning(f"Could not parse argument {parameter_name} of type {type_hint}")
+        except Exception as e:
+            logger.error(f"Error processing argument {parameter_name}: {str(e)}")
+            continue
+
+    return json_schema

agno/utils/knowledge.py

@@ -0,0 +1,36 @@
+from typing import Any, Dict, List, Optional, Union
+
+from agno.filters import FilterExpr
+from agno.utils.log import log_info
+
+
+def get_agentic_or_user_search_filters(
+    filters: Optional[Dict[str, Any]], effective_filters: Optional[Union[Dict[str, Any], List[FilterExpr]]]
+) -> Dict[str, Any]:
+    """Helper function to determine the final filters to use for the search.
+
+    Args:
+        filters: Filters passed by the agent.
+        effective_filters: Filters passed by user.
+
+    Returns:
+        Dict[str, Any]: The final filters to use for the search.
+    """
+    search_filters = None
+
+    # If agentic filters exist and manual filters (passed by user) do not, use agentic filters
+    if filters and not effective_filters:
+        search_filters = filters
+
+    # If both agentic filters exist and manual filters (passed by user) exist, use manual filters (give priority to user and override)
+    if filters and effective_filters:
+        if isinstance(effective_filters, dict):
+            search_filters = effective_filters
+        elif isinstance(effective_filters, list):
+            # If effective_filters is a list (likely List[FilterExpr]), convert both filters and effective_filters to a dict if possible, otherwise raise
+            raise ValueError(
+                "Merging dict and list of filters is not supported; effective_filters should be a dict for search compatibility."
+            )
+
+    log_info(f"Filters used by Agent: {search_filters}")
+    return search_filters or {}

agno/utils/location.py

@@ -0,0 +1,19 @@
+from typing import Any, Dict
+
+import requests
+
+from agno.utils.log import log_warning
+
+
+def get_location() -> Dict[str, Any]:
+    """Get approximate location using IP geolocation."""
+    try:
+        response = requests.get("https://api.ipify.org?format=json", timeout=5)
+        ip = response.json()["ip"]
+        response = requests.get(f"http://ip-api.com/json/{ip}", timeout=5)
+        if response.status_code == 200:
+            data = response.json()
+            return {"city": data.get("city"), "region": data.get("region"), "country": data.get("country")}
+    except Exception as e:
+        log_warning(f"Failed to get location: {e}")
+    return {}

agno/utils/log.py

@@ -0,0 +1,255 @@
+import logging
+from functools import lru_cache
+from os import getenv
+from typing import Any, Literal, Optional
+
+from rich.logging import RichHandler
+from rich.text import Text
+
+LOGGER_NAME = "agno"
+TEAM_LOGGER_NAME = f"{LOGGER_NAME}-team"
+WORKFLOW_LOGGER_NAME = f"{LOGGER_NAME}-workflow"
+
+# Define custom styles for different log sources
+LOG_STYLES = {
+    "agent": {
+        "debug": "green",
+        "info": "blue",
+    },
+    "team": {
+        "debug": "magenta",
+        "info": "steel_blue1",
+    },
+    "workflow": {
+        "debug": "sandy_brown",
+        "info": "orange3",
+    },
+}
+
+
+class ColoredRichHandler(RichHandler):
+    def __init__(self, *args, source_type: Optional[str] = None, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.source_type = source_type
+
+    def get_level_text(self, record: logging.LogRecord) -> Text:
+        # Return empty Text if message is empty
+        if not record.msg:
+            return Text("")
+
+        level_name = record.levelname.lower()
+        if self.source_type and self.source_type in LOG_STYLES:
+            if level_name in LOG_STYLES[self.source_type]:
+                color = LOG_STYLES[self.source_type][level_name]
+                return Text(record.levelname, style=color)
+        else:
+            if level_name in LOG_STYLES["agent"]:
+                color = LOG_STYLES["agent"][level_name]
+                return Text(record.levelname, style=color)
+        return super().get_level_text(record)
+
+
+class AgnoLogger(logging.Logger):
+    def __init__(self, name: str, level: int = logging.NOTSET):
+        super().__init__(name, level)
+
+    def debug(self, msg: str, center: bool = False, symbol: str = "*", *args, **kwargs):  # type: ignore
+        if center:
+            msg = center_header(str(msg), symbol)
+        super().debug(msg, *args, **kwargs)
+
+    def info(self, msg: str, center: bool = False, symbol: str = "*", *args, **kwargs):  # type: ignore
+        if center:
+            msg = center_header(str(msg), symbol)
+        super().info(msg, *args, **kwargs)
+
+
+def build_logger(logger_name: str, source_type: Optional[str] = None) -> Any:
+    # If a logger with the name "agno.{source_type}" is already set, we want to use that one
+    _logger = logging.getLogger(f"agno.{logger_name}")
+    if _logger.handlers or _logger.level != logging.NOTSET:
+        return _logger
+
+    # Set the custom logger class as the default for this logger
+    logging.setLoggerClass(AgnoLogger)
+
+    # Create logger with custom class
+    _logger = logging.getLogger(logger_name)
+
+    # Reset logger class to default to avoid affecting other loggers
+    logging.setLoggerClass(logging.Logger)
+
+    # https://rich.readthedocs.io/en/latest/reference/logging.html#rich.logging.RichHandler
+    # https://rich.readthedocs.io/en/latest/logging.html#handle-exceptions
+    rich_handler = ColoredRichHandler(
+        show_time=False,
+        rich_tracebacks=False,
+        show_path=True if getenv("AGNO_API_RUNTIME") == "dev" else False,
+        tracebacks_show_locals=False,
+        source_type=source_type or "agent",
+    )
+    rich_handler.setFormatter(
+        logging.Formatter(
+            fmt="%(message)s",
+            datefmt="[%X]",
+        )
+    )
+
+    _logger.addHandler(rich_handler)
+    _logger.setLevel(logging.INFO)
+    _logger.propagate = False
+    return _logger
+
+
+agent_logger: AgnoLogger = build_logger(LOGGER_NAME, source_type="agent")
+team_logger: AgnoLogger = build_logger(TEAM_LOGGER_NAME, source_type="team")
+workflow_logger: AgnoLogger = build_logger(WORKFLOW_LOGGER_NAME, source_type="workflow")
+
+# Set the default logger to the agent logger
+logger: AgnoLogger = agent_logger
+
+
+debug_on: bool = False
+debug_level: Literal[1, 2] = 1
+
+
+def set_log_level_to_debug(source_type: Optional[str] = None, level: Literal[1, 2] = 1):
+    if source_type is None:
+        use_agent_logger()
+
+    _logger = logging.getLogger(LOGGER_NAME if source_type is None else f"{LOGGER_NAME}-{source_type}")
+    _logger.setLevel(logging.DEBUG)
+
+    global debug_on
+    debug_on = True
+
+    global debug_level
+    debug_level = level
+
+
+def set_log_level_to_info(source_type: Optional[str] = None):
+    _logger = logging.getLogger(LOGGER_NAME if source_type is None else f"{LOGGER_NAME}-{source_type}")
+    _logger.setLevel(logging.INFO)
+
+    global debug_on
+    debug_on = False
+
+
+def set_log_level_to_warning(source_type: Optional[str] = None):
+    _logger = logging.getLogger(LOGGER_NAME if source_type is None else f"{LOGGER_NAME}-{source_type}")
+    _logger.setLevel(logging.WARNING)
+
+    global debug_on
+    debug_on = False
+
+
+def set_log_level_to_error(source_type: Optional[str] = None):
+    _logger = logging.getLogger(LOGGER_NAME if source_type is None else f"{LOGGER_NAME}-{source_type}")
+    _logger.setLevel(logging.ERROR)
+
+    global debug_on
+    debug_on = False
+
+
+def center_header(message: str, symbol: str = "*") -> str:
+    try:
+        import shutil
+
+        terminal_width = shutil.get_terminal_size().columns
+    except Exception:
+        terminal_width = 80  # fallback width
+
+    header = f" {message} "
+    return f"{header.center(terminal_width - 20, symbol)}"
+
+
+def use_team_logger():
+    """Switch the default logger to use team_logger"""
+    global logger
+    logger = team_logger
+
+
+def use_agent_logger():
+    """Switch the default logger to use the default agent logger"""
+    global logger
+    logger = agent_logger
+
+
+def use_workflow_logger():
+    """Switch the default logger to use workflow_logger"""
+    global 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
+    global debug_level
+
+    if debug_on:
+        if debug_level >= log_level:
+            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
+    if _using_default_logger(logger):
+        logger.info(msg, center, symbol, *args, **kwargs)
+    else:
+        logger.info(msg, *args, **kwargs)
+
+
+def log_warning(msg, *args, **kwargs):
+    global logger
+    logger.warning(msg, *args, **kwargs)
+
+
+def log_error(msg, *args, **kwargs):
+    global logger
+    logger.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