agno 2.1.2__py3-none-any.whl → 2.3.13__py3-none-any.whl

agno/tools/tavily.py

@@ -17,21 +17,51 @@ class TavilyTools(Toolkit):
         api_key: Optional[str] = None,
         enable_search: bool = True,
         enable_search_context: bool = False,
+        enable_extract: bool = False,
         all: bool = False,
         max_tokens: int = 6000,
         include_answer: bool = True,
         search_depth: Literal["basic", "advanced"] = "advanced",
+        extract_depth: Literal["basic", "advanced"] = "basic",
+        include_images: bool = False,
+        include_favicon: bool = False,
+        extract_timeout: Optional[int] = None,
+        extract_format: Literal["markdown", "text"] = "markdown",
         format: Literal["json", "markdown"] = "markdown",
         **kwargs,
     ):
+        """Initialize TavilyTools with search and extract capabilities.
+
+        Args:
+            api_key: Tavily API key. If not provided, will use TAVILY_API_KEY env var.
+            enable_search: Enable web search functionality. Defaults to True.
+            enable_search_context: Use search context mode instead of regular search. Defaults to False.
+            enable_extract: Enable URL content extraction functionality. Defaults to False.
+            all: Enable all available tools. Defaults to False.
+            max_tokens: Maximum tokens for search results. Defaults to 6000.
+            include_answer: Include AI-generated answer in search results. Defaults to True.
+            search_depth: Search depth level - basic (1 credit) or advanced (2 credits). Defaults to "advanced".
+            extract_depth: Extract depth level - basic (1 credit/5 URLs) or advanced (2 credits/5 URLs). Defaults to "basic".
+            include_images: Include images in extracted content. Defaults to False.
+            include_favicon: Include favicon in extracted content. Defaults to False.
+            extract_timeout: Timeout in seconds for extraction requests. Defaults to None.
+            extract_format: Output format for extracted content - markdown or text. Defaults to "markdown".
+            format: Output format for search results - json or markdown. Defaults to "markdown".
+            **kwargs: Additional arguments passed to Toolkit.
+        """
         self.api_key = api_key or getenv("TAVILY_API_KEY")
         if not self.api_key:
             logger.error("TAVILY_API_KEY not provided")
 
         self.client: TavilyClient = TavilyClient(api_key=self.api_key)
         self.search_depth: Literal["basic", "advanced"] = search_depth
+        self.extract_depth: Literal["basic", "advanced"] = extract_depth
         self.max_tokens: int = max_tokens
         self.include_answer: bool = include_answer
+        self.include_images: bool = include_images
+        self.include_favicon: bool = include_favicon
+        self.extract_timeout: Optional[int] = extract_timeout
+        self.extract_format: Literal["markdown", "text"] = extract_format
         self.format: Literal["json", "markdown"] = format
 
         tools: List[Any] = []
@@ -42,6 +72,9 @@ class TavilyTools(Toolkit):
             else:
                 tools.append(self.web_search_using_tavily)
 
+        if enable_extract or all:
+            tools.append(self.extract_url_content)
+
         super().__init__(name="tavily_tools", tools=tools, **kwargs)
 
     def web_search_using_tavily(self, query: str, max_results: int = 5) -> str:
@@ -106,3 +139,116 @@ class TavilyTools(Toolkit):
         return self.client.get_search_context(
             query=query, search_depth=self.search_depth, max_tokens=self.max_tokens, include_answer=self.include_answer
         )
+
+    def extract_url_content(self, urls: str) -> str:
+        """Extract content from one or more URLs using Tavily's Extract API.
+        This function retrieves the main content from web pages in markdown or text format.
+
+        Args:
+            urls (str): Single URL or multiple comma-separated URLs to extract content from.
+                       Example: "https://example.com" or "https://example.com,https://another.com"
+
+        Returns:
+            str: Extracted content in the specified format (markdown or text).
+                 For multiple URLs, returns combined content with URL headers.
+                 Failed extractions are noted in the output.
+        """
+        # Parse URLs - handle both single and comma-separated multiple URLs
+        url_list = [url.strip() for url in urls.split(",") if url.strip()]
+
+        if not url_list:
+            return "Error: No valid URLs provided."
+
+        try:
+            # Prepare extract parameters
+            extract_params: Dict[str, Any] = {
+                "urls": url_list,
+                "depth": self.extract_depth,
+            }
+
+            # Add optional parameters if specified
+            if self.include_images:
+                extract_params["include_images"] = True
+            if self.include_favicon:
+                extract_params["include_favicon"] = True
+            if self.extract_timeout is not None:
+                extract_params["timeout"] = self.extract_timeout
+
+            # Call Tavily Extract API
+            response = self.client.extract(**extract_params)
+
+            # Process response based on format preference
+            if not response or "results" not in response:
+                return "Error: No content could be extracted from the provided URL(s)."
+
+            results = response.get("results", [])
+            if not results:
+                return "Error: No content could be extracted from the provided URL(s)."
+
+            # Format output
+            if self.extract_format == "markdown":
+                return self._format_extract_markdown(results)
+            elif self.extract_format == "text":
+                return self._format_extract_text(results)
+            else:
+                # Fallback to JSON if format is unrecognized
+                return json.dumps(results, indent=2)
+
+        except Exception as e:
+            logger.error(f"Error extracting content from URLs: {e}")
+            return f"Error extracting content: {str(e)}"
+
+    def _format_extract_markdown(self, results: List[Dict[str, Any]]) -> str:
+        """Format extraction results as markdown.
+
+        Args:
+            results: List of extraction result dictionaries from Tavily API.
+
+        Returns:
+            str: Formatted markdown content.
+        """
+        output = []
+
+        for result in results:
+            url = result.get("url", "Unknown URL")
+            raw_content = result.get("raw_content", "")
+            failed_reason = result.get("failed_reason")
+
+            if failed_reason:
+                output.append(f"## {url}\n\n **Extraction Failed**: {failed_reason}\n\n")
+            elif raw_content:
+                output.append(f"## {url}\n\n{raw_content}\n\n")
+            else:
+                output.append(f"## {url}\n\n*No content available*\n\n")
+
+        return "".join(output) if output else "No content extracted."
+
+    def _format_extract_text(self, results: List[Dict[str, Any]]) -> str:
+        """Format extraction results as plain text.
+
+        Args:
+            results: List of extraction result dictionaries from Tavily API.
+
+        Returns:
+            str: Formatted plain text content.
+        """
+        output = []
+
+        for result in results:
+            url = result.get("url", "Unknown URL")
+            raw_content = result.get("raw_content", "")
+            failed_reason = result.get("failed_reason")
+
+            output.append(f"URL: {url}")
+            output.append("-" * 80)
+
+            if failed_reason:
+                output.append(f"EXTRACTION FAILED: {failed_reason}")
+            elif raw_content:
+                output.append(raw_content)
+            else:
+                output.append("No content available")
+
+            output.append("\n")
+
+        return "\n".join(output) if output else "No content extracted."

agno/tools/toolkit.py

@@ -6,6 +6,10 @@ from agno.utils.log import log_debug, log_warning, logger
 
 
 class Toolkit:
+    # Set to True for toolkits that require connection management (e.g., database connections)
+    # When True, the Agent will automatically call connect() before using tools and close() after
+    _requires_connect: bool = False
+
     def __init__(
         self,
         name: str = "toolkit",
@@ -139,6 +143,27 @@ class Toolkit:
             logger.warning(f"Failed to create Function for: {function.__name__}")
             raise e
 
+    @property
+    def requires_connect(self) -> bool:
+        """Whether the toolkit requires connection management."""
+        return self._requires_connect
+
+    def connect(self) -> None:
+        """
+        Establish any required connections for the toolkit.
+        Override this method in subclasses that require connection management.
+        Called automatically by the Agent when _requires_connect is True.
+        """
+        pass
+
+    def close(self) -> None:
+        """
+        Close any open connections for the toolkit.
+        Override this method in subclasses that require connection management.
+        Called automatically by the Agent when _requires_connect is True.
+        """
+        pass
+
     def __repr__(self):
         return f"<{self.__class__.__name__} name={self.name} functions={list(self.functions.keys())}>"
 

agno/tools/workflow.py

@@ -130,9 +130,13 @@ class WorkflowTools(Toolkit):
     ) -> str:
         """Use this tool to execute the workflow with the specified inputs and parameters.
         After thinking through the requirements, use this tool to run the workflow with appropriate inputs.
+
         Args:
-            input_data: The input data for the workflow.
+            input: The input data for the workflow.
         """
+        if isinstance(input, dict):
+            input = RunWorkflowInput.model_validate(input)
+
         try:
             log_debug(f"Running workflow with input: {input.input_data}")
 
@@ -170,6 +174,9 @@ class WorkflowTools(Toolkit):
             input_data: The input data for the workflow (use a `str` for a simple input)
             additional_data: The additional data for the workflow. This is a dictionary of key-value pairs that will be passed to the workflow. E.g. {"topic": "food", "style": "Humour"}
         """
+        if isinstance(input, dict):
+            input = RunWorkflowInput.model_validate(input)
+
         try:
             log_debug(f"Running workflow with input: {input.input_data}")
 

agno/tools/yfinance.py

@@ -1,5 +1,5 @@
 import json
-from typing import Any, List
+from typing import Any, List, Optional
 
 from agno.tools import Toolkit
 from agno.utils.log import log_debug
@@ -18,6 +18,7 @@ class YFinanceTools(Toolkit):
 
     def __init__(
         self,
+        session: Optional[Any] = None,
         **kwargs,
     ):
         tools: List[Any] = [
@@ -31,7 +32,7 @@ class YFinanceTools(Toolkit):
             self.get_technical_indicators,
             self.get_historical_stock_prices,
         ]
-
+        self.session = session
         super().__init__(name="yfinance_tools", tools=tools, **kwargs)
 
     def get_current_stock_price(self, symbol: str) -> str:
@@ -46,7 +47,7 @@ class YFinanceTools(Toolkit):
         """
         try:
             log_debug(f"Fetching current price for {symbol}")
-            stock = yf.Ticker(symbol)
+            stock = yf.Ticker(symbol, session=self.session)
             # Use "regularMarketPrice" for regular market hours, or "currentPrice" for pre/post market
             current_price = stock.info.get("regularMarketPrice", stock.info.get("currentPrice"))
             return f"{current_price:.4f}" if current_price else f"Could not fetch current price for {symbol}"
@@ -63,7 +64,7 @@ class YFinanceTools(Toolkit):
             str: JSON containing company profile and overview.
         """
         try:
-            company_info_full = yf.Ticker(symbol).info
+            company_info_full = yf.Ticker(symbol, session=self.session).info
             if company_info_full is None:
                 return f"Could not fetch company info for {symbol}"
 
@@ -120,7 +121,7 @@ class YFinanceTools(Toolkit):
         """
         try:
             log_debug(f"Fetching historical prices for {symbol}")
-            stock = yf.Ticker(symbol)
+            stock = yf.Ticker(symbol, session=self.session)
             historical_price = stock.history(period=period, interval=interval)
             return historical_price.to_json(orient="index")
         except Exception as e:
@@ -150,7 +151,7 @@ class YFinanceTools(Toolkit):
         """
         try:
             log_debug(f"Fetching fundamentals for {symbol}")
-            stock = yf.Ticker(symbol)
+            stock = yf.Ticker(symbol, session=self.session)
             info = stock.info
             fundamentals = {
                 "symbol": symbol,
@@ -181,7 +182,7 @@ class YFinanceTools(Toolkit):
         """
         try:
             log_debug(f"Fetching income statements for {symbol}")
-            stock = yf.Ticker(symbol)
+            stock = yf.Ticker(symbol, session=self.session)
             financials = stock.financials
             return financials.to_json(orient="index")
         except Exception as e:
@@ -198,7 +199,7 @@ class YFinanceTools(Toolkit):
         """
         try:
             log_debug(f"Fetching key financial ratios for {symbol}")
-            stock = yf.Ticker(symbol)
+            stock = yf.Ticker(symbol, session=self.session)
             key_ratios = stock.info
             return json.dumps(key_ratios, indent=2)
         except Exception as e:
@@ -215,7 +216,7 @@ class YFinanceTools(Toolkit):
         """
         try:
             log_debug(f"Fetching analyst recommendations for {symbol}")
-            stock = yf.Ticker(symbol)
+            stock = yf.Ticker(symbol, session=self.session)
             recommendations = stock.recommendations
             return recommendations.to_json(orient="index")
         except Exception as e:
@@ -233,7 +234,7 @@ class YFinanceTools(Toolkit):
         """
         try:
             log_debug(f"Fetching company news for {symbol}")
-            news = yf.Ticker(symbol).news
+            news = yf.Ticker(symbol, session=self.session).news
             return json.dumps(news[:num_stories], indent=2)
         except Exception as e:
             return f"Error fetching company news for {symbol}: {e}"
@@ -251,7 +252,7 @@ class YFinanceTools(Toolkit):
         """
         try:
             log_debug(f"Fetching technical indicators for {symbol}")
-            indicators = yf.Ticker(symbol).history(period=period)
+            indicators = yf.Ticker(symbol, session=self.session).history(period=period)
             return indicators.to_json(orient="index")
         except Exception as e:
             return f"Error fetching technical indicators for {symbol}: {e}"

agno/tracing/__init__.py

@@ -0,0 +1,12 @@
+"""
+Agno Tracing Module
+
+This module provides OpenTelemetry-based tracing capabilities for Agno agents.
+It uses the openinference-instrumentation-agno package for automatic instrumentation
+and provides a custom DatabaseSpanExporter to store traces in the Agno database.
+"""
+
+from agno.tracing.exporter import DatabaseSpanExporter
+from agno.tracing.setup import setup_tracing
+
+__all__ = ["DatabaseSpanExporter", "setup_tracing"]

agno/tracing/exporter.py

@@ -0,0 +1,157 @@
+"""
+Custom OpenTelemetry SpanExporter that writes traces to Agno database.
+"""
+
+import asyncio
+from collections import defaultdict
+from typing import Dict, List, Sequence, Union
+
+from opentelemetry.sdk.trace import ReadableSpan  # type: ignore
+from opentelemetry.sdk.trace.export import SpanExporter, SpanExportResult  # type: ignore
+
+from agno.db.base import AsyncBaseDb, BaseDb
+from agno.tracing.schemas import Span, create_trace_from_spans
+from agno.utils.log import logger
+
+
+class DatabaseSpanExporter(SpanExporter):
+    """Custom OpenTelemetry SpanExporter that writes to Agno database"""
+
+    def __init__(self, db: Union[BaseDb, AsyncBaseDb]):
+        """
+        Initialize the DatabaseSpanExporter.
+
+        Args:
+            db: Database instance (sync or async) to store traces
+        """
+        self.db = db
+        self._shutdown = False
+
+    def export(self, spans: Sequence[ReadableSpan]) -> SpanExportResult:
+        """
+        Export spans to the database.
+
+        This method:
+        1. Converts OpenTelemetry spans to Span objects
+        2. Groups spans by trace_id
+        3. Creates Trace records (one per trace_id)
+        4. Creates Span records (multiple per trace_id)
+
+        Args:
+            spans: Sequence of OpenTelemetry ReadableSpan objects
+
+        Returns:
+            SpanExportResult indicating success or failure
+        """
+        if self._shutdown:
+            logger.warning("DatabaseSpanExporter is shutdown, cannot export spans")
+            return SpanExportResult.FAILURE
+
+        if not spans:
+            return SpanExportResult.SUCCESS
+
+        try:
+            # Convert OpenTelemetry spans to Span objects
+            converted_spans: List[Span] = []
+            for span in spans:
+                try:
+                    converted_span = Span.from_otel_span(span)
+                    converted_spans.append(converted_span)
+                except Exception as e:
+                    logger.error(f"Failed to convert span {span.name}: {e}")
+                    # Continue processing other spans
+                    continue
+
+            if not converted_spans:
+                return SpanExportResult.SUCCESS
+
+            # Group spans by trace_id
+            spans_by_trace: Dict[str, List[Span]] = defaultdict(list)
+            for converted_span in converted_spans:
+                spans_by_trace[converted_span.trace_id].append(converted_span)
+
+            # Handle async DB
+            if isinstance(self.db, AsyncBaseDb):
+                self._export_async(spans_by_trace)
+            else:
+                # Synchronous database
+                self._export_sync(spans_by_trace)
+
+            return SpanExportResult.SUCCESS
+        except Exception as e:
+            logger.error(f"Failed to export spans to database: {e}", exc_info=True)
+            return SpanExportResult.FAILURE
+
+    def _export_sync(self, spans_by_trace: Dict[str, List[Span]]) -> None:
+        """Export traces and spans to synchronous database"""
+        try:
+            # Create trace and span records for each trace
+            for trace_id, spans in spans_by_trace.items():
+                # Create trace record (aggregate of all spans)
+                trace = create_trace_from_spans(spans)
+                if trace:
+                    self.db.upsert_trace(trace)
+
+                # Create span records
+                self.db.create_spans(spans)
+
+        except Exception as e:
+            logger.error(f"Failed to export sync traces: {e}", exc_info=True)
+            raise
+
+    def _export_async(self, spans_by_trace: Dict[str, List[Span]]) -> None:
+        """Handle async database export"""
+        try:
+            loop = asyncio.get_event_loop()
+            if loop.is_running():
+                # We're in an async context, schedule the coroutine
+                asyncio.create_task(self._do_async_export(spans_by_trace))
+            else:
+                # No running loop, run in new loop
+                loop.run_until_complete(self._do_async_export(spans_by_trace))
+        except RuntimeError:
+            # No event loop, create new one
+            try:
+                asyncio.run(self._do_async_export(spans_by_trace))
+            except Exception as e:
+                logger.error(f"Failed to export async traces: {e}", exc_info=True)
+
+    async def _do_async_export(self, spans_by_trace: Dict[str, List[Span]]) -> None:
+        """Actually perform the async export"""
+        try:
+            # Create trace and span records for each trace
+            for trace_id, spans in spans_by_trace.items():
+                # Create trace record (aggregate of all spans)
+                trace = create_trace_from_spans(spans)
+                if trace:
+                    create_trace_result = self.db.upsert_trace(trace)
+                    if create_trace_result is not None:
+                        await create_trace_result
+
+                # Create span records
+                create_spans_result = self.db.create_spans(spans)
+                if create_spans_result is not None:
+                    await create_spans_result
+
+        except Exception as e:
+            logger.error(f"Failed to do async export: {e}", exc_info=True)
+            raise
+
+    def shutdown(self) -> None:
+        """Shutdown the exporter"""
+        self._shutdown = True
+        logger.debug("DatabaseSpanExporter shutdown")
+
+    def force_flush(self, timeout_millis: int = 30000) -> bool:
+        """
+        Force flush any pending spans.
+
+        Since we write immediately to the database, this is a no-op.
+
+        Args:
+            timeout_millis: Timeout in milliseconds
+
+        Returns:
+            True if flush was successful
+        """
+        return True