waldiez 0.6.0__py3-none-any.whl → 0.6.1__py3-none-any.whl

waldiez/exporting/agent/extras/rag/chroma_extras.py

@@ -3,7 +3,6 @@
 """Get chroma db related imports and content."""
 
 from pathlib import Path
-from typing import Set
 
 from waldiez.models import WaldiezRagUserProxy
 
@@ -33,7 +32,8 @@ def _get_chroma_client_string(agent: WaldiezRagUserProxy) -> tuple[str, str]:
         local_path = Path(agent.retrieve_config.db_config.local_storage_path)
         client_str += (
             "PersistentClient(\n"
-            f'    path=r"{local_path}",' + "\n"
+            f'    path=r"{local_path}",'
+            "\n"
             "    settings=Settings(anonymized_telemetry=False),\n"
             ")"
         )
@@ -80,7 +80,7 @@ def _get_chroma_embedding_function_string(
 
 def get_chroma_db_args(
     agent: WaldiezRagUserProxy, agent_name: str
-) -> tuple[str, Set[str], str, str]:
+) -> tuple[str, set[str], str, str]:
     """Get the 'kwargs to use for ChromaVectorDB.
 
     Parameters
@@ -107,8 +107,10 @@ def get_chroma_db_args(
     if to_import_embedding:
         to_import.add(to_import_embedding)
     kwarg_string = (
-        f"            client={agent_name}_client," + "\n"
-        f"            embedding_function={embedding_function_arg}," + "\n"
+        f"            client={agent_name}_client,"
+        "\n"
+        f"            embedding_function={embedding_function_arg},"
+        "\n"
     )
     # The RAG example:
     # https://ag2ai.github.io/ag2/docs/notebooks/agentchat_groupchat_RAG/
@@ -123,30 +125,36 @@ def get_chroma_db_args(
         content_before += (
             f"{agent_name}_embedding_function = "
             "SentenceTransformerEmbeddingFunction(\n"
-            f'    model_name="{vector_db_model}",' + "\n"
-            ")\n"
+            f'    model_name="{vector_db_model}",'
+            "\n)\n"
         )
     collection_name = agent.retrieve_config.collection_name
     get_or_create = agent.retrieve_config.get_or_create
     if collection_name:
         if get_or_create:
             content_before += (
-                f"{agent_name}_client.get_or_create_collection" + "(\n"
-                f'    "{collection_name}",' + "\n"
-                f"    embedding_function={embedding_function_arg}," + "\n"
-                ")" + "\n"
+                f"{agent_name}_client.get_or_create_collection"
+                "(\n"
+                f'    "{collection_name}",'
+                "\n"
+                f"    embedding_function={embedding_function_arg},"
+                "\n)\n"
             )
         else:
             content_before += (
                 "try:\n"
-                f"    {agent_name}_client.get_collection(" + "\n"
-                f'        "{collection_name}",' + "\n"
-                f"        embedding_function={embedding_function_arg}," + "\n"
-                "    )\n"
+                f"    {agent_name}_client.get_collection("
+                "\n"
+                f'        "{collection_name}",'
+                "\n"
+                f"        embedding_function={embedding_function_arg},"
+                "\n    )\n"
                 "except ValueError:\n"
-                f"    {agent_name}_client.create_collection(" + "\n"
-                f'        "{collection_name}",' + "\n"
-                f"        embedding_function={embedding_function_arg}," + "\n"
-                "    )\n"
+                f"    {agent_name}_client.create_collection("
+                "\n"
+                f'        "{collection_name}",'
+                "\n"
+                f"        embedding_function={embedding_function_arg},"
+                "\n    )\n"
             )
     return kwarg_string, to_import, embedding_function_body, content_before

waldiez/exporting/agent/extras/rag/mongo_extras.py

@@ -2,8 +2,6 @@
 # Copyright (c) 2024 - 2025 Waldiez and contributors.
 """Get mongodb related content and imports."""
 
-from typing import Set
-
 from waldiez.models import WaldiezRagUserProxy
 
 
@@ -45,7 +43,7 @@ def _get_mongodb_embedding_function_string(
 
 def get_mongodb_db_args(
     agent: WaldiezRagUserProxy, agent_name: str
-) -> tuple[str, Set[str], str]:
+) -> tuple[str, set[str], str]:
     """Get the kwargs to use for MongoDBAtlasVectorDB.
 
     Parameters
@@ -63,14 +61,16 @@ def get_mongodb_db_args(
     embedding_function_arg, to_import_embedding, embedding_function_body = (
         _get_mongodb_embedding_function_string(agent, agent_name)
     )
-    to_import: Set[str] = (
+    to_import: set[str] = (
         set() if not to_import_embedding else {to_import_embedding}
     )
-    tab = " " * 12
+    tab: str = " " * 12
     db_config = agent.retrieve_config.db_config
-    kwarg_string = (
-        f'{tab}connection_string="{db_config.connection_url}",' + "\n"
-        f"{tab}embedding_function={embedding_function_arg}," + "\n"
+    kwarg_string: str = (
+        f'{tab}connection_string="{db_config.connection_url}",'
+        "\n"
+        f"{tab}embedding_function={embedding_function_arg},"
+        "\n"
     )
     wait_until_document_ready = db_config.wait_until_document_ready
     wait_until_index_ready = db_config.wait_until_index_ready

waldiez/exporting/agent/extras/rag/pgvector_extras.py

@@ -2,8 +2,6 @@
 # Copyright (c) 2024 - 2025 Waldiez and contributors.
 """Get pgvector related content and imports."""
 
-from typing import Set
-
 from waldiez.models import WaldiezRagUserProxy
 
 
@@ -64,7 +62,7 @@ def _get_pgvector_embedding_function_string(
 
 def get_pgvector_db_args(
     agent: WaldiezRagUserProxy, agent_name: str
-) -> tuple[str, Set[str], str]:
+) -> tuple[str, set[str], str]:
     """Get the kwargs to use for PGVectorDB.
 
     Parameters
@@ -89,7 +87,9 @@ def get_pgvector_db_args(
         else {to_import_client}
     )
     kwarg_str = (
-        f"            client={client_str}," + "\n"
-        f"            embedding_function={embedding_function_arg}," + "\n"
+        f"            client={client_str},"
+        "\n"
+        f"            embedding_function={embedding_function_arg},"
+        "\n"
     )
     return kwarg_str, to_import, embedding_function_body

waldiez/exporting/agent/extras/rag/qdrant_extras.py

@@ -3,7 +3,6 @@
 """Get qdrant db related imports and content."""
 
 from pathlib import Path
-from typing import Set
 
 from waldiez.models import WaldiezRagUserProxy
 
@@ -81,7 +80,7 @@ def _get_qdrant_embedding_function_string(
 
 def get_qdrant_db_args(
     agent: WaldiezRagUserProxy, agent_name: str
-) -> tuple[str, Set[str], str]:
+) -> tuple[str, set[str], str]:
     """Get the kwargs to use for QdrantVectorDB.
 
     Parameters
@@ -106,7 +105,9 @@ def get_qdrant_db_args(
         else {to_import_client}
     )
     kwarg_string = (
-        f"            client={client_str}," + "\n"
-        f"            embedding_function={embedding_function_arg}," + "\n"
+        f"            client={client_str},"
+        "\n"
+        f"            embedding_function={embedding_function_arg},"
+        "\n"
     )
     return kwarg_string, to_import, embedding_function_body

waldiez/exporting/agent/extras/rag/vector_db_extras.py

@@ -21,7 +21,7 @@ class VectorDBExtras:
 
     before_arg: str
     vector_db_arg: str
-    imports: set[str] = field(default_factory=set[str])
+    imports: set[str] = field(default_factory=set)
 
 
 def get_vector_db_extras(

waldiez/exporting/agent/extras/rag_user_proxy_agent_extras.py

@@ -2,8 +2,6 @@
 # Copyright (c) 2024 - 2025 Waldiez and contributors.
 """RAG user proxy agent configuration processor."""
 
-from typing import Union
-
 from waldiez.models import (
     WaldiezAgent,
     WaldiezRagUserProxy,
@@ -115,7 +113,7 @@ class RagUserProxyAgentProcessor:
             self.agent.retrieve_config
         )
         if not retrieve_config:
-            return "", ""
+            return "", ""  # pyright: ignore[reportUnreachable]
         args_dict = self._get_args_dict()
         if not args_dict:
             return "", ""
@@ -146,7 +144,7 @@ class RagUserProxyAgentProcessor:
 
     def _get_args_string(
         self,
-        args_dict: dict[str, Union[str, list[str]]],
+        args_dict: dict[str, str | list[str]],
         vector_db_extras: VectorDBExtras,
         before_agent: str,
     ) -> str:
@@ -193,11 +191,11 @@ class RagUserProxyAgentProcessor:
             return f"{new_model_name}"
         return WaldiezRagUserProxyModels[self.agent.retrieve_config.vector_db]
 
-    def _get_args_dict(self) -> dict[str, Union[str, list[str]]]:
+    def _get_args_dict(self) -> dict[str, str | list[str]]:
         if not isinstance(self.agent, WaldiezRagUserProxy):
             return {}
         model_arg = self._get_model_arg()
-        args_dict: dict[str, Union[str, list[str]]] = {
+        args_dict: dict[str, str | list[str]] = {
             "task": self.agent.retrieve_config.task,
             "model": model_arg,
         }
@@ -212,7 +210,7 @@ class RagUserProxyAgentProcessor:
             if arg_value is not None:
                 args_dict[arg] = arg_value
                 args_dict[arg] = getattr(self.agent.retrieve_config, arg)
-        docs_path: Union[str, list[str]] = []
+        docs_path: str | list[str] = []
         if self.agent.retrieve_config.docs_path:
             doc_paths = (
                 self.agent.retrieve_config.docs_path

waldiez/exporting/agent/extras/reasoning_agent_extras.py

@@ -3,8 +3,6 @@
 # pylint: disable=too-few-public-methods,no-self-use
 """Reasoning agent configuration processor."""
 
-from typing import Optional
-
 from waldiez.models import WaldiezAgent, WaldiezReasoningAgent
 
 from ...core import (
@@ -37,9 +35,9 @@ class ReasoningAgentProcessor:
 
     def process(
         self,
-        code_execution_config: Optional[CodeExecutionConfig] = None,
-        termination_config: Optional[TerminationConfig] = None,
-        system_message_config: Optional[SystemMessageConfig] = None,
+        code_execution_config: CodeExecutionConfig | None = None,
+        termination_config: TerminationConfig | None = None,
+        system_message_config: SystemMessageConfig | None = None,
     ) -> ReasoningExtras:
         """Process reasoning agent configuration.
 

waldiez/exporting/chats/exporter.py

@@ -2,7 +2,7 @@
 # Copyright (c) 2024 - 2025 Waldiez and contributors.
 """Chats exporter."""
 
-from typing import Any, Optional
+from typing import Any
 
 from waldiez.models import (
     WaldiezAgent,
@@ -25,8 +25,8 @@ class ChatsExporter(Exporter[ChatExtras]):
         all_chats: list[WaldiezChat],
         chat_names: dict[str, str],
         main_chats: list[WaldiezAgentConnection],
-        root_group_manager: Optional[WaldiezGroupManager],
-        context: Optional[ExporterContext] = None,
+        root_group_manager: WaldiezGroupManager | None,
+        context: ExporterContext | None = None,
         **kwargs: Any,
     ) -> None:
         """Initialize the chats exporter.
@@ -92,6 +92,6 @@ class ChatsExporter(Exporter[ChatExtras]):
             extras.append_after_all_agents(extras.chat_registration)
         return extras
 
-    def generate_main_content(self) -> Optional[str]:
+    def generate_main_content(self) -> str | None:
         """Generate the main content of the export."""
         return None

waldiez/exporting/chats/processor.py

@@ -3,7 +3,6 @@
 """Chats processor."""
 
 from dataclasses import dataclass
-from typing import Optional
 
 from waldiez.models import (
     WaldiezAgent,
@@ -53,7 +52,7 @@ class ChatsProcessor:
         root_group_manager: WaldiezGroupManager | None,
         for_notebook: bool,
         is_async: bool,
-        cache_seed: Optional[int],
+        cache_seed: int | None,
         serializer: Serializer,
         extras: ChatExtras,
     ) -> None:

waldiez/exporting/chats/utils/common.py

@@ -5,7 +5,6 @@
 """Common utilities for exporting chats."""
 
 import json
-from typing import Optional
 
 from waldiez.models import WaldiezAgent, WaldiezChat
 
@@ -14,7 +13,7 @@ def get_chat_message_string(
     sender: WaldiezAgent,
     chat: WaldiezChat,
     chat_names: dict[str, str],
-) -> tuple[str, Optional[str]]:
+) -> tuple[str, str | None]:
     """Get the agent's message as a string.
 
     Parameters
@@ -37,7 +36,7 @@ def get_chat_message_string(
         return "None", None
     if chat.message.type == "string":
         if chat.message.content is None:  # pragma: no cover
-            # should be coverred previousliy on pydantic validation
+            # should be covered previously on pydantic validation
             return "None", None
         if not chat.message.content:
             return "", None
@@ -52,16 +51,23 @@ def get_chat_message_string(
     return function_name, function_content
 
 
+def _stop_logging(space: str, is_async: bool) -> str:
+    tab = "    "
+    if is_async:
+        return f"{space}{tab}{tab}{tab}{tab}await stop_logging()\n"
+    return f"{space}{tab}{tab}{tab}{tab}stop_logging()\n"
+
+
 def get_event_handler_string(
-    tab: str,
+    space: str,
     is_async: bool,
 ) -> str:
     """Get the event handler string.
 
     Parameters
     ----------
-    tab : str
-        The tab string.
+    space : str
+        The space before the content.
     is_async : bool
         Whether the handler is asynchronous.
 
@@ -70,56 +76,82 @@ def get_event_handler_string(
     str
         The event handler string.
     """
+    tab = "    "
     content = (
-        f"{tab}if on_event:\n"
-        f"{tab}    if not isinstance(results, list):\n"
-        f"{tab}        results = [results]  # pylint: disable=redefined-variable-type\n"
-        f"{tab}    for index, result in enumerate(results):\n"
+        f"{space}if not isinstance(results, list):\n"
+        f"{space}{tab}results = [results]  # pylint: disable=redefined-variable-type\n"
+        f"{space}got_agents = False\n"
+        f"{space}known_agents: list[ConversableAgent] = []\n"
+        f"{space}result_events: list[dict[str, Any]] = []\n"
+        f"{space}if on_event:\n"
+        f"{space}{tab}for index, result in enumerate(results):\n"
+        f"{space}{tab}{tab}result_events = []\n"
     )
+    await_str = "await " if is_async else ""
     if is_async:
         content += (
-            f"{tab}        async for event in result.events:\n"
-            f"{tab}            try:\n"
-            f"{tab}                should_continue = await on_event(event)\n"
-            f"{tab}            except BaseException as e:\n"
-            f'{tab}                print(f"Error in event handler: {{e}}")\n'
-            f"{tab}                raise SystemExit(\n"
-            f'{tab}                    "Error in event handler: " + str(e)\n'
-            f"{tab}                ) from e\n"
+            f"{space}{tab}{tab}async for event in result.events:\n{_add_event_dump(space, tab)}"
+            f"{space}{tab}{tab}{tab}if not got_agents:\n"
+            f"{space}{tab}{tab}{tab}{tab}known_agents = _get_known_agents()\n"
+            f"{space}{tab}{tab}{tab}{tab}got_agents = True\n"
+            f"{space}{tab}{tab}{tab}try:\n"
+            f"{space}{tab}{tab}{tab}{tab}should_continue = await on_event(event, known_agents)\n"
+            f"{space}{tab}{tab}{tab}except BaseException as e:\n{_stop_logging(space, is_async)}"
+            f"{space}{tab}{tab}{tab}{tab}await store_error(e)\n"
+            f"{space}{tab}{tab}{tab}{tab}raise SystemExit(\n"
+            f'{space}{tab}{tab}{tab}{tab}{tab}"Error in event handler: " + str(e)\n'
+            f"{space}{tab}{tab}{tab}{tab}) from e\n"
         )
     else:
         content += (
-            f"{tab}        for event in result.events:\n"
-            f"{tab}            try:\n"
-            f"{tab}                should_continue = on_event(event)\n"
-            f"{tab}            except BaseException as e:\n"
-            f'{tab}                print(f"Error in event handler: {{e}}")\n'
-            f"{tab}                raise SystemExit(\n"
-            f'{tab}                    "Error in event handler: " + str(e)\n'
-            f"{tab}                ) from e\n"
+            f"{space}{tab}{tab}for event in result.events:\n{_add_event_dump(space, tab)}"
+            f"{space}{tab}{tab}{tab}if not got_agents:\n"
+            f"{space}{tab}{tab}{tab}{tab}known_agents = _get_known_agents()\n"
+            f"{space}{tab}{tab}{tab}{tab}got_agents = True\n"
+            f"{space}{tab}{tab}{tab}try:\n"
+            f"{space}{tab}{tab}{tab}{tab}should_continue = on_event(event, known_agents)\n"
+            f"{space}{tab}{tab}{tab}except BaseException as e:\n{_stop_logging(space, is_async)}"
+            f"{space}{tab}{tab}{tab}{tab}store_error(e)\n"
+            f"{space}{tab}{tab}{tab}{tab}raise SystemExit(\n"
+            f'{space}{tab}{tab}{tab}{tab}{tab}"Error in event handler: " + str(e)\n'
+            f"{space}{tab}{tab}{tab}{tab}) from e\n"
         )
     content += (
-        f'{tab}            if event.type == "run_completion":\n'
-        f"{tab}                break\n"
-        f"{tab}            if not should_continue:\n"
-        f'{tab}                raise SystemExit("Event handler stopped processing")\n'
+        f'{space}{tab}{tab}{tab}if getattr(event, "type") == "run_completion":\n'
+        f"{space}{tab}{tab}{tab}{tab}break\n"
+        f"{space}{tab}{tab}{tab}if not should_continue:\n{_stop_logging(space, is_async)}"
+        f"{space}{tab}{tab}{tab}{tab}{await_str}store_error()\n"
+        f'{space}{tab}{tab}{tab}{tab}raise SystemExit("Event handler stopped processing")\n'
     )
-    content += get_result_dicts_string(tab, is_async)
+    content += get_result_dicts_string(space, is_async)
     content += (
-        f"{tab}else:\n"
-        f"{tab}    if not isinstance(results, list):\n"
-        f"{tab}        results = [results]  # pylint: disable=redefined-variable-type\n"
-        f"{tab}    for index, result in enumerate(results):\n"
+        f"{space}else:\n{space}{tab}for index, result in enumerate(results):\n"
+        f"{space}{tab}{tab}result_events = []\n"
     )
     if is_async:
-        content += f"{tab}        await result.process()\n"
+        content += (
+            f"{space}{tab}{tab}await result.process()\n"
+            f"{space}{tab}{tab}async for event in result.events:\n"
+        )
     else:
-        content += f"{tab}        result.process()\n"
-    content += get_result_dicts_string(tab, is_async)
-
+        content += (
+            f"{space}{tab}{tab}result.process()\n"
+            f"{space}{tab}{tab}for event in result.events:\n"
+        )
+    content += _add_event_dump(space, tab)
+    content += get_result_dicts_string(space, is_async)
     return content
 
 
+def _add_event_dump(space: str, tab: str) -> str:
+    return (
+        f"{space}{tab}{tab}{tab}try:\n"
+        f'{space}{tab}{tab}{tab}{tab}result_events.append(event.model_dump(mode="json", fallback=str))\n'
+        f"{space}{tab}{tab}{tab}except BaseException:  # pylint: disable=broad-exception-caught\n"
+        f"{space}{tab}{tab}{tab}{tab}pass\n"
+    )
+
+
 def get_result_dicts_string(tab: str, is_async: bool) -> str:
     """Get the result dicts string.
 
@@ -135,24 +167,33 @@ def get_result_dicts_string(tab: str, is_async: bool) -> str:
     str
         The result dicts string.
     """
+    # fmt: off
     space = f"{tab}        "
-    flow_content = f"{space}result_dict = {{\n"
+    flow_content = f"{space}result_cost = "
+    if is_async:
+        flow_content += "await "
+    flow_content += "result.cost\n"
+    flow_content += f"{space}result_context_variables = "
+    if is_async:
+        flow_content += "await "
+    flow_content += "result.context_variables\n"
+    flow_content += f"{space}result_dict = {{\n"
     flow_content += f'{space}    "index": index,\n'
+    flow_content += f'{space}    "uuid": str(result.uuid),\n'
+    flow_content += f'{space}    "events": result_events,\n'
     if is_async:
         flow_content += f'{space}    "messages": await result.messages,\n'
         flow_content += f'{space}    "summary": await result.summary,\n'
-        flow_content += f'{space}    "cost": (await result.cost).model_dump(mode="json", fallback=str) if await result.cost else None,\n'
-        flow_content += f'{space}    "context_variables": (await result.context_variables).model_dump(mode="json", fallback=str) if await result.context_variables else None,\n'
-        flow_content += (
-            f'{space}    "last_speaker": await result.last_speaker,\n'
-        )
+        flow_content += f'{space}    "cost": result_cost.model_dump(mode="json", fallback=str) if result_cost else None,\n'
+        flow_content += f'{space}    "context_variables": result_context_variables.model_dump(mode="json", fallback=str) if result_context_variables else None,\n'
+        flow_content += f'{space}    "last_speaker": await result.last_speaker,\n'
     else:
         flow_content += f'{space}    "messages": result.messages,\n'
         flow_content += f'{space}    "summary": result.summary,\n'
-        flow_content += f'{space}    "cost": result.cost.model_dump(mode="json", fallback=str) if result.cost else None,\n'
-        flow_content += f'{space}    "context_variables": result.context_variables.model_dump(mode="json", fallback=str) if result.context_variables else None,\n'
+        flow_content += f'{space}    "cost": result_cost.model_dump(mode="json", fallback=str) if result_cost else None,\n'
+        flow_content += f'{space}    "context_variables": result_context_variables.model_dump(mode="json", fallback=str) if result_context_variables else None,\n'
         flow_content += f'{space}    "last_speaker": result.last_speaker,\n'
-    flow_content += f'{space}    "uuid": str(result.uuid),\n'
     flow_content += f"{space}}}\n"
     flow_content += f"{space}result_dicts.append(result_dict)\n"
+    # fmt: on
     return flow_content

waldiez/exporting/chats/utils/group.py

@@ -40,19 +40,19 @@ def export_group_chats(
     tuple[str, str]
         The group chat string and the import string.
     """
-    tab = "    " * tabs
-    run_group_chat = "run_group_chat"
+    space = "    " * tabs
+    run_group_chat: str = "run_group_chat"
     if is_async:
         run_group_chat = "await a_run_group_chat"
     manager_name = agent_names[manager.id]
     pattern_name = f"{manager_name}_pattern"
-    content = f"{tab}results = {run_group_chat}(" + "\n"
-    content += f"{tab}    pattern={pattern_name}," + "\n"
+    content = f"{space}results = {run_group_chat}(" + "\n"
+    content += f"{space}    pattern={pattern_name}," + "\n"
     if initial_chat:
-        content += f"{tab}    messages={json.dumps(initial_chat)}," + "\n"
+        content += f"{space}    messages={json.dumps(initial_chat)}," + "\n"
     else:
-        content += f'{tab}    messages="",\n'
-    content += f"{tab}    max_rounds={manager.data.max_round},\n"
-    content += f"{tab})\n"
-    content += get_event_handler_string(tab=tab, is_async=is_async)
+        content += f'{space}    messages="",\n'
+    content += f"{space}    max_rounds={manager.data.max_round},\n"
+    content += f"{space})\n"
+    content += get_event_handler_string(space=space, is_async=is_async)
     return content

waldiez/exporting/chats/utils/nested.py

@@ -3,7 +3,7 @@
 # pylint: disable=too-many-locals
 """Nested chats exporting."""
 
-from typing import Any, Callable, Optional
+from typing import Any, Callable
 
 from waldiez.models import (
     WaldiezAgent,
@@ -73,7 +73,7 @@ def export_nested_chat_registration(
         )
         content += f"{var_name}: list[dict[str, Any]] = {chat_queue}" + "\n"
         content += f"""
-{agent_name}.register_nested_chats(  # pyright: ignore
+{agent_name}.register_nested_chats(
     trigger={trigger_names},
     chat_queue={var_name},
     use_async={is_async},
@@ -125,7 +125,7 @@ def get_nested_chat_message_string(
     agent_names: dict[str, str],
     chat_names: dict[str, str],
     serializer: Callable[..., str],
-) -> tuple[str, Optional[str]]:
+) -> tuple[str, str | None]:
     """Get the nested chat message string.
 
     Parameters
@@ -145,10 +145,10 @@ def get_nested_chat_message_string(
 
     Returns
     -------
-    tuple[str, Optional[str]]
+    tuple[str, str | None]
         The message string and the method name if the message is a method.
     """
-    sender_name: Optional[str] = None
+    sender_name: str | None = None
     sender_id = waldiez_chat.target if message.is_reply else waldiez_chat.source
     recipient_id = (
         waldiez_chat.source if message.is_reply else waldiez_chat.target
@@ -240,7 +240,7 @@ def get_chat_nested_string(
     chat: WaldiezChat,
     is_reply: bool,
     chat_names: dict[str, str],
-) -> tuple[str, Optional[str]]:
+) -> tuple[str, str | None]:
     """Get the nested chat message.
 
     Parameters
@@ -254,7 +254,7 @@ def get_chat_nested_string(
 
     Returns
     -------
-    tuple[str, Optional[str]]
+    tuple[str, str | None]
         If the message is a string, the message content and None.
         If the message is a method, the method name and the method content.
         If the message is None, 'None' and None.

waldiez/exporting/chats/utils/sequential.py

@@ -68,7 +68,7 @@ def export_sequential_chat(
         additional_methods_string += additional_methods
         content += "\n" + f"{tab}    {chat_string}"
     content += "\n" + "    " * tabs + "])\n"
-    content += get_event_handler_string(tab=tab, is_async=is_async)
+    content += get_event_handler_string(space=tab, is_async=is_async)
     return content, additional_methods_string
 
 

waldiez/exporting/chats/utils/single.py

@@ -157,7 +157,7 @@ def get_simple_chat_string(
     )
     chat_string += message_arg
     chat_string += "\n" + f"{tab})" + "\n"
-    chat_string += get_event_handler_string(tab=tab, is_async=is_async)
+    chat_string += get_event_handler_string(space=tab, is_async=is_async)
     return chat_string, additional_methods_string
 
 
@@ -212,7 +212,7 @@ def get_empty_simple_chat_string(
     )
     content += message_arg
     content += f"{tab})" + "\n"
-    content += get_event_handler_string(tab=tab, is_async=is_async)
+    content += get_event_handler_string(space=tab, is_async=is_async)
     return content, ""