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

waldiez/running/step_by_step/events_processor.py

@@ -1,11 +1,20 @@
 # SPDX-License-Identifier: Apache-2.0.
 # Copyright (c) 2024 - 2025 Waldiez and contributors.
+
 # pylint: disable=unused-argument,no-self-use
+# pyright: reportMissingTypeStubs=false, reportImportCycles=false
+# pyright: reportDeprecated=false, reportUnknownMemberType=false
+# pyright: reportUnknownVariableType=false, reportUnknownArgumentType=false
+
 """Command handler for step-by-step execution."""
 
-from typing import TYPE_CHECKING, Any, Union
+import inspect
+from collections.abc import Mapping, Sequence
+from dataclasses import asdict, is_dataclass
+from typing import TYPE_CHECKING, Any, Optional, Union
 
 if TYPE_CHECKING:
+    from autogen.agentchat import ConversableAgent  # type: ignore
     from autogen.events.base_event import BaseEvent  # type: ignore
     from autogen.messages.base_message import BaseMessage  # type: ignore
 
@@ -21,7 +30,9 @@ class EventProcessor:
         self.runner = runner
 
     def process_event(
-        self, event: Union["BaseEvent", "BaseMessage"]
+        self,
+        event: Union["BaseEvent", "BaseMessage"],
+        agents: list["ConversableAgent"],
     ) -> dict[str, Any]:
         """Shared logic for both sync and async event processing.
 
@@ -29,6 +40,8 @@ class EventProcessor:
         ----------
         event : BaseEvent | BaseMessage
             The event to process.
+        agents : list[ConversableAgent]
+            The workflow's known agents.
 
         Returns
         -------
@@ -45,19 +58,20 @@ class EventProcessor:
         self._update_participant_info(event_info)
         self._manage_event_history(event_info)
         self._check_for_input_request(event_info)
+        self._add_agents_info(event_info, agents)
 
         should_break = self.runner.should_break_on_event(
-            event, self.runner.step_mode
+            event, sender_only=True
         )
 
         return {
-            "action": "continue",
-            "should_break": should_break,
+            "action": "break" if should_break else "continue",
             "event_info": event_info,
         }
 
     def _create_event_info(
-        self, event: Union["BaseEvent", "BaseMessage"]
+        self,
+        event: Union["BaseEvent", "BaseMessage"],
     ) -> dict[str, Any]:
         """Create event info dictionary from event object.
 
@@ -92,7 +106,7 @@ class EventProcessor:
         if not event_info["sender"] or not event_info["recipient"]:
             self._extract_participants_from_content(event_info)
 
-        self._handle_group_chat_speaker(event_info)
+        self._check_for_event_speaker(event_info)
         self._extract_participants_from_direct_content(event_info)
 
         # Update last known participants
@@ -115,14 +129,14 @@ class EventProcessor:
             and "chat_info" in content
             and isinstance(content["chat_info"], dict)
         ):
-            content = content.get("chat_info", {})  # pyright: ignore
+            content = content.get("chat_info", {})
 
         if not event_info["sender"] and "sender" in content:
             event_info["sender"] = content["sender"]
         if not event_info["recipient"] and "recipient" in content:
             event_info["recipient"] = content["recipient"]
 
-    def _handle_group_chat_speaker(self, event_info: dict[str, Any]) -> None:
+    def _check_for_event_speaker(self, event_info: dict[str, Any]) -> None:
         """Handle speaker information for group chat events.
 
         Parameters
@@ -130,11 +144,7 @@ class EventProcessor:
         event_info : dict[str, Any]
             Event information dictionary to update.
         """
-        if (
-            event_info.get("type") == "group_chat_run_chat"
-            and "content" in event_info
-            and isinstance(event_info["content"], dict)
-        ):
+        if "content" in event_info and isinstance(event_info["content"], dict):
             content = event_info.get("content", {})
             speaker = content.get("speaker")
             if isinstance(speaker, str) and speaker:
@@ -197,3 +207,173 @@ class EventProcessor:
             event_info["recipient"] = sender
             self.runner.last_sender = recipient
             self.runner.last_recipient = sender
+
+    @staticmethod
+    def _get_agent_dump(
+        agent: Optional["ConversableAgent"],
+    ) -> dict[str, Any] | None:
+        if not agent:
+            return None
+        dump = {
+            name: _trimmed(value)
+            for name, value in vars(agent).items()
+            if not name.startswith("_")
+            and not inspect.ismethod(value)
+            and not inspect.isfunction(value)
+            and name.upper() != name
+            and name != "chat_messages"
+        }
+        for attr_key in ["name", "description", "system_message"]:
+            attr_val = getattr(agent, attr_key)
+            if attr_val:
+                dump[attr_key] = _trimmed(attr_val)
+        try:
+            dump["chat_messages"] = {
+                _to_json_key(agent): [_trimmed(message) for message in messages]
+                for _agent, messages in agent.chat_messages.items()
+            }
+        except BaseException:  # pylint: disable=broad-exception-caught
+            pass
+        dump["cost"] = {
+            "actual": agent.get_actual_usage(),
+            "total": agent.get_total_usage(),
+        }
+        return dump
+
+    def _add_agents_info(
+        self, event_info: dict[str, Any], agents: list["ConversableAgent"]
+    ) -> None:
+        """Add agents info."""
+        sender = event_info.get("sender", self.runner.last_sender)
+        recipient = event_info.get("recipient", self.runner.last_recipient)
+
+        agent_map = {agent.name: agent for agent in agents}
+
+        sender_agent = agent_map.get(sender)
+        recipient_agent = agent_map.get(recipient)
+
+        ordered_agents: list["ConversableAgent"] = []
+        seen: set[str] = set()
+
+        for a in (sender_agent, recipient_agent):
+            if a and a.name not in seen:
+                ordered_agents.append(a)
+                seen.add(a.name)
+
+        for a in agents:
+            if a.name not in seen:
+                ordered_agents.append(a)
+                seen.add(a.name)
+
+        event_info["agents"] = {
+            "sender": self._get_agent_dump(sender_agent),
+            "recipient": self._get_agent_dump(recipient_agent),
+            "all": [self._get_agent_dump(a) for a in ordered_agents if a],
+        }
+
+
+# pylint: disable=too-complex,too-many-return-statements,
+# pylint: disable=broad-exception-caught,too-complex,too-many-branches
+def _trimmed(  # noqa: C901
+    value: Any, max_len: int = 200, _depth: int = 0, _max_depth: int = 10
+) -> Any:
+    """Recursively trim values for serialization."""
+    if _depth >= _max_depth:
+        # Hard stop
+        s = str(value)
+        return (s[:max_len] + "...") if len(s) > max_len else s
+
+    if isinstance(value, str):
+        return value[:max_len] + "..." if len(value) > max_len else value
+
+    if value is None or isinstance(value, (int, float, bool)):
+        return value
+
+    if isinstance(value, (bytes, bytearray)):
+        try:
+            s = value.decode("utf-8", errors="replace")
+            return s[:max_len] + "..." if len(s) > max_len else s
+        except Exception:
+            return f"<{type(value).__name__}> {len(value)} bytes"
+
+    if callable(value):
+        # pylint: disable=too-many-try-statements
+        try:
+            name = getattr(value, "__name__", repr(value))
+            module = getattr(value, "__module__", "")
+            if module:
+                s = f"<callable> {module}.{name}"
+            else:
+                s = f"<callable> {name}"
+            return s[:max_len] + "..." if len(s) > max_len else s
+        except Exception:
+            return "<callable>"
+
+    if _is_dataclass_instance(value):
+        try:
+            value = asdict(value)
+        except Exception:
+            s = str(value)
+            return (s[:max_len] + "...") if len(s) > max_len else s
+
+    if isinstance(value, Mapping):
+        out: dict[str, Any] = {}
+        for k, v in value.items():
+            jk = _to_json_key(k, max_len)
+            out[jk] = _trimmed(v, max_len, _depth + 1, _max_depth)
+        return out
+    if isinstance(value, (set, frozenset)):
+        items = [_trimmed(it, max_len, _depth + 1, _max_depth) for it in value]
+        try:
+            items.sort(key=repr)
+        except Exception:
+            pass
+        return items
+
+    if isinstance(value, Sequence) and not isinstance(
+        value, (str, bytes, bytearray)
+    ):
+        return [_trimmed(it, max_len, _depth + 1, _max_depth) for it in value]
+    if hasattr(value, "__dict__"):
+        try:
+            return _trimmed(
+                {
+                    k: v
+                    for k, v in vars(value).items()
+                    if not str(k).startswith("_") and str(k) != "key"
+                },
+                max_len,
+                _depth + 1,
+                _max_depth,
+            )
+        except Exception:
+            pass
+
+    # Fallback: stringify and trim
+    try:
+        s = str(value)
+        return s[:max_len] + "..." if len(s) > max_len else s
+    except Exception:
+        return None
+
+
+def _is_dataclass_instance(obj: Any) -> bool:
+    """Check if an object is an instance of a dataclass."""
+    return is_dataclass(obj) and not isinstance(obj, type)
+
+
+def _to_json_key(key: Any, max_len: int = 200) -> str:
+    """Convert dict key to a JSON-legal key."""
+    if key is None or isinstance(key, (bool, int, float)):
+        return str(key)
+
+    if isinstance(key, str):
+        return key[:max_len] + "..." if len(key) > max_len else key
+
+    for _key in ["name", "_name", "__name__"]:
+        if hasattr(key, _key):
+            return str(getattr(key, _key))
+
+    # Non-primitive key: include type to avoid collisions like 1 vs "1"
+    s = f"<{type(key).__name__}> {repr(key)}"
+    return s[:max_len] + "..." if len(s) > max_len else s

waldiez/running/step_by_step/step_by_step_models.py

@@ -1,6 +1,9 @@
 # SPDX-License-Identifier: Apache-2.0.
 # Copyright (c) 2024 - 2025 Waldiez and contributors.
+
 # pylint: disable=unused-argument,disable=line-too-long
+# pyright: reportUnusedParameter=false, reportUnnecessaryIsInstance=false
+# pyright: reportDeprecated=false
 # flake8: noqa: E501
 """Step-by-step execution models for Waldiez."""
 
@@ -9,6 +12,7 @@ from enum import Enum
 from typing import Annotated, Any, Literal, Union
 
 from pydantic import BaseModel, Field, ValidationInfo, field_validator
+from typing_extensions import override
 
 
 class WaldiezBreakpointType(Enum):
@@ -58,7 +62,7 @@ class WaldiezBreakpoint(BaseModel):
 
     type: WaldiezBreakpointType
     event_type: str | None = None  # Required for EVENT and AGENT_EVENT
-    agent_name: str | None = None  # Required for AGENT and AGENT_EVENT
+    agent: str | None = None  # Required for AGENT and AGENT_EVENT
     description: str | None = None  # Human-readable description
 
     # noinspection PyNestedDecorators,PyUnusedLocal
@@ -93,48 +97,50 @@ class WaldiezBreakpoint(BaseModel):
 
         # Basic validation - event types should be alphanumeric with underscores
         if not re.match(r"^[a-zA-Z][a-zA-Z0-9_]*$", v):
-            raise ValueError(
+            msg = (
                 "Invalid breakpoint format. Event type must start with a letter and contain only "
                 "letters, numbers, and underscores"
             )
+            raise ValueError(msg)
         return v
 
     # noinspection PyNestedDecorators,PyUnusedLocal
-    @field_validator("agent_name")
+    @field_validator("agent")
     @classmethod
-    def validate_agent_name(
+    def validate_agent(
         cls,
         v: str | None,
         info: ValidationInfo,
     ) -> str | None:
-        """Validate agent name format.
+        """Validate agent name/id format.
 
         Parameters
         ----------
         v : str | None
-            The agent name to validate.
+            The agent name or id to validate.
         info : ValidationInfo
             Validation context information.
 
         Returns
         -------
         str | None
-            The validated agent name or None if not provided.
+            The validated agent or None if not provided.
 
         Raises
         ------
         ValueError
-            If the agent name format is invalid.
+            If the agent format is invalid.
         """
         if v is None:
             return v
 
-        # Agent names should not be empty or just whitespace
+        # Agent name/id should not be empty or just whitespace
         if not v.strip():
-            raise ValueError("Agent name cannot be empty or just whitespace")
+            raise ValueError("Agent cannot be empty or just whitespace")
 
         return v.strip()
 
+    @override
     def model_post_init(self, __context: Any, /) -> None:
         """Validate breakpoint consistency after initialization.
 
@@ -146,28 +152,31 @@ class WaldiezBreakpoint(BaseModel):
         if self.type == WaldiezBreakpointType.EVENT and not self.event_type:
             raise ValueError("EVENT breakpoints require an event_type")
 
-        if self.type == WaldiezBreakpointType.AGENT and not self.agent_name:
+        if self.type == WaldiezBreakpointType.AGENT and not self.agent:
             raise ValueError("AGENT breakpoints require an agent_name")
 
         if self.type == WaldiezBreakpointType.AGENT_EVENT:
-            if not self.event_type or not self.agent_name:
-                raise ValueError(
+            if not self.event_type or not self.agent:
+                msg = (
                     "AGENT_EVENT breakpoints require both"
                     " event_type and agent_name"
                 )
+                raise ValueError(msg)
 
+    @override
     def __hash__(self) -> int:
         """Get the hash value for the breakpoint."""
-        return hash((self.type, self.event_type, self.agent_name))
+        return hash((self.type, self.event_type, self.agent))
 
+    @override
     def __str__(self) -> str:
         """Get the string representation for display."""
         if self.type == WaldiezBreakpointType.EVENT:
             return f"event:{self.event_type}"
         if self.type == WaldiezBreakpointType.AGENT:
-            return f"agent:{self.agent_name}"
+            return f"agent:{self.agent}"
         if self.type == WaldiezBreakpointType.AGENT_EVENT:
-            return f"{self.agent_name}:{self.event_type}"
+            return f"{self.agent}:{self.event_type}"
         # else:  # ALL
         return "all"
 
@@ -194,7 +203,7 @@ class WaldiezBreakpoint(BaseModel):
         ValueError
             If the breakpoint string format is invalid.
         """
-        if not breakpoint_str or not isinstance(  # pyright: ignore
+        if not breakpoint_str or not isinstance(
             breakpoint_str,
             str,
         ):
@@ -213,50 +222,109 @@ class WaldiezBreakpoint(BaseModel):
             event_type = breakpoint_str[6:]  # Remove "event:" prefix
             if not event_type:
                 raise ValueError("Event type cannot be empty after 'event:'")
-            return cls(type=WaldiezBreakpointType.EVENT, event_type=event_type)
+            return cls(
+                type=WaldiezBreakpointType.EVENT,
+                event_type=event_type,
+            )
 
         if breakpoint_str.startswith("agent:"):
-            agent_name = breakpoint_str[6:]  # Remove "agent:" prefix
-            if not agent_name:
-                raise ValueError("Agent name cannot be empty after 'agent:'")
-            return cls(type=WaldiezBreakpointType.AGENT, agent_name=agent_name)
+            agent = breakpoint_str[6:]  # Remove "agent:" prefix
+            if not agent:
+                raise ValueError(
+                    "Agent identifier cannot be empty after 'agent:'"
+                )
+            return cls(
+                type=WaldiezBreakpointType.AGENT,
+                agent=agent,
+            )
 
         if ":" in breakpoint_str and not breakpoint_str.startswith(
             ("event:", "agent:")
         ):
-            # Format: "agent_name:event_type"
+            # Format: "agent:event_type"
             parts = breakpoint_str.split(":", 1)
             if len(parts) != 2:
                 raise ValueError("Invalid agent:event format")
 
-            agent_name, event_type = parts
-            if not agent_name or not event_type:
+            agent, event_type = parts
+            if not agent or not event_type:
                 raise ValueError(
-                    "Both agent name and event type must be specified"
+                    "Both agent identifier and event type must be specified"
                 )
 
             return cls(
                 type=WaldiezBreakpointType.AGENT_EVENT,
-                agent_name=agent_name,
+                agent=agent,
                 event_type=event_type,
             )
-
-        # Default to event type - but validate it's reasonable
         if ":" in breakpoint_str:
-            raise ValueError(
+            msg = (
                 "Invalid breakpoint format. Use 'event:type', 'agent:name', "
                 "'agent:event', or 'all'"
             )
+            raise ValueError(msg)
+
+        return cls(
+            type=WaldiezBreakpointType.EVENT,
+            event_type=breakpoint_str,
+        )
 
-        return cls(type=WaldiezBreakpointType.EVENT, event_type=breakpoint_str)
+    def matches_agent(
+        self,
+        event: dict[str, Any],
+        agent_id_to_name: dict[str, str],
+        sender_only: bool,
+    ) -> bool:
+        """Check if the event's sender or recipient matches the breakpoint's agent.
 
-    def matches(self, event: dict[str, Any]) -> bool:
+        Parameters
+        ----------
+        event : dict[str, Any]
+            The event to check against.
+        agent_id_to_name : dict[str, str]
+            The mapping between an agent's id and its name.
+        sender_only : dict[str, Any]
+            Only check for sender match.
+
+        Returns
+        -------
+        bool
+            True if the event's sender or recipient matches the breakpoint's agent.
+        """
+        if not self.agent:
+            return False
+        # Normalize both the event's sender/recipient and the breakpoint's agent
+        _event_sender = event.get("sender", "")
+        event_sender = agent_id_to_name.get(_event_sender, _event_sender)
+        _event_recipient = event.get("recipient", "")
+        event_recipient = agent_id_to_name.get(
+            _event_recipient, _event_recipient
+        )
+        breakpoint_agent = (
+            agent_id_to_name.get(self.agent, self.agent) if self.agent else ""
+        )
+        if not breakpoint_agent:
+            return False
+        if sender_only:
+            return breakpoint_agent == event_sender
+        return breakpoint_agent in (event_sender, event_recipient)
+
+    def matches(
+        self,
+        event: dict[str, Any],
+        agent_id_to_name: dict[str, str],
+        sender_only: bool,
+    ) -> bool:
         """Check if this breakpoint matches the given event.
 
         Parameters
         ----------
         event : dict[str, Any]
             The event to check against.
+        agent_id_to_name : dict[str, str]
+            The mapping between an agent's id and its name.
+        sender_only : dict[str, Any]
+            On agent events, only check for sender match.
 
         Returns
         -------
@@ -270,22 +338,22 @@ class WaldiezBreakpoint(BaseModel):
             return event.get("type") == self.event_type
 
         if self.type == WaldiezBreakpointType.AGENT:
-            return (
-                event.get("sender") == self.agent_name
-                or event.get("recipient") == self.agent_name
+            return self.matches_agent(
+                event, agent_id_to_name, sender_only=sender_only
             )
 
         if self.type == WaldiezBreakpointType.AGENT_EVENT:
-            return event.get("type") == self.event_type and (
-                event.get("sender") == self.agent_name
-                or event.get("recipient") == self.agent_name
+            event_type = event.get("type", "")
+            if event_type != self.event_type:
+                return False
+            return self.matches_agent(
+                event, agent_id_to_name, sender_only=sender_only
             )
 
         # noinspection PyUnreachableCode
         return False
 
 
-# Enhanced configuration class for runtime settings
 class WaldiezDebugConfig(BaseModel):
     """Configuration for debug session settings."""
 
@@ -296,7 +364,6 @@ class WaldiezDebugConfig(BaseModel):
     command_timeout_seconds: float = Field(default=300.0, gt=0)
 
 
-# Rest of the existing message classes remain the same...
 class WaldiezDebugBreakpointsList(BaseModel):
     """Debug breakpoints message."""
 
@@ -314,7 +381,6 @@ class WaldiezDebugBreakpointsList(BaseModel):
                 try:
                     result.append(WaldiezBreakpoint.from_string(bp))
                 except ValueError:
-                    # Skip invalid breakpoints rather than failing
                     continue
             else:
                 result.append(bp)
@@ -325,7 +391,7 @@ class WaldiezDebugBreakpointAdded(BaseModel):
     """Debug breakpoint added message."""
 
     type: Literal["debug_breakpoint_added"] = "debug_breakpoint_added"
-    breakpoint: Union[str, WaldiezBreakpoint]
+    breakpoint: str | WaldiezBreakpoint
 
     @property
     def breakpoint_object(self) -> WaldiezBreakpoint:
@@ -339,7 +405,7 @@ class WaldiezDebugBreakpointRemoved(BaseModel):
     """Debug breakpoint removed message."""
 
     type: Literal["debug_breakpoint_removed"] = "debug_breakpoint_removed"
-    breakpoint: Union[str, WaldiezBreakpoint]
+    breakpoint: str | WaldiezBreakpoint
 
     @property
     def breakpoint_object(self) -> WaldiezBreakpoint:
@@ -423,6 +489,7 @@ class WaldiezDebugBreakpointCleared(BaseModel):
     message: str
 
 
+# pylint: disable=invalid-name
 WaldiezDebugMessage = Annotated[
     Union[
         WaldiezDebugPrint,