waldiez 0.3.11__py3-none-any.whl → 0.3.12__py3-none-any.whl

waldiez/_version.py

@@ -2,4 +2,4 @@
 # Copyright (c) 2024 - 2025 Waldiez and contributors.
 """Version information for Waldiez."""
 
-__version__ = "0.3.11"
+__version__ = "0.3.12"

waldiez/exporting/agent/agent_exporter.py

@@ -6,7 +6,7 @@
 from pathlib import Path
 from typing import Callable, Dict, List, Optional, Tuple, Union
 
-from waldiez.models import WaldiezAgent, WaldiezChat
+from waldiez.models import WaldiezAgent, WaldiezChat, WaldiezModel
 
 from ..base import (
     AgentPosition,
@@ -18,9 +18,8 @@ from ..base import (
     ImportPosition,
 )
 from .utils import (
-    get_agent_class_name,
     get_agent_code_execution_config,
-    get_agent_imports,
+    get_captain_agent_extras,
     get_group_manager_extras,
     get_is_termination_message,
     get_rag_user_extras,
@@ -36,9 +35,9 @@ class AgentExporter(BaseExporter, ExporterMixin):
         self,
         agent: WaldiezAgent,
         agent_names: Dict[str, str],
-        model_names: Dict[str, str],
-        skill_names: Dict[str, str],
+        models: Tuple[List[WaldiezModel], Dict[str, str]],
         chats: Tuple[List[WaldiezChat], Dict[str, str]],
+        skill_names: Dict[str, str],
         is_async: bool,
         group_chat_members: List[WaldiezAgent],
         for_notebook: bool,
@@ -53,12 +52,12 @@ class AgentExporter(BaseExporter, ExporterMixin):
             The agent to export.
         agent_names : Dict[str, str]
             The agent ids to names mapping.
-        model_names : Dict[str, str]
-            The model ids to names mapping.
-        skill_names : Dict[str, str]
-            The skill ids to names mapping.
+        models : Tuple[List[WaldiezModel], Dict[str, str]]
+            All the models and the model ids to names mapping.
         chats : Tuple[List[WaldiezChat], Dict[str, str]]
             All the chats and the chat ids to names mapping.
+        skill_names : Dict[str, str]
+            The skill ids to names mapping.
         is_async : bool
             Whether the whole flow is async.
         for_notebook : bool
@@ -72,14 +71,14 @@ class AgentExporter(BaseExporter, ExporterMixin):
         if output_dir is not None and not isinstance(output_dir, Path):
             output_dir = Path(output_dir)
         self.output_dir = output_dir
-        self.model_names = model_names
+        self.models = models[0]
+        self.model_names = models[1]
         self.skill_names = skill_names
         self.arguments_resolver = arguments_resolver
         self.group_chat_members = group_chat_members
         self.chats = chats
         self.is_async = is_async
         self._agent_name = agent_names[agent.id]
-        self._agent_class = get_agent_class_name(self.agent)
         # content, argument, import
         self._code_execution = get_agent_code_execution_config(
             agent=self.agent,
@@ -119,6 +118,13 @@ class AgentExporter(BaseExporter, ExporterMixin):
             agent=self.agent,
             serializer=self.serializer,
         )
+        self._captain = get_captain_agent_extras(
+            agent=self.agent,
+            agent_names=self.agent_names,
+            all_models=self.models,
+            serializer=self.serializer,
+            output_dir=self.output_dir,
+        )
 
     def get_imports(self) -> Optional[List[Tuple[str, ImportPosition]]]:
         """Get the imports.
@@ -130,7 +136,7 @@ class AgentExporter(BaseExporter, ExporterMixin):
         """
         position = ImportPosition.THIRD_PARTY
         # default imports based on the agent class.
-        agent_imports = get_agent_imports(self._agent_class)
+        agent_imports = self.agent.ag2_imports
         # if code execution is enabled, update the imports.
         if self._code_execution[2]:
             agent_imports.add(self._code_execution[2])
@@ -220,7 +226,6 @@ class AgentExporter(BaseExporter, ExporterMixin):
         """
         agent = self.agent
         agent_name = self._agent_name
-        agent_class = self._agent_class
         retrieve_arg = self._rag[1]
         group_chat_arg = self._group_chat[1]
         is_termination = self._termination[0]
@@ -231,8 +236,10 @@ class AgentExporter(BaseExporter, ExporterMixin):
             default_auto_reply = (
                 f'"{self.string_escape(agent.data.agent_default_auto_reply)}"'
             )
-        extras = f"{group_chat_arg}{retrieve_arg}{self._reasoning}"
-        agent_str = f"""{agent_name} = {agent_class}(
+        extras = (
+            f"{group_chat_arg}{retrieve_arg}{self._reasoning}{self._captain}"
+        )
+        agent_str = f"""{agent_name} = {self.agent.ag2_class}(
     name="{agent_name}",
     description="{agent.description}"{system_message_arg},
     human_input_mode="{agent.data.human_input_mode}",

waldiez/exporting/agent/utils/__init__.py

@@ -2,8 +2,7 @@
 # Copyright (c) 2024 - 2025 Waldiez and contributors.
 """Utility functions for generating agent related strings."""
 
-from .agent_class_name import get_agent_class_name
-from .agent_imports import get_agent_imports
+from .captain_agent import get_captain_agent_extras
 from .code_execution import get_agent_code_execution_config
 from .group_manager import get_group_manager_extras
 from .rag_user import get_rag_user_extras
@@ -13,10 +12,9 @@ from .teachability import get_agent_teachability_string
 from .termination_message import get_is_termination_message
 
 __all__ = [
-    "get_agent_class_name",
-    "get_agent_imports",
     "get_agent_code_execution_config",
     "get_agent_teachability_string",
+    "get_captain_agent_extras",
     "get_group_manager_extras",
     "get_is_termination_message",
     "get_rag_user_extras",

waldiez/exporting/agent/utils/captain_agent.py

@@ -0,0 +1,254 @@
+# SPDX-License-Identifier: Apache-2.0.
+# Copyright (c) 2024 - 2025 Waldiez and contributors.
+""" "Extras for exporting a captain agent."""
+
+import json
+import os
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Callable, Dict, List, Optional, Union
+
+from waldiez.models import (
+    WaldiezAgent,
+    WaldiezCaptainAgent,
+    WaldiezModel,
+    WaldiezModelData,
+)
+
+
+def get_captain_agent_extras(
+    agent: WaldiezAgent,
+    agent_names: Dict[str, str],
+    all_models: List[WaldiezModel],
+    serializer: Callable[..., str],
+    output_dir: Optional[Union[str, Path]],
+) -> str:
+    """Get the extra args for the captain agent.
+
+    Parameters
+    ----------
+    agent : WaldiezAgent
+        The agent.
+    agent_names : Dict[str, str]
+        A mapping of agent ids to agent names.
+    all_models : List[WaldiezModel]
+        All the models in the flow.
+    serializer : Callable[..., str]
+        The serializer to use.
+    output_dir : Optional[Union[str, Path]]
+        The output directory to save the agent lib and nested config.
+    Returns
+    -------
+    str
+        The extra args to use in the captain agent.
+    """
+    # extra args: nested_config, agent_lib, tool_lib
+    if not isinstance(agent, WaldiezCaptainAgent):
+        return ""
+    agent_name = agent_names[agent.id]
+    save_path = str(output_dir) if output_dir else "."
+    extra_args_content = "\n" + f'    agent_config_save_path=r"{save_path}",'
+    if agent.data.agent_lib:
+        lib_dict = [
+            lib.model_dump(by_alias=False) for lib in 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)
+        extra_args_content += "\n" + f'    agent_lib=r"{agent_lib_path}",'
+    if agent.data.tool_lib:
+        extra_args_content += "\n" + f'    tool_lib="{agent.data.tool_lib}",'
+    nested_config = generate_nested_config(
+        agent,
+        agent_name,
+        all_models,
+        save_path,
+    )
+    serialized_nested_config = serializer(nested_config)
+    extra_args_content += (
+        "\n" + f"    nested_config={serialized_nested_config},"
+    )
+    return extra_args_content
+
+
+def generate_nested_config(
+    agent: WaldiezCaptainAgent,
+    agent_name: str,
+    all_models: List[WaldiezModel],
+    save_path: str,
+) -> Dict[str, Any]:
+    """Generate the nested config for the captain agent.
+
+    Parameters
+    ----------
+    agent : WaldiezCaptainAgent
+        The captain agent.
+    agent_name : str
+        The agent name.
+    all_models : List[WaldiezModel]
+        All the models in the flow.
+    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 = get_llm_config(agent, all_models)
+    to_serialize = {
+        "config_list": [llm_config],
+    }
+    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(to_serialize, f, ensure_ascii=False, indent=4)
+    config_file_or_env = f'r"{config_file_or_env_path}"'
+    nested_config = {
+        "autobuild_init_config": {
+            "config_file_or_env": config_file_or_env,
+            "builder_model": llm_config["model"],
+            "agent_model": llm_config["model"],
+        },
+        "autobuild_build_config": get_auto_build_build_config(
+            agent, llm_config
+        ),
+        "group_chat_config": {"max_round": agent.data.max_round},
+        "group_chat_llm_config": None,
+        "max_turns": agent.data.max_turns,
+    }
+    return nested_config
+
+
+def get_llm_config(
+    agent: WaldiezAgent,
+    all_models: List[WaldiezModel],
+) -> Dict[str, Any]:
+    """Get the config list environment variable name and its dict value.
+
+    Parameters
+    ----------
+    agent : WaldiezAgent
+        The agent.
+    all_models : List[WaldiezModel]
+        All the models in the flow.
+    Returns
+    -------
+    Dict[str, str]
+        The llm config dict.
+    """
+    model_name = "gpt-4o"
+    temperature: Optional[float] = 1
+    top_p: Optional[float] = 0.95
+    max_tokens: Optional[int] = 2048
+    if agent.data.model_ids:
+        waldiez_model = get_waldiez_model(agent.data.model_ids[0], all_models)
+        model_name = waldiez_model.name
+        temperature = waldiez_model.data.temperature
+        top_p = waldiez_model.data.top_p
+        max_tokens = waldiez_model.data.max_tokens
+    config_dict = {
+        "model": model_name,
+        "temperature": temperature,
+        "top_p": top_p,
+        "max_tokens": max_tokens,
+    }
+    return config_dict
+
+
+def get_auto_build_build_config(
+    agent: WaldiezAgent,
+    llm_config: Dict[str, Any],
+) -> Dict[str, Any]:
+    """Get the auto build build config.
+
+    Parameters
+    ----------
+    agent : WaldiezAgent
+        The agent.
+    llm_config : Dict[str, Any]
+        The llm config.
+
+    Returns
+    -------
+    Dict[str, Any]
+        The auto build build config.
+    """
+    coding = False
+    code_execution_config = {
+        "timeout": 300,
+        "work_dir": "groupchat",
+        "last_n_messages": 1,
+        "use_docker": False,
+    }
+    if agent.data.code_execution_config is not False:
+        coding = True
+        code_execution_config["work_dir"] = (
+            agent.data.code_execution_config.work_dir or "groupchat"
+        )
+        code_execution_config["last_n_messages"] = (
+            agent.data.code_execution_config.last_n_messages or 1
+        )
+        code_execution_config["timeout"] = (
+            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(
+    model_id: str, all_models: List[WaldiezModel]
+) -> WaldiezModel:
+    """Get the model name from the model id.
+
+    Parameters
+    ----------
+    model_id : str
+        The model id.
+    all_models : List[WaldiezModel]
+        All the models in the flow.
+
+    Returns
+    -------
+    str
+        The model name.
+    """
+    for model in all_models:
+        if model.id == model_id:
+            return 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=os.environ.get("OPENAI_API_KEY", "REPLACE_ME"),
+            api_version=None,
+            default_headers={},
+            price=None,
+        ),
+    )

waldiez/exporting/flow/flow_exporter.py

@@ -240,13 +240,10 @@ class FlowExporter(BaseExporter, ExporterMixin):
                 cache_seed=cache_seed,
             )
         else:
-            # content += f"    with Cache.disk(cache_seed={cache_seed}" + "):\n"
-            # content += f"{flow_chats}" + "\n"
-            # content += "\n" + chats_content + "\n"
             if chats_content.startswith("\n"):
                 chats_content = chats_content[1:]
             content += (
-                "\n" + f"with Cache.disk(cache_seed={cache_seed}):"
+                "\n" + f"with Cache.disk(cache_seed={cache_seed}) as cache:"
                 "\n" + chats_content + "\n"
             )
             if is_async:
@@ -431,9 +428,9 @@ class FlowExporter(BaseExporter, ExporterMixin):
             exporter = AgentExporter(
                 agent=agent,
                 agent_names=self.agent_names,
-                model_names=self.model_names,
-                skill_names=self.skill_names,
+                models=(self.models, self.model_names),
                 chats=(self.chats, self.chat_names),
+                skill_names=self.skill_names,
                 is_async=self.waldiez.is_async,
                 for_notebook=self.for_notebook,
                 output_dir=self.output_dir,

waldiez/exporting/flow/utils/def_main.py

@@ -53,7 +53,7 @@ def get_def_main(
     else:
         content += "def call_main() -> None:\n"
     content += '    """Run the main function and print the results."""\n'
-    content += "    results = "
+    content += "    results: Union[ChatResult, List[ChatResult], Dict[int, ChatResult]] = "
     if is_async:
         content += "await "
     content += "main()\n"
@@ -62,11 +62,12 @@ def get_def_main(
     content += "        ordered_results = dict(sorted(results.items()))\n"
     content += "        for _, result in ordered_results.items():\n"
     content += "            pprint(asdict(result))\n"
-    content += "    elif isinstance(results, list):\n"
+    content += "    else:\n"
+    content += "        if not isinstance(results, list):\n"
+    content += "            results = [results]\n"
     content += "        for result in results:\n"
     content += "            pprint(asdict(result))\n"
-    content += "    else:\n"
-    content += "        pprint(asdict(results))\n\n\n"
+    content += "\n\n"
     content += 'if __name__ == "__main__":\n'
     if is_async:
         content += "    anyio.run(call_main)\n"

waldiez/models/__init__.py

@@ -23,6 +23,9 @@ from .agents import (
     WaldiezAgentType,
     WaldiezAssistant,
     WaldiezAssistantData,
+    WaldiezCaptainAgent,
+    WaldiezCaptainAgentData,
+    WaldiezCaptainAgentLibEntry,
     WaldiezGroupManager,
     WaldiezGroupManagerData,
     WaldiezGroupManagerSpeakers,
@@ -87,6 +90,9 @@ __all__ = [
     "WaldiezAgentType",
     "WaldiezAssistant",
     "WaldiezAssistantData",
+    "WaldiezCaptainAgent",
+    "WaldiezCaptainAgentData",
+    "WaldiezCaptainAgentLibEntry",
     "WaldiezChat",
     "WaldiezChatData",
     "WaldiezChatSummary",

waldiez/models/agents/__init__.py

@@ -18,6 +18,15 @@ from .agent import (
 )
 from .agents import WaldiezAgents
 from .assistant import WaldiezAssistant, WaldiezAssistantData
+from .captain_agent import (
+    WaldiezCaptainAgent,
+    WaldiezCaptainAgentData,
+    WaldiezCaptainAgentLibEntry,
+)
+from .extra_requirements import (
+    get_captain_agent_extra_requirements,
+    get_retrievechat_extra_requirements,
+)
 from .group_manager import (
     CUSTOM_SPEAKER_SELECTION,
     CUSTOM_SPEAKER_SELECTION_ARGS,
@@ -77,6 +86,8 @@ from .swarm_agent import (
 from .user_proxy import WaldiezUserProxy, WaldiezUserProxyData
 
 __all__ = [
+    "get_retrievechat_extra_requirements",
+    "get_captain_agent_extra_requirements",
     "IS_TERMINATION_MESSAGE",
     "IS_TERMINATION_MESSAGE_ARGS",
     "IS_TERMINATION_MESSAGE_TYPES",
@@ -113,6 +124,9 @@ __all__ = [
     "WaldiezAgentNestedChatMessage",
     "WaldiezAgentTeachability",
     "WaldiezAgentTerminationMessage",
+    "WaldiezCaptainAgent",
+    "WaldiezCaptainAgentData",
+    "WaldiezCaptainAgentLibEntry",
     "WaldiezGroupManager",
     "WaldiezGroupManagerData",
     "WaldiezGroupManagerSpeakers",

waldiez/models/agents/agent/agent.py

@@ -2,7 +2,7 @@
 # Copyright (c) 2024 - 2025 Waldiez and contributors.
 """Base agent class to be inherited by all agents."""
 
-from typing import List
+from typing import List, Set
 
 from pydantic import Field
 from typing_extensions import Annotated, Literal
@@ -12,7 +12,7 @@ from .agent_data import WaldiezAgentData
 from .code_execution import WaldiezAgentCodeExecutionConfig
 
 WaldiezAgentType = Literal[
-    "user", "assistant", "manager", "rag_user", "swarm", "reasoning"
+    "user", "assistant", "manager", "rag_user", "swarm", "reasoning", "captain"
 ]
 
 
@@ -25,9 +25,7 @@ class WaldiezAgent(WaldiezBase):
         The ID of the agent.
     type : Literal["agent"]
         The type of the "node" in a graph: "agent"
-    agent_type : Literal[
-            "user", "assistant", "manager", "rag_user", "swarm", "reasoning"
-        ]
+    agent_type : WaldiezAgentType
         The type of the agent
     name: str
         The name of the agent.
@@ -65,9 +63,7 @@ class WaldiezAgent(WaldiezBase):
         ),
     ]
     agent_type: Annotated[
-        Literal[
-            "user", "assistant", "manager", "rag_user", "swarm", "reasoning"
-        ],
+        WaldiezAgentType,
         Field(
             ...,
             title="Agent type",
@@ -129,6 +125,73 @@ class WaldiezAgent(WaldiezBase):
         ),
     ]
 
+    @property
+    def ag2_class(self) -> str:
+        """Return the AG2 class of the agent."""
+        class_name = "ConversableAgent"
+        if self.data.is_multimodal:
+            return "MultimodalConversableAgent"
+        if self.agent_type == "assistant":
+            class_name = "AssistantAgent"
+        if self.agent_type == "user":
+            class_name = "UserProxyAgent"
+        if self.agent_type == "manager":
+            class_name = "GroupChatManager"
+        if self.agent_type == "rag_user":
+            class_name = "RetrieveUserProxyAgent"
+        if self.agent_type == "swarm":
+            class_name = "SwarmAgent"
+        if self.agent_type == "reasoning":
+            class_name = "ReasoningAgent"
+        if self.agent_type == "captain":
+            class_name = "CaptainAgent"
+        return class_name
+
+    @property
+    def ag2_imports(self) -> Set[str]:
+        """Return the AG2 imports of the agent."""
+        agent_class = self.ag2_class
+        imports = set(["import autogen"])
+        if agent_class == "AssistantAgent":
+            imports.add("from autogen import AssistantAgent")
+        elif agent_class == "UserProxyAgent":
+            imports.add("from autogen import UserProxyAgent")
+        elif agent_class == "GroupChatManager":
+            imports.add("from autogen import GroupChatManager")
+        elif agent_class == "RetrieveUserProxyAgent":
+            imports.add(
+                "from autogen.agentchat.contrib.retrieve_user_proxy_agent "
+                "import RetrieveUserProxyAgent"
+            )
+        elif agent_class == "MultimodalConversableAgent":
+            imports.add(
+                "from autogen.agentchat.contrib.multimodal_conversable_agent "
+                "import MultimodalConversableAgent"
+            )
+        elif agent_class == "SwarmAgent":
+            imports.add(
+                "from autogen import "
+                "AFTER_WORK, "
+                "ON_CONDITION, "
+                "UPDATE_SYSTEM_MESSAGE, "
+                "AfterWorkOption, "
+                "SwarmAgent, "
+                "SwarmResult"
+            )
+        elif agent_class == "ReasoningAgent":
+            imports.add(
+                "from autogen.agentchat.contrib.reasoning_agent "
+                "import ReasoningAgent, visualize_tree"
+            )
+        elif agent_class == "CaptainAgent":
+            imports.add(
+                "from autogen.agentchat.contrib.captainagent "
+                "import CaptainAgent"
+            )
+        else:  # pragma: no cover
+            imports.add("import ConversableAgent")
+        return imports
+
     def validate_linked_skills(
         self, skill_ids: List[str], agent_ids: List[str]
     ) -> None:

waldiez/models/agents/agents.py

@@ -10,7 +10,8 @@ from typing_extensions import Annotated, Self
 from ..common import WaldiezBase
 from .agent import WaldiezAgent
 from .assistant import WaldiezAssistant
-from .group_manager.group_manager import WaldiezGroupManager
+from .captain_agent import WaldiezCaptainAgent
+from .group_manager import WaldiezGroupManager
 from .rag_user import WaldiezRagUser
 from .reasoning import WaldiezReasoningAgent
 from .swarm_agent import WaldiezSwarmAgent
@@ -80,6 +81,14 @@ class WaldiezAgents(WaldiezBase):
             default_factory=list,
         ),
     ]
+    captain_agents: Annotated[
+        List[WaldiezCaptainAgent],
+        Field(
+            title="Captain Agents.",
+            description="Captain agents",
+            default_factory=list,
+        ),
+    ]
 
     @property
     def members(self) -> Iterator[WaldiezAgent]:
@@ -96,6 +105,7 @@ class WaldiezAgents(WaldiezBase):
         yield from self.reasoning_agents
         yield from self.swarm_agents
         yield from self.managers
+        yield from self.captain_agents
 
     @model_validator(mode="after")
     def validate_agents(self) -> Self:

waldiez/models/agents/captain_agent/__init__.py

@@ -0,0 +1,15 @@
+# SPDX-License-Identifier: Apache-2.0.
+# Copyright (c) 2024 - 2025 Waldiez and contributors.
+"""Captain agent model."""
+
+from .captain_agent import WaldiezCaptainAgent
+from .captain_agent_data import (
+    WaldiezCaptainAgentData,
+)
+from .captain_agent_lib_entry import WaldiezCaptainAgentLibEntry
+
+__all__ = [
+    "WaldiezCaptainAgentData",
+    "WaldiezCaptainAgent",
+    "WaldiezCaptainAgentLibEntry",
+]