agno 2.3.24__py3-none-any.whl → 2.3.25__py3-none-any.whl

agno/learn/utils.py

@@ -0,0 +1,209 @@
+"""
+Learning Machine Utilities
+==========================
+Helper functions for safe data handling.
+
+All functions are designed to never raise exceptions -
+they return None on any failure. This prevents learning
+extraction errors from crashing the main agent.
+"""
+
+from dataclasses import asdict, fields
+from typing import Any, Dict, List, Optional, Type, TypeVar
+
+T = TypeVar("T")
+
+
+def _safe_get(data: Any, key: str, default: Any = None) -> Any:
+    """Safely get a key from dict-like data.
+
+    Args:
+        data: Dict or object with attributes.
+        key: Key or attribute name to get.
+        default: Value to return if not found.
+
+    Returns:
+        The value, or default if not found.
+    """
+    if isinstance(data, dict):
+        return data.get(key, default)
+    return getattr(data, key, default)
+
+
+def _parse_json(data: Any) -> Optional[Dict]:
+    """Parse JSON string to dict, or return dict as-is.
+
+    Args:
+        data: JSON string, dict, or None.
+
+    Returns:
+        Parsed dict, or None if parsing fails.
+    """
+    if data is None:
+        return None
+    if isinstance(data, dict):
+        return data
+    if isinstance(data, str):
+        import json
+
+        try:
+            return json.loads(data)
+        except Exception:
+            return None
+    return None
+
+
+def from_dict_safe(cls: Type[T], data: Any) -> Optional[T]:
+    """Safely create a dataclass instance from dict-like data.
+
+    Works with any dataclass - automatically handles subclass fields.
+    Never raises - returns None on any failure.
+
+    Args:
+        cls: The dataclass type to instantiate.
+        data: Dict, JSON string, or existing instance.
+
+    Returns:
+        Instance of cls, or None if parsing fails.
+
+    Example:
+        >>> profile = from_dict_safe(UserProfile, {"user_id": "123"})
+        >>> profile.user_id
+        '123'
+    """
+    if data is None:
+        return None
+
+    # Already the right type
+    if isinstance(data, cls):
+        return data
+
+    try:
+        # Parse JSON string if needed
+        parsed = _parse_json(data)
+        if parsed is None:
+            return None
+
+        # Get valid field names for this class
+        field_names = {f.name for f in fields(cls)}  # type: ignore
+
+        # Filter to only valid fields
+        kwargs = {k: v for k, v in parsed.items() if k in field_names}
+
+        return cls(**kwargs)
+    except Exception:
+        return None
+
+
+def print_panel(
+    title: str,
+    subtitle: str,
+    lines: List[str],
+    *,
+    empty_message: str = "No data",
+    raw_data: Any = None,
+    raw: bool = False,
+) -> None:
+    """Print formatted panel output for learning stores.
+
+    Uses rich library for formatted output with a bordered panel.
+    Falls back to pprint when raw=True or rich is unavailable.
+
+    Args:
+        title: Panel title (e.g., "User Profile", "Session Context")
+        subtitle: Panel subtitle (e.g., user_id, session_id)
+        lines: Content lines to display inside the panel
+        empty_message: Message shown when lines is empty
+        raw_data: Object to pprint when raw=True
+        raw: If True, use pprint instead of formatted panel
+
+    Example:
+        >>> print_panel(
+        ...     title="User Profile",
+        ...     subtitle="alice@example.com",
+        ...     lines=["Name: Alice", "Memories:", "  [abc123] Loves Python"],
+        ...     raw_data=profile,
+        ... )
+        ╭──────────────── User Profile ─────────────────╮
+        │ Name: Alice                                   │
+        │ Memories:                                     │
+        │   [abc123] Loves Python                       │
+        ╰─────────────── alice@example.com ─────────────╯
+    """
+    if raw and raw_data is not None:
+        from pprint import pprint
+
+        pprint(to_dict_safe(raw_data) or raw_data)
+        return
+
+    try:
+        from rich.console import Console
+        from rich.panel import Panel
+
+        console = Console()
+
+        if not lines:
+            content = f"[dim]{empty_message}[/dim]"
+        else:
+            content = "\n".join(lines)
+
+        panel = Panel(
+            content,
+            title=f"[bold]{title}[/bold]",
+            subtitle=f"[dim]{subtitle}[/dim]",
+            border_style="blue",
+        )
+        console.print(panel)
+
+    except ImportError:
+        # Fallback if rich not installed
+        from pprint import pprint
+
+        print(f"=== {title} ({subtitle}) ===")
+        if not lines:
+            print(f"  {empty_message}")
+        else:
+            for line in lines:
+                print(f"  {line}")
+        print()
+
+
+def to_dict_safe(obj: Any) -> Optional[Dict[str, Any]]:
+    """Safely convert a dataclass to dict.
+
+    Works with any dataclass. Never raises - returns None on failure.
+
+    Args:
+        obj: Dataclass instance to convert.
+
+    Returns:
+        Dict representation, or None if conversion fails.
+
+    Example:
+        >>> profile = UserProfile(user_id="123")
+        >>> to_dict_safe(profile)
+        {'user_id': '123', 'name': None, ...}
+    """
+    if obj is None:
+        return None
+
+    try:
+        # Already a dict
+        if isinstance(obj, dict):
+            return obj
+
+        # Has to_dict method
+        if hasattr(obj, "to_dict"):
+            return obj.to_dict()
+
+        # Is a dataclass
+        if hasattr(obj, "__dataclass_fields__"):
+            return asdict(obj)
+
+        # Has __dict__
+        if hasattr(obj, "__dict__"):
+            return dict(obj.__dict__)
+
+        return None
+    except Exception:
+        return None

agno/models/base.py

@@ -174,6 +174,49 @@ class Model(ABC):
             return self.delay_between_retries * (2**attempt)
         return self.delay_between_retries
 
+    def _is_retryable_error(self, error: ModelProviderError) -> bool:
+        """Determine if an error is worth retrying.
+
+        Non-retryable errors include:
+        - Client errors (400, 401, 403, 413, 422) that won't change on retry
+        - Context window/token limit exceeded errors
+        - Payload too large errors
+
+        Retryable errors include:
+        - Rate limit errors (429)
+        - Server errors (500, 502, 503, 504)
+
+        Args:
+            error: The ModelProviderError to evaluate.
+
+        Returns:
+            True if the error is transient and worth retrying, False otherwise.
+        """
+        # Non-retryable status codes (client errors that won't change)
+        non_retryable_codes = {400, 401, 403, 404, 413, 422}
+        if error.status_code in non_retryable_codes:
+            return False
+
+        # Non-retryable error message patterns (context/token limits)
+        non_retryable_patterns = [
+            "context_length_exceeded",
+            "context window",
+            "maximum context length",
+            "token limit",
+            "max_tokens",
+            "too many tokens",
+            "payload too large",
+            "content_too_large",
+            "request too large",
+            "input too long",
+            "exceeds the model",
+        ]
+        error_msg = str(error.message).lower()
+        if any(pattern in error_msg for pattern in non_retryable_patterns):
+            return False
+
+        return True
+
     def _invoke_with_retry(self, **kwargs) -> ModelResponse:
         """
         Invoke the model with retry logic for ModelProviderError.
@@ -189,6 +232,10 @@ class Model(ABC):
                 return self.invoke(**kwargs)
             except ModelProviderError as e:
                 last_exception = e
+                # Check if error is non-retryable
+                if not self._is_retryable_error(e):
+                    log_error(f"Non-retryable model provider error: {e}")
+                    raise
                 if attempt < self.retries:
                     delay = self._get_retry_delay(attempt)
                     log_warning(
@@ -232,6 +279,10 @@ class Model(ABC):
                 return await self.ainvoke(**kwargs)
             except ModelProviderError as e:
                 last_exception = e
+                # Check if error is non-retryable
+                if not self._is_retryable_error(e):
+                    log_error(f"Non-retryable model provider error: {e}")
+                    raise
                 if attempt < self.retries:
                     delay = self._get_retry_delay(attempt)
                     log_warning(
@@ -277,6 +328,10 @@ class Model(ABC):
                 return  # Success, exit the retry loop
             except ModelProviderError as e:
                 last_exception = e
+                # Check if error is non-retryable (e.g., context window exceeded, auth errors)
+                if not self._is_retryable_error(e):
+                    log_error(f"Non-retryable model provider error: {e}")
+                    raise
                 if attempt < self.retries:
                     delay = self._get_retry_delay(attempt)
                     log_warning(
@@ -325,6 +380,10 @@ class Model(ABC):
                 return  # Success, exit the retry loop
             except ModelProviderError as e:
                 last_exception = e
+                # Check if error is non-retryable
+                if not self._is_retryable_error(e):
+                    log_error(f"Non-retryable model provider error: {e}")
+                    raise
                 if attempt < self.retries:
                     delay = self._get_retry_delay(attempt)
                     log_warning(

agno/os/routers/knowledge/knowledge.py

@@ -860,6 +860,7 @@ def attach_routes(router: APIRouter, knowledge_instances: List[Union[Knowledge,
                                     "name": "TextReader",
                                     "description": "Reads text files",
                                     "chunkers": [
+                                        "CodeChunker",
                                         "FixedSizeChunker",
                                         "AgenticChunker",
                                         "DocumentChunker",
@@ -898,6 +899,12 @@ def attach_routes(router: APIRouter, knowledge_instances: List[Union[Knowledge,
                                     "description": "Chunking strategy that uses an LLM to determine natural breakpoints in the text",
                                     "metadata": {"chunk_size": 5000},
                                 },
+                                "CodeChunker": {
+                                    "key": "CodeChunker",
+                                    "name": "CodeChunker",
+                                    "description": "The CodeChunker splits code into chunks based on its structure, leveraging Abstract Syntax Trees (ASTs) to create contextually relevant segments",
+                                    "metadata": {"chunk_size": 2048},
+                                },
                                 "DocumentChunker": {
                                     "key": "DocumentChunker",
                                     "name": "DocumentChunker",

agno/tools/browserbase.py

@@ -1,4 +1,5 @@
 import json
+import re
 from os import getenv
 from typing import Any, Dict, List, Optional
 
@@ -22,6 +23,8 @@ class BrowserbaseTools(Toolkit):
         enable_get_page_content: bool = True,
         enable_close_session: bool = True,
         all: bool = False,
+        parse_html: bool = True,
+        max_content_length: Optional[int] = 100000,
         **kwargs,
     ):
         """Initialize BrowserbaseTools.
@@ -36,7 +39,14 @@ class BrowserbaseTools(Toolkit):
             enable_get_page_content (bool): Enable the get_page_content tool. Defaults to True.
             enable_close_session (bool): Enable the close_session tool. Defaults to True.
             all (bool): Enable all tools. Defaults to False.
+            parse_html (bool): If True, extract only visible text content instead of raw HTML. Defaults to True.
+                This significantly reduces token usage and is recommended for most use cases.
+            max_content_length (int, optional): Maximum character length for page content. Defaults to 100000.
+                Content exceeding this limit will be truncated with a notice. Set to None for no limit.
         """
+        self.parse_html = parse_html
+        self.max_content_length = max_content_length
+
         self.api_key = api_key or getenv("BROWSERBASE_API_KEY")
         if not self.api_key:
             raise ValueError(
@@ -191,18 +201,70 @@ class BrowserbaseTools(Toolkit):
             self._cleanup()
             raise e
 
+    def _extract_text_content(self, html: str) -> str:
+        """Extract visible text content from HTML, removing scripts, styles, and tags.
+
+        Args:
+            html: Raw HTML content
+
+        Returns:
+            Cleaned text content
+        """
+        # Remove script and style elements
+        html = re.sub(r"<script[^>]*>.*?</script>", "", html, flags=re.DOTALL | re.IGNORECASE)
+        html = re.sub(r"<style[^>]*>.*?</style>", "", html, flags=re.DOTALL | re.IGNORECASE)
+        # Remove HTML comments
+        html = re.sub(r"<!--.*?-->", "", html, flags=re.DOTALL)
+        # Remove all HTML tags
+        html = re.sub(r"<[^>]+>", " ", html)
+        # Decode common HTML entities
+        html = html.replace("&nbsp;", " ")
+        html = html.replace("&amp;", "&")
+        html = html.replace("&lt;", "<")
+        html = html.replace("&gt;", ">")
+        html = html.replace("&quot;", '"')
+        html = html.replace("&#39;", "'")
+        # Normalize whitespace
+        html = re.sub(r"\s+", " ", html)
+        return html.strip()
+
+    def _truncate_content(self, content: str) -> str:
+        """Truncate content if it exceeds max_content_length.
+
+        Args:
+            content: The content to potentially truncate
+
+        Returns:
+            Original or truncated content with notice
+        """
+        if self.max_content_length is None or len(content) <= self.max_content_length:
+            return content
+
+        truncated = content[: self.max_content_length]
+        return f"{truncated}\n\n[Content truncated. Original length: {len(content)} characters. Showing first {self.max_content_length} characters.]"
+
     def get_page_content(self, connect_url: Optional[str] = None) -> str:
-        """Gets the HTML content of the current page.
+        """Gets the content of the current page.
 
         Args:
             connect_url (str, optional): The connection URL from an existing session
 
         Returns:
-            The page HTML content
+            The page content (text-only if parse_html=True, otherwise raw HTML)
         """
         try:
             self._initialize_browser(connect_url)
-            return self._page.content() if self._page else ""
+            if not self._page:
+                return ""
+
+            raw_content = self._page.content()
+
+            if self.parse_html:
+                content = self._extract_text_content(raw_content)
+            else:
+                content = raw_content
+
+            return self._truncate_content(content)
         except Exception as e:
             self._cleanup()
             raise e
@@ -307,17 +369,27 @@ class BrowserbaseTools(Toolkit):
             raise e
 
     async def aget_page_content(self, connect_url: Optional[str] = None) -> str:
-        """Gets the HTML content of the current page asynchronously.
+        """Gets the content of the current page asynchronously.
 
         Args:
             connect_url (str, optional): The connection URL from an existing session
 
         Returns:
-            The page HTML content
+            The page content (text-only if parse_html=True, otherwise raw HTML)
         """
         try:
             await self._ainitialize_browser(connect_url)
-            return await self._async_page.content() if self._async_page else ""
+            if not self._async_page:
+                return ""
+
+            raw_content = await self._async_page.content()
+
+            if self.parse_html:
+                content = self._extract_text_content(raw_content)
+            else:
+                content = raw_content
+
+            return self._truncate_content(content)
         except Exception as e:
             await self._acleanup()
             raise e

agno/tools/google_bigquery.py

@@ -11,6 +11,15 @@ except ImportError:
     raise ImportError("`bigquery` not installed. Please install using `pip install google-cloud-bigquery`")
 
 
+def _clean_sql(sql: str) -> str:
+    """Clean SQL query by normalizing whitespace while preserving token boundaries.
+
+    Replaces newlines with spaces (not empty strings) to prevent line comments
+    from swallowing subsequent SQL statements.
+    """
+    return sql.replace("\\n", " ").replace("\n", " ")
+
+
 class GoogleBigQueryTools(Toolkit):
     def __init__(
         self,
@@ -106,12 +115,12 @@ class GoogleBigQueryTools(Toolkit):
         """
         try:
             log_debug(f"Running Google SQL |\n{sql}")
-            cleaned_query = sql.replace("\\n", " ").replace("\n", "").replace("\\", "")
+            cleaned_query = _clean_sql(sql)
             job_config = bigquery.QueryJobConfig(default_dataset=f"{self.project}.{self.dataset}")
             query_job = self.client.query(cleaned_query, job_config)
             results = query_job.result()
             results_str = str([dict(row) for row in results])
-            return results_str.replace("\\", "").replace("\n", "")
+            return results_str.replace("\n", " ")
         except Exception as e:
             logger.error(f"Error while executing SQL: {e}")
             return ""

agno/utils/agent.py

@@ -30,6 +30,7 @@ if TYPE_CHECKING:
 async def await_for_open_threads(
     memory_task: Optional[Task] = None,
     cultural_knowledge_task: Optional[Task] = None,
+    learning_task: Optional[Task] = None,
 ) -> None:
     if memory_task is not None:
         try:
@@ -43,9 +44,17 @@ async def await_for_open_threads(
         except Exception as e:
             log_warning(f"Error in cultural knowledge creation: {str(e)}")
 
+    if learning_task is not None:
+        try:
+            await learning_task
+        except Exception as e:
+            log_warning(f"Error in learning extraction: {str(e)}")
+
 
 def wait_for_open_threads(
-    memory_future: Optional[Future] = None, cultural_knowledge_future: Optional[Future] = None
+    memory_future: Optional[Future] = None,
+    cultural_knowledge_future: Optional[Future] = None,
+    learning_future: Optional[Future] = None,
 ) -> None:
     if memory_future is not None:
         try:
@@ -60,11 +69,18 @@ def wait_for_open_threads(
         except Exception as e:
             log_warning(f"Error in cultural knowledge creation: {str(e)}")
 
+    if learning_future is not None:
+        try:
+            learning_future.result()
+        except Exception as e:
+            log_warning(f"Error in learning extraction: {str(e)}")
+
 
 async def await_for_thread_tasks_stream(
     run_response: Union[RunOutput, TeamRunOutput],
     memory_task: Optional[Task] = None,
     cultural_knowledge_task: Optional[Task] = None,
+    learning_task: Optional[Task] = None,
     stream_events: bool = False,
     events_to_skip: Optional[List[RunEvent]] = None,
     store_events: bool = False,
@@ -111,11 +127,18 @@ async def await_for_thread_tasks_stream(
         except Exception as e:
             log_warning(f"Error in cultural knowledge creation: {str(e)}")
 
+    if learning_task is not None:
+        try:
+            await learning_task
+        except Exception as e:
+            log_warning(f"Error in learning extraction: {str(e)}")
+
 
 def wait_for_thread_tasks_stream(
     run_response: Union[TeamRunOutput, RunOutput],
     memory_future: Optional[Future] = None,
     cultural_knowledge_future: Optional[Future] = None,
+    learning_future: Optional[Future] = None,
     stream_events: bool = False,
     events_to_skip: Optional[List[RunEvent]] = None,
     store_events: bool = False,
@@ -164,6 +187,12 @@ def wait_for_thread_tasks_stream(
         except Exception as e:
             log_warning(f"Error in cultural knowledge creation: {str(e)}")
 
+    if learning_future is not None:
+        try:
+            learning_future.result()
+        except Exception as e:
+            log_warning(f"Error in learning extraction: {str(e)}")
+
 
 def collect_joint_images(
     run_input: Optional[RunInput] = None,

{agno-2.3.24.dist-info → agno-2.3.25.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agno
-Version: 2.3.24
+Version: 2.3.25
 Summary: Agno: a lightweight library for building Multi-Agent Systems
 Author-email: Ashpreet Bedi <ashpreet@agno.com>
 Project-URL: homepage, https://agno.com
@@ -264,7 +264,8 @@ Requires-Dist: unstructured; extra == "markdown"
 Requires-Dist: markdown; extra == "markdown"
 Requires-Dist: aiofiles; extra == "markdown"
 Provides-Extra: chonkie
-Requires-Dist: chonkie[st]; extra == "chonkie"
+Requires-Dist: chonkie[semantic]; extra == "chonkie"
+Requires-Dist: chonkie[code]; extra == "chonkie"
 Requires-Dist: chonkie; extra == "chonkie"
 Provides-Extra: agui
 Requires-Dist: ag-ui-protocol; extra == "agui"
@@ -400,6 +401,27 @@ Requires-Dist: yfinance; extra == "integration-tests"
 Requires-Dist: sqlalchemy; extra == "integration-tests"
 Requires-Dist: Pillow; extra == "integration-tests"
 Requires-Dist: fastmcp; extra == "integration-tests"
+Provides-Extra: demo
+Requires-Dist: anthropic; extra == "demo"
+Requires-Dist: chromadb; extra == "demo"
+Requires-Dist: ddgs; extra == "demo"
+Requires-Dist: fastapi[standard]; extra == "demo"
+Requires-Dist: google-genai; extra == "demo"
+Requires-Dist: mcp; extra == "demo"
+Requires-Dist: nest_asyncio; extra == "demo"
+Requires-Dist: openai; extra == "demo"
+Requires-Dist: openinference-instrumentation-agno; extra == "demo"
+Requires-Dist: opentelemetry-api; extra == "demo"
+Requires-Dist: opentelemetry-sdk; extra == "demo"
+Requires-Dist: pandas; extra == "demo"
+Requires-Dist: parallel-web; extra == "demo"
+Requires-Dist: pgvector; extra == "demo"
+Requires-Dist: pillow; extra == "demo"
+Requires-Dist: psycopg[binary]; extra == "demo"
+Requires-Dist: pypdf; extra == "demo"
+Requires-Dist: sqlalchemy; extra == "demo"
+Requires-Dist: yfinance; extra == "demo"
+Requires-Dist: youtube-transcript-api; extra == "demo"
 Dynamic: license-file
 
 <div align="center" id="top">