agno 2.2.10__py3-none-any.whl → 2.2.11__py3-none-any.whl

agno/tools/parallel.py

@@ -0,0 +1,314 @@
+import json
+from os import getenv
+from typing import Any, Dict, List, Optional
+
+from agno.tools import Toolkit
+from agno.utils.log import log_error
+
+try:
+    from parallel import Parallel as ParallelClient
+except ImportError:
+    raise ImportError("`parallel-web` not installed. Please install using `pip install parallel-web`")
+
+
+class CustomJSONEncoder(json.JSONEncoder):
+    """Custom JSON encoder that handles non-serializable types by converting them to strings."""
+
+    def default(self, obj):
+        try:
+            return super().default(obj)
+        except TypeError:
+            return str(obj)
+
+
+class ParallelTools(Toolkit):
+    """
+    ParallelTools provides access to Parallel's web search and extraction APIs.
+
+    Parallel offers powerful APIs optimized for AI agents:
+    - Search API: AI-optimized web search that returns relevant excerpts tailored for LLMs
+    - Extract API: Extract content from specific URLs in clean markdown format, handling JavaScript-heavy pages and PDFs
+
+    Args:
+        api_key (Optional[str]): Parallel API key. If not provided, will use PARALLEL_API_KEY environment variable.
+        enable_search (bool): Enable Search API functionality. Default is True.
+        enable_extract (bool): Enable Extract API functionality. Default is True.
+        all (bool): Enable all tools. Overrides individual flags when True. Default is False.
+        max_results (int): Default maximum number of results for search operations. Default is 10.
+        max_chars_per_result (int): Default maximum characters per result for search operations. Default is 10000.
+        beta_version (str): Beta API version header. Default is "search-extract-2025-10-10".
+        mode (Optional[str]): Default search mode. Options: "one-shot" or "agentic". Default is None.
+        include_domains (Optional[List[str]]): Default domains to restrict results to. Default is None.
+        exclude_domains (Optional[List[str]]): Default domains to exclude from results. Default is None.
+        max_age_seconds (Optional[int]): Default cache age threshold (minimum 600). Default is None.
+        timeout_seconds (Optional[float]): Default timeout for content retrieval. Default is None.
+        disable_cache_fallback (Optional[bool]): Default cache fallback behavior. Default is None.
+    """
+
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        enable_search: bool = True,
+        enable_extract: bool = True,
+        all: bool = False,
+        max_results: int = 10,
+        max_chars_per_result: int = 10000,
+        beta_version: str = "search-extract-2025-10-10",
+        mode: Optional[str] = None,
+        include_domains: Optional[List[str]] = None,
+        exclude_domains: Optional[List[str]] = None,
+        max_age_seconds: Optional[int] = None,
+        timeout_seconds: Optional[float] = None,
+        disable_cache_fallback: Optional[bool] = None,
+        **kwargs,
+    ):
+        self.api_key: Optional[str] = api_key or getenv("PARALLEL_API_KEY")
+        if not self.api_key:
+            log_error("PARALLEL_API_KEY not set. Please set the PARALLEL_API_KEY environment variable.")
+
+        self.max_results = max_results
+        self.max_chars_per_result = max_chars_per_result
+        self.beta_version = beta_version
+        self.mode = mode
+        self.include_domains = include_domains
+        self.exclude_domains = exclude_domains
+        self.max_age_seconds = max_age_seconds
+        self.timeout_seconds = timeout_seconds
+        self.disable_cache_fallback = disable_cache_fallback
+
+        self.parallel_client = ParallelClient(
+            api_key=self.api_key, default_headers={"parallel-beta": self.beta_version}
+        )
+
+        tools: List[Any] = []
+        if all or enable_search:
+            tools.append(self.parallel_search)
+        if all or enable_extract:
+            tools.append(self.parallel_extract)
+
+        super().__init__(name="parallel_tools", tools=tools, **kwargs)
+
+    def parallel_search(
+        self,
+        objective: Optional[str] = None,
+        search_queries: Optional[List[str]] = None,
+        max_results: Optional[int] = None,
+        max_chars_per_result: Optional[int] = None,
+    ) -> str:
+        """Use this function to search the web using Parallel's Search API with a natural language objective.
+        You must provide at least one of objective or search_queries.
+
+        Args:
+            objective (Optional[str]): Natural-language description of what the web search is trying to find.
+            search_queries (Optional[List[str]]): Traditional keyword queries with optional search operators.
+            max_results (Optional[int]): Upper bound on results returned. Overrides constructor default.
+            max_chars_per_result (Optional[int]): Upper bound on total characters per url for excerpts.
+
+        Returns:
+            str: A JSON formatted string containing the search results with URLs, titles, publish dates, and relevant excerpts.
+        """
+        try:
+            if not objective and not search_queries:
+                return json.dumps({"error": "Please provide at least one of: objective or search_queries"}, indent=2)
+
+            # Use instance defaults if not provided
+            final_max_results = max_results if max_results is not None else self.max_results
+
+            search_params: Dict[str, Any] = {
+                "max_results": final_max_results,
+            }
+
+            # Add objective if provided
+            if objective:
+                search_params["objective"] = objective
+
+            # Add search_queries if provided
+            if search_queries:
+                search_params["search_queries"] = search_queries
+
+            # Add mode from constructor default
+            if self.mode:
+                search_params["mode"] = self.mode
+
+            # Add excerpts configuration
+            excerpts_config: Dict[str, Any] = {}
+            final_max_chars = max_chars_per_result if max_chars_per_result is not None else self.max_chars_per_result
+            if final_max_chars is not None:
+                excerpts_config["max_chars_per_result"] = final_max_chars
+
+            if excerpts_config:
+                search_params["excerpts"] = excerpts_config
+
+            # Add source_policy from constructor defaults
+            source_policy: Dict[str, Any] = {}
+            if self.include_domains:
+                source_policy["include_domains"] = self.include_domains
+            if self.exclude_domains:
+                source_policy["exclude_domains"] = self.exclude_domains
+
+            if source_policy:
+                search_params["source_policy"] = source_policy
+
+            # Add fetch_policy from constructor defaults
+            fetch_policy: Dict[str, Any] = {}
+            if self.max_age_seconds is not None:
+                fetch_policy["max_age_seconds"] = self.max_age_seconds
+            if self.timeout_seconds is not None:
+                fetch_policy["timeout_seconds"] = self.timeout_seconds
+            if self.disable_cache_fallback is not None:
+                fetch_policy["disable_cache_fallback"] = self.disable_cache_fallback
+
+            if fetch_policy:
+                search_params["fetch_policy"] = fetch_policy
+
+            search_result = self.parallel_client.beta.search(**search_params)
+
+            # Use model_dump() if available, otherwise convert to dict
+            try:
+                if hasattr(search_result, "model_dump"):
+                    return json.dumps(search_result.model_dump(), cls=CustomJSONEncoder)
+            except Exception:
+                pass
+
+            # Manually format the results
+            formatted_results: Dict[str, Any] = {
+                "search_id": getattr(search_result, "search_id", ""),
+                "results": [],
+            }
+
+            if hasattr(search_result, "results") and search_result.results:
+                results_list: List[Dict[str, Any]] = []
+                for result in search_result.results:
+                    formatted_result: Dict[str, Any] = {
+                        "title": getattr(result, "title", ""),
+                        "url": getattr(result, "url", ""),
+                        "publish_date": getattr(result, "publish_date", ""),
+                        "excerpt": getattr(result, "excerpt", ""),
+                    }
+                    results_list.append(formatted_result)
+                formatted_results["results"] = results_list
+
+            if hasattr(search_result, "warnings"):
+                formatted_results["warnings"] = search_result.warnings
+
+            if hasattr(search_result, "usage"):
+                formatted_results["usage"] = search_result.usage
+
+            return json.dumps(formatted_results, cls=CustomJSONEncoder, indent=2)
+
+        except Exception as e:
+            log_error(f"Error searching Parallel for objective '{objective}': {e}")
+            return json.dumps({"error": f"Search failed: {str(e)}"}, indent=2)
+
+    def parallel_extract(
+        self,
+        urls: List[str],
+        objective: Optional[str] = None,
+        search_queries: Optional[List[str]] = None,
+        excerpts: bool = True,
+        max_chars_per_excerpt: Optional[int] = None,
+        full_content: bool = False,
+        max_chars_for_full_content: Optional[int] = None,
+    ) -> str:
+        """Use this function to extract content from specific URLs using Parallel's Extract API.
+
+        Args:
+            urls (List[str]): List of public URLs to extract content from.
+            objective (Optional[str]): Search focus to guide content extraction.
+            search_queries (Optional[List[str]]): Keywords for targeting relevant content.
+            excerpts (bool): Include relevant text snippets.
+            max_chars_per_excerpt (Optional[int]): Upper bound on total characters per url. Only used when excerpts is True.
+            full_content (bool): Include complete page text.
+            max_chars_for_full_content (Optional[int]): Limit on characters per url. Only used when full_content is True.
+
+        Returns:
+            str: A JSON formatted string containing extracted content with titles, publish dates, excerpts and/or full content.
+        """
+        try:
+            if not urls:
+                return json.dumps({"error": "Please provide at least one URL to extract"}, indent=2)
+
+            extract_params: Dict[str, Any] = {
+                "urls": urls,
+            }
+
+            # Add objective if provided
+            if objective:
+                extract_params["objective"] = objective
+
+            # Add search_queries if provided
+            if search_queries:
+                extract_params["search_queries"] = search_queries
+
+            # Add excerpts configuration
+            if excerpts and max_chars_per_excerpt is not None:
+                extract_params["excerpts"] = {"max_chars_per_result": max_chars_per_excerpt}
+            else:
+                extract_params["excerpts"] = excerpts
+
+            # Add full_content configuration
+            if full_content and max_chars_for_full_content is not None:
+                extract_params["full_content"] = {"max_chars_per_result": max_chars_for_full_content}
+            else:
+                extract_params["full_content"] = full_content
+
+            # Add fetch_policy from constructor defaults
+            fetch_policy: Dict[str, Any] = {}
+            if self.max_age_seconds is not None:
+                fetch_policy["max_age_seconds"] = self.max_age_seconds
+            if self.timeout_seconds is not None:
+                fetch_policy["timeout_seconds"] = self.timeout_seconds
+            if self.disable_cache_fallback is not None:
+                fetch_policy["disable_cache_fallback"] = self.disable_cache_fallback
+
+            if fetch_policy:
+                extract_params["fetch_policy"] = fetch_policy
+
+            extract_result = self.parallel_client.beta.extract(**extract_params)
+
+            # Use model_dump() if available, otherwise convert to dict
+            try:
+                if hasattr(extract_result, "model_dump"):
+                    return json.dumps(extract_result.model_dump(), cls=CustomJSONEncoder)
+            except Exception:
+                pass
+
+            # Manually format the results
+            formatted_results: Dict[str, Any] = {
+                "extract_id": getattr(extract_result, "extract_id", ""),
+                "results": [],
+                "errors": [],
+            }
+
+            if hasattr(extract_result, "results") and extract_result.results:
+                results_list: List[Dict[str, Any]] = []
+                for result in extract_result.results:
+                    formatted_result: Dict[str, Any] = {
+                        "url": getattr(result, "url", ""),
+                        "title": getattr(result, "title", ""),
+                        "publish_date": getattr(result, "publish_date", ""),
+                    }
+
+                    if excerpts and hasattr(result, "excerpts"):
+                        formatted_result["excerpts"] = result.excerpts
+
+                    if full_content and hasattr(result, "full_content"):
+                        formatted_result["full_content"] = result.full_content
+
+                    results_list.append(formatted_result)
+                formatted_results["results"] = results_list
+
+            if hasattr(extract_result, "errors") and extract_result.errors:
+                formatted_results["errors"] = extract_result.errors
+
+            if hasattr(extract_result, "warnings"):
+                formatted_results["warnings"] = extract_result.warnings
+
+            if hasattr(extract_result, "usage"):
+                formatted_results["usage"] = extract_result.usage
+
+            return json.dumps(formatted_results, cls=CustomJSONEncoder, indent=2)
+
+        except Exception as e:
+            log_error(f"Error extracting from Parallel: {e}")
+            return json.dumps({"error": f"Extract failed: {str(e)}"}, indent=2)

agno/utils/models/claude.py

@@ -68,6 +68,8 @@ def _format_image_for_message(image: Image) -> Optional[Dict[str, Any]]:
     }
 
     try:
+        img_type = None
+
         # Case 0: Image is an Anthropic uploaded file
         if image.content is not None and hasattr(image.content, "id"):
             content_bytes = image.content
@@ -80,7 +82,6 @@ def _format_image_for_message(image: Image) -> Optional[Dict[str, Any]]:
             import os
             from urllib.parse import urlparse
 
-            img_type = None
             if image.url:
                 parsed_url = urlparse(image.url)
                 _, ext = os.path.splitext(parsed_url.path)

agno/workflow/step.py

@@ -11,9 +11,10 @@ from agno.agent import Agent
 from agno.media import Audio, Image, Video
 from agno.models.metrics import Metrics
 from agno.run import RunContext
-from agno.run.agent import RunCompletedEvent, RunOutput, RunContentEvent
+from agno.run.agent import RunCompletedEvent, RunContentEvent, RunOutput
 from agno.run.base import BaseRunOutputEvent
-from agno.run.team import RunCompletedEvent as TeamRunCompletedEvent, RunContentEvent as TeamRunContentEvent
+from agno.run.team import RunCompletedEvent as TeamRunCompletedEvent
+from agno.run.team import RunContentEvent as TeamRunContentEvent
 from agno.run.team import TeamRunOutput
 from agno.run.workflow import (
     StepCompletedEvent,

agno/workflow/types.py

@@ -17,6 +17,7 @@ from agno.utils.media import (
     reconstruct_videos,
 )
 from agno.utils.serialize import json_serializer
+from agno.utils.timer import Timer
 
 
 @dataclass
@@ -405,12 +406,18 @@ class WorkflowMetrics:
     """Complete metrics for a workflow execution"""
 
     steps: Dict[str, StepMetrics]
+    # Timer utility for tracking execution time
+    timer: Optional[Timer] = None
+    # Total workflow execution time
+    duration: Optional[float] = None
 
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dictionary"""
-        return {
+        result: Dict[str, Any] = {
             "steps": {name: step.to_dict() for name, step in self.steps.items()},
+            "duration": self.duration,
         }
+        return result
 
     @classmethod
     def from_dict(cls, data: Dict[str, Any]) -> "WorkflowMetrics":
@@ -419,8 +426,20 @@ class WorkflowMetrics:
 
         return cls(
             steps=steps,
+            duration=data.get("duration"),
         )
 
+    def start_timer(self):
+        if self.timer is None:
+            self.timer = Timer()
+        self.timer.start()
+
+    def stop_timer(self, set_duration: bool = True):
+        if self.timer is not None:
+            self.timer.stop()
+            if set_duration:
+                self.duration = self.timer.elapsed
+
 
 @dataclass
 class WebSocketHandler:

agno/workflow/workflow.py

@@ -974,8 +974,8 @@ class Workflow:
         websocket_handler: Optional[WebSocketHandler] = None,
     ) -> "WorkflowRunOutputEvent":
         """Handle workflow events for storage - similar to Team._handle_event"""
-        from agno.run.base import BaseRunOutputEvent
         from agno.run.agent import RunOutput
+        from agno.run.base import BaseRunOutputEvent
         from agno.run.team import TeamRunOutput
 
         if isinstance(event, (RunOutput, TeamRunOutput)):
@@ -1136,7 +1136,11 @@ class Workflow:
             else:
                 return len(self.steps)
 
-    def _aggregate_workflow_metrics(self, step_results: List[Union[StepOutput, List[StepOutput]]]) -> WorkflowMetrics:
+    def _aggregate_workflow_metrics(
+        self,
+        step_results: List[Union[StepOutput, List[StepOutput]]],
+        current_workflow_metrics: Optional[WorkflowMetrics] = None,
+    ) -> WorkflowMetrics:
         """Aggregate metrics from all step responses into structured workflow metrics"""
         steps_dict = {}
 
@@ -1164,8 +1168,13 @@ class Workflow:
         for step_result in step_results:
             process_step_output(cast(StepOutput, step_result))
 
+        duration = None
+        if current_workflow_metrics and current_workflow_metrics.duration is not None:
+            duration = current_workflow_metrics.duration
+
         return WorkflowMetrics(
             steps=steps_dict,
+            duration=duration,
         )
 
     def _call_custom_function(self, func: Callable, execution_input: WorkflowExecutionInput, **kwargs: Any) -> Any:
@@ -1316,7 +1325,14 @@ class Workflow:
 
                 # Update the workflow_run_response with completion data
                 if collected_step_outputs:
-                    workflow_run_response.metrics = self._aggregate_workflow_metrics(collected_step_outputs)
+                    # Stop the timer for the Run duration
+                    if workflow_run_response.metrics:
+                        workflow_run_response.metrics.stop_timer()
+
+                    workflow_run_response.metrics = self._aggregate_workflow_metrics(
+                        collected_step_outputs,
+                        workflow_run_response.metrics,  # type: ignore[arg-type]
+                    )
                     last_output = cast(StepOutput, collected_step_outputs[-1])
 
                     # Use deepest nested content if this is a container (Steps/Router/Loop/etc.)
@@ -1361,6 +1377,10 @@ class Workflow:
                 raise e
 
             finally:
+                # Stop timer on error
+                if workflow_run_response.metrics:
+                    workflow_run_response.metrics.stop_timer()
+
                 self._update_session_metrics(session=session, workflow_run_response=workflow_run_response)
                 session.upsert_run(run=workflow_run_response)
                 self.save_session(session=session)
@@ -1551,7 +1571,14 @@ class Workflow:
 
                 # Update the workflow_run_response with completion data
                 if collected_step_outputs:
-                    workflow_run_response.metrics = self._aggregate_workflow_metrics(collected_step_outputs)
+                    # Stop the timer for the Run duration
+                    if workflow_run_response.metrics:
+                        workflow_run_response.metrics.stop_timer()
+
+                    workflow_run_response.metrics = self._aggregate_workflow_metrics(
+                        collected_step_outputs,
+                        workflow_run_response.metrics,  # type: ignore[arg-type]
+                    )
                     last_output = cast(StepOutput, collected_step_outputs[-1])
 
                     # Use deepest nested content if this is a container (Steps/Router/Loop/etc.)
@@ -1618,7 +1645,14 @@ class Workflow:
                 # Preserve all progress (completed steps + partial step) before cancellation
                 if collected_step_outputs:
                     workflow_run_response.step_results = collected_step_outputs
-                    workflow_run_response.metrics = self._aggregate_workflow_metrics(collected_step_outputs)
+                    # Stop the timer for the Run duration
+                    if workflow_run_response.metrics:
+                        workflow_run_response.metrics.stop_timer()
+
+                    workflow_run_response.metrics = self._aggregate_workflow_metrics(
+                        collected_step_outputs,
+                        workflow_run_response.metrics,  # type: ignore[arg-type]
+                    )
 
                 cancelled_event = WorkflowCancelledEvent(
                     run_id=workflow_run_response.run_id or "",
@@ -1660,6 +1694,10 @@ class Workflow:
         )
         yield self._handle_event(workflow_completed_event, workflow_run_response)
 
+        # Stop timer on error
+        if workflow_run_response.metrics:
+            workflow_run_response.metrics.stop_timer()
+
         # Store the completed workflow response
         self._update_session_metrics(session=session, workflow_run_response=workflow_run_response)
         session.upsert_run(run=workflow_run_response)
@@ -1863,7 +1901,14 @@ class Workflow:
 
                 # Update the workflow_run_response with completion data
                 if collected_step_outputs:
-                    workflow_run_response.metrics = self._aggregate_workflow_metrics(collected_step_outputs)
+                    # Stop the timer for the Run duration
+                    if workflow_run_response.metrics:
+                        workflow_run_response.metrics.stop_timer()
+
+                    workflow_run_response.metrics = self._aggregate_workflow_metrics(
+                        collected_step_outputs,
+                        workflow_run_response.metrics,  # type: ignore[arg-type]
+                    )
                     last_output = cast(StepOutput, collected_step_outputs[-1])
 
                     # Use deepest nested content if this is a container (Steps/Router/Loop/etc.)
@@ -1903,6 +1948,10 @@ class Workflow:
                 workflow_run_response.content = f"Workflow execution failed: {e}"
                 raise e
 
+        # Stop timer on error
+        if workflow_run_response.metrics:
+            workflow_run_response.metrics.stop_timer()
+
         self._update_session_metrics(session=workflow_session, workflow_run_response=workflow_run_response)
         workflow_session.upsert_run(run=workflow_run_response)
         if self._has_async_db():
@@ -2114,7 +2163,14 @@ class Workflow:
 
                 # Update the workflow_run_response with completion data
                 if collected_step_outputs:
-                    workflow_run_response.metrics = self._aggregate_workflow_metrics(collected_step_outputs)
+                    # Stop the timer for the Run duration
+                    if workflow_run_response.metrics:
+                        workflow_run_response.metrics.stop_timer()
+
+                    workflow_run_response.metrics = self._aggregate_workflow_metrics(
+                        collected_step_outputs,
+                        workflow_run_response.metrics,  # type: ignore[arg-type]
+                    )
                     last_output = cast(StepOutput, collected_step_outputs[-1])
 
                     # Use deepest nested content if this is a container (Steps/Router/Loop/etc.)
@@ -2181,7 +2237,14 @@ class Workflow:
                 # Preserve all progress (completed steps + partial step) before cancellation
                 if collected_step_outputs:
                     workflow_run_response.step_results = collected_step_outputs
-                    workflow_run_response.metrics = self._aggregate_workflow_metrics(collected_step_outputs)
+                    # Stop the timer for the Run duration
+                    if workflow_run_response.metrics:
+                        workflow_run_response.metrics.stop_timer()
+
+                    workflow_run_response.metrics = self._aggregate_workflow_metrics(
+                        collected_step_outputs,
+                        workflow_run_response.metrics,  # type: ignore[arg-type]
+                    )
 
                 cancelled_event = WorkflowCancelledEvent(
                     run_id=workflow_run_response.run_id or "",
@@ -2227,6 +2290,10 @@ class Workflow:
         )
         yield self._handle_event(workflow_completed_event, workflow_run_response, websocket_handler=websocket_handler)
 
+        # Stop timer on error
+        if workflow_run_response.metrics:
+            workflow_run_response.metrics.stop_timer()
+
         # Store the completed workflow response
         self._update_session_metrics(session=workflow_session, workflow_run_response=workflow_run_response)
         workflow_session.upsert_run(run=workflow_run_response)
@@ -2288,6 +2355,10 @@ class Workflow:
             status=RunStatus.pending,
         )
 
+        # Start the run metrics timer
+        workflow_run_response.metrics = WorkflowMetrics(steps={})
+        workflow_run_response.metrics.start_timer()
+
         # Store PENDING response immediately
         workflow_session.upsert_run(run=workflow_run_response)
         if self._has_async_db():
@@ -2402,6 +2473,10 @@ class Workflow:
             status=RunStatus.pending,
         )
 
+        # Start the run metrics timer
+        workflow_run_response.metrics = WorkflowMetrics(steps={})
+        workflow_run_response.metrics.start_timer()
+
         # Prepare execution input
         inputs = WorkflowExecutionInput(
             input=input,
@@ -3445,6 +3520,10 @@ class Workflow:
             created_at=int(datetime.now().timestamp()),
         )
 
+        # Start the run metrics timer
+        workflow_run_response.metrics = WorkflowMetrics(steps={})
+        workflow_run_response.metrics.start_timer()
+
         if stream:
             return self._execute_stream(
                 session=workflow_session,
@@ -3632,6 +3711,10 @@ class Workflow:
             created_at=int(datetime.now().timestamp()),
         )
 
+        # Start the run metrics timer
+        workflow_run_response.metrics = WorkflowMetrics(steps={})
+        workflow_run_response.metrics.start_timer()
+
         if stream:
             return self._aexecute_stream(  # type: ignore
                 execution_input=inputs,
@@ -3978,7 +4061,7 @@ class Workflow:
 
         # If workflow has metrics, convert and add them to session metrics
         if workflow_run_response.metrics:
-            run_session_metrics = self._calculate_session_metrics_from_workflow_metrics(workflow_run_response.metrics)
+            run_session_metrics = self._calculate_session_metrics_from_workflow_metrics(workflow_run_response.metrics)  # type: ignore[arg-type]
 
             session_metrics += run_session_metrics
 

{agno-2.2.10.dist-info → agno-2.2.11.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agno
-Version: 2.2.10
+Version: 2.2.11
 Summary: Agno: a lightweight library for building Multi-Agent Systems
 Author-email: Ashpreet Bedi <ashpreet@agno.com>
 Project-URL: homepage, https://agno.com
@@ -165,6 +165,8 @@ Provides-Extra: notion
 Requires-Dist: notion-client; extra == "notion"
 Provides-Extra: opencv
 Requires-Dist: opencv-python; extra == "opencv"
+Provides-Extra: parallel
+Requires-Dist: parallel-web; extra == "parallel"
 Provides-Extra: psycopg
 Requires-Dist: psycopg-binary; extra == "psycopg"
 Requires-Dist: psycopg; extra == "psycopg"
@@ -316,6 +318,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[parallel]; extra == "tools"
 Requires-Dist: agno[scrapegraph]; extra == "tools"
 Requires-Dist: agno[valyu]; extra == "tools"
 Requires-Dist: agno[confluence]; extra == "tools"