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

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/workflow/workflow.py

@@ -4481,3 +4481,201 @@ class Workflow:
                 session_id=session_id,
                 **kwargs,
             )
+
+    def deep_copy(self, *, update: Optional[Dict[str, Any]] = None) -> "Workflow":
+        """Create and return a deep copy of this Workflow, optionally updating fields.
+
+        This creates a fresh Workflow instance with isolated mutable state while sharing
+        heavy resources like database connections. Steps containing agents/teams are also
+        deep copied to ensure complete isolation.
+
+        Args:
+            update: Optional dictionary of fields to override in the new Workflow.
+
+        Returns:
+            Workflow: A new Workflow instance with copied state.
+        """
+        from copy import copy, deepcopy
+        from dataclasses import fields
+
+        from agno.utils.log import log_debug, log_warning
+
+        # Extract the fields to set for the new Workflow
+        fields_for_new_workflow: Dict[str, Any] = {}
+
+        for f in fields(self):
+            # Skip private fields (not part of __init__ signature)
+            if f.name.startswith("_"):
+                continue
+
+            field_value = getattr(self, f.name)
+            if field_value is not None:
+                # Special handling for steps that may contain agents/teams
+                if f.name == "steps" and field_value is not None:
+                    fields_for_new_workflow[f.name] = self._deep_copy_steps(field_value)
+                # Special handling for workflow agent
+                elif f.name == "agent" and field_value is not None:
+                    if hasattr(field_value, "deep_copy"):
+                        fields_for_new_workflow[f.name] = field_value.deep_copy()
+                    else:
+                        fields_for_new_workflow[f.name] = field_value
+                # Share heavy resources - these maintain connections/pools that shouldn't be duplicated
+                elif f.name == "db":
+                    fields_for_new_workflow[f.name] = field_value
+                # For compound types, attempt a deep copy
+                elif isinstance(field_value, (list, dict, set)):
+                    try:
+                        fields_for_new_workflow[f.name] = deepcopy(field_value)
+                    except Exception:
+                        try:
+                            fields_for_new_workflow[f.name] = copy(field_value)
+                        except Exception as e:
+                            log_warning(f"Failed to copy field: {f.name} - {e}")
+                            fields_for_new_workflow[f.name] = field_value
+                # For pydantic models, attempt a model_copy
+                elif isinstance(field_value, BaseModel):
+                    try:
+                        fields_for_new_workflow[f.name] = field_value.model_copy(deep=True)
+                    except Exception:
+                        try:
+                            fields_for_new_workflow[f.name] = field_value.model_copy(deep=False)
+                        except Exception:
+                            fields_for_new_workflow[f.name] = field_value
+                # For other types, attempt a shallow copy
+                else:
+                    try:
+                        fields_for_new_workflow[f.name] = copy(field_value)
+                    except Exception:
+                        fields_for_new_workflow[f.name] = field_value
+
+        # Update fields if provided
+        if update:
+            fields_for_new_workflow.update(update)
+
+        # Create a new Workflow
+        try:
+            new_workflow = self.__class__(**fields_for_new_workflow)
+            log_debug(f"Created new {self.__class__.__name__}")
+            return new_workflow
+        except Exception as e:
+            from agno.utils.log import log_error
+            log_error(f"Failed to create deep copy of {self.__class__.__name__}: {e}")
+            raise
+
+    def _deep_copy_steps(self, steps: Any) -> Any:
+        """Deep copy workflow steps, handling nested agents and teams."""
+        from agno.workflow.steps import Steps
+
+        if steps is None:
+            return None
+
+        # Handle Steps container
+        if isinstance(steps, Steps):
+            copied_steps = []
+            if steps.steps:
+                for step in steps.steps:
+                    copied_steps.append(self._deep_copy_single_step(step))
+            return Steps(steps=copied_steps)
+
+        # Handle list of steps
+        if isinstance(steps, list):
+            return [self._deep_copy_single_step(step) for step in steps]
+
+        # Handle callable steps
+        if callable(steps):
+            return steps
+
+        # Handle single step
+        return self._deep_copy_single_step(steps)
+
+    def _deep_copy_single_step(self, step: Any) -> Any:
+        """Deep copy a single step, handling nested agents and teams."""
+        from copy import copy, deepcopy
+
+        from agno.agent import Agent
+        from agno.team import Team
+        from agno.workflow.condition import Condition
+        from agno.workflow.loop import Loop
+        from agno.workflow.parallel import Parallel
+        from agno.workflow.router import Router
+        from agno.workflow.step import Step
+        from agno.workflow.steps import Steps
+
+        # Handle Step with agent or team
+        if isinstance(step, Step):
+            step_kwargs: Dict[str, Any] = {}
+            if step.name:
+                step_kwargs["name"] = step.name
+            if step.description:
+                step_kwargs["description"] = step.description
+            if step.executor:
+                step_kwargs["executor"] = step.executor
+            if step.agent:
+                step_kwargs["agent"] = step.agent.deep_copy() if hasattr(step.agent, "deep_copy") else step.agent
+            if step.team:
+                step_kwargs["team"] = step.team.deep_copy() if hasattr(step.team, "deep_copy") else step.team
+            # Copy Step configuration attributes
+            for attr in [
+                "max_retries",
+                "timeout_seconds",
+                "skip_on_failure",
+                "strict_input_validation",
+                "add_workflow_history",
+                "num_history_runs",
+            ]:
+                if hasattr(step, attr):
+                    value = getattr(step, attr)
+                    # Only include non-default values to avoid overriding defaults
+                    if value is not None:
+                        step_kwargs[attr] = value
+            return Step(**step_kwargs)
+
+        # Handle direct Agent
+        if isinstance(step, Agent):
+            return step.deep_copy() if hasattr(step, "deep_copy") else step
+
+        # Handle direct Team
+        if isinstance(step, Team):
+            return step.deep_copy() if hasattr(step, "deep_copy") else step
+
+        # Handle Parallel steps
+        if isinstance(step, Parallel):
+            copied_parallel_steps = [self._deep_copy_single_step(s) for s in step.steps] if step.steps else []
+            return Parallel(*copied_parallel_steps, name=step.name, description=step.description)
+
+        # Handle Loop steps
+        if isinstance(step, Loop):
+            copied_loop_steps = [self._deep_copy_single_step(s) for s in step.steps] if step.steps else []
+            return Loop(
+                steps=copied_loop_steps,
+                name=step.name,
+                description=step.description,
+                max_iterations=step.max_iterations,
+                end_condition=step.end_condition,
+            )
+
+        # Handle Condition steps
+        if isinstance(step, Condition):
+            copied_condition_steps = [self._deep_copy_single_step(s) for s in step.steps] if step.steps else []
+            return Condition(
+                evaluator=step.evaluator, steps=copied_condition_steps, name=step.name, description=step.description
+            )
+
+        # Handle Router steps
+        if isinstance(step, Router):
+            copied_choices = [self._deep_copy_single_step(s) for s in step.choices] if step.choices else []
+            return Router(choices=copied_choices, name=step.name, description=step.description, selector=step.selector)
+
+        # Handle Steps container
+        if isinstance(step, Steps):
+            copied_steps = [self._deep_copy_single_step(s) for s in step.steps] if step.steps else []
+            return Steps(name=step.name, description=step.description, steps=copied_steps)
+
+        # For other types, attempt deep copy
+        try:
+            return deepcopy(step)
+        except Exception:
+            try:
+                return copy(step)
+            except Exception:
+                return step

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agno
-Version: 2.3.24
+Version: 2.3.26
 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">