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

waldiez/running/standard_runner.py

@@ -2,6 +2,7 @@
 # Copyright (c) 2024 - 2025 Waldiez and contributors.
 
 # pyright: reportUnknownMemberType=false, reportAttributeAccessIssue=false
+# pyright: reportMissingTypeStubs=false, reportDeprecated=false
 # pylint: disable=duplicate-code,too-few-public-methods
 """Run a waldiez flow.
 
@@ -16,12 +17,16 @@ import traceback
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, Union
 
+from typing_extensions import override
+
 from waldiez.models.waldiez import Waldiez
-from waldiez.running.run_results import WaldiezRunResults
 
 from .base_runner import WaldiezBaseRunner
+from .events_mixin import EventsMixin
+from .results_mixin import WaldiezRunResults
 
 if TYPE_CHECKING:
+    from autogen.agentchat import ConversableAgent  # type: ignore
     from autogen.events import BaseEvent  # type: ignore
     from autogen.messages import BaseMessage  # type: ignore
 
@@ -59,20 +64,8 @@ class WaldiezStandardRunner(WaldiezBaseRunner):
         self._event_count = 0
         self._processed_events = 0
 
-    @staticmethod
-    def print(*args: Any, **kwargs: Any) -> None:
-        """Print.
-
-        Parameters
-        ----------
-        *args : Any
-            Positional arguments to print.
-        **kwargs : Any
-            Keyword arguments to print.
-        """
-        WaldiezBaseRunner.print(*args, **kwargs)
-
     # pylint: disable=unused-argument
+    @override
     def _run(
         self,
         temp_dir: Path,
@@ -108,9 +101,9 @@ class WaldiezStandardRunner(WaldiezBaseRunner):
                 )
             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())
             results = loaded_module.main(
@@ -133,6 +126,7 @@ class WaldiezStandardRunner(WaldiezBaseRunner):
     def _on_event(
         self,
         event: Union["BaseEvent", "BaseMessage"],
+        agents: list["ConversableAgent"],
     ) -> bool:
         """Process an event from the workflow."""
         self._event_count += 1
@@ -142,7 +136,7 @@ class WaldiezStandardRunner(WaldiezBaseRunner):
             )
             return False
         try:
-            WaldiezBaseRunner.process_event(event)
+            EventsMixin.process_event(event, agents)
             self._processed_events += 1
         except SystemExit:  # pragma: no cover
             self.log.debug("Execution stopped by user (sync)")
@@ -159,6 +153,7 @@ class WaldiezStandardRunner(WaldiezBaseRunner):
     async def _a_on_event(
         self,
         event: Union["BaseEvent", "BaseMessage"],
+        agents: list["ConversableAgent"],
     ) -> bool:
         """Process an event from the workflow asynchronously."""
         self._event_count += 1
@@ -168,7 +163,7 @@ class WaldiezStandardRunner(WaldiezBaseRunner):
             )
             return False
         try:
-            await WaldiezBaseRunner.a_process_event(event)
+            await EventsMixin.a_process_event(event, agents)
             self._processed_events += 1
         except SystemExit:  # pragma: no cover
             self.log.debug("Execution stopped by user (async)")
@@ -183,6 +178,7 @@ class WaldiezStandardRunner(WaldiezBaseRunner):
         return not self._stop_requested.is_set()
 
     # pylint: disable=too-complex
+    @override
     async def _a_run(
         self,
         temp_dir: Path,
@@ -199,7 +195,7 @@ class WaldiezStandardRunner(WaldiezBaseRunner):
             # fmt: on
             """Execute the workflow in an async context."""
             # pylint: disable=import-outside-toplevel
-            from autogen.io import IOStream  # pyright: ignore
+            from autogen.io import IOStream
 
             from waldiez.io import StructuredIOStream
 
@@ -208,10 +204,11 @@ class WaldiezStandardRunner(WaldiezBaseRunner):
             try:
                 loaded_module = self._load_module(output_file, temp_dir)
                 if self._stop_requested.is_set():  # pragma: no cover
-                    self.log.debug(
+                    msg = (
                         "Execution stopped before AG2 "
                         "workflow event processing (async)"
                     )
+                    self.log.debug(msg)
                     return []
                 # noinspection DuplicatedCode
                 if self.structured_io:
@@ -220,12 +217,12 @@ class WaldiezStandardRunner(WaldiezBaseRunner):
                     )
                 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())
-                results = await loaded_module.main(  # pyright: ignore
+                results = await loaded_module.main(
                     on_event=self._a_on_event
                 )
                 self.print(MESSAGES["workflow_finished"])

waldiez/running/step_by_step/breakpoints_mixin.py

@@ -1,11 +1,18 @@
 # SPDX-License-Identifier: Apache-2.0.
 # Copyright (c) 2024 - 2025 Waldiez and contributors.
+
 # pylint: disable=unused-argument
+# pyright: reportDeprecated=false, reportMissingTypeStubs=false
+# pyright: reportUnusedParameter=false, reportUnnecessaryIsInstance=false
+# pyright: reportUnknownMemberType=false, reportUnknownVariableType=false
+# pyright: reportUnknownArgumentType=false
+
 """Breakpoints management mixin for step-by-step debugging."""
 
 import logging
+from collections.abc import Iterable
 from functools import lru_cache
-from typing import TYPE_CHECKING, Any, Callable, Iterable, Union
+from typing import TYPE_CHECKING, Any, Callable, Union
 
 from .step_by_step_models import (
     WaldiezBreakpoint,
@@ -13,6 +20,7 @@ from .step_by_step_models import (
     WaldiezDebugBreakpointCleared,
     WaldiezDebugBreakpointRemoved,
     WaldiezDebugBreakpointsList,
+    WaldiezDebugConfig,
     WaldiezDebugError,
     WaldiezDebugMessage,
 )
@@ -57,9 +65,14 @@ def handle_breakpoint_errors(func: Callable[..., bool]) -> Callable[..., bool]:
 class BreakpointsMixin:
     """Mixin class for managing breakpoints in step-by-step debugging."""
 
+    _breakpoints: set[WaldiezBreakpoint]
+    _agent_id_to_name: dict[str, str]
+    _config: WaldiezDebugConfig
+
     def __init__(self, *args: Any, **kwargs: Any) -> None:
         """Initialize breakpoints storage."""
-        self._breakpoints: set[WaldiezBreakpoint] = set()
+        self._breakpoints = set()
+        self._agent_id_to_name = {}
 
         # Statistics for monitoring
         self._breakpoint_stats = {
@@ -72,6 +85,45 @@ class BreakpointsMixin:
         self._check_breakpoint_match_cached = lru_cache(maxsize=1000)(
             self._check_breakpoint_match_impl
         )
+        self._config = kwargs.get("config", WaldiezDebugConfig())
+
+    @staticmethod
+    def get_initial_breakpoints(
+        items: Iterable[Any],
+    ) -> set[WaldiezBreakpoint]:
+        """Get initial breakpoints.
+
+        Parameters
+        ----------
+        items : Iterable[Any]
+            The items to parse for getting the endpoints.
+
+        Returns
+        -------
+        set[WaldiezBreakpoint]
+            The parsed breakpoints.
+        """
+        breakpoints: set[WaldiezBreakpoint] = set()
+        for item in items:
+            if isinstance(item, str):
+                try:
+                    entry = WaldiezBreakpoint.from_string(item)
+                    breakpoints.add(entry)
+                except BaseException:  # pylint: disable=broad-exception-caught
+                    pass
+            elif isinstance(item, WaldiezBreakpoint):
+                breakpoints.add(item)
+        return breakpoints
+
+    def set_agent_id_to_name(self, mapping: dict[str, str]) -> None:
+        """Set the agent id to agent name mapping.
+
+        Parameters
+        ----------
+        mapping : dict[str, str]
+            The agent id to agent name mapping.
+        """
+        self._agent_id_to_name = mapping
 
     # noinspection PyTypeHints
     def emit(self, message: WaldiezDebugMessage) -> None:
@@ -97,6 +149,7 @@ class BreakpointsMixin:
         event_type: str,
         sender: str,
         recipient: str,
+        sender_only: bool,
         breakpoints_sig: frozenset[str],
     ) -> bool:
         """Check if the event matches any breakpoints.
@@ -109,6 +162,8 @@ class BreakpointsMixin:
             The event sender.
         recipient : str
             The event recipient.
+        sender_only : bool
+            Only check for event's sender agent.
         breakpoints_sig : frozenset[str]
             Signature of current breakpoints for cache invalidation.
 
@@ -119,8 +174,8 @@ class BreakpointsMixin:
         """
         event_dict = {
             "type": event_type,
-            "sender": sender,
-            "recipient": recipient,
+            "sender": self._agent_id_to_name.get(sender, sender),
+            "recipient": self._agent_id_to_name.get(recipient, recipient),
         }
 
         # Reconstruct breakpoints from signature for cache safety
@@ -130,10 +185,24 @@ class BreakpointsMixin:
                 WaldiezBreakpoint.from_string(bp_str)
                 for bp_str in breakpoints_sig
             }
-            return any(bp.matches(event_dict) for bp in breakpoints)
+            return any(
+                bp.matches(
+                    event_dict,
+                    self._agent_id_to_name,
+                    sender_only=sender_only,
+                )
+                for bp in breakpoints
+            )
         except Exception:  # pylint: disable=broad-exception-caught
             # Fallback to current breakpoints if signature is malformed
-            return any(bp.matches(event_dict) for bp in self._breakpoints)
+            return any(
+                bp.matches(
+                    event_dict,
+                    self._agent_id_to_name,
+                    sender_only=sender_only,
+                )
+                for bp in self._breakpoints
+            )
 
     @handle_breakpoint_errors
     def add_breakpoint(self, spec: str) -> bool:
@@ -149,7 +218,7 @@ class BreakpointsMixin:
         bool
             True if the breakpoint was added successfully, False otherwise.
         """
-        if not spec or not isinstance(spec, str):  # pyright: ignore
+        if not spec or not isinstance(spec, str):
             self.emit(
                 WaldiezDebugError(
                     error="Invalid event type: must be a non-empty string"
@@ -197,7 +266,7 @@ class BreakpointsMixin:
         if isinstance(spec, WaldiezBreakpoint):
             breakpoint_obj = spec
             spec_str = str(spec)
-        elif isinstance(spec, str) and spec:  # pyright: ignore
+        elif isinstance(spec, str) and spec:
             try:
                 breakpoint_obj = WaldiezBreakpoint.from_string(spec)
                 spec_str = spec
@@ -320,8 +389,83 @@ class BreakpointsMixin:
         except ValueError:
             return False
 
+    @staticmethod
+    def _get_event_core(event_dict: dict[str, Any]) -> tuple[str, str, str]:
+        event_type = event_dict.get("type", "unknown")
+        sender = event_dict.get("sender", "")
+        if not sender:
+            event_content = event_dict.get("content", {})
+            if isinstance(event_content, dict):
+                sender = event_content.get(
+                    "sender",
+                    event_content.get("speaker", ""),
+                )
+        if not isinstance(sender, str):
+            sender = ""
+        recipient = event_dict.get("recipient", "")
+        if not recipient:
+            event_content = event_dict.get("content", {})
+            if isinstance(event_content, dict):
+                recipient = event_content.get("recipient")
+        if not isinstance(recipient, str):
+            recipient = ""
+        return event_type, sender, recipient
+
+    def _got_breakpoint_match(
+        self, event_dump: dict[str, Any], sender_only: bool
+    ) -> bool:
+        event_type, sender, recipient = BreakpointsMixin._get_event_core(
+            event_dump
+        )
+        event_dict = {
+            "type": event_type,
+            "sender": sender,
+            "recipient": recipient,
+        }
+
+        has_agent_breakpoints = any(
+            bp.agent is not None for bp in self._breakpoints
+        )
+        if has_agent_breakpoints:
+            # Don't use cache for agent-based breakpoints
+            # (we might have a mix of agent ids and names)
+            matches_breakpoint = any(
+                bp.matches(
+                    event_dict,
+                    self._agent_id_to_name,
+                    sender_only=sender_only,
+                )
+                for bp in self._breakpoints
+            )
+        else:
+            # Get current breakpoints signature for cache invalidation
+            breakpoints_sig = self._get_breakpoints_signature()
+
+            # Check cached result
+            # noinspection PyBroadException
+            try:
+                matches_breakpoint = self._check_breakpoint_match_cached(
+                    event_type, sender, recipient, sender_only, breakpoints_sig
+                )
+                self._breakpoint_stats["cache_hits"] += 1
+            except Exception:  # pylint: disable=broad-exception-caught
+                # Fallback to non-cached check
+                matches_breakpoint = any(
+                    bp.matches(
+                        event_dict,
+                        self._agent_id_to_name,
+                        sender_only=sender_only,
+                    )
+                    for bp in self._breakpoints
+                )
+                self._breakpoint_stats["cache_misses"] += 1
+
+        return matches_breakpoint
+
     def should_break_on_event(
-        self, event: Union["BaseEvent", "BaseMessage"], step_mode: bool = True
+        self,
+        event: Union["BaseEvent", "BaseMessage"],
+        sender_only: bool,
     ) -> bool:
         """Determine if we should break on this event.
 
@@ -329,8 +473,8 @@ class BreakpointsMixin:
         ----------
         event : Union[BaseEvent, BaseMessage]
             The event to check.
-        step_mode : bool, optional
-            Whether step mode is enabled, by default True.
+        sender_only : bool
+            Only check for event's sender agent.
 
         Returns
         -------
@@ -344,59 +488,30 @@ class BreakpointsMixin:
         if event_type == "input_request":
             return False
 
-        # Quick path: if no breakpoints and not in step mode, don't break
-        if not self._breakpoints and not step_mode:
-            return False
-
-        # Quick path: if step mode and no specific breakpoints,
-        # break on everything
-        if step_mode and not self._breakpoints:
-            return True
+        if not self._breakpoints:
+            return not bool(self._config.auto_continue)
 
         # Check if this event matches any breakpoint using caching
-        if hasattr(event, "model_dump"):
-            # pylint: disable=too-many-try-statements,broad-exception-caught
-            try:
-                event_dict = event.model_dump(
-                    mode="python", exclude_none=True, fallback=str
-                )
-
-                # Extract event details for cache key
-                event_type_key = event_dict.get("type", "unknown")
-                sender = event_dict.get("sender", "")
-                recipient = event_dict.get("recipient", "")
-
-                # Get current breakpoints signature for cache invalidation
-                breakpoints_sig = self._get_breakpoints_signature()
-
-                # Check cached result
-                # noinspection PyBroadException
-                try:
-                    matches_breakpoint = self._check_breakpoint_match_cached(
-                        event_type_key, sender, recipient, breakpoints_sig
-                    )
-                    self._breakpoint_stats["cache_hits"] += 1
-                except Exception:
-                    # Fallback to non-cached check
-                    matches_breakpoint = any(
-                        bp.matches(event_dict) for bp in self._breakpoints
-                    )
-                    self._breakpoint_stats["cache_misses"] += 1
-
+        if not hasattr(event, "model_dump"):
+            return not bool(self._config.auto_continue)
+        # pylint: disable=too-many-try-statements,broad-exception-caught
+        try:
+            event_dump = event.model_dump(
+                mode="python", exclude_none=True, fallback=str
+            )
+            matches_breakpoint = self._got_breakpoint_match(
+                event_dump, sender_only=sender_only
+            )
+            # If any breakpoint matches: break regardless of step_mode
+            if matches_breakpoint:
                 self._breakpoint_stats["total_matches"] += 1
+                return True
 
-                # If any breakpoint matches: break regardless of step_mode
-                if matches_breakpoint:
-                    return True
-
-            except Exception as e:  # pylint: disable=broad-exception-caught
-                logging.warning("Error processing event for breakpoints: %s", e)
-                self._breakpoint_stats["cache_misses"] += 1
+        except Exception as e:  # pylint: disable=broad-exception-caught
+            logging.warning("Error processing event for breakpoints: %s", e)
+            self._breakpoint_stats["cache_misses"] += 1
 
-        # No specific breakpoints matched:
-        # - If step_mode, break on every event (single-step behavior)
-        # - If not step_mode, do not break
-        return bool(step_mode)
+        return not bool(self._config.auto_continue)
 
     def get_breakpoint_stats(self) -> dict[str, Any]:
         """Get breakpoint statistics including performance metrics.
@@ -410,7 +525,7 @@ class BreakpointsMixin:
             {
                 "type": bp.type.value,
                 "event_type": bp.event_type,
-                "agent_name": bp.agent_name,
+                "agent": bp.agent,
                 "description": bp.description,
                 "string_repr": str(bp),
             }
@@ -476,6 +591,23 @@ class BreakpointsMixin:
         """
         return [str(bp) for bp in sorted(self._breakpoints, key=str)]
 
+    def is_auto_run(self) -> bool:
+        """Check if we are in auto-run mode.
+
+        Returns
+        -------
+        bool
+            False if we don't have any breakpoints and
+            we don't have any 'all' breakpoints, True otherwise.
+        """
+        if not self._breakpoints:
+            return False
+        if any(bp.type.value == "all" for bp in self._breakpoints):
+            self._breakpoints.clear()
+            self._invalidate_cache()
+            return False
+        return True
+
     def import_breakpoints(
         self, breakpoint_specs: list[str]
     ) -> tuple[int, list[str]]:

waldiez/running/step_by_step/command_handler.py

@@ -1,6 +1,9 @@
 # SPDX-License-Identifier: Apache-2.0.
 # Copyright (c) 2024 - 2025 Waldiez and contributors.
+
 # pylint: disable=unused-argument
+# pyright: reportImportCycles=false, reportUnusedParameter=false
+
 """Command handler for step-by-step execution."""
 
 from typing import TYPE_CHECKING, Callable