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

waldiez/_version.py

@@ -5,4 +5,4 @@
 This file is automatically generated by Hatchling.
 Do not edit this file directly.
 """
-__version__ = VERSION = "0.5.1"
+__version__ = VERSION = "0.5.3"

waldiez/cli.py

@@ -139,6 +139,7 @@ def run(
             structured,
             not patch_io,  # skip_patch_io
             False,  # skip_mmd
+            False,  # skip_timeline
         )
     else:
         runner.run(
@@ -148,6 +149,7 @@ def run(
             threaded=threaded,
             skip_patch_io=not patch_io,
             skip_mmd=False,
+            skip_timeline=False,
         )
 
 

waldiez/exporting/agent/extras/group_manager_agent_extas.py

@@ -353,8 +353,12 @@ class GroupManagerProcessor:
 
         # Selection method
         if speakers.selection_method != "custom":
+            selection_method = speakers.selection_method
+            if selection_method == "default":
+                # this only on pattern based group chats :(
+                selection_method = "auto"
             config_lines.append(
-                f'    speaker_selection_method="{speakers.selection_method}",'
+                f'    speaker_selection_method="{selection_method}",'
             )
         else:
             # Custom selection method

waldiez/exporting/chats/processor.py

@@ -103,10 +103,10 @@ class ChatsProcessor:
         """Process the chats export."""
         self._gather_imports()
         self._handle_chat_registrations()
-        chat_initiation = self._generate_chat_initation()
+        chat_initiation = self._generate_chat_initiation()
         self._extras.set_chat_initiation(chat_initiation)
 
-    def _generate_chat_initation(self) -> str:
+    def _generate_chat_initiation(self) -> str:
         """Generate the chat definition string.
 
         Returns
@@ -120,7 +120,7 @@ class ChatsProcessor:
             return export_group_chats(
                 agent_names=self._agent_names,
                 manager=self._root_group_manager,
-                intial_chat=None,
+                initial_chat=None,
                 tabs=self._chat_tabs,
                 is_async=self._is_async,
             )
@@ -139,7 +139,7 @@ class ChatsProcessor:
                 return export_group_chats(
                     agent_names=self._agent_names,
                     manager=recipient,
-                    intial_chat=chat_massage_string,
+                    initial_chat=chat_massage_string,
                     tabs=self._chat_tabs,
                     is_async=self._is_async,
                 )

waldiez/exporting/chats/utils/group.py

@@ -14,7 +14,7 @@ from waldiez.models import WaldiezGroupManager
 def export_group_chats(
     agent_names: dict[str, str],
     manager: WaldiezGroupManager,
-    intial_chat: str | None,
+    initial_chat: str | None,
     tabs: int,
     is_async: bool,
 ) -> str:
@@ -26,7 +26,7 @@ def export_group_chats(
         The agent names.
     manager : WaldiezGroupManager
         The group manager agent.
-    intial_chat : str | None
+    initial_chat : str | None
         The initial chat to use if any.
     tabs : int
         The number of tabs for indentation.
@@ -46,8 +46,8 @@ def export_group_chats(
     pattern_name = f"{manager_name}_pattern"
     content = f"{tab}results, _, __ = {initiate_group_chat}(" + "\n"
     content += f"{tab}    pattern={pattern_name}," + "\n"
-    if intial_chat:
-        content += f"{tab}    messages={json.dumps(intial_chat)}," + "\n"
+    if initial_chat:
+        content += f"{tab}    messages={json.dumps(initial_chat)}," + "\n"
     else:
         content += f'{tab}    messages="",\n'
     content += f"{tab}    max_rounds={manager.data.max_round},\n"

waldiez/exporting/chats/utils/single.py

@@ -26,7 +26,7 @@ def export_single_chat(
     tabs: int,
     is_async: bool,
     skip_cache: bool,
-    tab_leng: int = 4,
+    tab_length: int = 4,
 ) -> tuple[str, str]:
     """Get the chat string when there is only one chat in the flow.
 
@@ -50,7 +50,7 @@ def export_single_chat(
         Whether the chat is asynchronous.
     skip_cache : bool
         Whether to skip the cache argument.
-    tab_leng : int, optional
+    tab_length : int, optional
         The length of the tab string, by default 4.
 
     Returns
@@ -94,7 +94,7 @@ def export_single_chat(
     )
     ```
     """
-    tab = " " * tab_leng * tabs if tabs > 0 else ""
+    tab = " " * tab_length * tabs if tabs > 0 else ""
     chat_args = chat.get_chat_args(for_queue=False, sender=sender)
     # chat_args = update_summary_chat_args(chat_args, skip_summary=True)
     if not chat_args:

waldiez/exporting/tools/exporter.py

@@ -23,7 +23,7 @@ from .registration import ToolRegistrationProcessor
 
 
 class ToolsExporter(Exporter[ToolExtras]):
-    """Rools exporter with structured extras."""
+    """Tools exporter with structured extras."""
 
     def __init__(
         self,

waldiez/models/chat/chat_message.py

@@ -159,7 +159,7 @@ class WaldiezChatMessage(WaldiezBase):
                 )
             content = self.content
         if self.type == "rag_message_generator":
-            if self.use_carryover:
+            if not self.use_carryover:
                 content = get_last_carryover_method_content(
                     text_content=self.content or "",
                 )

waldiez/models/tool/extra_requirements.py

@@ -4,6 +4,7 @@
 
 from typing import Iterator, Set
 
+from .predefined import get_predefined_tool_requirements
 from .tool import WaldiezTool
 
 
@@ -31,6 +32,10 @@ def get_tools_extra_requirements(
             tool_requirements.add(f"ag2[interop-langchain]=={autogen_version}")
         if tool.tool_type == "crewai":
             tool_requirements.add(f"ag2[interop-crewai]=={autogen_version}")
+        if tool.is_predefined:
+            tool_requirements.update(
+                get_predefined_tool_requirements(tool.name)
+            )
         for requirement in tool.requirements:
             tool_requirements.add(requirement)
     return tool_requirements

waldiez/models/tool/predefined/__init__.py

@@ -0,0 +1,24 @@
+# SPDX-License-Identifier: Apache-2.0.
+# Copyright (c) 2024 - 2025 Waldiez and contributors.
+
+"""Predefined tools for Waldiez."""
+
+from ._config import PredefinedToolConfig
+from .protocol import PredefinedTool
+from .registry import (
+    PREDEFINED_TOOLS,
+    get_predefined_tool_config,
+    get_predefined_tool_imports,
+    get_predefined_tool_requirements,
+    list_predefined_tools,
+)
+
+__all__ = [
+    "PredefinedTool",
+    "PredefinedToolConfig",
+    "PREDEFINED_TOOLS",
+    "get_predefined_tool_imports",
+    "get_predefined_tool_config",
+    "get_predefined_tool_requirements",
+    "list_predefined_tools",
+]

waldiez/models/tool/predefined/_config.py

@@ -0,0 +1,68 @@
+# SPDX-License-Identifier: Apache-2.0.
+# Copyright (c) 2024 - 2025 Waldiez and contributors.
+"""Predefined tool configuration for Waldiez."""
+
+from dataclasses import dataclass
+
+from .protocol import PredefinedTool
+
+
+@dataclass
+class PredefinedToolConfig:
+    """Configuration for a predefined tool."""
+
+    name: str
+    description: str
+    required_secrets: list[str]
+    required_kwargs: dict[str, type]
+    requirements: list[str]
+    tags: list[str]
+    implementation: PredefinedTool
+
+    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.
+        """
+        return self.implementation.validate_secrets(secrets)
+
+    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.
+        """
+        return self.implementation.validate_kwargs(kwargs)
+
+    def get_content(
+        self,
+        secrets: dict[str, str],
+    ) -> str:
+        """Get the content of the tool.
+
+        Parameters
+        ----------
+        secrets : dict[str, str]
+            Dictionary of secrets/environment variables.
+
+        Returns
+        -------
+        str
+            Content of the tool.
+        """
+        return self.implementation.get_content(secrets)

waldiez/models/tool/predefined/_google.py

@@ -0,0 +1,166 @@
+# SPDX-License-Identifier: Apache-2.0.
+# Copyright (c) 2024 - 2025 Waldiez and contributors.
+# pylint: disable=line-too-long
+# flake8: noqa: E501
+"""Predefined Google search tool for Waldiez."""
+
+import os
+from typing import Any
+
+from ._config import PredefinedToolConfig
+from .protocol import PredefinedTool
+
+
+class GoogleSearchToolImpl(PredefinedTool):
+    """Google search tool for Waldiez."""
+
+    required_secrets: list[str] = [
+        "GOOGLE_SEARCH_API_KEY",
+    ]
+    required_kwargs: dict[str, type] = {
+        "google_search_engine_id": str,
+    }
+    _kwargs: dict[str, Any] = {}
+
+    @property
+    def name(self) -> str:
+        """Tool name."""
+        return "google_search"
+
+    @property
+    def description(self) -> str:
+        """Tool description."""
+        return "Search Google for a given query."
+
+    @property
+    def kwargs(self) -> dict[str, Any]:
+        """Keyword arguments for the tool, used for initialization."""
+        return self._kwargs
+
+    @property
+    def requirements(self) -> list[str]:
+        """Python requirements for the tool."""
+        return ["ag2[google-search,gemini,openai]"]
+
+    @property
+    def tags(self) -> list[str]:
+        """Tags for the tool, used for categorization."""
+        return ["google", "search", "web"]
+
+    @property
+    def tool_imports(self) -> list[str]:
+        """Imports required for the tool implementation."""
+        return [
+            "from autogen.tools.experimental import GoogleSearchTool",
+        ]
+
+    @property
+    def google_search_engine_id(self) -> str:
+        """Google search engine ID."""
+        from_env = os.environ.get("GOOGLE_SEARCH_ENGINE_ID", "")
+        if from_env:
+            return from_env
+        return str(self.kwargs.get("google_search_engine_id", ""))
+
+    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: list[str] = []
+        for secret in self.required_secrets:
+            if secret not in secrets:
+                missing.append(secret)
+        return missing
+
+    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.
+
+        Raises
+        ------
+        ValueError
+            If any keyword argument is invalid
+            (cannot be cast to the required type).
+        """
+        missing: list[str] = []
+        invalid: list[str] = []
+        for name, type_of in self.required_kwargs.items():
+            if name not in kwargs:
+                missing.append(name)
+            elif not isinstance(kwargs[name], type_of):
+                try:
+                    kwargs[name] = type_of(kwargs[name])
+                    self._kwargs[name] = kwargs[name]
+                except Exception:  # pylint: disable=broad-except
+                    invalid.append(name)
+                else:
+                    if name in self._kwargs:
+                        self._kwargs[name] = kwargs[name]
+            else:
+                self._kwargs[name] = kwargs[name]
+        if invalid:
+            raise ValueError(f"Invalid keyword arguments: {invalid}")
+        return missing
+
+    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.
+        """
+        os.environ["GOOGLE_SEARCH_API_KEY"] = secrets.get(
+            "GOOGLE_SEARCH_API_KEY", ""
+        )
+        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}",
+)
+"""
+        return content
+
+
+GoogleSearchTool = GoogleSearchToolImpl()
+GoogleSearchConfig = PredefinedToolConfig(
+    name=GoogleSearchTool.name,
+    description=GoogleSearchTool.description,
+    required_secrets=GoogleSearchTool.required_secrets,
+    required_kwargs=GoogleSearchTool.required_kwargs,
+    requirements=GoogleSearchTool.requirements,
+    tags=GoogleSearchTool.tags,
+    implementation=GoogleSearchTool,
+)

waldiez/models/tool/predefined/_tavily.py

@@ -0,0 +1,124 @@
+# SPDX-License-Identifier: Apache-2.0.
+# Copyright (c) 2024 - 2025 Waldiez and contributors.
+# pylint: disable=line-too-long
+# flake8: noqa: E501
+"""Predefined Tavily search tool for Waldiez."""
+
+import os
+from typing import Any
+
+from ._config import PredefinedToolConfig
+from .protocol import PredefinedTool
+
+
+class TavilySearchToolImpl(PredefinedTool):
+    """Tavily search tool for Waldiez."""
+
+    required_secrets: list[str] = ["TAVILY_API_KEY"]
+    required_kwargs: dict[str, type] = {}
+
+    @property
+    def name(self) -> str:
+        """Tool name."""
+        return "tavily_search"
+
+    @property
+    def description(self) -> str:
+        """Tool description."""
+        return "Search Tavily 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[tavily, openai]"]
+
+    @property
+    def tags(self) -> list[str]:
+        """Tags for the tool, used for categorization."""
+        return ["tavily", "search", "web"]
+
+    @property
+    def tool_imports(self) -> list[str]:
+        """Imports required for the tool implementation."""
+        return [
+            "from autogen.tools.experimental import TavilySearchTool",
+        ]
+
+    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 = []
+        if not secrets.get("TAVILY_API_KEY"):
+            missing.append("TAVILY_API_KEY")
+        return missing
+
+    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.
+        """
+        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.
+        """
+        os.environ["TAVILY_API_KEY"] = secrets.get(
+            "TAVILY_API_KEY", os.environ.get("TAVILY_API_KEY", "")
+        )
+        content = f"""
+tavily_api_key = os.environ.get("TAVILY_API_KEY", "")
+if not tavily_api_key:
+    raise ValueError("TAVILY_API_KEY is required for Tavily search tool.")
+{self.name} = TavilySearchTool(
+    tavily_api_key=tavily_api_key,
+)
+"""
+        return content
+
+
+TavilySearchTool = TavilySearchToolImpl()
+TavilySearchConfig = PredefinedToolConfig(
+    name=TavilySearchTool.name,
+    description=TavilySearchTool.description,
+    required_secrets=TavilySearchTool.required_secrets,
+    required_kwargs=TavilySearchTool.required_kwargs,
+    requirements=TavilySearchTool.requirements,
+    tags=TavilySearchTool.tags,
+    implementation=TavilySearchTool,
+)

waldiez/models/tool/predefined/_wikipedia.py

@@ -0,0 +1,130 @@
+# SPDX-License-Identifier: Apache-2.0.
+# Copyright (c) 2024 - 2025 Waldiez and contributors.
+"""Predefined Wikipedia search tool for Waldiez."""
+
+from typing import Any
+
+from ._config import PredefinedToolConfig
+from .protocol import PredefinedTool
+
+
+class WikipediaSearchToolImpl(PredefinedTool):
+    """Wikipedia search tool for Waldiez."""
+
+    required_secrets: list[str] = []
+    kwargs_types: dict[str, type] = {
+        "language": str,
+        "top_k": int,
+        "verbose": bool,
+    }
+    required_kwargs: dict[str, type] = {}
+
+    @property
+    def name(self) -> str:
+        """Tool name."""
+        return "wikipedia_search"
+
+    @property
+    def description(self) -> str:
+        """Tool description."""
+        return "Search Wikipedia for a given query."
+
+    @property
+    def kwargs(self) -> dict[str, Any]:
+        """Keyword arguments for the tool, used for initialization."""
+        return {
+            "language": "en",
+            "top_k": 3,
+            "verbose": False,
+        }
+
+    @property
+    def requirements(self) -> list[str]:
+        """Python requirements for the tool."""
+        return ["ag2[wikipedia, openai]"]
+
+    @property
+    def tags(self) -> list[str]:
+        """Tags for the tool, used for categorization."""
+        return ["wikipedia", "search", "knowledge", "reference"]
+
+    @property
+    def tool_imports(self) -> list[str]:
+        """Imports required for the tool implementation."""
+        return [
+            "from autogen.tools.experimental import WikipediaQueryRunTool",
+            "from autogen.tools.experimental import WikipediaPageLoadTool",
+        ]
+
+    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.
+        """
+        return []
+
+    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, _ in self.kwargs.items():
+            if key in kwargs:
+                type_of = self.required_kwargs.get(key, str)
+                try:
+                    casted = type_of(kwargs[key])
+                    if key in self.kwargs:
+                        self.kwargs[key] = casted
+                except Exception:  # pylint: disable=broad-except
+                    pass
+        return []
+
+    def get_content(
+        self,
+        secrets: dict[str, str],
+    ) -> str:
+        """Get the content of the tool.
+
+        Parameters
+        ----------
+        secrets : dict[str, str]
+            Dictionary of secrets/environment variables.
+
+        Returns
+        -------
+        str
+            Content of the tool.
+        """
+        content = f"{self.name} = WikipediaQueryRunTool(\n"
+        for key, value in self.kwargs.items():
+            content += f"    {key}={value!r},\n"
+        content += ")\n"
+        return content
+
+
+WikipediaSearchTool = WikipediaSearchToolImpl()
+WikipediaSearchConfig = PredefinedToolConfig(
+    name=WikipediaSearchTool.name,
+    description=WikipediaSearchTool.description,
+    required_secrets=WikipediaSearchTool.required_secrets,
+    required_kwargs=WikipediaSearchTool.required_kwargs,
+    requirements=WikipediaSearchTool.requirements,
+    tags=WikipediaSearchTool.tags,
+    implementation=WikipediaSearchTool,
+)