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

waldiez/running/step_by_step/step_by_step_runner.py

@@ -1,10 +1,11 @@
 # SPDX-License-Identifier: Apache-2.0.
 # Copyright (c) 2024 - 2025 Waldiez and contributors.
 
-# pylint: disable=line-too-long
+# pylint: disable=duplicate-code,line-too-long
 # pyright: reportUnknownMemberType=false, reportAttributeAccessIssue=false
 # pyright: reportUnknownArgumentType=false, reportOptionalMemberAccess=false
-# pylint: disable=duplicate-code
+# pyright: reportDeprecated=false, reportMissingTypeStubs=false
+# pyright: reportUnsafeMultipleInheritance=false
 # flake8: noqa: E501
 
 """Step-by-step Waldiez runner with user interaction capabilities."""
@@ -12,20 +13,23 @@
 import asyncio
 import threading
 import traceback
+import uuid
 from collections import deque
+from collections.abc import Iterable
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, Iterable, Union
+from typing import TYPE_CHECKING, Any, Union
 
 from pydantic import ValidationError
+from typing_extensions import override
 
-from waldiez.io.utils import DEBUG_INPUT_PROMPT, gen_id
 from waldiez.models.waldiez import Waldiez
 from waldiez.running.step_by_step.command_handler import CommandHandler
 from waldiez.running.step_by_step.events_processor import EventProcessor
 
 from ..base_runner import WaldiezBaseRunner
+from ..events_mixin import EventsMixin
 from ..exceptions import StopRunningException
-from ..run_results import WaldiezRunResults
+from ..results_mixin import WaldiezRunResults
 from .breakpoints_mixin import BreakpointsMixin
 from .step_by_step_models import (
     VALID_CONTROL_COMMANDS,
@@ -40,10 +44,10 @@ from .step_by_step_models import (
 )
 
 if TYPE_CHECKING:
+    from autogen.agentchat import ConversableAgent  # type: ignore
     from autogen.events import BaseEvent  # type: ignore
     from autogen.messages import BaseMessage  # type: ignore
 
-
 MESSAGES = {
     "workflow_starting": "<Waldiez step-by-step> - Starting workflow...",
     "workflow_finished": "<Waldiez step-by-step> - Workflow finished",
@@ -52,6 +56,21 @@ MESSAGES = {
         "<Waldiez step-by-step> - Workflow execution failed: {error}"
     ),
 }
+DEBUG_INPUT_PROMPT = (
+    # cspell: disable-next-line
+    "[Step] (c)ontinue, (r)un, (q)uit, (i)nfo, (h)elp, (st)ats: "
+)
+
+
+def gen_id() -> str:
+    """Generate a new id.
+
+    Returns
+    -------
+    str
+        The new id.
+    """
+    return str(uuid.uuid4())
 
 
 # pylint: disable=too-many-instance-attributes
@@ -67,7 +86,7 @@ class WaldiezStepByStepRunner(WaldiezBaseRunner, BreakpointsMixin):
         structured_io: bool = False,
         dot_env: str | Path | None = None,
         auto_continue: bool = False,
-        breakpoints: Iterable[str] | None = None,
+        breakpoints: Iterable[Any] | None = None,
         config: WaldiezDebugConfig | None = None,
         **kwargs: Any,
     ) -> None:
@@ -80,7 +99,8 @@ class WaldiezStepByStepRunner(WaldiezBaseRunner, BreakpointsMixin):
             dot_env=dot_env,
             **kwargs,
         )
-        BreakpointsMixin.__init__(self)
+        BreakpointsMixin.__init__(self, config=config)
+        self.set_agent_id_to_name(waldiez.flow.unique_names["agent_names"])
 
         # Configuration
         self._config = config or WaldiezDebugConfig()
@@ -112,6 +132,8 @@ class WaldiezStepByStepRunner(WaldiezBaseRunner, BreakpointsMixin):
         # Command handling
         self._command_handler = CommandHandler(self)
         self._event_processor = EventProcessor(self)
+        auto_run = self.is_auto_run()
+        self._config.auto_continue = auto_run
 
     @property
     def auto_continue(self) -> bool:
@@ -207,19 +229,6 @@ class WaldiezStepByStepRunner(WaldiezBaseRunner, BreakpointsMixin):
         """Get the maximum event history size."""
         return self._config.max_event_history
 
-    @staticmethod
-    def print(*args: Any, **kwargs: Any) -> None:
-        """Print method.
-
-        Parameters
-        ----------
-        *args : Any
-            Positional arguments to print.
-        **kwargs : Any
-            Keyword arguments to print.
-        """
-        WaldiezBaseRunner.print(*args, **kwargs)
-
     def add_to_history(self, event_info: dict[str, Any]) -> None:
         """Add an event to the history.
 
@@ -259,6 +268,7 @@ class WaldiezStepByStepRunner(WaldiezBaseRunner, BreakpointsMixin):
         self.emit(WaldiezDebugEventInfo(event=event_info))
 
     # noinspection PyTypeHints
+    @override
     def emit(self, message: WaldiezDebugMessage) -> None:
         """Emit a debug message.
 
@@ -463,16 +473,25 @@ class WaldiezStepByStepRunner(WaldiezBaseRunner, BreakpointsMixin):
 
         return self._command_handler.handle_command(user_input or "")
 
-    def _get_user_action(self) -> WaldiezDebugStepAction:
-        """Get user action with timeout support."""
+    def _get_user_action(self, force: bool) -> WaldiezDebugStepAction:
+        """Get user action with timeout support.
+
+        Parameters
+        ----------
+        force : bool
+            Force getting the user's action, even if in auto-run mode.
+        """
         if self._config.auto_continue:
             self.step_mode = True
-            return WaldiezDebugStepAction.CONTINUE
-
+            if force:
+                self._config.auto_continue = False
+            else:
+                return WaldiezDebugStepAction.CONTINUE
         while True:
             request_id = gen_id()
             try:
                 if not self.structured_io:
+                    # if structured, we already do this (print the prompt)
                     self.emit(
                         WaldiezDebugInputRequest(
                             prompt=DEBUG_INPUT_PROMPT, request_id=request_id
@@ -481,8 +500,9 @@ class WaldiezStepByStepRunner(WaldiezBaseRunner, BreakpointsMixin):
             except Exception as e:  # pylint: disable=broad-exception-caught
                 self.log.warning("Failed to emit input request: %s", e)
             try:
-                user_input = WaldiezBaseRunner.get_user_input(
-                    DEBUG_INPUT_PROMPT
+                user_input = EventsMixin.get_user_input(
+                    DEBUG_INPUT_PROMPT,
+                    request_id=request_id,
                 ).strip()
                 return self._parse_user_action(
                     user_input, request_id=request_id
@@ -492,11 +512,14 @@ class WaldiezStepByStepRunner(WaldiezBaseRunner, BreakpointsMixin):
                 self._stop_requested.set()
                 return WaldiezDebugStepAction.QUIT
 
-    async def _a_get_user_action(self) -> WaldiezDebugStepAction:
+    async def _a_get_user_action(self, force: bool) -> WaldiezDebugStepAction:
         """Get user action asynchronously."""
         if self._config.auto_continue:
             self.step_mode = True
-            return WaldiezDebugStepAction.CONTINUE
+            if force:
+                self._config.auto_continue = False
+            else:
+                return WaldiezDebugStepAction.CONTINUE
 
         while True:
             request_id = gen_id()
@@ -508,7 +531,7 @@ class WaldiezStepByStepRunner(WaldiezBaseRunner, BreakpointsMixin):
                     )
                 )
 
-                user_input = await WaldiezBaseRunner.a_get_user_input(
+                user_input = await EventsMixin.a_get_user_input(
                     DEBUG_INPUT_PROMPT
                 )
                 user_input = user_input.strip()
@@ -519,36 +542,45 @@ class WaldiezStepByStepRunner(WaldiezBaseRunner, BreakpointsMixin):
             except (KeyboardInterrupt, EOFError):
                 return WaldiezDebugStepAction.QUIT
 
-    def _handle_step_interaction(self) -> bool:
-        """Handle step-by-step user interaction."""
+    def _handle_step_interaction(self, force: bool) -> bool:
+        """Handle step-by-step user interaction.
+
+        Parameters
+        ----------
+        force : bool
+            Force getting the user's action, even if in auto-run mode.
+        """
         while True:
-            action = self._get_user_action()
+            action = self._get_user_action(force)
             if action in (
                 WaldiezDebugStepAction.CONTINUE,
                 WaldiezDebugStepAction.STEP,
             ):
                 return True
             if action == WaldiezDebugStepAction.RUN:
+                self._config.auto_continue = True
                 return True
             if action == WaldiezDebugStepAction.QUIT:
                 return False
             # For other actions (info, help, etc.), continue the loop
 
-    async def _a_handle_step_interaction(self) -> bool:
+    async def _a_handle_step_interaction(self, force: bool) -> bool:
         """Handle step-by-step user interaction asynchronously."""
         while True:
-            action = await self._a_get_user_action()
+            action = await self._a_get_user_action(force)
             if action in (
                 WaldiezDebugStepAction.CONTINUE,
                 WaldiezDebugStepAction.STEP,
             ):
                 return True
             if action == WaldiezDebugStepAction.RUN:
+                self._config.auto_continue = True
                 return True
             if action == WaldiezDebugStepAction.QUIT:
                 return False
             # For other actions (info, help, etc.), continue the loop
 
+    @override
     def _run(
         self,
         temp_dir: Path,
@@ -586,9 +618,9 @@ class WaldiezStepByStepRunner(WaldiezBaseRunner, BreakpointsMixin):
             else:
                 stream = IOStream.get_default()
 
-            WaldiezBaseRunner._print = stream.print
-            WaldiezBaseRunner._input = stream.input
-            WaldiezBaseRunner._send = stream.send
+            EventsMixin.set_print_function(stream.print)
+            EventsMixin.set_input_function(stream.input)
+            EventsMixin.set_send_function(stream.send)
 
             self.print(MESSAGES["workflow_starting"])
             self.print(self.waldiez.info.model_dump_json())
@@ -608,30 +640,44 @@ class WaldiezStepByStepRunner(WaldiezBaseRunner, BreakpointsMixin):
 
         return results_container["results"]
 
-    def _on_event(self, event: Union["BaseEvent", "BaseMessage"]) -> bool:
+    def _re_emit_if_needed(self, event_info: dict[str, Any]) -> None:
+        # emit again if type is text, swapping the sender and without recipient
+        if event_info.get("type", "") == "text":
+            event_info["sender"] = event_info["recipient"]
+            event_info["recipient"] = None
+            event_info["agents"]["sender"] = event_info["agents"]["recipient"]
+            event_info["agents"]["recipient"] = None
+            self.emit_event(event_info)
+
+    def _on_event(
+        self,
+        event: Union["BaseEvent", "BaseMessage"],
+        agents: list["ConversableAgent"],
+    ) -> bool:
         """Process an event with step-by-step debugging."""
         # pylint: disable=too-many-try-statements,broad-exception-caught
         try:
             # Use the event processor for core logic
-            result = self._event_processor.process_event(event)
+            result = self._event_processor.process_event(event, agents)
 
             if result["action"] == "stop":
                 self.log.debug(
                     "Step-by-step execution stopped before event processing"
                 )
                 return False
-            self.emit_event(result["event_info"])
+            event_info = result["event_info"]
+            self.emit_event(event_info)
             # Handle breakpoint logic
-            if result["should_break"]:
-                if not self._handle_step_interaction():
+            if result["action"] == "break":
+                if not self._handle_step_interaction(force=True):
                     self._stop_requested.set()
                     if hasattr(event, "type") and event.type == "input_request":
                         event.content.respond("exit")
                         return True
                     raise StopRunningException(StopRunningException.reason)
-
+                self._re_emit_if_needed(event_info)
             # Process the actual event
-            WaldiezBaseRunner.process_event(event, skip_send=True)
+            EventsMixin.process_event(event, agents, skip_send=True)
             self._processed_events += 1
 
         except Exception as e:
@@ -644,6 +690,7 @@ class WaldiezStepByStepRunner(WaldiezBaseRunner, BreakpointsMixin):
         return not self._stop_requested.is_set()
 
     # pylint: disable=too-complex
+    @override
     async def _a_run(
         self,
         temp_dir: Path,
@@ -657,7 +704,7 @@ class WaldiezStepByStepRunner(WaldiezBaseRunner, BreakpointsMixin):
 
         async def _execute_workflow() -> list[dict[str, Any]]:
             # pylint: disable=import-outside-toplevel
-            from autogen.io import IOStream  # pyright: ignore
+            from autogen.io import IOStream
 
             from waldiez.io import StructuredIOStream
 
@@ -677,9 +724,9 @@ class WaldiezStepByStepRunner(WaldiezBaseRunner, BreakpointsMixin):
                 else:
                     stream = IOStream.get_default()
 
-                WaldiezBaseRunner._print = stream.print
-                WaldiezBaseRunner._input = stream.input
-                WaldiezBaseRunner._send = stream.send
+                EventsMixin.set_print_function(stream.print)
+                EventsMixin.set_input_function(stream.input)
+                EventsMixin.set_send_function(stream.send)
 
                 self.print(MESSAGES["workflow_starting"])
                 self.print(self.waldiez.info.model_dump_json())
@@ -713,31 +760,34 @@ class WaldiezStepByStepRunner(WaldiezBaseRunner, BreakpointsMixin):
             return []
 
     async def _a_on_event(
-        self, event: Union["BaseEvent", "BaseMessage"]
+        self,
+        event: Union["BaseEvent", "BaseMessage"],
+        agents: list["ConversableAgent"],
     ) -> bool:
         """Process an event with step-by-step debugging asynchronously."""
         # pylint: disable=too-many-try-statements,broad-exception-caught
         try:
             # Use the event processor for core logic
-            result = self._event_processor.process_event(event)
+            result = self._event_processor.process_event(event, agents)
 
             if result["action"] == "stop":
                 self.log.debug(
                     "Async step-by-step execution stopped before event processing"
                 )
                 return False
-            self.emit_event(result["event_info"])
+            event_info = result["event_info"]
+            self.emit_event(event_info)
             # Handle breakpoint logic
-            if result["should_break"]:
-                if not await self._a_handle_step_interaction():
+            if result["action"] == "break":
+                if not await self._a_handle_step_interaction(force=True):
                     self._stop_requested.set()
                     if hasattr(event, "type") and event.type == "input_request":
-                        event.content.respond("exit")
+                        await event.content.respond("exit")
                         return True
                     raise StopRunningException(StopRunningException.reason)
-
+                self._re_emit_if_needed(event_info)
             # Process the actual event
-            await WaldiezBaseRunner.a_process_event(event, skip_send=True)
+            await EventsMixin.a_process_event(event, agents, skip_send=True)
             self._processed_events += 1
 
         except Exception as e:

waldiez/running/subprocess_runner/__base__.py

@@ -50,6 +50,10 @@ class BaseSubprocessRunner:
         self.dot_env = dot_env
         self.logger = logger or logging.getLogger(self.__class__.__name__)
         self.waiting_for_input = False
+        breakpoints = kwargs.get("breakpoints", [])
+        if not isinstance(breakpoints, list):
+            breakpoints = []
+        self.breakpoints: list[str] = breakpoints
 
     def build_command(
         self,
@@ -110,6 +114,10 @@ class BaseSubprocessRunner:
         if self.dot_env:
             cmd.extend(["--dot-env", str(self.dot_env)])
 
+        if self.breakpoints:
+            for entry in self.breakpoints:
+                cmd.extend(["--breakpoints", entry])
+        self.logger.debug("Runner command: %s", " ".join(cmd))
         return cmd
 
     def parse_output(
@@ -138,7 +146,7 @@ class BaseSubprocessRunner:
         try:
             data = json.loads(line)
             if isinstance(data, dict):
-                return data  # pyright: ignore
+                return data  # pyright: ignore[reportUnknownVariableType]
         except json.JSONDecodeError:
             return self.create_output_message(stream=stream, content=line)
         return self.create_output_message(

waldiez/running/subprocess_runner/_async_runner.py

@@ -10,8 +10,9 @@ import logging
 
 # noinspection PyProtectedMember
 from asyncio.subprocess import Process as AsyncProcess
+from collections.abc import Coroutine
 from pathlib import Path
-from typing import Any, Callable, Coroutine, Literal, Optional
+from typing import Any, Callable, Literal
 
 from .__base__ import BaseSubprocessRunner
 
@@ -57,7 +58,7 @@ class AsyncSubprocessRunner(BaseSubprocessRunner):
         )
         self.on_output = on_output
         self.on_input_request = on_input_request
-        self.process: Optional[AsyncProcess] = None
+        self.process: AsyncProcess | None = None
         self.input_queue: asyncio.Queue[str] = asyncio.Queue()
         self.output_queue: asyncio.Queue[dict[str, Any]] = asyncio.Queue()
         self._monitor_tasks: list[asyncio.Task[Any]] = []
@@ -158,7 +159,8 @@ class AsyncSubprocessRunner(BaseSubprocessRunner):
                     await self.process.wait()
 
             except Exception as e:
-                self.logger.error(f"Error stopping subprocess: {e}")
+                if not isinstance(e, AttributeError):
+                    self.logger.error(f"Error stopping subprocess: {e}")
         self.process = None
 
     async def _start_monitoring(self) -> None:

waldiez/running/subprocess_runner/_sync_runner.py

@@ -93,6 +93,7 @@ class SyncSubprocessRunner(BaseSubprocessRunner):
                 stdin=subprocess.PIPE,
                 stdout=subprocess.PIPE,
                 stderr=subprocess.PIPE,
+                encoding="utf-8",
                 text=True,
                 bufsize=1,  # Line buffered
             )
@@ -351,8 +352,9 @@ class SyncSubprocessRunner(BaseSubprocessRunner):
                         f"Thread {thread.name} did not stop gracefully"
                     )
 
+    # pylint: disable=too-complex
     # noinspection TryExceptPass,PyBroadException
-    def _cleanup_process(self) -> None:
+    def _cleanup_process(self) -> None:  # noqa: C901
         """Cleanup process resources."""
         if self.process:
             if self.process.stdin:
@@ -381,7 +383,9 @@ class SyncSubprocessRunner(BaseSubprocessRunner):
                 self.process.kill()
                 self.process.wait()
             except BaseException as e:
-                self.logger.error(f"Error stopping subprocess: {e}")
+                if not isinstance(e, AttributeError):
+                    # already "None"
+                    self.logger.error(f"Error stopping subprocess: {e}")
             finally:
                 self.process = None
 

waldiez/running/subprocess_runner/runner.py

@@ -1,5 +1,7 @@
 # SPDX-License-Identifier: Apache-2.0.
 # Copyright (c) 2024 - 2025 Waldiez and contributors.
+
+# pyright: reportAttributeAccessIssue=false,reportUnknownArgumentType=false
 # flake8: noqa: G004
 """Waldiez subprocess runner that inherits from BaseRunner."""
 
@@ -8,15 +10,15 @@ import re
 from pathlib import Path
 from typing import Any, Callable, Literal
 
+from typing_extensions import override
+
 from waldiez.models import Waldiez
 
 from ..base_runner import WaldiezBaseRunner
+from ..step_by_step.breakpoints_mixin import BreakpointsMixin
 from ._async_runner import AsyncSubprocessRunner
 from ._sync_runner import SyncSubprocessRunner
 
-# TODO: check output directory and return the results from the JSON logs
-# in self._run and self._a_run
-
 
 # noinspection PyUnusedLocal
 class WaldiezSubprocessRunner(WaldiezBaseRunner):
@@ -71,6 +73,7 @@ class WaldiezSubprocessRunner(WaldiezBaseRunner):
             dot_env=dot_env,
             **kwargs,
         )
+        self.breakpoints = self._parse_breakpoints(**kwargs)
 
         # Store callbacks
         self.sync_on_output = on_output or self._default_sync_output
@@ -106,17 +109,27 @@ class WaldiezSubprocessRunner(WaldiezBaseRunner):
         # noinspection RegExpRedundantEscape
         file_name = re.sub(r"[^a-zA-Z0-9_\-\.]", "_", file_name)[:30]
         file_name = f"{file_name}.waldiez"
-        with open(file_name, "w", encoding="utf-8") as f:
+        with open(file_name, "w", encoding="utf-8", newline="\n") as f:
             f.write(self.waldiez.model_dump_json())
         return Path(file_name).resolve()
 
+    @staticmethod
+    def _parse_breakpoints(**kwargs: Any) -> list[str]:
+        initial_breakpoints = kwargs.get("breakpoints")
+        if isinstance(initial_breakpoints, (list, set, tuple)):
+            breakpoints = BreakpointsMixin.get_initial_breakpoints(
+                initial_breakpoints
+            )
+            return [str(item) for item in breakpoints]
+        return []
+
     def _default_sync_output(self, data: dict[str, Any]) -> None:
         """Get the default sync output handler."""
         if data.get("type") == "error":
             self.log.error(data.get("data", ""))
         else:
             content = data.get("data", data)
-            self._print(content)
+            self.print(content)
 
     def _default_sync_input_request(self, prompt: str) -> None:
         """Get the default sync input request handler."""
@@ -141,6 +154,7 @@ class WaldiezSubprocessRunner(WaldiezBaseRunner):
             uploads_root=self.uploads_root,
             dot_env=self.dot_env_path,
             logger=self.log,
+            breakpoints=self.breakpoints,
         )
         return self.async_runner
 
@@ -153,9 +167,11 @@ class WaldiezSubprocessRunner(WaldiezBaseRunner):
             uploads_root=self.uploads_root,
             dot_env=self.dot_env_path,
             logger=self.log,
+            breakpoints=self.breakpoints,
         )
         return self.sync_runner
 
+    @override
     def run(
         self,
         output_path: str | Path | None = None,
@@ -220,6 +236,7 @@ class WaldiezSubprocessRunner(WaldiezBaseRunner):
                 return _output_path / f"{filename}.py"
         return self._waldiez_file.with_suffix(".py")
 
+    @override
     def _run(
         self,
         temp_dir: Path,
@@ -242,14 +259,8 @@ class WaldiezSubprocessRunner(WaldiezBaseRunner):
             runner = self._create_sync_subprocess_runner()
 
             # Run subprocess
-            success = runner.run_subprocess(self._waldiez_file, mode=self.mode)
-            return [
-                {
-                    "success": success,
-                    "runner": "sync_subprocess",
-                    "mode": self.mode,
-                }
-            ]
+            runner.run_subprocess(self._waldiez_file, mode=self.mode)
+            return self.read_from_output(output_file.parent)
 
         except Exception as e:
             self.log.error("Error in sync subprocess execution: %s", e)
@@ -261,6 +272,7 @@ class WaldiezSubprocessRunner(WaldiezBaseRunner):
                 }
             ]
 
+    @override
     async def a_run(
         self,
         output_path: str | Path | None = None,
@@ -311,6 +323,7 @@ class WaldiezSubprocessRunner(WaldiezBaseRunner):
             **kwargs,
         )
 
+    @override
     async def _a_run(
         self,
         temp_dir: Path,
@@ -356,17 +369,11 @@ class WaldiezSubprocessRunner(WaldiezBaseRunner):
             runner = self._create_async_subprocess_runner()
 
             # Run subprocess
-            success = await runner.run_subprocess(
+            await runner.run_subprocess(
                 self._waldiez_file,
                 mode=self.mode,
             )
-            return [
-                {
-                    "success": success,
-                    "runner": "async_subprocess",
-                    "mode": self.mode,
-                }
-            ]
+            return await self.a_read_from_output(output_file.parent)
 
         except Exception as e:
             self.log.error("Error in async subprocess execution: %s", e)
@@ -408,6 +415,7 @@ class WaldiezSubprocessRunner(WaldiezBaseRunner):
                 self.sync_runner.provide_user_input, user_input
             )
 
+    @override
     def stop(self) -> None:
         """Stop the workflow execution."""
         super().stop()  # Set the base runner stop flag
@@ -461,9 +469,11 @@ class WaldiezSubprocessRunner(WaldiezBaseRunner):
             self.sync_runner.stop()
         self.sync_runner = None
 
+    @override
     def _after_run(
         self,
         results: list[dict[str, Any]],
+        error: BaseException | None,
         output_file: Path,
         waldiez_file: Path,
         uploads_root: Path | None,
@@ -476,7 +486,9 @@ class WaldiezSubprocessRunner(WaldiezBaseRunner):
         Parameters
         ----------
         results : list[dict[str, Any]]
-            Results from the workflow execution
+            Results from the workflow execution.
+        error : BaseException | None
+            Optional error during the run.
         output_file : Path
             Output file path
         waldiez_file : Path
@@ -493,9 +505,11 @@ class WaldiezSubprocessRunner(WaldiezBaseRunner):
         # Cleanup subprocess runners
         self._cleanup_subprocess_runners()
 
+    @override
     async def _a_after_run(
         self,
         results: list[dict[str, Any]],
+        error: BaseException | None,
         output_file: Path,
         waldiez_file: Path,
         uploads_root: Path | None,
@@ -508,7 +522,9 @@ class WaldiezSubprocessRunner(WaldiezBaseRunner):
         Parameters
         ----------
         results : list[dict[str, Any]]
-            Results from the workflow execution
+            Results from the workflow execution.
+        error : BaseException | None
+            Optional error during the run.
         output_file : Path
             Output file path
         waldiez_file : Path

waldiez/running/timeline_processor.py

@@ -93,7 +93,7 @@ class TimelineProcessor:
         bool
             True if the value is missing, NaN, or empty; False otherwise.
         """
-        if pd.isna(value):  # pyright: ignore
+        if pd.isna(value):
             return True
         if isinstance(value, str) and (
             value.strip() == "" or value.lower() == "nan"