waldiez 0.3.12__py3-none-any.whl → 0.4.1__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.12"
+__version__ = "0.4.1"

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

@@ -239,7 +239,11 @@ class AgentExporter(BaseExporter, ExporterMixin):
         extras = (
             f"{group_chat_arg}{retrieve_arg}{self._reasoning}{self._captain}"
         )
-        agent_str = f"""{agent_name} = {self.agent.ag2_class}(
+        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/captain_agent.py

@@ -47,7 +47,7 @@ def get_captain_agent_extras(
         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}",'
+    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
@@ -56,7 +56,7 @@ def get_captain_agent_extras(
         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}",'
+        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(
@@ -97,19 +97,15 @@ def generate_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}"'
+        json.dump([llm_config], f, ensure_ascii=False, indent=4)
     nested_config = {
         "autobuild_init_config": {
-            "config_file_or_env": config_file_or_env,
+            "config_file_or_env": config_file_or_env_name,
             "builder_model": llm_config["model"],
             "agent_model": llm_config["model"],
         },
@@ -146,10 +142,11 @@ def get_llm_config(
     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
+        llm_config = waldiez_model.get_llm_config(skip_price=True)
+        for key in ["temperature", "top_p", "max_tokens"]:
+            if key not in llm_config:
+                llm_config[key] = None
+        return llm_config
     config_dict = {
         "model": model_name,
         "temperature": temperature,

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,8 +211,9 @@ 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 += get_start_logging(is_async=is_async, tabs=0) + "\n"
         content += "start_logging()\n\n"
         if models_output:
             content += self.get_comment("models", self.for_notebook) + "\n"

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/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

waldiez/exporting/flow/utils/importing_utils.py

@@ -36,21 +36,6 @@ COMMON_AUTOGEN_IMPORTS = [
 ]
 
 
-def get_standard_imports() -> str:
-    """Get the standard imports.
-
-    Returns
-    -------
-    str
-        The standard imports.
-    """
-    builtin_imports = BUILTIN_IMPORTS.copy()
-    imports_string = "\n".join(builtin_imports) + "\n"
-    typing_imports = "from typing import " + ", ".join(TYPING_IMPORTS)
-    imports_string += typing_imports
-    return imports_string
-
-
 def sort_imports(
     all_imports: List[Tuple[str, ImportPosition]],
 ) -> Tuple[List[str], List[str], List[str], List[str], bool]:
@@ -66,10 +51,10 @@ def sort_imports(
     Tuple[List[str], List[str], List[str], List[str], bool]
         The sorted imports and a flag if we got `import autogen`.
     """
-    builtin_imports = []
-    third_party_imports = []
-    local_imports = []
-    autogen_imports = COMMON_AUTOGEN_IMPORTS.copy()
+    builtin_imports: List[str] = []
+    third_party_imports: List[str] = []
+    local_imports: List[str] = []
+    autogen_imports: List[str] = COMMON_AUTOGEN_IMPORTS.copy()
     got_import_autogen = False
     for import_string, position in all_imports:
         if "import autogen" in import_string:
@@ -85,11 +70,22 @@ def sort_imports(
         elif position == ImportPosition.LOCAL:
             local_imports.append(import_string)
     autogen_imports = list(set(autogen_imports))
+    third_party_imports = ensure_np_import(third_party_imports)
+    sorted_builtins = sorted(
+        [imp for imp in builtin_imports if imp.startswith("import ")]
+    ) + sorted([imp for imp in builtin_imports if imp.startswith("from ")])
+    sorted_third_party = sorted(
+        [imp for imp in third_party_imports if imp.startswith("import ")]
+    ) + sorted([imp for imp in third_party_imports if imp.startswith("from ")])
+    sorted_locals = sorted(
+        [imp for imp in local_imports if imp.startswith("import ")]
+    ) + sorted([imp for imp in local_imports if imp.startswith("from ")])
+
     return (
-        sorted(builtin_imports),
+        sorted_builtins,
         sorted(autogen_imports),
-        sorted(third_party_imports),
-        sorted(local_imports),
+        sorted_third_party,
+        sorted_locals,
         got_import_autogen,
     )
 
@@ -131,7 +127,6 @@ def get_the_imports_string(
             "\nimport anyio"
             "\nimport nest_asyncio"
             "\nfrom aiocsv import AsyncDictWriter"
-            "\nfrom asyncer import asyncify"
         )
     if got_import_autogen:
         final_string += "\nimport autogen  # type: ignore\n"
@@ -150,6 +145,27 @@ def get_the_imports_string(
     return final_string.replace("\n\n\n", "\n\n")  # avoid too many newlines
 
 
+def ensure_np_import(third_party_imports: List[str]) -> List[str]:
+    """Ensure numpy is imported.
+
+    Parameters
+    ----------
+    third_party_imports : List[str]
+        The third party imports.
+
+    Returns
+    -------
+    List[str]
+        The third party imports with numpy.
+    """
+    if (
+        not third_party_imports
+        or "import numpy as np" not in third_party_imports
+    ):
+        third_party_imports.append("import numpy as np")
+    return third_party_imports
+
+
 def gather_imports(
     model_imports: Optional[List[Tuple[str, ImportPosition]]],
     skill_imports: Optional[List[Tuple[str, ImportPosition]]],
@@ -174,13 +190,14 @@ def gather_imports(
     Tuple[str, ImportPosition]
         The gathered imports.
     """
-    imports_string = get_standard_imports()
-    all_imports: List[Tuple[str, ImportPosition]] = [
-        (
-            imports_string,
-            ImportPosition.BUILTINS,
+    all_imports: List[Tuple[str, ImportPosition]] = []
+    for import_statement in BUILTIN_IMPORTS:
+        all_imports.append(
+            (
+                import_statement,
+                ImportPosition.BUILTINS,
+            )
         )
-    ]
     if model_imports:
         all_imports.extend(model_imports)
     if skill_imports:
@@ -189,4 +206,21 @@ def gather_imports(
         all_imports.extend(chat_imports)
     if agent_imports:
         all_imports.extend(agent_imports)
-    return list(set(all_imports))
+    # let's try to avoid this:
+    # from typing import Annotated
+    # from typing import Annotated, Any, Callable, Dict, ...Union
+    all_typing_imports = TYPING_IMPORTS.copy()
+    final_imports: List[Tuple[str, ImportPosition]] = []
+    for import_statement, import_position in all_imports:
+        if import_statement.startswith("from typing"):
+            to_import = import_statement.split("import")[1].strip()
+            if to_import:
+                all_typing_imports.append(to_import)
+        else:
+            final_imports.append((import_statement, import_position))
+    unique_typing_imports = list(set(all_typing_imports))
+    one_typing_import = "from typing import " + ", ".join(
+        sorted(unique_typing_imports)
+    )
+    final_imports.insert(1, (one_typing_import, ImportPosition.BUILTINS))
+    return list(set(final_imports))

waldiez/exporting/flow/utils/logging_utils.py

@@ -16,11 +16,13 @@ get_sqlite_to_csv_call_string
 """
 
 
-def get_start_logging(tabs: int = 0) -> str:
+def get_start_logging(is_async: bool, tabs: int = 0) -> str:
     """Get the logging start call string.
 
     Parameters
     ----------
+    is_async : bool
+        Whether to use async mode.
     tabs : int, optional
         The number of tabs to use for indentation, by default 0
 
@@ -41,7 +43,8 @@ def get_start_logging(tabs: int = 0) -> str:
         )
     """
     tab = "    " * tabs
-    content = f'''
+    if is_async is False:
+        return f'''
 {tab}def start_logging() -> None:
 {tab}    """Start logging."""
 {tab}    runtime_logging.start(
@@ -49,7 +52,20 @@ def get_start_logging(tabs: int = 0) -> str:
 {tab}        config={{"dbname": "flow.db"}},
 {tab}    )
 '''
-    return content
+    return f'''
+{tab}def start_logging() -> None:
+{tab}    """Start logging."""
+{tab}    # pylint: disable=import-outside-toplevel
+{tab}    from anyio.from_thread import start_blocking_portal
+
+{tab}    with start_blocking_portal(backend="asyncio") as portal:
+{tab}        portal.call(
+{tab}            runtime_logging.start,
+{tab}            None,
+{tab}            "sqlite",
+{tab}            {{"dbname": "flow.db"}},
+{tab}        )
+'''
 
 
 # pylint: disable=differing-param-doc,differing-type-doc
@@ -336,6 +352,11 @@ def get_stop_logging(tabs: int, is_async: bool) -> str:
         content += "async "
     content += "def stop_logging() -> None:\n"
     content += '    """Stop logging."""\n'
-    content += f"{tab}    runtime_logging.stop()\n"
+    if is_async:
+        content += f"{tab}    # pylint: disable=import-outside-toplevel\n"
+        content += f"{tab}    from asyncer import asyncify\n\n"
+        content += f"{tab}    await asyncify(runtime_logging.stop)()\n"
+    else:
+        content += f"{tab}    runtime_logging.stop()\n"
     content += get_sqlite_out_call(tabs + 1, is_async)
     return content

waldiez/exporting/skills/skills_exporter.py

@@ -89,12 +89,18 @@ class SkillsExporter(BaseExporter, ExporterMixin):
         Tuple[str, int]
             The exported imports and the position of the imports.
         """
-        if not self.skill_imports:
-            return []
         imports: List[Tuple[str, ImportPosition]] = []
-        for skill_import in self.skill_imports:
-            if (skill_import, ImportPosition.LOCAL) not in imports:
-                imports.append((skill_import, ImportPosition.LOCAL))
+        if not self.skill_imports:
+            return imports
+        # standard imports
+        for import_statement in self.skill_imports[0]:
+            imports.append((import_statement, ImportPosition.BUILTINS))
+        # third party imports
+        for import_statement in self.skill_imports[1]:
+            imports.append((import_statement, ImportPosition.THIRD_PARTY))
+        # secrets/local imports
+        for import_statement in self.skill_imports[2]:
+            imports.append((import_statement, ImportPosition.LOCAL))
         return imports
 
     def get_before_export(
@@ -156,11 +162,12 @@ class SkillsExporter(BaseExporter, ExporterMixin):
             the before export strings, the after export strings,
             and the environment variables.
         """
+        content = self.generate()
         imports = self.get_imports()
         after_export = self.get_after_export()
         environment_variables = self.get_environment_variables()
         result: ExporterReturnType = {
-            "content": self.generate(),
+            "content": content,
             "imports": imports,
             "before_export": None,
             "after_export": after_export,

waldiez/exporting/skills/utils.py

@@ -94,6 +94,7 @@ def _write_skill_secrets(
         return
     if not isinstance(output_dir, Path):
         output_dir = Path(output_dir)
+    output_dir.mkdir(parents=True, exist_ok=True)
     secrets_file = output_dir / f"{flow_name}_{skill_name}_secrets.py"
     first_line = f'"""Secrets for the skill: {skill_name}."""' + "\n"
     with secrets_file.open("w", encoding="utf-8", newline="\n") as f:
@@ -108,7 +109,7 @@ def export_skills(
     skills: List[WaldiezSkill],
     skill_names: Dict[str, str],
     output_dir: Optional[Union[str, Path]] = None,
-) -> Tuple[List[str], List[Tuple[str, str]], str]:
+) -> Tuple[Tuple[List[str], List[str], List[str]], List[Tuple[str, str]], str]:
     """Get the skills' contents and secrets.
 
     If `output_dir` is provided, the contents are saved to that directory.
@@ -126,19 +127,26 @@ def export_skills(
 
     Returns
     -------
-    Tuple[Set[str], Set[Tuple[str, str]], str]
+    Tuple[Tuple[List[str], List[str], List[str]], List[Tuple[str, str]], str]
         - The skill imports to use in the main file.
         - The skill secrets to set as environment variables.
         - The skills contents.
     """
-    skill_imports: List[str] = []
+    skill_imports: Tuple[List[str], List[str], List[str]] = ([], [], [])
     skill_secrets: List[Tuple[str, str]] = []
     skill_contents: str = ""
     # if the skill.is_shared,
     # its contents must be first (before the other skills)
     shared_skill_contents = ""
     for skill in skills:
-        skill_imports.append(get_skill_imports(flow_name, skill))
+        standard_skill_imports, third_party_skill_imports = skill.get_imports()
+        if standard_skill_imports:
+            skill_imports[0].extend(standard_skill_imports)
+        if third_party_skill_imports:
+            skill_imports[1].extend(third_party_skill_imports)
+        secrets_import = get_skill_secrets_import(flow_name, skill)
+        if secrets_import:
+            skill_imports[2].append(secrets_import)
         for key, value in skill.secrets.items():
             skill_secrets.append((key, value))
         _write_skill_secrets(
@@ -153,8 +161,14 @@ def export_skills(
         if skill.is_shared:
             shared_skill_contents += skill_content + "\n\n"
         else:
+            if skill.is_interop:
+                skill_content += _add_interop_extras(
+                    skill=skill, skill_names=skill_names
+                )
             skill_contents += skill_content + "\n\n"
     skill_contents = shared_skill_contents + skill_contents
+    # remove dupes from imports if any and sort them
+    skill_imports = _sort_imports(skill_imports)
     return (
         skill_imports,
         skill_secrets,
@@ -162,8 +176,77 @@ def export_skills(
     )
 
 
-def get_skill_imports(flow_name: str, skill: WaldiezSkill) -> str:
-    """Get the skill imports string.
+def _add_interop_extras(
+    skill: WaldiezSkill,
+    skill_names: Dict[str, str],
+) -> str:
+    """Add the interop conversion.
+
+    Parameters
+    ----------
+    skill : WaldiezSkill
+        The skill
+    skill_names : Dict[str, str]
+        The skill names.
+
+    Returns
+    -------
+    str
+        The extra content to convert the tool.
+    """
+    skill_name = skill_names[skill.id]
+    interop_instance = f"ag2_{skill_name}_interop = Interoperability()" + "\n"
+    extra_content = (
+        f"ag2_{skill_name} = "
+        f"ag2_{skill_name}_interop.convert_tool("
+        f"tool={skill_name}, "
+        f'type="{skill.skill_type}")'
+    )
+    return "\n" + interop_instance + extra_content
+
+
+def _sort_imports(
+    skill_imports: Tuple[List[str], List[str], List[str]],
+) -> Tuple[List[str], List[str], List[str]]:
+    """Sort the imports.
+
+    Parameters
+    ----------
+    skill_imports : Tuple[List[str], List[str], List[str]]
+        The skill imports.
+
+    Returns
+    -------
+    Tuple[List[str], List[str], List[str]]
+        The sorted skill imports.
+    """
+
+    # "from x import y" and "import z"
+    # the "import a" should be first (and sorted)
+    # then the "from b import c" (and sorted)
+    standard_lib_imports = skill_imports[0]
+    third_party_imports = skill_imports[1]
+    secrets_imports = skill_imports[2]
+
+    sorted_standard_lib_imports = sorted(
+        [imp for imp in standard_lib_imports if imp.startswith("import ")]
+    ) + sorted([imp for imp in standard_lib_imports if imp.startswith("from ")])
+
+    sorted_third_party_imports = sorted(
+        [imp for imp in third_party_imports if imp.startswith("import ")]
+    ) + sorted([imp for imp in third_party_imports if imp.startswith("from ")])
+
+    sorted_secrets_imports = sorted(secrets_imports)
+
+    return (
+        sorted_standard_lib_imports,
+        sorted_third_party_imports,
+        sorted_secrets_imports,
+    )
+
+
+def get_skill_secrets_import(flow_name: str, skill: WaldiezSkill) -> str:
+    """Get the skill secrets import string.
 
     Parameters
     ----------
@@ -263,6 +346,9 @@ def get_agent_skill_registrations(
             skill for skill in all_skills if skill.id == linked_skill.id
         )
         skill_name = skill_names[linked_skill.id]
+        if waldiez_skill.is_interop:
+            # the name of the the converted to ag2 tool
+            skill_name = f"ag2_{skill_name}"
         skill_description = (
             waldiez_skill.description or f"Description of {skill_name}"
         )