waldiez 0.3.11__py3-none-any.whl → 0.4.0__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.4.0"

waldiez/cli.py

@@ -86,10 +86,8 @@ def run(
     ),
 ) -> None:
     """Run a Waldiez flow."""
-    # a swarm chat without a user agent
-    # creates a new user (this has a default code execution with docker)
-    # temp (until we handle/detect docker setup)
     os.environ["AUTOGEN_USE_DOCKER"] = "0"
+    os.environ["NEP50_DISABLE_WARNING"] = "1"
     output_path = _get_output_path(output, force)
     with file.open("r", encoding="utf-8") as _file:
         try:

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,14 @@ 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}"
+        )
+        ag2_class = self.agent.ag2_class
+        if agent.agent_type == "swarm":
+            # SwarmAgent is deprecated.
+            ag2_class = "ConversableAgent"
+        agent_str = f"""{agent_name} = {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,250 @@
+# 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" + "    agent_config_save_path=os.getcwd(),"
+    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="{lib_json_name}",'
+    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)
+    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], f, ensure_ascii=False, indent=4)
+    nested_config = {
+        "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": 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/agent/utils/swarm_agent.py

@@ -21,11 +21,11 @@ from waldiez.models import (
 # functions (List[Callable]):
 #   -A list of functions to register with the agent.
 # update_agent_state_before_reply (List[Callable]):
-# - A list of functions, including UPDATE_SYSTEM_MESSAGEs,
+# - A list of functions, including UpdateSystemMessage,
 #   called to update the agent before it replies.
 
 # Additional methods:
-# register_hand_off(hand_offs: List[AfterWork|OnCondition]):
+# register_hand_off(agent, hand_offs: List[AfterWork|OnCondition]):
 
 
 def get_swarm_extras(
@@ -173,14 +173,14 @@ def get_update_agent_state_before_reply_arg(
                     name_suffix=agent_names[agent.id],
                 )
                 arg_string += (
-                    "\n" + f"{tab}{tab}UPDATE_SYSTEM_MESSAGE({function_name}),"
+                    "\n" + f"{tab}{tab}UpdateSystemMessage({function_name}),"
                 )
                 before_agent += "\n" + function_content + "\n"
             else:
                 escaped_function = string_escape(function.update_function)
                 arg_string += (
                     "\n"
-                    + f'{tab}{tab}UPDATE_SYSTEM_MESSAGE("{escaped_function}"),'
+                    + f'{tab}{tab}UpdateSystemMessage("{escaped_function}"),'
                 )
         else:
             skill_name = skill_names.get(function, "")
@@ -233,7 +233,12 @@ def get_agent_handoff_registrations(
     if not agent.handoffs:
         return before_agent, after_agent
     tab = "    "
-    after_agent = f"{agent_name}.register_hand_off(" + "\n" + f"{tab}[" + "\n"
+    # change {agent}.register_hand_off([...
+    # to register_hand_off({agent}, [...
+    # after_agent = f"{agent_name}.register_hand_off(" + "\n" + f"{tab}[" + "\n"
+    after_agent = (
+        "register_hand_off(\n" + f"{tab}{agent_name}," + "\n" + f"{tab}[" + "\n"
+    )
     for hand_off in agent.handoffs:
         if isinstance(hand_off, WaldiezSwarmOnCondition):
             registration, before_handoff = get_agent_on_condition_handoff(
@@ -385,7 +390,7 @@ def _get_agent_on_condition_handoff_to_agent(
     before_agent = ""
     tab = "    "
     on_condition = (
-        f"{tab}{tab}ON_CONDITION(" + "\n"
+        f"{tab}{tab}OnCondition(" + "\n"
         f"{tab}{tab}{tab}target={recipient}," + "\n"
         f'{tab}{tab}{tab}condition="{condition}",' + "\n"
     )
@@ -431,7 +436,7 @@ def _get_agent_on_condition_handoff_to_nested_chat(
     before_agent += f"{chat_queue_var_name} = {chat_queue} " + "\n"
     condition_string = string_escape(condition)
     on_condition = (
-        f"{tab}{tab}ON_CONDITION(" + "\n"
+        f"{tab}{tab}OnCondition(" + "\n"
         f"{tab}{tab}{tab}target=" + "{\n"
         f'{tab}{tab}{tab}{tab}"chat_queue": {chat_queue_var_name},' + "\n"
         f'{tab}{tab}{tab}{tab}"config": None,' + "\n"

waldiez/exporting/base/utils/comments.py

@@ -13,6 +13,7 @@ from typing_extensions import Literal
 CommentKey = Literal[
     "agents", "imports", "skills", "models", "nested", "run", "logging"
 ]
+"""Possible keys for comments."""
 
 
 def comment(for_notebook: bool, hashtags: int = 1) -> str:

waldiez/exporting/chats/utils/swarm.py

@@ -196,7 +196,7 @@ def get_swarm_after_work_string(
         The after work string and the additional methods string.
     """
     if not chat.after_work:
-        return "AFTER_WORK(AfterWorkOption.TERMINATE)", ""
+        return "AfterWork(AfterWorkOption.TERMINATE)", ""
     additional_methods = ""
     after_work_string, function_content = chat.after_work.get_recipient(
         agent_names=agent_names,

waldiez/exporting/flow/flow_exporter.py

@@ -52,6 +52,7 @@ from .utils import (
     get_after_run_content,
     get_def_main,
     get_ipynb_content_start,
+    get_np_no_nep50_handle,
     get_py_content_start,
     get_sqlite_out,
     get_start_logging,
@@ -210,6 +211,7 @@ class FlowExporter(BaseExporter, ExporterMixin):
         )
         content += self.get_comment("imports", self.for_notebook) + "\n"
         content += imports[0] + "\n"
+        content += get_np_no_nep50_handle() + "\n"
         content += self.get_comment("logging", self.for_notebook) + "\n"
         content += get_start_logging(tabs=0) + "\n"
         content += "start_logging()\n\n"
@@ -240,13 +242,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 +430,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/__init__.py

@@ -14,14 +14,11 @@ from .def_main import get_def_main
 from .flow_content import (
     get_after_run_content,
     get_ipynb_content_start,
+    get_np_no_nep50_handle,
     get_py_content_start,
 )
 from .flow_names import ensure_unique_names
-from .importing_utils import (
-    gather_imports,
-    get_standard_imports,
-    get_the_imports_string,
-)
+from .importing_utils import gather_imports, get_the_imports_string
 from .logging_utils import (
     get_sqlite_out,
     get_sqlite_out_call,
@@ -41,12 +38,12 @@ __all__ = [
     "gather_imports",
     "get_after_run_content",
     "get_def_main",
+    "get_np_no_nep50_handle",
     "get_py_content_start",
     "get_ipynb_content_start",
     "get_start_logging",
     "get_stop_logging",
     "get_sqlite_out",
     "get_sqlite_out_call",
-    "get_standard_imports",
     "get_the_imports_string",
 ]

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/exporting/flow/utils/flow_content.py

@@ -71,12 +71,14 @@ PYLINT_RULES = [
     "unknown-option-value",
     "unused-argument",
     "unused-import",
+    "unused-variable",
     "invalid-name",
     "import-error",
     "inconsistent-quotes",
     "missing-function-docstring",
     "missing-param-doc",
     "missing-return-doc",
+    "ungrouped-imports",
 ]
 
 
@@ -159,3 +161,39 @@ def get_after_run_content(
 {space}{tab}pass
 """
     return content
+
+
+def get_np_no_nep50_handle() -> str:
+    """Handle catching the "module numpy has no attribute _no_pep50_warning" error.
+
+    Returns
+    -------
+    str
+        The content to handle the error.
+    """
+    # https://github.com/numpy/numpy/blob/v2.2.2/\
+    #   doc/source/release/2.2.0-notes.rst#nep-50-promotion-state-option-removed
+    content = '''
+# try to make sure we don't get:
+# module 'numpy' has no attribute '_no_nep50_warning'"
+os.environ["NEP50_DEPRECATION_WARNING"] = "0"
+os.environ["NEP50_DISABLE_WARNING"] = "1"
+os.environ["NPY_PROMOTION_STATE"] = "weak"
+if not hasattr(np, "_no_pep50_warning"):
+
+    import contextlib
+    from typing import Generator
+
+    @contextlib.contextmanager
+    def _np_no_nep50_warning() -> Generator[None, None, None]:
+        """Dummy function to avoid the warning.
+
+        Yields
+        ------
+        None
+            Nothing.
+        """
+        yield
+    setattr(np, "_no_pep50_warning", _np_no_nep50_warning)  # noqa
+'''
+    return content