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

waldiez/exporting/agent/exporter.py

@@ -0,0 +1,354 @@
+# SPDX-License-Identifier: Apache-2.0.
+# Copyright (c) 2024 - 2025 Waldiez and contributors.
+# pylint: disable=too-many-arguments,too-many-positional-arguments
+# pylint: disable=too-many-return-statements,too-many-instance-attributes
+"""Export agents."""
+
+from pathlib import Path
+from typing import Any, Callable, Optional, Union
+
+from waldiez.models import (
+    WaldiezAgent,
+    WaldiezAgentConnection,
+    WaldiezChat,
+    WaldiezModel,
+)
+
+from ..core import (
+    ContentOrder,
+    Exporter,
+    ExporterContext,
+    ExportPosition,
+    StandardExtras,
+)
+from .code_execution import CodeExecutionProcessor
+from .extras.captain_agent_extras import CaptainAgentProcessor
+from .extras.group_manager_agent_extas import GroupManagerProcessor
+from .extras.group_member_extras import GroupMemberAgentProcessor
+from .extras.rag_user_proxy_agent_extras import RagUserProxyAgentProcessor
+from .extras.reasoning_agent_extras import ReasoningAgentProcessor
+from .processor import AgentProcessor
+from .system_message import SystemMessageProcessor
+from .termination import TerminationProcessor
+
+
+class AgentExporter(Exporter[StandardExtras]):
+    """Agent exporter with standard extras."""
+
+    def __init__(
+        self,
+        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],
+        is_async: bool = False,
+        for_notebook: bool = False,
+        cache_seed: Optional[int] = None,
+        initial_chats: Optional[list[WaldiezAgentConnection]] = 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,
+    ):
+        """Initialize the 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.
+        """
+        super().__init__(context, **kwargs)
+
+        self.agent = agent
+        self.agent_names = agent_names
+        self.models = models[0]
+        self.model_names = models[1]
+        self.all_chats = chats[0]
+        self.chat_names = chats[1]
+        self.tool_names = tool_names
+        self.is_async = is_async
+        self.for_notebook = for_notebook
+        self.cache_seed = cache_seed
+        self.initial_chats = initial_chats or []
+        self.group_chat_members = group_chat_members or []
+        self.arguments_resolver = arguments_resolver or fallback_args_resolver
+        self.output_dir = Path(output_dir) if output_dir else None
+
+        # Initialize extras based on agent type
+        self._extras = self._create_agent_extras()
+
+    @property
+    def extras(self) -> StandardExtras:
+        """Get the agent extras."""
+        return self._extras
+
+    def _create_agent_extras(self) -> StandardExtras:
+        """Create and populate agent extras based on agent type."""
+        # Determine the appropriate extras type
+        if self.agent.is_group_manager:
+            return self._create_group_manager_extras()
+        if self.agent.is_group_member:
+            return self._create_group_member_extras()
+        if self.agent.is_captain:
+            return self._create_captain_extras()
+        if self.agent.is_reasoning:
+            return self.create_reasoning_extras()
+        if self.agent.is_rag_user:
+            return self._create_rag_user_extras()
+        return self._create_standard_extras()
+
+    def _create_standard_extras(self) -> StandardExtras:
+        """Create standard agent extras."""
+        extras = StandardExtras(self.agent.id)
+
+        # Process code execution
+        if self.agent.data.code_execution_config is not False:
+            code_processor = CodeExecutionProcessor(
+                agent=self.agent,
+                agent_name=self.agent_names[self.agent.id],
+                tool_names=self.tool_names,
+            )
+            code_config = code_processor.process()
+            extras.set_code_execution(code_config)
+
+        # Process termination message
+        termination_processor = TerminationProcessor(
+            agent=self.agent,
+            agent_name=self.agent_names[self.agent.id],
+        )
+        termination_config = termination_processor.process()
+        extras.set_termination_config(termination_config)
+
+        # Process system message
+        system_message_processor = SystemMessageProcessor(
+            agent=self.agent,
+        )
+        system_message_config = system_message_processor.process()
+        extras.set_system_message_config(system_message_config)
+
+        return extras
+
+    def _create_group_manager_extras(self) -> StandardExtras:
+        """Create group manager agent extras."""
+        # Start with standard extras
+        standard_extras = self._create_standard_extras()
+
+        # Add group manager specific processing
+        group_manager_processor = GroupManagerProcessor(
+            agent=self.agent,
+            agent_names=self.agent_names,
+            all_models=self.models,
+            model_names=self.model_names,
+            initial_chats=self.initial_chats,
+            group_chat_members=self.group_chat_members,
+            serializer=(self.context.get_serializer().serialize),
+        )
+
+        group_manager_extras = group_manager_processor.process(
+            system_message_config=standard_extras.system_message_config,
+            termination_config=standard_extras.termination_config,
+            code_execution_config=standard_extras.code_execution_config,
+        )
+        return group_manager_extras
+
+    def _create_group_member_extras(self) -> StandardExtras:
+        """Create group member agent extras."""
+        # Start with standard extras
+        extras = self._create_standard_extras()
+        # Add group member specific processing
+        group_member_processor = GroupMemberAgentProcessor(
+            agent=self.agent,
+            agent_names=self.agent_names,
+            tool_names=self.tool_names,
+            chat_names=self.chat_names,
+            all_chats=self.all_chats,
+            serializer=self.context.get_serializer().serialize,
+        )
+        group_member_results = group_member_processor.process()
+        if group_member_results.before_agent:
+            extras.append_before_agent(group_member_results.before_agent)
+        # Add group member specific arguments
+        for arg in group_member_results.extra_arguments:
+            extras.add_arg(arg)
+        # Add group member specific imports
+        for import_stmt in group_member_results.extra_imports:
+            extras.add_import(import_stmt)
+        if group_member_results.after_agent:
+            extras.append_after_agent(group_member_results.after_agent)
+        return extras
+
+    def _create_rag_user_extras(self) -> StandardExtras:
+        """Create RAG user agent extras."""
+        # Start with standard extras
+        extras = self._create_standard_extras()
+
+        rag_processor = RagUserProxyAgentProcessor(
+            agent=self.agent,
+            agent_name=self.agent_names[self.agent.id],
+            model_names=self.model_names,
+        )
+        rag_result = rag_processor.process()
+        # Add RAG user specific arguments
+        for arg in rag_result.extra_args:
+            extras.add_arg(arg)
+        # Add RAG user specific imports
+        extras.add_imports(rag_result.extra_imports)
+        if rag_result.before_agent:
+            extras.prepend_before_agent(rag_result.before_agent)
+        return extras
+
+    def _create_captain_extras(self) -> StandardExtras:
+        """Create captain agent extras."""
+        # Start with standard extras
+        extras = self._create_standard_extras()
+
+        # Add captain specific processing
+        captain_processor = CaptainAgentProcessor(
+            agent=self.agent,
+            agent_names=self.agent_names,
+            all_models=self.models,
+            serializer=(
+                self.context.get_serializer()
+                if self.context.serializer
+                else None
+            ),
+            output_dir=self.output_dir,
+        )
+
+        captain_result = captain_processor.process(
+            system_message_config=extras.system_message_config,
+            termination_config=extras.termination_config,
+            code_execution_config=extras.code_execution_config,
+        )
+
+        # # Add captain arguments
+        for arg in captain_result.extra_args:
+            extras.add_arg(arg)
+
+        # # Add captain imports
+        extras.add_imports(captain_result.extra_imports)
+
+        # # Add any captain-specific before content
+        if captain_result.before_agent:
+            extras.append_before_agent(captain_result.before_agent)
+
+        return extras
+
+    def create_reasoning_extras(self) -> StandardExtras:
+        """Create reasoning-specific extras for the agent.
+
+        Returns
+        -------
+        StandardExtras
+            The reasoning-specific extras.
+        """
+        # Start with standard extras
+        extras = self._create_standard_extras()
+
+        reasoning_processor = ReasoningAgentProcessor(
+            agent=self.agent,
+            serializer=(
+                self.context.get_serializer()
+                if self.context.serializer
+                else None
+            ),
+        )
+        # Process reasoning-specific content
+        reason_extras = reasoning_processor.process(
+            code_execution_config=extras.code_execution_config,
+            termination_config=extras.termination_config,
+            system_message_config=extras.system_message_config,
+        )
+        # Add reasoning arguments
+        for arg in reason_extras.extra_args:
+            extras.add_arg(arg)
+
+        return reason_extras
+
+    def generate_main_content(self) -> Optional[str]:
+        """Generate the main agent definition.
+
+        Returns
+        -------
+        Optional[str]
+            The main agent definition content, or None if not applicable.
+        """
+        # Use AgentProcessor to generate the main definition
+        agent_processor = AgentProcessor(
+            agent=self.agent,
+            agent_names=self.agent_names,
+            arguments_resolver=self.arguments_resolver,
+            extras=self.extras,
+        )
+        result = agent_processor.process().content
+        if result:
+            # Add the main agent definition content
+            self.add_content(
+                result,
+                ExportPosition.AGENTS,
+                order=(
+                    ContentOrder.MAIN_CONTENT
+                    if not self.agent.is_group_manager
+                    else ContentOrder.LATE_CLEANUP
+                ),
+            )
+            self.extras.append_after_all_agents(result)
+        return result
+
+    def _add_default_imports(self) -> None:
+        """Add default imports for agents."""
+        # Add default agent imports
+        if hasattr(self.agent, "ag2_imports"):
+            for import_stmt in self.agent.ag2_imports:
+                self.add_import(import_stmt)
+
+        # Add tools import if agent has tools
+        if self.agent.data.tools:
+            self.add_import("from autogen import register_function")
+
+
+# pylint: disable=unused-argument
+def fallback_args_resolver(agent: WaldiezAgent) -> list[str]:
+    """Fallback resolver for agent arguments.
+
+    Parameters
+    ----------
+    agent : WaldiezAgent
+        The agent for which to resolve arguments.
+
+    Returns
+    -------
+    list[str]
+        An empty list (no extra args).
+    """
+    return []

waldiez/exporting/agent/extras/__init__.py

@@ -0,0 +1,15 @@
+# SPDX-License-Identifier: Apache-2.0.
+# Copyright (c) 2024 - 2025 Waldiez and contributors.
+"""Agents exporter extras."""
+
+from .captain_agent_extras import CaptainAgentProcessor
+from .group_manager_agent_extas import GroupManagerProcessor
+from .group_member_extras import GroupMemberAgentProcessor
+from .reasoning_agent_extras import ReasoningAgentProcessor
+
+__all__ = [
+    "CaptainAgentProcessor",
+    "GroupManagerProcessor",
+    "GroupMemberAgentProcessor",
+    "ReasoningAgentProcessor",
+]

waldiez/exporting/agent/extras/captain_agent_extras.py

@@ -0,0 +1,315 @@
+# SPDX-License-Identifier: Apache-2.0.
+# Copyright (c) 2024 - 2025 Waldiez and contributors.
+# pylint: disable=too-few-public-methods,no-self-use
+"""Captain agent configuration processor."""
+
+import json
+import os
+import uuid
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Optional
+
+from waldiez.models import (
+    WaldiezAgent,
+    WaldiezCaptainAgent,
+    WaldiezModel,
+    WaldiezModelData,
+)
+
+from ...core import (
+    CodeExecutionConfig,
+    DefaultSerializer,
+    Serializer,
+    SystemMessageConfig,
+    TerminationConfig,
+)
+from ...core.extras.agent_extras import CaptainExtras
+
+
+class CaptainAgentProcessor:
+    """Processor for captain agent configuration."""
+
+    def __init__(
+        self,
+        agent: WaldiezAgent,
+        agent_names: dict[str, str],
+        all_models: list[WaldiezModel],
+        serializer: Optional[Serializer] = None,
+        output_dir: Optional[Path] = None,
+    ):
+        self.agent = agent
+        self.agent_names = agent_names
+        self.all_models = all_models
+        self.serializer = serializer or DefaultSerializer()
+        self.output_dir = output_dir
+
+    def process(
+        self,
+        code_execution_config: Optional[CodeExecutionConfig] = None,
+        termination_config: Optional[TerminationConfig] = None,
+        system_message_config: Optional[SystemMessageConfig] = None,
+    ) -> CaptainExtras:
+        """Process group manager and return extras.
+
+        Parameters
+        ----------
+        code_execution_config : CodeExecutionConfig, optional
+            Configuration for code execution, by default None.
+        termination_config : TerminationConfig, optional
+            Configuration for termination, by default None.
+        system_message_config : SystemMessageConfig, optional
+            Configuration for system messages, by default None.
+
+        Returns
+        -------
+        CaptainExtras
+            The processed result containing extra arguments, before content,
+            imports, and environment variables.
+        """
+        result = CaptainExtras(
+            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_captain or not isinstance(
+            self.agent, WaldiezCaptainAgent
+        ):
+            return result
+        agent_name = self.agent_names[self.agent.id]
+        save_path = str(self.output_dir) if self.output_dir else "."
+        if save_path != ".":
+            os.makedirs(save_path, exist_ok=True)
+        result.add_arg("agent_config_save_path=os.getcwd()", tabs=1)
+        if self.agent.data.agent_lib:
+            lib_dict = [
+                lib.model_dump(by_alias=False)
+                for lib in self.agent.data.agent_lib
+            ]
+            lib_json_name = f"{agent_name}_agent_lib.json"
+            agent_lib_path = os.path.join(save_path, lib_json_name)
+            with open(agent_lib_path, "w", encoding="utf-8", newline="\n") as f:
+                json.dump(lib_dict, f, ensure_ascii=False, indent=4)
+            result.add_arg(f'agent_lib="{lib_json_name}"', tabs=1)
+        if self.agent.data.tool_lib:
+            result.add_arg(f'tool_lib="{self.agent.data.tool_lib}"', tabs=1)
+        nested_config = self._generate_nested_config(
+            self.agent,
+            agent_name,
+            save_path,
+        )
+        result.set_nested_config(nested_config)
+        serialized_nested_config = self.serializer.serialize(nested_config)
+        result.add_arg(f"nested_config={serialized_nested_config}", tabs=1)
+        return result
+
+    def _generate_nested_config(
+        self,
+        agent: WaldiezCaptainAgent,
+        agent_name: str,
+        save_path: str,
+    ) -> dict[str, Any]:
+        """Generate the nested config for the captain agent.
+
+        Parameters
+        ----------
+        agent_name : str
+            The agent name.
+        save_path : str
+            The path to save the nested config.
+
+        Returns
+        -------
+        dict[str, Any]
+            The nested config.
+        """
+        config_file_or_env_name = f"{agent_name}_llm_config.json"
+        llm_config_list = self._get_llm_configs()
+        os.makedirs(save_path, exist_ok=True)
+        config_file_or_env_path = os.path.join(
+            save_path, config_file_or_env_name
+        )
+        with open(
+            config_file_or_env_path, "w", encoding="utf-8", newline="\n"
+        ) as f:
+            json.dump(llm_config_list, f, ensure_ascii=False, indent=4)
+        llm_config = llm_config_list[0]
+        if "temperature" not in llm_config:
+            llm_config["temperature"] = 1
+        if "top_p" not in llm_config:
+            llm_config["top_p"] = 0.95
+        if "max_tokens" not in llm_config:
+            llm_config["max_tokens"] = 2048
+        return {
+            "autobuild_init_config": {
+                "config_file_or_env": config_file_or_env_name,
+                "builder_model": llm_config["model"],
+                "agent_model": llm_config["model"],
+            },
+            "autobuild_build_config": self._get_auto_build_build_config(
+                llm_config
+            ),
+            "group_chat_config": {"max_round": agent.data.max_round},
+            "group_chat_llm_config": None,
+            "max_turns": agent.data.max_turns,
+        }
+
+    def _get_llm_configs(self) -> list[dict[str, Any]]:
+        """Get the LLM configurations for the captain agent.
+
+        Returns
+        -------
+        list[dict[str, Any]]
+            The list of LLM configurations.
+        """
+        temperature = 1
+        top_p = 0.95
+        max_tokens = 2048
+        models_in_list: list[WaldiezModel] = []
+        config_list: list[dict[str, Any]] = []
+        for model_id in self.agent.data.model_ids:
+            model = self._get_waldiez_model(model_id)
+            if model not in models_in_list:
+                models_in_list.append(model)
+                llm_config = model.get_llm_config(skip_price=True)
+                config_list.append(llm_config)
+        if not config_list:
+            default_model = self._get_default_model(uuid.uuid4().hex)
+            default_llm_config = default_model.get_llm_config(skip_price=True)
+            if "temperature" not in default_llm_config:
+                default_llm_config["temperature"] = temperature
+            if "top_p" not in default_llm_config:
+                default_llm_config["top_p"] = top_p
+            if "max_tokens" not in default_llm_config:
+                default_llm_config["max_tokens"] = max_tokens
+            config_list.append(default_llm_config)
+        return config_list
+
+    def _get_auto_build_build_config(
+        self,
+        llm_config: dict[str, Any],
+    ) -> dict[str, Any]:
+        """Get the auto build build config.
+
+        Parameters
+        ----------
+        llm_config : dict[str, Any]
+            The LLM configuration.
+
+        Returns
+        -------
+        dict[str, Any]
+            The auto build build config.
+        """
+        coding = False
+        code_execution_config: dict[str, Any] = {
+            "timeout": 300,
+            "work_dir": "groupchat",
+            "last_n_messages": 1,
+            "use_docker": False,
+        }
+        if self.agent.data.code_execution_config is not False:
+            coding = True
+            code_execution_config["work_dir"] = (
+                self.agent.data.code_execution_config.work_dir or "groupchat"
+            )
+            code_execution_config["last_n_messages"] = (
+                self.agent.data.code_execution_config.last_n_messages or 1
+            )
+            code_execution_config["timeout"] = (
+                self.agent.data.code_execution_config.timeout or 300
+            )
+        return {
+            "default_llm_config": {
+                "temperature": llm_config["temperature"],
+                "top_p": llm_config["top_p"],
+                "max_tokens": llm_config["max_tokens"],
+            },
+            "code_execution_config": code_execution_config,
+            "coding": coding,
+        }
+
+    def _get_waldiez_model(self, model_id: str) -> WaldiezModel:
+        """Get the Waldiez model by its ID.
+
+        Parameters
+        ----------
+        model_id : str
+            The model's ID.
+
+        Returns
+        -------
+        WaldiezModel
+            The Waldiez model.
+        """
+        for model in self.all_models:
+            if model.id == model_id:
+                return model
+        return self._get_default_model(model_id)
+
+    def _get_default_model(self, model_id: str) -> WaldiezModel:
+        """Get the default model.
+
+        Parameters
+        ----------
+        model_id : str
+            The model's id.
+
+        Returns
+        -------
+        WaldiezModel
+            The default model.
+        """
+        now = (
+            datetime.now(tz=timezone.utc)
+            .isoformat(timespec="milliseconds")
+            .replace("+00:00", "Z")
+        )
+        return WaldiezModel(
+            id=model_id,
+            type="model",
+            name="gpt-4o",
+            description="The GPT-4o model.",
+            tags=["gpt-4o"],
+            requirements=[],
+            created_at=now,
+            updated_at=now,
+            data=WaldiezModelData(
+                api_type="openai",
+                temperature=1,
+                top_p=0.95,
+                max_tokens=2048,
+                base_url=None,
+                api_key=None,
+                api_version=None,
+                default_headers={},
+                price=None,
+            ),
+        )
+
+
+# DEFAULT_NESTED_CONFIG = {
+#         "autobuild_init_config": {
+#             "config_file_or_env": "OAI_CONFIG_LIST",
+#             "builder_model": "gpt-4o",
+#             "agent_model": "gpt-4o",
+#         },
+#         "autobuild_build_config": {
+#             "default_llm_config": {
+#                   "temperature": 1,
+#                   "top_p": 0.95,
+#                   "max_tokens": 2048
+#             },
+#             "code_execution_config": {
+#                 "timeout": 300,
+#                 "work_dir": "groupchat",
+#                 "last_n_messages": 1,
+#                 "use_docker": False,
+#             },
+#             "coding": True,
+#         },
+#         "group_chat_config": {"max_round": 10},
+#         "group_chat_llm_config": None,
+#         "max_turns": 5,
+#     }