waldiez 0.5.3__py3-none-any.whl → 0.5.5__py3-none-any.whl

waldiez/models/model/model.py

@@ -9,7 +9,9 @@ from pydantic import Field
 from typing_extensions import Annotated, Literal
 
 from ..common import WaldiezBase, now
-from .model_data import WaldiezModelAPIType, WaldiezModelAWS, WaldiezModelData
+from ._aws import WaldiezModelAWS
+from ._llm import get_llm_arg, get_llm_imports, get_llm_requirements
+from .model_data import WaldiezModelAPIType, WaldiezModelData
 
 DEFAULT_BASE_URLS: dict[WaldiezModelAPIType, str] = {
     "deepseek": "https://api.deepseek.com/v1",
@@ -26,7 +28,7 @@ DEFAULT_BASE_URLS: dict[WaldiezModelAPIType, str] = {
 # we can omit the base_url for these models
 MODEL_NEEDS_BASE_URL: dict[WaldiezModelAPIType, bool] = {
     "openai": False,
-    "azure": False,
+    "azure": True,
     "google": False,
     "anthropic": False,
     "cohere": False,
@@ -172,6 +174,10 @@ class WaldiezModel(WaldiezBase):
         )
         if api_key and api_key != "REPLACE_ME":
             os.environ[env_key] = api_key
+            if api_key == "GOOGLE_GEMINI_API_KEY":
+                # llama-index expects GOOGLE_API_KEY
+                # https://docs.llamaindex.ai/en/stable/examples/llm/gemini/
+                os.environ["GOOGLE_API_KEY"] = api_key
         return api_key or "REPLACE_ME"
 
     @property
@@ -228,6 +234,43 @@ class WaldiezModel(WaldiezBase):
             return set_bedrock_aws_config(_llm_config, self.data.aws)
         return set_default_base_url(_llm_config, self.data.api_type)
 
+    def get_llm_requirements(self, ag2_version: str) -> set[str]:
+        """Get the LLM requirements for the model.
+
+        Parameters
+        ----------
+        ag2_version : str
+            The version of AG2 to use for the requirements.
+
+        Returns
+        -------
+        set[str]
+            The set of LLM requirements for the model.
+        """
+        return get_llm_requirements(self, ag2_version=ag2_version)
+
+    def get_llm_imports(self) -> set[str]:
+        """Get the LLM import statements for the model.
+
+        Returns
+        -------
+        set[str]
+            The set of LLM import statements for the model.
+        """
+        return get_llm_imports(self)
+
+    def get_llm_arg(
+        self,
+    ) -> tuple[str, str]:
+        """Get the LLM argument and any content before it.
+
+        Returns
+        -------
+        tuple[str, str]
+            The LLM argument string for the model and any content before it.
+        """
+        return get_llm_arg(self)
+
 
 def set_default_base_url(
     llm_config: dict[str, Any], api_type: WaldiezModelAPIType

waldiez/models/model/model_data.py

@@ -9,6 +9,8 @@ from pydantic import Field
 from typing_extensions import Annotated, Literal
 
 from ..common import WaldiezBase
+from ._aws import WaldiezModelAWS
+from ._price import WaldiezModelPrice
 
 WaldiezModelAPIType = Literal[
     "openai",
@@ -27,89 +29,6 @@ WaldiezModelAPIType = Literal[
 """Possible API types for the model."""
 
 
-class WaldiezModelAWS(WaldiezBase):
-    """AWS related parameters.
-
-    Attributes
-    ----------
-    region : Optional[str]
-        The AWS region, by default None.
-    access_key : Optional[str]
-        The AWS access key, by default None.
-    secret_key : Optional[str]
-        The AWS secret access key, by default None.
-    session_token : Optional[str]
-        The AWS session token, by default None.
-    profile_name : Optional[str]
-        The AWS profile name, by default Nonde.
-    """
-
-    region: Annotated[
-        Optional[str],
-        Field(
-            None,
-            alias="region",
-            title="Region",
-            description="The AWS region",
-        ),
-    ] = None
-    access_key: Annotated[
-        Optional[str],
-        Field(
-            None,
-            alias="accessKey",
-            title="Access Ke",
-            description="The AWS access key",
-        ),
-    ] = None
-    secret_key: Annotated[
-        Optional[str],
-        Field(
-            None,
-            alias="secretKey",
-            title="Secret Key",
-            description="The AWS secret key",
-        ),
-    ] = None
-    session_token: Annotated[
-        Optional[str],
-        Field(
-            None,
-            alias="sessionToken",
-            title="Session Token",
-            description="The AWS session token",
-        ),
-    ] = None
-    profile_name: Annotated[
-        Optional[str],
-        Field(
-            None,
-            alias="profileName",
-            title="Profile Name",
-            description="The AWS Profile name to use",
-        ),
-    ] = None
-
-
-class WaldiezModelPrice(WaldiezBase):
-    """Model Price.
-
-    Attributes
-    ----------
-    prompt_price_per_1k : float
-        The prompt price per 1k tokens.
-    completion_token_price_per_1k : float
-        The completion token price per 1k tokens.
-    """
-
-    prompt_price_per_1k: Annotated[
-        Optional[float], Field(None, alias="promptPricePer1k")
-    ]
-    completion_token_price_per_1k: Annotated[
-        Optional[float], Field(None, alias="completionTokenPricePer1k")
-    ]
-
-
 # pylint: disable=line-too-long
 class WaldiezModelData(WaldiezBase):
     """Waldiez Model Data.

waldiez/models/tool/predefined/_duckduckgo.py

@@ -0,0 +1,123 @@
+# SPDX-License-Identifier: Apache-2.0.
+# Copyright (c) 2024 - 2025 Waldiez and contributors.
+"""Predefined DuckDuckGo search tool for Waldiez."""
+
+from typing import Any
+
+from ._config import PredefinedToolConfig
+from .protocol import PredefinedTool
+
+
+class DuckDuckGoSearchToolImpl(PredefinedTool):
+    """DuckDuckGo search tool for Waldiez."""
+
+    required_secrets: list[str] = []
+    required_kwargs: dict[str, type] = {}
+
+    @property
+    def name(self) -> str:
+        """Tool name."""
+        return "duckduckgo_search"
+
+    @property
+    def description(self) -> str:
+        """Tool description."""
+        return "Search DuckDuckGo for a given query."
+
+    @property
+    def kwargs(self) -> dict[str, Any]:
+        """Keyword arguments for the tool, used for initialization."""
+        return {}
+
+    @property
+    def requirements(self) -> list[str]:
+        """Python requirements for the tool."""
+        return ["ag2[duckduckgo]", "ddgs"]
+
+    @property
+    def tags(self) -> list[str]:
+        """Tags for the tool, used for categorization."""
+        return ["duckduckgo", "search", "web"]
+
+    @property
+    def tool_imports(self) -> list[str]:
+        """Imports required for the tool implementation."""
+        return [
+            "from autogen.tools.experimental import DuckDuckGoSearchTool",
+        ]
+
+    def validate_secrets(self, secrets: dict[str, str]) -> list[str]:
+        """Validate secrets and return list of missing required ones.
+
+        Parameters
+        ----------
+        secrets : dict[str, str]
+            Dictionary of secrets/environment variables.
+
+        Returns
+        -------
+        list[str]
+            List of missing required secrets.
+        """
+        # no secrets required for DuckDuckGo search tool
+        return []
+
+    def validate_kwargs(self, kwargs: dict[str, str]) -> list[str]:
+        """Validate keyword arguments and return list of missing required ones.
+
+        Parameters
+        ----------
+        kwargs : dict[str, str]
+            Dictionary of keyword arguments.
+
+        Returns
+        -------
+        list[str]
+            List of missing required keyword arguments.
+        """
+        # no keyword arguments required for DuckDuckGo search tool
+        return []
+
+    def get_content(
+        self,
+        secrets: dict[str, str],
+    ) -> str:
+        """Get content for the tool.
+
+        Parameters
+        ----------
+        secrets : dict[str, str]
+            Dictionary of secrets/environment variables.
+
+        Returns
+        -------
+        str
+            The content for the tool.
+        """
+        content = f'''
+def {self.name}(query: str, num_results: int = 5) -> list[dict[str, Any]]:
+    """Perform a DuckDuckGo search and return formatted results.
+
+    Args:
+        query: The search query string.
+        num_results: The maximum number of results to return. Defaults to 5.
+
+    Returns:
+        A list of dictionaries of the search results.
+    """
+    tool = DuckDuckGoSearchTool()
+    return tool(query=query, num_results=num_results)
+'''
+        return content
+
+
+DuckDuckGoSearchTool = DuckDuckGoSearchToolImpl()
+DuckDuckGoSearchConfig = PredefinedToolConfig(
+    name=DuckDuckGoSearchTool.name,
+    description=DuckDuckGoSearchTool.description,
+    required_secrets=DuckDuckGoSearchTool.required_secrets,
+    required_kwargs=DuckDuckGoSearchTool.required_kwargs,
+    requirements=DuckDuckGoSearchTool.requirements,
+    tags=DuckDuckGoSearchTool.tags,
+    implementation=DuckDuckGoSearchTool,
+)

waldiez/models/tool/predefined/_google.py

@@ -142,15 +142,37 @@ class GoogleSearchToolImpl(PredefinedTool):
         google_search_engine_id = self.google_search_engine_id
         if not google_search_engine_id:
             google_search_engine_id = secrets.get("GOOGLE_SEARCH_ENGINE_ID", "")
-        content = f"""
-google_search_api_key = os.environ.get("GOOGLE_SEARCH_API_KEY", "")
-if not google_search_api_key:
-    raise ValueError("GOOGLE_SEARCH_API_KEY is required for Google search tool.")
-{self.name} = GoogleSearchTool(
-    search_api_key=google_search_api_key,
-    search_engine_id="{google_search_engine_id}",
-)
-"""
+        content = f'''
+def {self.name}(
+    query: str,
+    search_api_key: str,
+    search_engine_id: str,
+    num_results: int = 10,
+) -> list[dict[str, Any]]:
+    """Perform a Google search and return formatted results.
+
+    Args:
+        query: The search query string.
+        search_api_key: The API key for the Google Search API.
+        search_engine_id: The search engine ID for the Google Search API.
+        num_results: The maximum number of results to return. Defaults to 10.
+    Returns:
+        A list of dictionaries of the search results.
+    """
+    google_search_api_key = os.environ.get("GOOGLE_SEARCH_API_KEY", "")
+    if not google_search_api_key:
+        raise ValueError("GOOGLE_SEARCH_API_KEY is required for Google search tool.")
+    {self.name}_tool = GoogleSearchTool(
+        search_api_key=google_search_api_key,
+        search_engine_id="{google_search_engine_id}",
+    )
+    return {self.name}_tool(
+        query=query,
+        search_api_key=search_api_key,
+        search_engine_id=search_engine_id,
+        num_results=num_results
+    )
+'''
         return content
 
 

waldiez/models/tool/predefined/_perplexity.py

@@ -0,0 +1,161 @@
+# SPDX-License-Identifier: Apache-2.0.
+# Copyright (c) 2024 - 2025 Waldiez and contributors.
+# pylint: disable=line-too-long
+# flake8: noqa: E501
+"""Predefined Perplexity AI search tool for Waldiez."""
+
+import os
+from typing import Any
+
+from ._config import PredefinedToolConfig
+from .protocol import PredefinedTool
+
+
+class PerplexitySearchToolImpl(PredefinedTool):
+    """Perplexity AI search tool for Waldiez."""
+
+    required_secrets: list[str] = ["PERPLEXITY_API_KEY"]
+    required_kwargs: dict[str, type] = {}
+    kwarg_types: dict[str, type] = {
+        "model": str,
+        "max_tokens": int,
+        "search_domain_filters": list,
+    }
+
+    @property
+    def name(self) -> str:
+        """Tool name."""
+        return "perplexity_search"
+
+    @property
+    def description(self) -> str:
+        """Tool description."""
+        return "Search Perplexity AI for a given query."
+
+    @property
+    def kwargs(self) -> dict[str, Any]:
+        """Keyword arguments for the tool, used for initialization."""
+        return {
+            "model": "sonar",
+            "max_tokens": 1000,
+            "search_domain_filter": None,
+        }
+
+    @property
+    def requirements(self) -> list[str]:
+        """Python requirements for the tool."""
+        return []
+
+    @property
+    def tags(self) -> list[str]:
+        """Tags for the tool, used for categorization."""
+        return ["perplexity", "search", "web"]
+
+    @property
+    def tool_imports(self) -> list[str]:
+        """Imports required for the tool implementation."""
+        return [
+            "from autogen.tools.experimental import PerplexitySearchTool",
+            "from autogen.tools.experimental.perplexity.perplexity_search import SearchResponse",
+        ]
+
+    def validate_secrets(self, secrets: dict[str, str]) -> list[str]:
+        """Validate secrets and return list of missing required ones.
+
+        Parameters
+        ----------
+        secrets : dict[str, str]
+            Dictionary of secrets/environment variables.
+
+        Returns
+        -------
+        list[str]
+            List of missing required secrets.
+        """
+        missing_secrets: list[str] = []
+        if not secrets.get("PERPLEXITY_API_KEY"):
+            missing_secrets.append("PERPLEXITY_API_KEY")
+        return missing_secrets
+
+    def validate_kwargs(self, kwargs: dict[str, Any]) -> list[str]:
+        """Validate keyword arguments and return list of missing required ones.
+
+        Parameters
+        ----------
+        kwargs : dict[str, Any]
+            Dictionary of keyword arguments.
+
+        Returns
+        -------
+        list[str]
+            List of missing required keyword arguments.
+        """
+        for key, value in self.kwargs.items():
+            if key in kwargs:  # pragma: no branch
+                type_of = self.kwarg_types.get(key, str)
+                try:
+                    casted = type_of(value)
+                    if key in self.kwargs:  # pragma: no branch
+                        self.kwargs[key] = casted
+                except Exception:  # pylint: disable=broad-except
+                    pass
+        return []
+
+    def get_content(
+        self,
+        secrets: dict[str, str],
+    ) -> str:
+        """Get content for the tool.
+
+        Parameters
+        ----------
+        secrets : dict[str, str]
+            Dictionary of secrets/environment variables.
+
+        Returns
+        -------
+        str
+            Content retrieved by the tool.
+        """
+        os.environ["PERPLEXITY_API_KEY"] = secrets.get("PERPLEXITY_API_KEY", "")
+        content = f'''
+def {self.name}(
+    query: str,
+    model: str = "{self.kwargs["model"]}",
+    max_tokens: int = {self.kwargs["max_tokens"]},
+    search_domain_filter: Optional[list[str]] = {self.kwargs["search_domain_filter"]},
+) -> "SearchResponse":
+    """Perform a Perplexity AI search and return formatted results.
+
+    Args:
+        query: The search query string.
+        model: The model to use for the search. Defaults to "{self.kwargs["model"]}".
+        max_tokens: The maximum number of tokens to return. Defaults to {self.kwargs["max_tokens"]}.
+        search_domain_filter: List of domain filters for the search. Defaults to {self.kwargs["search_domain_filter"]}.
+    Returns:
+        A list of dictionaries of the search results.
+    """
+    perplexity_api_key = os.environ.get("PERPLEXITY_API_KEY", "")
+    if not perplexity_api_key:
+        raise ValueError("PERPLEXITY_API_KEY is required for Perplexity search tool.")
+    perplexity_search_tool = PerplexitySearchTool(
+        api_key=perplexity_api_key,
+        model=model,
+        max_tokens=max_tokens,
+        search_domain_filter=search_domain_filter,
+    )
+    return perplexity_search_tool(query=query)
+'''
+        return content
+
+
+PerplexitySearchTool = PerplexitySearchToolImpl()
+PerplexitySearchConfig = PredefinedToolConfig(
+    name=PerplexitySearchTool.name,
+    description=PerplexitySearchTool.description,
+    required_secrets=PerplexitySearchTool.required_secrets,
+    required_kwargs=PerplexitySearchTool.required_kwargs,
+    requirements=PerplexitySearchTool.requirements,
+    tags=PerplexitySearchTool.tags,
+    implementation=PerplexitySearchTool,
+)

waldiez/models/tool/predefined/_searxng.py

@@ -0,0 +1,152 @@
+# SPDX-License-Identifier: Apache-2.0.
+# Copyright (c) 2024 - 2025 Waldiez and contributors.
+# pylint: disable=line-too-long
+# flake8: noqa: E501
+"""Predefined SearxNG search tool for Waldiez."""
+
+from typing import Any
+
+from ._config import PredefinedToolConfig
+from .protocol import PredefinedTool
+
+
+class SearxNGSearchToolImpl(PredefinedTool):
+    """SearxNG search tool for Waldiez."""
+
+    required_secrets: list[str] = []
+    required_kwargs: dict[str, type] = {}
+    kwarg_types: dict[str, type] = {
+        "base_url": str,
+    }
+
+    @property
+    def name(self) -> str:
+        """Tool name."""
+        return "searxng_search"
+
+    @property
+    def description(self) -> str:
+        """Tool description."""
+        return "Search SearxNG for a given query."
+
+    @property
+    def kwargs(self) -> dict[str, Any]:
+        """Keyword arguments for the tool, used for initialization."""
+        return {
+            "base_url": "https://searxng.site/search",
+        }
+
+    @property
+    def requirements(self) -> list[str]:
+        """Python requirements for the tool."""
+        return []
+
+    @property
+    def tags(self) -> list[str]:
+        """Tags for the tool, used for categorization."""
+        return ["searxng", "search", "web"]
+
+    @property
+    def tool_imports(self) -> list[str]:
+        """Imports required for the tool implementation."""
+        return [
+            "from autogen.tools.experimental import SearxngSearchTool",
+        ]
+
+    def validate_secrets(self, secrets: dict[str, str]) -> list[str]:
+        """Validate secrets and return list of missing required ones.
+
+        Parameters
+        ----------
+        secrets : dict[str, str]
+            Dictionary of secrets to validate.
+
+        Returns
+        -------
+        list[str]
+            List of missing required secrets.
+        """
+        return []  # No secrets required for this tool.
+
+    def validate_kwargs(self, kwargs: dict[str, Any]) -> list[str]:
+        """Validate keyword arguments and return list of missing required ones.
+
+        Parameters
+        ----------
+        kwargs : dict[str, Any]
+            Dictionary of keyword arguments to validate.
+
+        Returns
+        -------
+        list[str]
+            List of missing required keyword arguments.
+        """
+        for key, value in self.kwargs.items():
+            if key in kwargs:  # pragma: no branch
+                type_of = self.kwarg_types.get(key, str)
+                try:
+                    casted = type_of(value)
+                    if key in self.kwargs:  # pragma: no branch
+                        self.kwargs[key] = casted
+                except Exception:  # pylint: disable=broad-except
+                    pass
+        return []
+
+    def get_content(
+        self,
+        secrets: dict[str, str],
+    ) -> str:
+        """Get content for the tool.
+
+        Parameters
+        ----------
+        secrets : dict[str, str]
+            Dictionary of secrets/environment variables.
+
+        Returns
+        -------
+        str
+            Content retrieved by the tool.
+        """
+        content = f'''
+def {self.name}(
+        query: str,
+        max_results: int = 5,
+        categories: list[str] | None = None,
+        language: str | None = None,
+    ) -> list[dict[str, Any]]:
+    """Perform a SearxNG search and return formatted results.
+
+    Args:
+        query: The search query string.
+        max_results: The maximum number of results to return. Defaults to 5.
+        categories: List of categories to search in.
+        language: Language code (e.g., 'en-US').
+        base_url: SearxNG instance URL.
+
+    Returns:
+        A list of dictionaries, each containing 'title', 'link', and 'snippet' of a search result.
+    """
+    tool = SearxngSearchTool(
+        base_url="{self.kwargs["base_url"]}",
+    )
+    return tool(
+        query=query,
+        max_results=max_results,
+        categories=categories,
+        language=language,
+    )
+'''
+        return content
+
+
+SearxNGSearchTool = SearxNGSearchToolImpl()
+SearxNGSearchConfig = PredefinedToolConfig(
+    name=SearxNGSearchTool.name,
+    description=SearxNGSearchTool.description,
+    tags=SearxNGSearchTool.tags,
+    requirements=SearxNGSearchTool.requirements,
+    required_kwargs=SearxNGSearchTool.required_kwargs,
+    required_secrets=SearxNGSearchTool.required_secrets,
+    implementation=SearxNGSearchTool,
+)