ag2 0.9.1a1__py3-none-any.whl → 0.9.1.post0__py3-none-any.whl

autogen/tools/experimental/perplexity/perplexity_search.py

@@ -0,0 +1,260 @@
+"""
+Module: perplexity_search_tool
+Copyright (c) 2023 - 2025, AG2ai, Inc., AG2ai open-source projects maintainers and core contributors
+SPDX-License-Identifier: Apache-2.0
+
+This module provides classes for interacting with the Perplexity AI search API.
+It defines data models for responses and a tool for executing web and conversational searches.
+"""
+
+import json
+import os
+from typing import Any, Optional, Union
+
+import requests
+from pydantic import BaseModel, ValidationError
+
+from autogen.tools import Tool
+
+
+class Message(BaseModel):
+    """
+    Represents a message in the chat conversation.
+
+    Attributes:
+        role (str): The role of the message sender (e.g., "system", "user").
+        content (str): The text content of the message.
+    """
+
+    role: str
+    content: str
+
+
+class Usage(BaseModel):
+    """
+    Model representing token usage details.
+
+    Attributes:
+        prompt_tokens (int): The number of tokens used for the prompt.
+        completion_tokens (int): The number of tokens generated in the completion.
+        total_tokens (int): The total number of tokens (prompt + completion).
+        search_context_size (str): The size context used in the search (e.g., "high").
+    """
+
+    prompt_tokens: int
+    completion_tokens: int
+    total_tokens: int
+    search_context_size: str
+
+
+class Choice(BaseModel):
+    """
+    Represents one choice in the response from the Perplexity API.
+
+    Attributes:
+        index (int): The index of this choice.
+        finish_reason (str): The reason why the API finished generating this choice.
+        message (Message): The message object containing the response text.
+    """
+
+    index: int
+    finish_reason: str
+    message: Message
+
+
+class PerplexityChatCompletionResponse(BaseModel):
+    """
+    Represents the full chat completion response from the Perplexity API.
+
+    Attributes:
+        id (str): Unique identifier for the response.
+        model (str): The model name used for generating the response.
+        created (int): Timestamp when the response was created.
+        usage (Usage): Token usage details.
+        citations (list[str]): list of citation strings included in the response.
+        object (str): Type of the response object.
+        choices (list[Choice]): list of choices returned by the API.
+    """
+
+    id: str
+    model: str
+    created: int
+    usage: Usage
+    citations: list[str]
+    object: str
+    choices: list[Choice]
+
+
+class SearchResponse(BaseModel):
+    """
+    Represents the response from a search query.
+
+    Attributes:
+        content (Optional[str]): The textual content returned from the search.
+        citations (Optional[list[str]]): A list of citation URLs relevant to the search result.
+        error (Optional[str]): An error message if the search failed.
+    """
+
+    content: Union[str, None]
+    citations: Union[list[str], None]
+    error: Union[str, None]
+
+
+class PerplexitySearchTool(Tool):
+    """
+    Tool for interacting with the Perplexity AI search API.
+
+    This tool uses the Perplexity API to perform web search, news search,
+    and conversational search, returning concise and precise responses.
+
+    Attributes:
+        url (str): API endpoint URL.
+        model (str): Name of the model to be used.
+        api_key (str): API key for authenticating with the Perplexity API.
+        max_tokens (int): Maximum tokens allowed for the API response.
+        search_domain_filters (Optional[list[str]]): Optional list of domain filters for the search.
+    """
+
+    def __init__(
+        self,
+        model: str = "sonar",
+        api_key: Optional[str] = None,
+        max_tokens: int = 1000,
+        search_domain_filter: Optional[list[str]] = None,
+    ):
+        """
+        Initializes a new instance of the PerplexitySearchTool.
+
+        Args:
+            model (str, optional): The model to use. Defaults to "sonar".
+            api_key (Optional[str], optional): API key for authentication.
+            max_tokens (int, optional): Maximum number of tokens for the response. Defaults to 1000.
+            search_domain_filter (Optional[list[str]], optional): list of domain filters to restrict search.
+
+        Raises:
+            ValueError: If the API key is missing, the model is empty, max_tokens is not positive,
+                        or if search_domain_filter is not a list when provided.
+        """
+        self.api_key = api_key or os.getenv("PERPLEXITY_API_KEY")
+        self._validate_tool_config(model, self.api_key, max_tokens, search_domain_filter)
+        self.url = "https://api.perplexity.ai/chat/completions"
+        self.model = model
+        self.max_tokens = max_tokens
+        self.search_domain_filters = search_domain_filter
+        super().__init__(
+            name="perplexity-search",
+            description="Perplexity AI search tool for web search, news search, and conversational search "
+            "for finding answers to everyday questions, conducting in-depth research and analysis.",
+            func_or_tool=self.search,
+        )
+
+    @staticmethod
+    def _validate_tool_config(
+        model: str, api_key: Union[str, None], max_tokens: int, search_domain_filter: Union[list[str], None]
+    ) -> None:
+        """
+        Validates the configuration parameters for the search tool.
+
+        Args:
+            model (str): The model to use.
+            api_key (Union[str, None]): The API key for authentication.
+            max_tokens (int): Maximum tokens allowed.
+            search_domain_filter (Union[list[str], None]): Domain filters for search.
+
+        Raises:
+            ValueError: If the API key is missing, model is empty, max_tokens is not positive,
+                        or search_domain_filter is not a list.
+        """
+        if not api_key:
+            raise ValueError("Perplexity API key is missing")
+        if not model:
+            raise ValueError("model cannot be empty")
+        if max_tokens <= 0:
+            raise ValueError("max_tokens must be positive")
+        if search_domain_filter is not None and not isinstance(search_domain_filter, list):
+            raise ValueError("search_domain_filter must be a list")
+
+    def _execute_query(self, payload: dict[str, Any]) -> "PerplexityChatCompletionResponse":
+        """
+        Executes a query by sending a POST request to the Perplexity API.
+
+        Args:
+            payload (dict[str, Any]): The payload to send in the API request.
+
+        Returns:
+            PerplexityChatCompletionResponse: Parsed response from the Perplexity API.
+
+        Raises:
+            RuntimeError: If there is a network error, HTTP error, JSON parsing error, or if the response
+                          cannot be parsed into a PerplexityChatCompletionResponse.
+        """
+        headers = {"Authorization": f"Bearer {self.api_key}", "Content-Type": "application/json"}
+        response = requests.request("POST", self.url, json=payload, headers=headers, timeout=10)
+        try:
+            response.raise_for_status()
+        except requests.exceptions.Timeout as e:
+            raise RuntimeError(
+                f"Perplexity API => Request timed out: {response.text}. Status code: {response.status_code}"
+            ) from e
+        except requests.exceptions.HTTPError as e:
+            raise RuntimeError(
+                f"Perplexity API => HTTP error occurred: {response.text}. Status code: {response.status_code}"
+            ) from e
+        except requests.exceptions.RequestException as e:
+            raise RuntimeError(
+                f"Perplexity API => Error during request: {response.text}. Status code: {response.status_code}"
+            ) from e
+
+        try:
+            response_json = response.json()
+        except json.JSONDecodeError as e:
+            raise RuntimeError(f"Perplexity API => Invalid JSON response received. Error: {e}") from e
+
+        try:
+            # This may raise a pydantic.ValidationError if the response structure is not as expected.
+            perp_resp = PerplexityChatCompletionResponse(**response_json)
+        except ValidationError as e:
+            raise RuntimeError("Perplexity API => Validation error when parsing API response: " + str(e)) from e
+        except Exception as e:
+            raise RuntimeError(
+                "Perplexity API => Failed to parse API response into PerplexityChatCompletionResponse: " + str(e)
+            ) from e
+
+        return perp_resp
+
+    def search(self, query: str) -> "SearchResponse":
+        """
+        Perform a search query using the Perplexity AI API.
+
+        Constructs the payload, executes the query, and parses the response to return
+        a concise search result along with any provided citations.
+
+        Args:
+            query (str): The search query.
+
+        Returns:
+            SearchResponse: A model containing the search result content and citations.
+
+        Raises:
+            ValueError: If the search query is invalid.
+            RuntimeError: If there is an error during the search process.
+        """
+        if not query or not isinstance(query, str):
+            raise ValueError("A valid non-empty query string must be provided.")
+
+        payload = {
+            "model": self.model,
+            "messages": [{"role": "system", "content": "Be precise and concise."}, {"role": "user", "content": query}],
+            "max_tokens": self.max_tokens,
+            "search_domain_filter": self.search_domain_filters,
+            "web_search_options": {"search_context_size": "high"},
+        }
+
+        try:
+            perplexity_response = self._execute_query(payload)
+            content = perplexity_response.choices[0].message.content
+            citations = perplexity_response.citations
+            return SearchResponse(content=content, citations=citations, error=None)
+        except Exception as e:
+            # Return a SearchResponse with an error message if something goes wrong.
+            return SearchResponse(content=None, citations=None, error=f"{e}")

autogen/tools/experimental/tavily/__init__.py

@@ -0,0 +1,7 @@
+# Copyright (c) 2023 - 2025, AG2ai, Inc., AG2ai open-source projects maintainers and core contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from .tavily_search import TavilySearchTool
+
+__all__ = ["TavilySearchTool"]

autogen/tools/experimental/tavily/tavily_search.py

@@ -0,0 +1,183 @@
+# Copyright (c) 2023 - 2025, AG2ai, Inc., AG2ai open-source projects maintainers and core contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+import os
+from typing import Annotated, Any, Optional, Union
+
+from ....doc_utils import export_module
+from ....import_utils import optional_import_block, require_optional_import
+from ....llm_config import LLMConfig
+from ... import Depends, Tool
+from ...dependency_injection import on
+
+with optional_import_block():
+    from tavily import TavilyClient
+
+
+@require_optional_import(
+    [
+        "tavily",
+    ],
+    "tavily",
+)
+def _execute_tavily_query(
+    query: str,
+    tavily_api_key: str,
+    search_depth: str = "basic",
+    topic: str = "general",
+    include_answer: str = "basic",
+    include_raw_content: bool = False,
+    include_domains: list[str] = [],
+    num_results: int = 5,
+) -> Any:
+    """
+    Execute a search query using the Tavily API.
+
+    Args:
+        query (str): The search query string.
+        tavily_api_key (str): The API key for Tavily.
+        search_depth (str, optional): The depth of the search ('basic' or 'advanced'). Defaults to "basic".
+        topic (str, optional): The topic of the search. Defaults to "general".
+        include_answer (str, optional): Whether to include an AI-generated answer ('basic' or 'advanced'). Defaults to "basic".
+        include_raw_content (bool, optional): Whether to include raw content in the results. Defaults to False.
+        include_domains (list[str], optional): A list of domains to include in the search. Defaults to [].
+        num_results (int, optional): The maximum number of results to return. Defaults to 5.
+
+    Returns:
+        Any: The raw response object from the Tavily API client.
+    """
+    tavily_client = TavilyClient(api_key=tavily_api_key)
+    return tavily_client.search(
+        query=query,
+        search_depth=search_depth,
+        topic=topic,
+        include_answer=include_answer,
+        include_raw_content=include_raw_content,
+        include_domains=include_domains,
+        max_results=num_results,
+    )
+
+
+def _tavily_search(
+    query: str,
+    tavily_api_key: str,
+    search_depth: str = "basic",
+    topic: str = "general",
+    include_answer: str = "basic",
+    include_raw_content: bool = False,
+    include_domains: list[str] = [],
+    num_results: int = 5,
+) -> list[dict[str, Any]]:
+    """
+    Perform a Tavily search and format the results.
+
+    This function takes search parameters, executes the query using `_execute_tavily_query`,
+    and formats the results into a list of dictionaries containing title, link, and snippet.
+
+    Args:
+        query (str): The search query string.
+        tavily_api_key (str): The API key for Tavily.
+        search_depth (str, optional): The depth of the search ('basic' or 'advanced'). Defaults to "basic".
+        topic (str, optional): The topic of the search. Defaults to "general".
+        include_answer (str, optional): Whether to include an AI-generated answer ('basic' or 'advanced'). Defaults to "basic".
+        include_raw_content (bool, optional): Whether to include raw content in the results. Defaults to False.
+        include_domains (list[str], optional): A list of domains to include in the search. Defaults to [].
+        num_results (int, optional): The maximum number of results to return. Defaults to 5.
+
+    Returns:
+        list[dict[str, Any]]: A list of dictionaries, where each dictionary represents a search result
+            with keys 'title', 'link', and 'snippet'. Returns an empty list if no results are found.
+    """
+    res = _execute_tavily_query(
+        query=query,
+        tavily_api_key=tavily_api_key,
+        search_depth=search_depth,
+        topic=topic,
+        include_answer=include_answer,
+        include_raw_content=include_raw_content,
+        include_domains=include_domains,
+        num_results=num_results,
+    )
+
+    return [
+        {"title": item.get("title", ""), "link": item.get("url", ""), "snippet": item.get("content", "")}
+        for item in res.get("results", [])
+    ]
+
+
+@export_module("autogen.tools.experimental")
+class TavilySearchTool(Tool):
+    """
+    TavilySearchTool is a tool that uses the Tavily Search API to perform a search.
+
+    This tool allows agents to leverage the Tavily search engine for information retrieval.
+    It requires a Tavily API key, which can be provided during initialization or set as
+    an environment variable `TAVILY_API_KEY`.
+
+    Attributes:
+        tavily_api_key (str): The API key used for authenticating with the Tavily API.
+    """
+
+    def __init__(
+        self, *, llm_config: Optional[Union[LLMConfig, dict[str, Any]]] = None, tavily_api_key: Optional[str] = None
+    ):
+        """
+        Initializes the TavilySearchTool.
+
+        Args:
+            llm_config (Optional[Union[LLMConfig, dict[str, Any]]]): LLM configuration. (Currently unused but kept for potential future integration).
+            tavily_api_key (Optional[str]): The API key for the Tavily Search API. If not provided,
+                it attempts to read from the `TAVILY_API_KEY` environment variable.
+
+        Raises:
+            ValueError: If `tavily_api_key` is not provided either directly or via the environment variable.
+        """
+        self.tavily_api_key = tavily_api_key or os.getenv("TAVILY_API_KEY")
+
+        if self.tavily_api_key is None:
+            raise ValueError("tavily_api_key must be provided either as an argument or via TAVILY_API_KEY env var")
+
+        def tavily_search(
+            query: Annotated[str, "The search query."],
+            tavily_api_key: Annotated[Optional[str], Depends(on(self.tavily_api_key))],
+            search_depth: Annotated[Optional[str], "Either 'advanced' or 'basic'"] = "basic",
+            include_answer: Annotated[Optional[str], "Either 'advanced' or 'basic'"] = "basic",
+            include_raw_content: Annotated[Optional[bool], "Include the raw contents"] = False,
+            include_domains: Annotated[Optional[list[str]], "Specific web domains to search"] = [],
+            num_results: Annotated[int, "The number of results to return."] = 5,
+        ) -> list[dict[str, Any]]:
+            """
+            Performs a search using the Tavily API and returns formatted results.
+
+            Args:
+                query: The search query string.
+                tavily_api_key: The API key for Tavily (injected dependency).
+                search_depth: The depth of the search ('basic' or 'advanced'). Defaults to "basic".
+                include_answer: Whether to include an AI-generated answer ('basic' or 'advanced'). Defaults to "basic".
+                include_raw_content: Whether to include raw content in the results. Defaults to False.
+                include_domains: A list of domains to include in the search. Defaults to [].
+                num_results: The maximum number of results to return. Defaults to 5.
+
+            Returns:
+                A list of dictionaries, each containing 'title', 'link', and 'snippet' of a search result.
+
+            Raises:
+                ValueError: If the Tavily API key is not available.
+            """
+            if tavily_api_key is None:
+                raise ValueError("Tavily API key is missing.")
+            return _tavily_search(
+                query=query,
+                tavily_api_key=tavily_api_key,
+                search_depth=search_depth or "basic",
+                include_answer=include_answer or "basic",
+                include_raw_content=include_raw_content or False,
+                include_domains=include_domains or [],
+                num_results=num_results,
+            )
+
+        super().__init__(
+            name="tavily_search",
+            description="Use the Tavily Search API to perform a search.",
+            func_or_tool=tavily_search,
+        )

autogen/tools/experimental/web_search_preview/__init__.py

@@ -0,0 +1,7 @@
+# Copyright (c) 2023 - 2025, AG2ai, Inc., AG2ai open-source projects maintainers and core contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from .web_search_preview import WebSearchPreviewTool
+
+__all__ = ["WebSearchPreviewTool"]

autogen/tools/experimental/web_search_preview/web_search_preview.py

@@ -0,0 +1,114 @@
+# Copyright (c) 2023 - 2025, AG2ai, Inc., AG2ai open-source projects maintainers and core contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+
+import copy
+import logging
+import os
+from typing import Annotated, Any, Literal, Optional, Type, Union
+
+from pydantic import BaseModel
+
+from ....doc_utils import export_module
+from ....import_utils import optional_import_block, require_optional_import
+from ....llm_config import LLMConfig
+from ... import Tool
+
+with optional_import_block():
+    from openai import OpenAI
+    from openai.types.responses import WebSearchToolParam
+    from openai.types.responses.web_search_tool import UserLocation
+
+
+@require_optional_import("openai>=1.66.2", "openai")
+@export_module("autogen.tools.experimental")
+class WebSearchPreviewTool(Tool):
+    """WebSearchPreviewTool is a tool that uses OpenAI's web_search_preview tool to perform a search."""
+
+    def __init__(
+        self,
+        *,
+        llm_config: Union[LLMConfig, dict[str, Any]],
+        search_context_size: Literal["low", "medium", "high"] = "medium",
+        user_location: Optional[dict[str, str]] = None,
+        instructions: Optional[str] = None,
+        text_format: Optional[Type[BaseModel]] = None,
+    ):
+        """Initialize the WebSearchPreviewTool.
+
+        Args:
+            llm_config: The LLM configuration to use. This should be a dictionary
+                containing the model name and other parameters.
+            search_context_size: The size of the search context. One of `low`, `medium`, or `high`.
+                `medium` is the default.
+            user_location: The location of the user. This should be a dictionary containing
+                the city, country, region, and timezone.
+            instructions: Inserts a system (or developer) message as the first item in the model's context.
+            text_format: The format of the text to be returned. This should be a subclass of `BaseModel`.
+                The default is `None`, which means the text will be returned as a string.
+        """
+        self.web_search_tool_param = WebSearchToolParam(
+            type="web_search_preview",
+            search_context_size=search_context_size,
+            user_location=UserLocation(**user_location) if user_location else None,  # type: ignore[typeddict-item]
+        )
+        self.instructions = instructions
+        self.text_format = text_format
+
+        if isinstance(llm_config, LLMConfig):
+            llm_config = llm_config.model_dump()
+
+        llm_config = copy.deepcopy(llm_config)
+
+        if "config_list" not in llm_config:
+            raise ValueError("llm_config must contain 'config_list' key")
+
+        # Find first OpenAI model which starts with "gpt-4"
+        self.model = None
+        self.api_key = None
+        for model in llm_config["config_list"]:
+            if model["model"].startswith("gpt-4") and model.get("api_type", "openai") == "openai":
+                self.model = model["model"]
+                self.api_key = model.get("api_key", os.getenv("OPENAI_API_KEY"))
+                break
+        if self.model is None:
+            raise ValueError(
+                "No OpenAI model starting with 'gpt-4' found in llm_config, other models do not support web_search_preview"
+            )
+
+        if not self.model.startswith("gpt-4.1") and not self.model.startswith("gpt-4o-search-preview"):
+            logging.warning(
+                f"We recommend using a model starting with 'gpt-4.1' or 'gpt-4o-search-preview' for web_search_preview, but found {self.model}. "
+                "This may result in suboptimal performance."
+            )
+
+        def web_search_preview(
+            query: Annotated[str, "The search query. Add all relevant context to the query."],
+        ) -> Union[str, Optional[BaseModel]]:
+            client = OpenAI()
+
+            if not self.text_format:
+                response = client.responses.create(
+                    model=self.model,  # type: ignore[arg-type]
+                    tools=[self.web_search_tool_param],
+                    input=query,
+                    instructions=self.instructions,
+                )
+                return response.output_text
+
+            else:
+                response = client.responses.parse(
+                    model=self.model,  # type: ignore[arg-type]
+                    tools=[self.web_search_tool_param],
+                    input=query,
+                    instructions=self.instructions,
+                    text_format=self.text_format,
+                )
+                return response.output_parsed
+
+        super().__init__(
+            name="web_search_preview",
+            description="Tool used to perform a web search. It can be used as google search or directly searching a specific website.",
+            func_or_tool=web_search_preview,
+        )

autogen/tools/experimental/wikipedia/__init__.py

@@ -0,0 +1,7 @@
+# Copyright (c) 2023 - 2025, AG2ai, Inc., AG2ai open-source projects maintainers and core contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from .wikipedia import WikipediaPageLoadTool, WikipediaQueryRunTool
+
+__all__ = ["WikipediaPageLoadTool", "WikipediaQueryRunTool"]