agno 2.0.8__py3-none-any.whl → 2.0.9__py3-none-any.whl

agno/tools/mcp_toolbox.py

@@ -0,0 +1,284 @@
+from typing import Any, Callable, Dict, List, Literal, Optional, Union
+from warnings import warn
+
+from agno.tools.function import Function
+from agno.tools.mcp import MCPTools
+from agno.utils.log import logger
+
+try:
+    from toolbox_core import ToolboxClient  # type: ignore
+except ImportError:
+    raise ImportError("`toolbox_core` not installed. Please install using `pip install -U toolbox-core`.")
+
+
+class MCPToolsMeta(type):
+    """Metaclass for MCPTools to ensure proper initialization with AgentOS"""
+
+    @property
+    def __name__(cls):
+        return "MCPTools"
+
+
+class MCPToolbox(MCPTools, metaclass=MCPToolsMeta):
+    """
+    A toolkit that combines MCPTools server connectivity with MCP Toolbox for Databases client (toolbox-core).
+
+    MCPToolbox connects to an MCP Toolbox server and registers all available tools, then uses
+    toolbox-core to filter those tools by toolset or tool name. This enables agents to
+    receive only the specific tools they need while maintaining full MCP execution capabilities.
+    """
+
+    def __init__(
+        self,
+        url: str,
+        toolsets: Optional[List[str]] = None,
+        tool_name: Optional[str] = None,
+        headers: Optional[Dict[str, Any]] = None,
+        transport: Literal["stdio", "sse", "streamable-http"] = "streamable-http",
+        **kwargs,
+    ):
+        """Initialize MCPToolbox with filtering capabilities.
+
+        Args:
+            url (str): Base URL for the toolbox service.
+            toolsets (Optional[List[str]], optional): List of toolset names to filter tools by. Defaults to None.
+            tool_name (Optional[str], optional): Single tool name to load. Defaults to None.
+            headers (Optional[Dict[str, Any]], optional): Headers for toolbox-core client requests. Defaults to None.
+            transport (Literal["stdio", "sse", "streamable-http"], optional): MCP transport protocol. Defaults to "streamable-http".
+
+        """
+
+        # Ensure the URL ends in "/mcp" as expected
+        if not url.endswith("/mcp"):
+            url = url + "/mcp"
+
+        super().__init__(url=url, transport=transport, **kwargs)
+
+        self.name = "toolbox_client"
+        self.toolbox_url = url
+        self.toolsets = toolsets
+        self.tool_name = tool_name
+        self.headers = headers
+        self._core_client_initialized = False
+
+        # Validate that only one of toolsets or tool_name is provided
+        filter_params = [toolsets, tool_name]
+        non_none_params = [p for p in filter_params if p is not None]
+        if len(non_none_params) > 1:
+            raise ValueError("Only one of toolsets or tool_name can be specified")
+
+    async def connect(self):
+        """Initialize MCPToolbox instance and connect to the MCP server."""
+        # First, connect to MCP server and load all available tools
+        await super().connect()
+
+        if self._core_client_initialized:
+            return
+
+        # Then, connect to the ToolboxClient and filter tools based on toolsets or tool_name
+        await self._connect_toolbox_client()
+
+    async def _connect_toolbox_client(self):
+        try:
+            if self.toolsets is not None or self.tool_name is not None:
+                self.__core_client = ToolboxClient(
+                    url=self.toolbox_url,
+                    client_headers=self.headers,
+                )
+                self._core_client_initialized = True
+
+                if self.toolsets is not None:
+                    # Load multiple toolsets
+                    all_functions = await self.load_multiple_toolsets(toolset_names=self.toolsets)
+                    # Replace functions dict with filtered subset
+                    filtered_functions = {func.name: func for func in all_functions}
+                    self.functions = filtered_functions
+                elif self.tool_name is not None:
+                    tool = await self.load_tool(tool_name=self.tool_name)
+                    # Replace functions dict with just this single tool
+                    self.functions = {tool.name: tool}
+        except Exception as e:
+            raise RuntimeError(f"Failed to connect to ToolboxClient: {e}") from e
+
+    def _handle_auth_params(
+        self,
+        auth_token_getters: dict[str, Callable[[], str]] = {},
+        auth_tokens: Optional[dict[str, Callable[[], str]]] = None,
+        auth_headers: Optional[dict[str, Callable[[], str]]] = None,
+    ):
+        """handle authentication parameters for toolbox-core client"""
+        if auth_tokens:
+            if auth_token_getters:
+                warn(
+                    "Both `auth_token_getters` and `auth_tokens` are provided. `auth_tokens` is deprecated, and `auth_token_getters` will be used.",
+                    DeprecationWarning,
+                )
+            else:
+                warn(
+                    "Argument `auth_tokens` is deprecated. Use `auth_token_getters` instead.",
+                    DeprecationWarning,
+                )
+                auth_token_getters = auth_tokens
+
+        if auth_headers:
+            if auth_token_getters:
+                warn(
+                    "Both `auth_token_getters` and `auth_headers` are provided. `auth_headers` is deprecated, and `auth_token_getters` will be used.",
+                    DeprecationWarning,
+                )
+            else:
+                warn(
+                    "Argument `auth_headers` is deprecated. Use `auth_token_getters` instead.",
+                    DeprecationWarning,
+                )
+                auth_token_getters = auth_headers
+        return auth_token_getters
+
+    async def load_tool(
+        self,
+        tool_name: str,
+        auth_token_getters: dict[str, Callable[[], str]] = {},
+        auth_tokens: Optional[dict[str, Callable[[], str]]] = None,
+        auth_headers: Optional[dict[str, Callable[[], str]]] = None,
+        bound_params: dict[str, Union[Any, Callable[[], Any]]] = {},
+    ) -> Function:
+        """Loads the tool with the given tool name from the Toolbox service.
+
+        Args:
+            tool_name (str): The name of the tool to load.
+            auth_token_getters (dict[str, Callable[[], str]], optional): A mapping of authentication source names to functions that retrieve ID tokens. Defaults to {}.
+            auth_tokens (Optional[dict[str, Callable[[], str]]], optional): Deprecated. Use `auth_token_getters` instead.
+            auth_headers (Optional[dict[str, Callable[[], str]]], optional): Deprecated. Use `auth_token_getters` instead.
+            bound_params (dict[str, Union[Any, Callable[[], Any]]], optional): A mapping of parameter names to their bound values. Defaults to {}.
+
+        Raises:
+            RuntimeError: If the tool is not found in the MCP functions registry.
+
+        Returns:
+            Function: The loaded tool function.
+        """
+        auth_token_getters = self._handle_auth_params(
+            auth_token_getters=auth_token_getters,
+            auth_tokens=auth_tokens,
+            auth_headers=auth_headers,
+        )
+
+        core_sync_tool = await self.__core_client.load_tool(
+            name=tool_name,
+            auth_token_getters=auth_token_getters,
+            bound_params=bound_params,
+        )
+        # Return the Function object from our MCP functions registry
+        if core_sync_tool._name in self.functions:
+            return self.functions[core_sync_tool._name]
+        else:
+            raise RuntimeError(f"Tool '{tool_name}' was not found in MCP functions registry")
+
+    async def load_toolset(
+        self,
+        toolset_name: Optional[str] = None,
+        auth_token_getters: dict[str, Callable[[], str]] = {},
+        auth_tokens: Optional[dict[str, Callable[[], str]]] = None,
+        auth_headers: Optional[dict[str, Callable[[], str]]] = None,
+        bound_params: dict[str, Union[Any, Callable[[], Any]]] = {},
+        strict: bool = False,
+    ) -> List[Function]:
+        """Loads tools from the configured toolset.
+
+        Args:
+            toolset_name (Optional[str], optional): The name of the toolset to load. Defaults to None.
+            auth_token_getters (dict[str, Callable[[], str]], optional): A mapping of authentication source names to functions that retrieve ID tokens. Defaults to {}.
+            auth_tokens (Optional[dict[str, Callable[[], str]]], optional): Deprecated. Use `auth_token_getters` instead.
+            auth_headers (Optional[dict[str, Callable[[], str]]], optional): Deprecated. Use `auth_token_getters` instead.
+            bound_params (dict[str, Union[Any, Callable[[], Any]]], optional): A mapping of parameter names to their bound values. Defaults to {}.
+            strict (bool, optional): If True, raises an error if *any* loaded tool instance fails
+                to utilize all of the given parameters or auth tokens. (if any
+                provided). If False (default), raises an error only if a
+                user-provided parameter or auth token cannot be applied to *any*
+                loaded tool across the set.
+
+        Returns:
+            List[Function]: A list of all tools loaded from the Toolbox.
+        """
+        auth_token_getters = self._handle_auth_params(
+            auth_token_getters=auth_token_getters,
+            auth_tokens=auth_tokens,
+            auth_headers=auth_headers,
+        )
+
+        core_sync_tools = await self.__core_client.load_toolset(
+            name=toolset_name,
+            auth_token_getters=auth_token_getters,
+            bound_params=bound_params,
+            strict=strict,
+        )
+
+        tools = []
+        for core_sync_tool in core_sync_tools:
+            if core_sync_tool._name in self.functions:
+                tools.append(self.functions[core_sync_tool._name])
+            else:
+                logger.debug(f"Tool '{core_sync_tool._name}' from toolset '{toolset_name}' not available in MCP server")
+        return tools
+
+    async def load_multiple_toolsets(
+        self,
+        toolset_names: List[str],
+        auth_token_getters: dict[str, Callable[[], str]] = {},
+        bound_params: dict[str, Union[Any, Callable[[], Any]]] = {},
+        strict: bool = False,
+    ) -> List[Function]:
+        """Load tools from multiple toolsets.
+
+        Args:
+            toolset_names (List[str]): A list of toolset names to load.
+            auth_token_getters (dict[str, Callable[[], str]], optional): A mapping of authentication source names to functions that retrieve ID tokens. Defaults to {}.
+            bound_params (dict[str, Union[Any, Callable[[], Any]]], optional): A mapping of parameter names to their bound values. Defaults to {}.
+            strict (bool, optional): If True, raises an error if *any* loaded tool instance fails to utilize all of the given parameters or auth tokens. Defaults to False.
+
+        Returns:
+            List[Function]: A list of all tools loaded from the specified toolsets.
+        """
+        all_tools = []
+        for toolset_name in toolset_names:
+            tools = await self.load_toolset(
+                toolset_name=toolset_name,
+                auth_token_getters=auth_token_getters,
+                bound_params=bound_params,
+                strict=strict,
+            )
+            all_tools.extend(tools)
+        return all_tools
+
+    async def close(self):
+        """Close the underlying asynchronous client."""
+        if self._core_client_initialized and hasattr(self, "_MCPToolbox__core_client"):
+            await self.__core_client.close()
+        await super().close()
+
+    async def load_toolset_safe(self, toolset_name: str) -> List[str]:
+        """Safely load a toolset and return tool names."""
+        try:
+            tools = await self.load_toolset(toolset_name)
+            return [tool.name for tool in tools]
+        except Exception as e:
+            raise RuntimeError(f"Failed to load toolset '{toolset_name}': {e}") from e
+
+    def get_client(self) -> ToolboxClient:
+        """Get the underlying ToolboxClient."""
+        if not self._core_client_initialized:
+            raise RuntimeError("ToolboxClient not initialized. Call connect() first.")
+        return self.__core_client
+
+    async def __aenter__(self):
+        """Initialize the direct toolbox client."""
+        await super().__aenter__()
+        await self.connect()
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        """Clean up the toolbox client."""
+        # Close ToolboxClient first, then MCP client
+        if self._core_client_initialized and hasattr(self, "_MCPToolbox__core_client"):
+            await self.__core_client.close()
+        await super().__aexit__(exc_type, exc_val, exc_tb)

agno/tools/scrapegraph.py

@@ -3,6 +3,7 @@ from os import getenv
 from typing import Any, List, Optional
 
 from agno.tools import Toolkit
+from agno.utils.log import log_debug, log_error
 
 try:
     from scrapegraph_py import Client
@@ -23,11 +24,14 @@ class ScrapeGraphTools(Toolkit):
         enable_crawl: bool = False,
         enable_searchscraper: bool = False,
         enable_agentic_crawler: bool = False,
+        enable_scrape: bool = False,
+        render_heavy_js: bool = False,
         all: bool = False,
         **kwargs,
     ):
         self.api_key: Optional[str] = api_key or getenv("SGAI_API_KEY")
         self.client = Client(api_key=self.api_key)
+        self.render_heavy_js = render_heavy_js
 
         # Start with smartscraper by default
         # Only enable markdownify if smartscraper is False
@@ -45,6 +49,8 @@ class ScrapeGraphTools(Toolkit):
             tools.append(self.searchscraper)
         if enable_agentic_crawler or all:
             tools.append(self.agentic_crawler)
+        if enable_scrape or all:
+            tools.append(self.scrape)
 
         super().__init__(name="scrapegraph_tools", tools=tools, **kwargs)
 
@@ -57,10 +63,13 @@ class ScrapeGraphTools(Toolkit):
             The structured data extracted from the webpage
         """
         try:
+            log_debug(f"ScrapeGraph smartscraper request for URL: {url}")
             response = self.client.smartscraper(website_url=url, user_prompt=prompt)
             return json.dumps(response["result"])
         except Exception as e:
-            return json.dumps({"error": str(e)})
+            error_msg = f"Smartscraper failed: {str(e)}"
+            log_error(error_msg)
+            return f"Error: {error_msg}"
 
     def markdownify(self, url: str) -> str:
         """Convert a webpage to markdown format.
@@ -70,10 +79,13 @@ class ScrapeGraphTools(Toolkit):
             The markdown version of the webpage
         """
         try:
+            log_debug(f"ScrapeGraph markdownify request for URL: {url}")
             response = self.client.markdownify(website_url=url)
             return response["result"]
         except Exception as e:
-            return f"Error converting to markdown: {str(e)}"
+            error_msg = f"Markdownify failed: {str(e)}"
+            log_error(error_msg)
+            return f"Error: {error_msg}"
 
     def crawl(
         self,
@@ -100,10 +112,11 @@ class ScrapeGraphTools(Toolkit):
             The structured data extracted from the website
         """
         try:
+            log_debug(f"ScrapeGraph crawl request for URL: {url}")
             response = self.client.crawl(
                 url=url,
                 prompt=prompt,
-                schema=schema,
+                data_schema=schema,
                 cache_website=cache_website,
                 depth=depth,
                 max_pages=max_pages,
@@ -112,7 +125,9 @@ class ScrapeGraphTools(Toolkit):
             )
             return json.dumps(response, indent=2)
         except Exception as e:
-            return json.dumps({"error": str(e)})
+            error_msg = f"Crawl failed: {str(e)}"
+            log_error(error_msg)
+            return f"Error: {error_msg}"
 
     def agentic_crawler(
         self,
@@ -143,21 +158,7 @@ class ScrapeGraphTools(Toolkit):
             JSON string containing the scraping results, including request_id, status, and extracted data
         """
         try:
-            # Validate required parameters for AI extraction
-            if ai_extraction and not user_prompt:
-                return json.dumps({"error": "user_prompt is required when ai_extraction=True"})
-
-            # Validate URL format
-            if not url.strip():
-                return json.dumps({"error": "URL cannot be empty"})
-            if not (url.startswith("http://") or url.startswith("https://")):
-                return json.dumps({"error": "Invalid URL - must start with http:// or https://"})
-
-            # Validate steps
-            if not steps:
-                return json.dumps({"error": "Steps cannot be empty"})
-            if any(not step.strip() for step in steps):
-                return json.dumps({"error": "All steps must contain valid instructions"})
+            log_debug(f"ScrapeGraph agentic_crawler request for URL: {url}")
 
             # Prepare parameters for the API call
             params = {"url": url, "steps": steps, "use_session": use_session, "ai_extraction": ai_extraction}
@@ -170,26 +171,52 @@ class ScrapeGraphTools(Toolkit):
 
             # Call the agentic scraper API
             response = self.client.agenticscraper(**params)
-
             return json.dumps(response, indent=2)
 
         except Exception as e:
-            return json.dumps({"error": str(e)})
+            error_msg = f"Agentic crawler failed: {str(e)}"
+            log_error(error_msg)
+            return f"Error: {error_msg}"
 
-    def searchscraper(self, prompt: str) -> str:
+    def searchscraper(self, user_prompt: str) -> str:
         """Search the web and extract information from the web.
         Args:
-            prompt (str): Search query
+            user_prompt (str): Search query
         Returns:
             JSON of the search results
         """
         try:
-            response = self.client.searchscraper(user_prompt=prompt)
-            if hasattr(response, "result"):
-                return json.dumps(response.result)
-            elif isinstance(response, dict) and "result" in response:
-                return json.dumps(response["result"])
-            else:
-                return json.dumps(response)
+            log_debug(f"ScrapeGraph searchscraper request with prompt: {user_prompt}")
+            response = self.client.searchscraper(user_prompt=user_prompt, render_heavy_js=self.render_heavy_js)
+            return json.dumps(response["result"])
+        except Exception as e:
+            error_msg = f"Searchscraper failed: {str(e)}"
+            log_error(error_msg)
+            return f"Error: {error_msg}"
+
+    def scrape(
+        self,
+        website_url: str,
+        headers: Optional[dict] = None,
+    ) -> str:
+        """Get raw HTML content from a website using the ScrapeGraphAI scrape API.
+
+        Args:
+            website_url (str): The URL of the website to scrape
+            headers (Optional[dict]): Optional headers to send with the request
+
+        Returns:
+            JSON string containing the HTML content and metadata
+        """
+        try:
+            log_debug(f"ScrapeGraph scrape request for URL: {website_url}")
+            response = self.client.scrape(
+                website_url=website_url,
+                headers=headers,
+                render_heavy_js=self.render_heavy_js,
+            )
+            return json.dumps(response, indent=2)
         except Exception as e:
-            return json.dumps({"error": str(e)})
+            error_msg = f"Scrape failed: {str(e)}"
+            log_error(error_msg)
+            return f"Error: {error_msg}"

agno/tools/whatsapp.py

@@ -16,7 +16,7 @@ class WhatsAppTools(Toolkit):
         self,
         access_token: Optional[str] = None,
         phone_number_id: Optional[str] = None,
-        version: str = "v22.0",
+        version: Optional[str] = None,
         recipient_waid: Optional[str] = None,
         async_mode: bool = False,
     ):

agno/utils/print_response/agent.py

@@ -423,7 +423,7 @@ def build_panels_stream(
             reasoning_panel = create_panel(content=step_content, title=f"Reasoning step {i}", border_style="green")
             panels.append(reasoning_panel)
 
-    if len(response_reasoning_content_buffer) > 0:
+    if len(response_reasoning_content_buffer) > 0 and show_reasoning:
         # Create panel for thinking
         thinking_panel = create_panel(
             content=Text(response_reasoning_content_buffer),
@@ -727,7 +727,7 @@ def build_panels(
             reasoning_panel = create_panel(content=step_content, title=f"Reasoning step {i}", border_style="green")
             panels.append(reasoning_panel)
 
-    if isinstance(run_response, RunOutput) and run_response.reasoning_content is not None:
+    if isinstance(run_response, RunOutput) and run_response.reasoning_content is not None and show_reasoning:
         # Create panel for thinking
         thinking_panel = create_panel(
             content=Text(run_response.reasoning_content),

agno/utils/print_response/team.py

@@ -125,7 +125,7 @@ def print_response(
                 panels.append(reasoning_panel)
             live_console.update(Group(*panels))
 
-        if isinstance(run_response, TeamRunOutput) and run_response.reasoning_content is not None:
+        if isinstance(run_response, TeamRunOutput) and run_response.reasoning_content is not None and show_reasoning:
             # Create panel for thinking
             thinking_panel = create_panel(
                 content=Text(run_response.reasoning_content),
@@ -497,7 +497,7 @@ def print_response_stream(
                     reasoning_panel = build_reasoning_step_panel(i, step, show_full_reasoning)
                     panels.append(reasoning_panel)
 
-            if len(_response_reasoning_content) > 0:
+            if len(_response_reasoning_content) > 0 and show_reasoning:
                 render = True
                 # Create panel for thinking
                 thinking_panel = create_panel(
@@ -679,7 +679,7 @@ def print_response_stream(
                 final_panels.append(reasoning_panel)
 
         # Add thinking panel if available
-        if _response_reasoning_content:
+        if _response_reasoning_content and show_reasoning:
             thinking_panel = create_panel(
                 content=Text(_response_reasoning_content),
                 title=f"Thinking ({response_timer.elapsed:.1f}s)",
@@ -938,7 +938,7 @@ async def aprint_response(
                 panels.append(reasoning_panel)
             live_console.update(Group(*panels))
 
-        if isinstance(run_response, TeamRunOutput) and run_response.reasoning_content is not None:
+        if isinstance(run_response, TeamRunOutput) and run_response.reasoning_content is not None and show_reasoning:
             # Create panel for thinking
             thinking_panel = create_panel(
                 content=Text(run_response.reasoning_content),
@@ -1306,7 +1306,7 @@ async def aprint_response_stream(
                     reasoning_panel = build_reasoning_step_panel(i, step, show_full_reasoning)
                     panels.append(reasoning_panel)
 
-            if len(_response_reasoning_content) > 0:
+            if len(_response_reasoning_content) > 0 and show_reasoning:
                 render = True
                 # Create panel for thinking
                 thinking_panel = create_panel(
@@ -1489,7 +1489,7 @@ async def aprint_response_stream(
                 final_panels.append(reasoning_panel)
 
         # Add thinking panel if available
-        if _response_reasoning_content:
+        if _response_reasoning_content and show_reasoning:
             thinking_panel = create_panel(
                 content=Text(_response_reasoning_content),
                 title=f"Thinking ({response_timer.elapsed:.1f}s)",

agno/utils/reasoning.py

@@ -1,4 +1,4 @@
-from typing import TYPE_CHECKING, List, Union
+from typing import TYPE_CHECKING, List, Optional, Tuple, Union
 
 from agno.models.message import Message
 from agno.models.metrics import Metrics
@@ -9,6 +9,27 @@ if TYPE_CHECKING:
     from agno.team.team import TeamRunOutput
 
 
+def extract_thinking_content(content: str) -> Tuple[Optional[str], str]:
+    """Extract thinking content from response text between <think> tags."""
+    if not content or "</think>" not in content:
+        return None, content
+
+    # Find the end of thinking content
+    end_idx = content.find("</think>")
+
+    # Look for opening <think> tag, if not found, assume thinking starts at beginning
+    start_idx = content.find("<think>")
+    if start_idx == -1:
+        reasoning_content = content[:end_idx].strip()
+    else:
+        start_idx = start_idx + len("<think>")
+        reasoning_content = content[start_idx:end_idx].strip()
+
+    output_content = content[end_idx + len("</think>") :].strip()
+
+    return reasoning_content, output_content
+
+
 def append_to_reasoning_content(run_response: Union["RunOutput", "TeamRunOutput"], content: str) -> None:
     """Helper to append content to the reasoning_content field."""
     if not hasattr(run_response, "reasoning_content") or not run_response.reasoning_content:  # type: ignore

agno/utils/string.py

@@ -158,6 +158,15 @@ def _parse_individual_json(content: str, output_schema: Type[BaseModel]) -> Opti
 def parse_response_model_str(content: str, output_schema: Type[BaseModel]) -> Optional[BaseModel]:
     structured_output = None
 
+    # Extract thinking content first to prevent <think> tags from corrupting JSON
+    from agno.utils.reasoning import extract_thinking_content
+
+    # handle thinking content b/w <think> tags
+    if "</think>" in content:
+        reasoning_content, output_content = extract_thinking_content(content)
+        if reasoning_content:
+            content = output_content
+
     # Clean content first to simplify all parsing attempts
     cleaned_content = _clean_json_content(content)
 

agno/workflow/workflow.py

@@ -1406,7 +1406,6 @@ class Workflow:
                         logger.info(f"Early termination requested by step {step_name}")
                         break
 
-
                 # Update the workflow_run_response with completion data
                 if collected_step_outputs:
                     workflow_run_response.metrics = self._aggregate_workflow_metrics(collected_step_outputs)

{agno-2.0.8.dist-info → agno-2.0.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agno
-Version: 2.0.8
+Version: 2.0.9
 Summary: Agno: a lightweight library for building Multi-Agent Systems
 Author-email: Ashpreet Bedi <ashpreet@agno.com>
 Project-URL: homepage, https://agno.com
@@ -163,6 +163,8 @@ Requires-Dist: psycopg-binary; extra == "psycopg"
 Requires-Dist: psycopg; extra == "psycopg"
 Provides-Extra: reportlab
 Requires-Dist: reportlab; extra == "reportlab"
+Provides-Extra: scrapegraph
+Requires-Dist: scrapegraph-py; extra == "scrapegraph"
 Provides-Extra: todoist
 Requires-Dist: todoist-api-python; extra == "todoist"
 Provides-Extra: valyu
@@ -300,6 +302,7 @@ Requires-Dist: agno[mcp]; extra == "tools"
 Requires-Dist: agno[browserbase]; extra == "tools"
 Requires-Dist: agno[agentql]; extra == "tools"
 Requires-Dist: agno[opencv]; extra == "tools"
+Requires-Dist: agno[scrapegraph]; extra == "tools"
 Requires-Dist: agno[valyu]; extra == "tools"
 Requires-Dist: agno[confluence]; extra == "tools"
 Requires-Dist: agno[oxylabs]; extra == "tools"