waldiez 0.4.7__py3-none-any.whl → 0.4.8__py3-none-any.whl

waldiez/exporting/agent/extras/rag_user_proxy_agent_extras.py

@@ -0,0 +1,245 @@
+# SPDX-License-Identifier: Apache-2.0.
+# Copyright (c) 2024 - 2025 Waldiez and contributors.
+"""RAG user proxy agent configuration processor."""
+
+from typing import Union
+
+from waldiez.models import (
+    WaldiezAgent,
+    WaldiezRagUserProxy,
+    WaldiezRagUserProxyModels,
+    WaldiezRagUserProxyRetrieveConfig,
+)
+
+from ...core import (
+    DefaultPathResolver,
+    DefaultSerializer,
+    ImportPosition,
+    ImportStatement,
+    InstanceArgument,
+    PathResolver,
+    Serializer,
+)
+from ...core.extras.agent_extras import RAGUserExtras
+from .rag import VectorDBExtras, get_vector_db_extras
+
+
+# pylint: disable=too-few-public-methods
+class RagUserProxyAgentProcessor:
+    """Processor for RAG user proxy agent configuration."""
+
+    _before_agent: str = ""
+
+    def __init__(
+        self,
+        agent: WaldiezAgent,
+        agent_name: str,
+        model_names: dict[str, str],
+        path_resolver: PathResolver | None = None,
+        serializer: Serializer | None = None,
+    ):
+        """Initialize the processor.
+
+        Parameters
+        ----------
+        agent : WaldiezAgent
+            The Waldiez RAG user proxy agent to process.
+        model_names : dict[str, str]
+            A mapping from model id to model name.
+        path_resolver : PathResolver | None
+            Optional path resolver for resolving paths.
+            Defaults to DefaultPathResolver if not provided.
+        serializer : Serializer | None
+            Optional serializer for the RAG configuration.
+            Defaults to DefaultSerializer if not provided.
+        """
+        self.agent = agent
+        self.agent_name = agent_name
+        self.model_names = model_names
+        self.path_resolver = path_resolver or DefaultPathResolver()
+        self.serializer = serializer or DefaultSerializer()
+
+    def process(self) -> RAGUserExtras:
+        """Process RAG user proxy agent configuration.
+
+        Returns
+        -------
+        RAGConfig
+            The processed result containing extra arguments, before content,
+            imports, and environment variables.
+        """
+        result = RAGUserExtras(self.agent.id)
+        if not self.agent.is_rag_user or not isinstance(
+            self.agent, WaldiezRagUserProxy
+        ):
+            return result
+        # Get the extra args
+        vector_db_extras = get_vector_db_extras(
+            agent=self.agent, agent_name=self.agent_name
+        )
+        before_agent, arg_value = self._get_retrieve_config(vector_db_extras)
+        if before_agent:
+            self._before_agent += before_agent
+        if arg_value:
+            retrieve_arg = InstanceArgument(
+                instance_id=self.agent.id,
+                name="retrieve_config",
+                value=arg_value,
+                tabs=1,
+            )
+            result.add_arg(retrieve_arg)
+        for import_statement in vector_db_extras.imports:
+            result.add_import(
+                ImportStatement(
+                    statement=import_statement,
+                    position=ImportPosition.THIRD_PARTY,
+                )
+            )
+        if self._before_agent:
+            result.prepend_before_agent(self._before_agent)
+        return result
+
+    def _get_retrieve_config(
+        self, vector_db_extras: VectorDBExtras
+    ) -> tuple[str, str]:
+        """Get the retrieve config argument for the agent.
+
+        Returns
+        -------
+        InstanceArgument | None
+            The retrieve config argument if applicable, otherwise None.
+        """
+        if not isinstance(self.agent, WaldiezRagUserProxy):
+            return "", ""
+        retrieve_config: WaldiezRagUserProxyRetrieveConfig = (
+            self.agent.retrieve_config
+        )
+        if not retrieve_config:
+            return "", ""
+        args_dict = self._get_args_dict()
+        if not args_dict:
+            return "", ""
+        before_agent = vector_db_extras.before_arg
+        if self.agent.retrieve_config.use_custom_token_count:
+            function_content, token_count_arg_name = (
+                retrieve_config.get_custom_token_count_function(
+                    name_suffix=self.agent_name
+                )
+            )
+            args_dict["custom_token_count_function"] = token_count_arg_name
+            before_agent += "\n" + function_content + "\n"
+        if self.agent.retrieve_config.use_custom_text_split:
+            function_content, text_split_arg_name = (
+                retrieve_config.get_custom_text_split_function(
+                    name_suffix=self.agent_name
+                )
+            )
+            args_dict["custom_text_split_function"] = text_split_arg_name
+            before_agent += "\n" + function_content + "\n"
+        if before_agent.strip() and not before_agent.endswith("\n"):
+            before_agent += "\n"
+        return before_agent, self._get_args_string(
+            args_dict,
+            vector_db_extras,
+            before_agent,
+        )
+
+    def _get_args_string(
+        self,
+        args_dict: dict[str, Union[str, list[str]]],
+        vector_db_extras: VectorDBExtras,
+        before_agent: str,
+    ) -> str:
+        if not isinstance(self.agent, WaldiezRagUserProxy):
+            return ""
+        args_content = self.serializer.serialize(args_dict)
+        # get the last line (where the dict ends)
+        args_parts = args_content.split("\n")
+        before_vector_db = args_parts[:-1]
+        closing_arg = args_parts[-1]
+        args_content = "\n".join(before_vector_db)
+        # add the vector_db arg
+        args_content += (
+            ",\n"
+            + f'        "vector_db": {vector_db_extras.vector_db_arg},'
+            + "\n"
+        )
+        # we should not need to include the client, but let's do it
+        # to avoid later issues (with telemetry or other client settings)
+        # https://github.com/ag2ai/ag2/blob/main/autogen/agentchat/\
+        #   contrib/retrieve_user_proxy_agent.py#L265-L266
+        if (
+            f"{self.agent_name}_client" in before_agent
+            and self.agent.retrieve_config.vector_db == "chroma"
+        ):
+            args_content += (
+                f'        "client": {self.agent_name}_client,' + "\n"
+            )
+        args_content += closing_arg
+        return args_content
+
+    def _get_model_arg(
+        self,
+    ) -> str:
+        if not isinstance(self.agent, WaldiezRagUserProxy):
+            return ""
+        if self.agent.data.model_ids:
+            model_name = self.model_names[self.agent.data.model_ids[0]]
+            new_model_name = f"{model_name}"
+            return f"{new_model_name}"
+        if self.agent.retrieve_config.model in self.model_names:
+            selected_model = self.model_names[self.agent.retrieve_config.model]
+            new_model_name = f"{selected_model}"
+            return f"{new_model_name}"
+        return WaldiezRagUserProxyModels[self.agent.retrieve_config.vector_db]
+
+    def _get_args_dict(self) -> dict[str, Union[str, list[str]]]:
+        if not isinstance(self.agent, WaldiezRagUserProxy):
+            return {}
+        model_arg = self._get_model_arg()
+        args_dict: dict[str, Union[str, list[str]]] = {
+            "task": self.agent.retrieve_config.task,
+            "model": model_arg,
+        }
+        optional_args = [
+            "chunk_token_size",
+            "context_max_tokens",
+            "customized_prompt",
+            "customized_answer_prefix",
+        ]
+        for arg in optional_args:
+            arg_value = getattr(self.agent.retrieve_config, arg)
+            if arg_value is not None:
+                args_dict[arg] = arg_value
+                args_dict[arg] = getattr(self.agent.retrieve_config, arg)
+        docs_path: Union[str, list[str]] = []
+        if self.agent.retrieve_config.docs_path:
+            doc_paths = (
+                self.agent.retrieve_config.docs_path
+                if isinstance(self.agent.retrieve_config.docs_path, list)
+                else [self.agent.retrieve_config.docs_path]
+            )
+            docs_path = [
+                item
+                for item in [
+                    self.path_resolver.resolve(path) for path in doc_paths
+                ]
+                if item
+            ]
+            args_dict["docs_path"] = docs_path
+        if docs_path:
+            args_dict["docs_path"] = docs_path
+        non_optional_args = [
+            "new_docs",
+            "update_context",
+            "get_or_create",
+            "overwrite",
+            "recursive",
+            "chunk_mode",
+            "must_break_at_empty_line",
+            "collection_name",
+            "distance_threshold",
+        ]
+        for arg in non_optional_args:
+            args_dict[arg] = getattr(self.agent.retrieve_config, arg)
+        return args_dict

waldiez/exporting/agent/extras/reasoning_agent_extras.py

@@ -0,0 +1,88 @@
+# SPDX-License-Identifier: Apache-2.0.
+# Copyright (c) 2024 - 2025 Waldiez and contributors.
+# pylint: disable=too-few-public-methods,no-self-use
+"""Reasoning agent configuration processor."""
+
+from typing import Optional
+
+from waldiez.models import WaldiezAgent, WaldiezReasoningAgent
+
+from ...core import (
+    CodeExecutionConfig,
+    DefaultSerializer,
+    InstanceArgument,
+    Serializer,
+    SystemMessageConfig,
+    TerminationConfig,
+)
+from ...core.extras.agent_extras import ReasoningExtras
+
+
+class ReasoningAgentProcessor:
+    """Processor for reasoning agent configuration."""
+
+    def __init__(self, agent: WaldiezAgent, serializer: Serializer | None):
+        """Initialize the processor with the agent and serializer.
+
+        Parameters
+        ----------
+        agent : WaldiezAgent
+            The Waldiez agent to process.
+        serializer : Serializer | None
+            Optional serializer for the reasoning configuration.
+            Defaults to DefaultSerializer if not provided.
+        """
+        self.agent = agent
+        self.serializer = serializer or DefaultSerializer()
+
+    def process(
+        self,
+        code_execution_config: Optional[CodeExecutionConfig] = None,
+        termination_config: Optional[TerminationConfig] = None,
+        system_message_config: Optional[SystemMessageConfig] = None,
+    ) -> ReasoningExtras:
+        """Process reasoning agent configuration.
+
+        Parameters
+        ----------
+        code_execution_config : CodeExecutionConfig, optional
+            Configuration for code execution, if applicable.
+        termination_config : TerminationConfig, optional
+            Configuration for termination, if applicable.
+        system_message_config : SystemMessageConfig, optional
+            Configuration for system messages, if applicable.
+
+        Returns
+        -------
+        ReasoningExtras
+            The processed result containing extra arguments, before content,
+            imports, and environment variables.
+        """
+        result = ReasoningExtras(
+            instance_id=self.agent.id,
+            code_execution_config=code_execution_config,
+            termination_config=termination_config,
+            system_message_config=system_message_config,
+        )
+        if not self.agent.is_reasoning or not isinstance(
+            self.agent, WaldiezReasoningAgent
+        ):  # pragma: no cover
+            return result
+
+        reasoning_config = self.agent.get_reasoning_config()
+        serialized = self.serializer.serialize(reasoning_config)
+        reason_arg = InstanceArgument(
+            instance_id=self.agent.id,
+            name="reason_config",
+            value=serialized,
+            tabs=1,
+        )
+        result.add_arg(reason_arg)
+        verbose_arg = InstanceArgument(
+            instance_id=self.agent.id,
+            name="verbose",
+            value=self.agent.data.verbose,
+            tabs=1,
+        )
+        result.add_arg(verbose_arg)
+        return result

waldiez/exporting/agent/factory.py

@@ -0,0 +1,95 @@
+# SPDX-License-Identifier: Apache-2.0.
+# Copyright (c) 2024 - 2025 Waldiez and contributors.
+# pylint: disable=too-few-public-methods,
+# pylint: disable=too-many-arguments,too-many-positional-arguments
+"""Factory for creating agent exporter."""
+
+from pathlib import Path
+from typing import Any, Callable, Optional, Union
+
+from waldiez.models import (
+    WaldiezAgent,
+    WaldiezAgentConnection,
+    WaldiezChat,
+    WaldiezModel,
+)
+
+from ..core import (
+    ExporterContext,
+    get_default_exporter_context,
+)
+from .exporter import AgentExporter
+
+
+def create_agent_exporter(
+    agent: WaldiezAgent,
+    agent_names: dict[str, str],
+    models: tuple[list[WaldiezModel], dict[str, str]],
+    chats: tuple[list[WaldiezChat], dict[str, str]],
+    tool_names: dict[str, str],
+    initial_chats: list[WaldiezAgentConnection],
+    is_async: bool = False,
+    for_notebook: bool = False,
+    cache_seed: Optional[int] = None,
+    group_chat_members: Optional[list[WaldiezAgent]] = None,
+    arguments_resolver: Optional[Callable[[WaldiezAgent], list[str]]] = None,
+    output_dir: Optional[Union[str, Path]] = None,
+    context: Optional[ExporterContext] = None,
+    **kwargs: Any,
+) -> AgentExporter:
+    """Create an agent exporter.
+
+    Parameters
+    ----------
+    agent : WaldiezAgent
+        The agent to export.
+    agent_names : dict[str, str]
+        Mapping of agent IDs to names.
+    models : tuple[list[WaldiezModel], dict[str, str]]
+        All models and model names mapping.
+    chats : tuple[list[WaldiezChat], dict[str, str]]
+        All chats and chat names mapping.
+    tool_names : dict[str, str]
+        Mapping of tool IDs to names.
+    is_async : bool, optional
+        Whether the flow is async, by default False
+    for_notebook : bool, optional
+        Whether exporting for notebook, by default False
+    cache_seed : Optional[int], optional
+        Cache seed if any, by default None
+    initial_chats : Optional[list[WaldiezAgentConnection]], optional
+        Initial chats for group managers, by default None
+    group_chat_members : Optional[list[WaldiezAgent]], optional
+        Group chat members if group manager, by default None
+    arguments_resolver : Optional[Callable], optional
+        Function to resolve additional arguments, by default None
+    output_dir : Optional[Union[str, Path]], optional
+        Output directory for generated files, by default None
+    context : Optional[ExporterContext], optional
+        Exporter context with dependencies, by default None
+    **kwargs : Any
+        Additional keyword arguments.
+
+    Returns
+    -------
+    AgentExporter
+        The created agent exporter.
+    """
+    if context is None:
+        context = get_default_exporter_context()
+    return AgentExporter(
+        agent=agent,
+        agent_names=agent_names,
+        models=models,
+        chats=chats,
+        tool_names=tool_names,
+        is_async=is_async,
+        for_notebook=for_notebook,
+        cache_seed=cache_seed,
+        initial_chats=initial_chats,
+        group_chat_members=group_chat_members,
+        arguments_resolver=arguments_resolver,
+        output_dir=output_dir,
+        context=context,
+        **kwargs,
+    )

waldiez/exporting/agent/processor.py

@@ -0,0 +1,150 @@
+# SPDX-License-Identifier: Apache-2.0.
+# Copyright (c) 2024 - 2025 Waldiez and contributors.
+# pylint: disable=too-few-public-methods, no-self-use
+"""Processor for generating Waldiez agent definitions."""
+
+import json
+from dataclasses import dataclass
+from typing import Callable
+
+from waldiez.models import WaldiezAgent
+
+from ..core.enums import GroupManagerStrategy
+from ..core.extras.agent_extras import GroupManagerExtras, StandardExtras
+
+
+@dataclass
+class AgentProcessingResult:
+    """Result from processing an agent."""
+
+    content: str = ""
+
+
+class AgentProcessor:
+    """Processor for main agent definition generation."""
+
+    def __init__(
+        self,
+        agent: WaldiezAgent,
+        agent_names: dict[str, str],
+        arguments_resolver: Callable[[WaldiezAgent], list[str]],
+        extras: StandardExtras,
+    ):
+        self.agent = agent
+        self.agent_names = agent_names
+        self.arguments_resolver = arguments_resolver
+        self.extras = extras
+
+    def _should_skip_group_manager(self) -> bool:
+        """Check if the group manager should be skipped.
+
+        Returns
+        -------
+        bool
+            True if the group manager should be skipped, False otherwise.
+        """
+        return (
+            isinstance(self.extras, GroupManagerExtras)
+            and self.extras.strategy == GroupManagerStrategy.PATTERN
+        )
+
+    def process(self) -> AgentProcessingResult:
+        """Process the agent and generate its definition.
+
+        Returns
+        -------
+        str
+            The generated agent definition string.
+        """
+        if (
+            isinstance(self.extras, GroupManagerExtras)
+            and self._should_skip_group_manager()
+        ):
+            return AgentProcessingResult(content="")
+        agent_name = self.agent_names[self.agent.id]
+
+        ag2_class = self.agent.ag2_class
+        # Build extra arguments
+        extra_args = ""
+        for arg in self.extras.extra_args:
+            extra_args += arg.get_content(append_new_line=True)
+
+        # Get additional arguments from resolver
+        resolved_args = self.arguments_resolver(self.agent)
+        if resolved_args:  # pragma: no branch
+            extra_args += ",\n".join(resolved_args)
+        # Build the agent definition
+        agent_str = f"""{agent_name} = {ag2_class}(
+{self.get_name_arg()}
+{self.get_description_arg()},{self.extras.get_system_message_arg()}
+{self.get_human_input_mode_arg()},
+{self.get_max_consecutive_auto_reply_arg()},
+{self.get_auto_reply_arg()},
+{self.extras.get_code_execution_arg()}
+{self.extras.get_termination_arg()}
+{extra_args}
+)"""
+
+        return AgentProcessingResult(content=agent_str)
+
+    def get_name_arg(self) -> str:
+        """Get the agent name argument.
+
+        Returns
+        -------
+        str
+            The agent name argument.
+        """
+        return f'    name="{self.agent_names[self.agent.id]}",'
+
+    def get_human_input_mode_arg(self) -> str:
+        """Get the human input mode argument.
+
+        Returns
+        -------
+        str
+            The human input mode argument.
+        """
+        return f'    human_input_mode="{self.agent.data.human_input_mode}"'
+
+    def get_max_consecutive_auto_reply_arg(self) -> str:
+        """Get the maximum consecutive auto reply argument.
+
+        Returns
+        -------
+        str
+            The maximum consecutive auto reply argument.
+        """
+        value = self.agent.data.max_consecutive_auto_reply
+        return f"    max_consecutive_auto_reply={value}"
+
+    def get_description_arg(self) -> str:
+        """Get the agent description.
+
+        Returns
+        -------
+        str
+            The agent description.
+        """
+        description = (
+            json.dumps(self.agent.description)
+            if self.agent.description
+            else '""'
+        )
+        return f"    description={description}"
+
+    def get_auto_reply_arg(self) -> str:
+        """Get the default auto reply argument.
+
+        Returns
+        -------
+        str
+            The default auto reply argument.
+        """
+        default_auto_reply = '""'
+        if self.agent.data.agent_default_auto_reply:
+            # Escape the default auto reply string
+            default_auto_reply = json.dumps(
+                self.agent.data.agent_default_auto_reply
+            )
+        return f"    default_auto_reply={default_auto_reply}"

waldiez/exporting/agent/system_message.py

@@ -0,0 +1,36 @@
+# SPDX-License-Identifier: Apache-2.0.
+# Copyright (c) 2024 - 2025 Waldiez and contributors.
+# pylint: disable=too-few-public-methods
+"""Termination message configuration for Waldiez agents."""
+
+import json
+
+from waldiez.models import WaldiezAgent
+
+from ..core import SystemMessageConfig
+
+
+class SystemMessageProcessor:
+    """Processor for system message configuration."""
+
+    def __init__(
+        self,
+        agent: WaldiezAgent,
+    ):
+        self.agent = agent
+
+    def process(self) -> SystemMessageConfig:
+        """Process system message configuration.
+
+        Returns
+        -------
+        SystemMessageConfig
+            The processed system message configuration.
+        """
+        if not self.agent.data.system_message:
+            return SystemMessageConfig()
+
+        return SystemMessageConfig(
+            before_agent_conent="",
+            system_message_arg=json.dumps(self.agent.data.system_message),
+        )

waldiez/exporting/agent/termination.py

@@ -0,0 +1,50 @@
+# SPDX-License-Identifier: Apache-2.0.
+# Copyright (c) 2024 - 2025 Waldiez and contributors.
+# pylint: disable=too-few-public-methods
+"""Termination message configuration for Waldiez agents."""
+
+from waldiez.models import WaldiezAgent
+
+from ..core import TerminationConfig
+
+
+class TerminationProcessor:
+    """Processor for termination message configuration."""
+
+    def __init__(
+        self,
+        agent: WaldiezAgent,
+        agent_name: str,
+    ):
+        self.agent = agent
+        self.agent_name = agent_name
+
+    def process(self) -> TerminationConfig:
+        """Process termination configuration.
+
+        Returns
+        -------
+        TerminationConfig
+            The processed termination configuration.
+        """
+        if self.agent.data.termination.type == "none":
+            return TerminationConfig(
+                termination_arg="None",
+                before_content="",
+            )
+        if self.agent.data.termination.type == "keyword":
+            return TerminationConfig(
+                termination_arg=self.agent.data.termination.string,
+                before_content="",
+            )
+        if self.agent.data.termination.type == "method":
+            content, function_name = (
+                self.agent.data.termination.get_termination_function(
+                    name_suffix=self.agent_name
+                )
+            )
+            return TerminationConfig(
+                termination_arg=function_name,
+                before_content="\n\n" + content + "\n",
+            )
+        return TerminationConfig()

waldiez/exporting/chats/__init__.py

@@ -1,7 +1,11 @@
 # SPDX-License-Identifier: Apache-2.0.
 # Copyright (c) 2024 - 2025 Waldiez and contributors.
-"""Export chats in a flow."""
+"""Chats exporter."""
 
-from .chats_exporter import ChatsExporter
+from .exporter import ChatsExporter
+from .factory import create_chats_exporter
 
-__all__ = ["ChatsExporter"]
+__all__ = [
+    "ChatsExporter",
+    "create_chats_exporter",
+]