autobyteus 1.2.1__py3-none-any.whl → 1.3.0__py3-none-any.whl

autobyteus/agent/streaming/parser/streaming_parser.py

@@ -0,0 +1,212 @@
+"""
+StreamingParser: Main driver class for the streaming response parser.
+
+This is the primary entry point for parsing LLM responses in real-time.
+It manages the state machine and provides a clean API for feeding chunks
+and collecting parsed segment events.
+"""
+from typing import List, Optional, Iterator
+import logging
+
+from .parser_context import ParserContext, ParserConfig
+from .states.text_state import TextState
+from .events import SegmentEvent, SegmentType, SegmentEventType
+
+logger = logging.getLogger(__name__)
+
+
+class StreamingParser:
+    """
+    Main driver for streaming LLM response parsing.
+    
+    This class provides a simple API for:
+    1. Feeding chunks of text from an LLM stream
+    2. Collecting structured SegmentEvents
+    3. Finalizing the stream when complete
+    
+    Example usage:
+        parser = StreamingParser()
+        
+        # As chunks arrive from LLM
+        for chunk in llm_stream:
+            events = parser.feed(chunk)
+            for event in events:
+                # Send to WebSocket, update UI, etc.
+                handle_event(event)
+        
+        # When stream ends
+        final_events = parser.finalize()
+    """
+    
+    def __init__(self, config: Optional[ParserConfig] = None):
+        """
+        Initialize the streaming parser.
+        
+        Args:
+            config: Optional parser configuration. Defaults to parsing
+                   XML tool calls.
+        """
+        self._context = ParserContext(config)
+        self._context.current_state = TextState(self._context)
+        self._is_finalized = False
+        logger.debug("StreamingParser initialized")
+
+    @property
+    def config(self) -> ParserConfig:
+        """Get the parser configuration."""
+        return self._context.config
+
+    def feed(self, chunk: str) -> List[SegmentEvent]:
+        """
+        Feed a chunk of text from the LLM stream.
+        
+        This method:
+        1. Appends the chunk to the internal buffer
+        2. Runs the state machine until the buffer is exhausted
+        3. Returns any events that were emitted
+        
+        Args:
+            chunk: A string chunk from the LLM response stream.
+            
+        Returns:
+            List of SegmentEvents emitted while processing this chunk.
+            
+        Raises:
+            RuntimeError: If called after finalize().
+        """
+        if self._is_finalized:
+            raise RuntimeError("Cannot feed chunks after finalize() has been called")
+        
+        if not chunk:
+            return []
+        
+        self._context.append(chunk)
+        
+        # Run the state machine until buffer is exhausted
+        while self._context.has_more_chars():
+            self._context.current_state.run()
+
+        # Drop consumed buffer data to avoid unbounded growth
+        self._context.compact()
+
+        # Return all events emitted during processing
+        return self._context.get_and_clear_events()
+
+    def finalize(self) -> List[SegmentEvent]:
+        """
+        Signal that the LLM stream has ended.
+        
+        This method:
+        1. Calls finalize() on the current state to flush any buffers
+        2. Returns any final events
+        3. Marks the parser as finalized
+        
+        Returns:
+            List of any remaining SegmentEvents.
+            
+        Raises:
+            RuntimeError: If called more than once.
+        """
+        if self._is_finalized:
+            raise RuntimeError("finalize() has already been called")
+        
+        self._is_finalized = True
+        
+        # Finalize the current state
+        self._context.current_state.finalize()
+
+        # Close any open text segment to complete the lifecycle.
+        if self._context.get_current_segment_type() == SegmentType.TEXT:
+            self._context.emit_segment_end()
+
+        # Clear any remaining buffer data
+        self._context.compact()
+
+        # Return any remaining events
+        return self._context.get_and_clear_events()
+
+    def feed_and_finalize(self, text: str) -> List[SegmentEvent]:
+        """
+        Convenience method to parse a complete response in one call.
+        
+        Args:
+            text: The complete LLM response text.
+            
+        Returns:
+            All SegmentEvents from parsing the complete response.
+        """
+        events = self.feed(text)
+        events.extend(self.finalize())
+        return events
+
+    @property
+    def is_finalized(self) -> bool:
+        """Check if the parser has been finalized."""
+        return self._is_finalized
+
+    def get_current_segment_id(self) -> Optional[str]:
+        """Get the ID of the currently active segment, if any."""
+        return self._context.get_current_segment_id()
+
+    def get_current_segment_type(self) -> Optional[SegmentType]:
+        """Get the type of the currently active segment, if any."""
+        return self._context.get_current_segment_type()
+
+
+def parse_complete_response(
+    text: str, 
+    config: Optional[ParserConfig] = None
+) -> List[SegmentEvent]:
+    """
+    Convenience function to parse a complete LLM response.
+    
+    Args:
+        text: The complete LLM response text.
+        config: Optional parser configuration.
+        
+    Returns:
+        List of all SegmentEvents from parsing.
+    """
+    parser = StreamingParser(config)
+    return parser.feed_and_finalize(text)
+
+
+def extract_segments(events: List[SegmentEvent]) -> List[dict]:
+    """
+    Extract segment summaries from a list of events.
+    
+    This is a utility function that converts the event stream into
+    a list of segment dictionaries with accumulated content.
+    
+    Args:
+        events: List of SegmentEvents.
+        
+    Returns:
+        List of segment dictionaries with 'id', 'type', 'content', 'metadata'.
+    """
+    segments = []
+    current_segment = None
+    
+    for event in events:
+        if event.event_type == SegmentEventType.START:
+            current_segment = {
+                "id": event.segment_id,
+                "type": event.segment_type.value if event.segment_type else "unknown",
+                "content": "",
+                "metadata": event.payload.get("metadata", {})
+            }
+        elif event.event_type == SegmentEventType.CONTENT:
+            if current_segment:
+                delta = event.payload.get("delta", "")
+                if isinstance(delta, str):
+                    current_segment["content"] += delta
+        elif event.event_type == SegmentEventType.END:
+            if current_segment:
+                segments.append(current_segment)
+                current_segment = None
+    
+    # Handle unclosed segment
+    if current_segment:
+        segments.append(current_segment)
+    
+    return segments

autobyteus/agent/streaming/parser/tool_call_parsing.py

@@ -0,0 +1,4 @@
+"""Compatibility shim for tool call parsing utilities."""
+from ..adapters.tool_call_parsing import *
+
+__all__ = ["parse_json_tool_call", "parse_xml_arguments"]

autobyteus/agent/streaming/parser/tool_constants.py

@@ -0,0 +1,7 @@
+"""
+Tool constants for the streaming parser.
+"""
+
+TOOL_NAME_WRITE_FILE = "write_file"
+TOOL_NAME_PATCH_FILE = "patch_file"
+TOOL_NAME_RUN_BASH = "run_bash"

autobyteus/agent/streaming/parser/tool_syntax_registry.py

@@ -0,0 +1,4 @@
+"""Compatibility shim for tool syntax registry."""
+from ..adapters.tool_syntax_registry import *
+
+__all__ = ["ToolSyntaxSpec", "get_tool_syntax_spec", "tool_syntax_registry_items"]

autobyteus/agent/streaming/parser/xml_tool_parsing_state_registry.py

@@ -0,0 +1,55 @@
+"""
+XmlToolParsingStateRegistry: Central registry for mapping tool names to their parsing states.
+
+This singleton allows:
+1.  Core defaults (write_file, patch_file, run_bash) to be registered.
+2.  External consumers (users, plugins) to register custom states for new tools (e.g., patch_prompt).
+3.  The main XmlTagInitializationState to perform dynamic lookups instead of hardcoded if/else.
+"""
+from typing import Dict, Optional, Type, TYPE_CHECKING
+from autobyteus.utils.singleton import SingletonMeta
+
+if TYPE_CHECKING:
+    from .states.base_state import BaseState
+
+class XmlToolParsingStateRegistry(metaclass=SingletonMeta):
+    """
+    Registry for dispatching <tool name="..."> tags to specific Parser State classes.
+    """
+
+    def __init__(self):
+        # Maps tool_name -> State Class
+        self._tool_states: Dict[str, Type["BaseState"]] = {}
+        
+        # Register Core Defaults
+        # We perform local imports to avoid top-level circular dependencies
+        from .states.xml_write_file_tool_parsing_state import XmlWriteFileToolParsingState
+        from .states.xml_patch_file_tool_parsing_state import XmlPatchFileToolParsingState
+        from .states.xml_run_bash_tool_parsing_state import XmlRunBashToolParsingState
+        from .tool_constants import TOOL_NAME_WRITE_FILE, TOOL_NAME_PATCH_FILE, TOOL_NAME_RUN_BASH
+        
+        self.register_tool_state(TOOL_NAME_WRITE_FILE, XmlWriteFileToolParsingState)
+        self.register_tool_state(TOOL_NAME_PATCH_FILE, XmlPatchFileToolParsingState)
+        self.register_tool_state(TOOL_NAME_RUN_BASH, XmlRunBashToolParsingState)
+
+    def register_tool_state(self, tool_name: str, state_class: Type["BaseState"]) -> None:
+        """
+        Register a custom parsing state for a specific tool.
+
+        Args:
+            tool_name: The name of the tool (e.g., 'write_file', 'patch_prompt').
+            state_class: The class handling the parsing (must inherit from BaseState).
+        """
+        self._tool_states[tool_name] = state_class
+
+    def get_state_for_tool(self, tool_name: str) -> Optional[Type["BaseState"]]:
+        """
+        Retrieve the parsing state class for a given tool.
+
+        Args:
+            tool_name: The tool name found in the XML tag.
+
+        Returns:
+            The registered state class, or None if not found.
+        """
+        return self._tool_states.get(tool_name)

autobyteus/agent/streaming/parsing_streaming_response_handler.py

@@ -0,0 +1,4 @@
+"""Compatibility shim for ParsingStreamingResponseHandler."""
+from .handlers.parsing_streaming_response_handler import ParsingStreamingResponseHandler
+
+__all__ = ["ParsingStreamingResponseHandler"]

autobyteus/agent/streaming/pass_through_streaming_response_handler.py

@@ -0,0 +1,4 @@
+"""Compatibility shim for PassThroughStreamingResponseHandler."""
+from .handlers.pass_through_streaming_response_handler import PassThroughStreamingResponseHandler
+
+__all__ = ["PassThroughStreamingResponseHandler"]

autobyteus/agent/streaming/queue_streamer.py

@@ -1,58 +1,4 @@
-# file: autobyteus/autobyteus/agent/streaming/queue_streamer.py
-import asyncio
-import logging
-from typing import TypeVar, AsyncIterator, Union, Any
-import queue as standard_queue
+"""Compatibility shim for stream_queue_items."""
+from .utils.queue_streamer import stream_queue_items
 
-logger = logging.getLogger(__name__)
-
-T = TypeVar('T')
-
-async def stream_queue_items(
-    queue: standard_queue.Queue[Union[T, object]], 
-    sentinel: object, 
-    source_name: str = "unspecified_queue" 
-) -> AsyncIterator[T]:
-    """
-    Asynchronously iterates over a standard `queue.Queue`, yielding items of type T
-    until a specific sentinel object is encountered. This is designed to be used
-    from an async context to consume from a queue populated by a synchronous/threaded context.
-
-    Args:
-        queue: The standard `queue.Queue` to stream items from.
-        sentinel: The unique object used to signal the end of data in the queue.
-        source_name: An optional identifier for the queue source, used in logging.
-
-    Yields:
-        Items of type T from the queue.
-
-    Raises:
-        TypeError: If queue is not a `queue.Queue`.
-        ValueError: If sentinel is None.
-        asyncio.CancelledError: If the generator is cancelled.
-        Exception: Propagates exceptions encountered during queue.get().
-    """
-    if not isinstance(queue, standard_queue.Queue):
-        raise TypeError(f"queue must be an instance of queue.Queue for source '{source_name}'.")
-    if sentinel is None: 
-        raise ValueError(f"sentinel object cannot be None for source '{source_name}'.")
-
-    logger.debug(f"Starting to stream items from queue '{source_name}'.")
-    loop = asyncio.get_running_loop()
-    try:
-        while True:
-            # Use run_in_executor to wait for the blocking get() call without blocking the event loop.
-            item: Any = await loop.run_in_executor(None, queue.get) 
-            if item is sentinel:
-                logger.debug(f"Sentinel {sentinel!r} received from queue '{source_name}'. Ending stream.")
-                break
-            
-            yield item # type: ignore 
-    except asyncio.CancelledError:
-        logger.info(f"Stream from queue '{source_name}' was cancelled.")
-        raise 
-    except Exception as e:
-        logger.error(f"Error streaming from queue '{source_name}': {e}", exc_info=True)
-        raise 
-    finally:
-        logger.debug(f"Exiting stream_queue_items for queue '{source_name}'.")
+__all__ = ["stream_queue_items"]

autobyteus/agent/streaming/segments/__init__.py

@@ -0,0 +1,5 @@
+"""Segment event definitions for streaming."""
+
+from .segment_events import SegmentEvent, SegmentType, SegmentEventType
+
+__all__ = ["SegmentEvent", "SegmentType", "SegmentEventType"]

autobyteus/agent/streaming/segments/segment_events.py

@@ -0,0 +1,82 @@
+"""
+Segment Event definitions for the Streaming Parser.
+
+These dataclasses define the structured events that the parser emits
+as it incrementally parses LLM response chunks.
+"""
+from dataclasses import dataclass, field
+from typing import Dict, Any, Optional
+from enum import Enum
+
+
+class SegmentType(str, Enum):
+    """Types of content segments that can be parsed from LLM responses."""
+    TEXT = "text"
+    TOOL_CALL = "tool_call"
+    WRITE_FILE = "write_file"
+    PATCH_FILE = "patch_file"
+    RUN_BASH = "run_bash"
+    REASONING = "reasoning"
+    MEDIA = "media"
+
+
+class SegmentEventType(str, Enum):
+    """Types of segment lifecycle events."""
+    START = "SEGMENT_START"
+    CONTENT = "SEGMENT_CONTENT"
+    END = "SEGMENT_END"
+
+
+@dataclass
+class SegmentEvent:
+    """
+    A structured event emitted by the streaming parser.
+    
+    Attributes:
+        event_type: The lifecycle stage of this event (START, CONTENT, END).
+        segment_id: Unique identifier for the segment this event belongs to.
+        segment_type: The type of content segment (only present in START events).
+        payload: Additional data for the event (e.g., delta content, metadata).
+    """
+    event_type: SegmentEventType
+    segment_id: str
+    segment_type: Optional[SegmentType] = None
+    payload: Dict[str, Any] = field(default_factory=dict)
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Serialize the event to a dictionary for JSON transmission."""
+        result = {
+            "type": self.event_type.value,
+            "segment_id": self.segment_id,
+            "payload": self.payload
+        }
+        if self.segment_type is not None:
+            result["segment_type"] = self.segment_type.value
+        return result
+
+    @classmethod
+    def start(cls, segment_id: str, segment_type: SegmentType, **metadata) -> "SegmentEvent":
+        """Factory method to create a SEGMENT_START event."""
+        return cls(
+            event_type=SegmentEventType.START,
+            segment_id=segment_id,
+            segment_type=segment_type,
+            payload={"metadata": metadata} if metadata else {}
+        )
+
+    @classmethod
+    def content(cls, segment_id: str, delta: Any) -> "SegmentEvent":
+        """Factory method to create a SEGMENT_CONTENT event."""
+        return cls(
+            event_type=SegmentEventType.CONTENT,
+            segment_id=segment_id,
+            payload={"delta": delta}
+        )
+
+    @classmethod
+    def end(cls, segment_id: str) -> "SegmentEvent":
+        """Factory method to create a SEGMENT_END event."""
+        return cls(
+            event_type=SegmentEventType.END,
+            segment_id=segment_id
+        )

autobyteus/agent/streaming/stream_event_payloads.py

@@ -1,223 +1,2 @@
-# file: autobyteus/autobyteus/agent/streaming/stream_event_payloads.py
-import logging
-from typing import Dict, Any, Optional, List, Union 
-from pydantic import BaseModel, Field
-
-from autobyteus.llm.utils.token_usage import TokenUsage 
-from autobyteus.agent.phases import AgentOperationalPhase
-
-
-logger = logging.getLogger(__name__)
-
-# --- Base Payload Model (Optional, for common fields if any) ---
-class BaseStreamPayload(BaseModel):
-    pass
-
-# --- Specific Payload Models for each StreamEventType ---
-
-class AssistantChunkData(BaseStreamPayload):
-    content: str
-    reasoning: Optional[str] = None
-    is_complete: bool
-    usage: Optional[TokenUsage] = None 
-    image_urls: Optional[List[str]] = None
-    audio_urls: Optional[List[str]] = None
-    video_urls: Optional[List[str]] = None
-
-
-class AssistantCompleteResponseData(BaseStreamPayload):
-    content: str
-    reasoning: Optional[str] = None
-    usage: Optional[TokenUsage] = None 
-    image_urls: Optional[List[str]] = None
-    audio_urls: Optional[List[str]] = None
-    video_urls: Optional[List[str]] = None
-
-class ToolInteractionLogEntryData(BaseStreamPayload):
-    log_entry: str
-    tool_invocation_id: str
-    tool_name: str
-
-class AgentOperationalPhaseTransitionData(BaseStreamPayload): 
-    new_phase: AgentOperationalPhase 
-    old_phase: Optional[AgentOperationalPhase] = None
-    trigger: Optional[str] = None
-    tool_name: Optional[str] = None
-    error_message: Optional[str] = None
-    error_details: Optional[str] = None
-
-class ErrorEventData(BaseStreamPayload):
-    source: str
-    message: str
-    details: Optional[str] = None
-
-class ToolInvocationApprovalRequestedData(BaseStreamPayload):
-    invocation_id: str
-    tool_name: str
-    arguments: Dict[str, Any]
-
-class ToolInvocationAutoExecutingData(BaseStreamPayload):
-    invocation_id: str
-    tool_name: str
-    arguments: Dict[str, Any]
-
-# NEW PAYLOAD
-class SystemTaskNotificationData(BaseStreamPayload):
-    sender_id: str
-    content: str
-
-class ToDoItemData(BaseStreamPayload):
-    description: str
-    todo_id: str
-    status: str
-
-class ToDoListUpdateData(BaseStreamPayload):
-    todos: List[ToDoItemData]
-
-class EmptyData(BaseStreamPayload):
-    pass
-
-# Union of all possible data payload types
-StreamDataPayload = Union[
-    AssistantChunkData,
-    AssistantCompleteResponseData, 
-    ToolInteractionLogEntryData,
-    AgentOperationalPhaseTransitionData, 
-    ErrorEventData,
-    ToolInvocationApprovalRequestedData,
-    ToolInvocationAutoExecutingData,
-    SystemTaskNotificationData, # NEW
-    ToDoListUpdateData,
-    EmptyData
-]
-
-# Factory functions to create payload models from various inputs
-
-def create_assistant_chunk_data(chunk_obj: Any) -> AssistantChunkData:
-    usage_data = None
-    if hasattr(chunk_obj, 'usage'):
-        usage_data = getattr(chunk_obj, 'usage')
-    elif isinstance(chunk_obj, dict) and 'usage' in chunk_obj:
-        usage_data = chunk_obj.get('usage')
-
-    parsed_usage = None
-    if usage_data:
-        if isinstance(usage_data, TokenUsage):
-            parsed_usage = usage_data
-        elif isinstance(usage_data, dict):
-            try:
-                parsed_usage = TokenUsage(**usage_data)
-            except Exception as e:
-                logger.warning(f"Could not parse usage dict into TokenUsage for AssistantChunkData: {e}. Usage dict: {usage_data}")
-        else:
-            logger.warning(f"Unsupported usage type {type(usage_data)} for AssistantChunkData.")
-
-    if hasattr(chunk_obj, 'content') and hasattr(chunk_obj, 'is_complete'):
-        return AssistantChunkData(
-            content=str(getattr(chunk_obj, 'content', '')),
-            reasoning=getattr(chunk_obj, 'reasoning', None),
-            is_complete=bool(getattr(chunk_obj, 'is_complete', False)),
-            usage=parsed_usage,
-            image_urls=getattr(chunk_obj, 'image_urls', None),
-            audio_urls=getattr(chunk_obj, 'audio_urls', None),
-            video_urls=getattr(chunk_obj, 'video_urls', None)
-        )
-    elif isinstance(chunk_obj, dict): 
-         return AssistantChunkData(
-            content=str(chunk_obj.get('content', '')),
-            reasoning=chunk_obj.get('reasoning', None),
-            is_complete=bool(chunk_obj.get('is_complete', False)),
-            usage=parsed_usage,
-            image_urls=chunk_obj.get('image_urls', None),
-            audio_urls=chunk_obj.get('audio_urls', None),
-            video_urls=chunk_obj.get('video_urls', None)
-        )
-    raise ValueError(f"Cannot create AssistantChunkData from {type(chunk_obj)}")
-
-def create_assistant_complete_response_data(complete_resp_obj: Any) -> AssistantCompleteResponseData:
-    usage_data = None
-    if hasattr(complete_resp_obj, 'usage'):
-        usage_data = getattr(complete_resp_obj, 'usage')
-    elif isinstance(complete_resp_obj, dict) and 'usage' in complete_resp_obj:
-        usage_data = complete_resp_obj.get('usage')
-    
-    parsed_usage = None
-    if usage_data:
-        if isinstance(usage_data, TokenUsage):
-            parsed_usage = usage_data
-        elif isinstance(usage_data, dict):
-            try:
-                parsed_usage = TokenUsage(**usage_data)
-            except Exception as e: # pragma: no cover
-                logger.warning(f"Could not parse usage dict into TokenUsage for AssistantCompleteResponseData: {e}. Usage dict: {usage_data}")
-        else: # pragma: no cover
-            logger.warning(f"Unsupported usage type {type(usage_data)} for AssistantCompleteResponseData.")
-
-    if hasattr(complete_resp_obj, 'content'):
-        return AssistantCompleteResponseData(
-            content=str(getattr(complete_resp_obj, 'content', '')),
-            reasoning=getattr(complete_resp_obj, 'reasoning', None),
-            usage=parsed_usage,
-            image_urls=getattr(complete_resp_obj, 'image_urls', None),
-            audio_urls=getattr(complete_resp_obj, 'audio_urls', None),
-            video_urls=getattr(complete_resp_obj, 'video_urls', None)
-        )
-    elif isinstance(complete_resp_obj, dict): 
-        return AssistantCompleteResponseData(
-            content=str(complete_resp_obj.get('content', '')),
-            reasoning=complete_resp_obj.get('reasoning', None),
-            usage=parsed_usage,
-            image_urls=complete_resp_obj.get('image_urls', None),
-            audio_urls=complete_resp_obj.get('audio_urls', None),
-            video_urls=complete_resp_obj.get('video_urls', None)
-        )
-    raise ValueError(f"Cannot create AssistantCompleteResponseData from {type(complete_resp_obj)}")
-
-def create_tool_interaction_log_entry_data(log_data: Any) -> ToolInteractionLogEntryData:
-    if isinstance(log_data, dict):
-        if all(k in log_data for k in ['log_entry', 'tool_invocation_id', 'tool_name']):
-            return ToolInteractionLogEntryData(**log_data)
-    raise ValueError(f"Cannot create ToolInteractionLogEntryData from {type(log_data)}. Expected dict with 'log_entry', 'tool_invocation_id', and 'tool_name' keys.")
-
-def create_agent_operational_phase_transition_data(phase_data_dict: Any) -> AgentOperationalPhaseTransitionData: 
-    if isinstance(phase_data_dict, dict):
-        return AgentOperationalPhaseTransitionData(**phase_data_dict) 
-    raise ValueError(f"Cannot create AgentOperationalPhaseTransitionData from {type(phase_data_dict)}") 
-
-def create_error_event_data(error_data_dict: Any) -> ErrorEventData:
-    if isinstance(error_data_dict, dict):
-        return ErrorEventData(**error_data_dict)
-    raise ValueError(f"Cannot create ErrorEventData from {type(error_data_dict)}")
-
-def create_tool_invocation_approval_requested_data(approval_data_dict: Any) -> ToolInvocationApprovalRequestedData:
-    if isinstance(approval_data_dict, dict):
-        return ToolInvocationApprovalRequestedData(**approval_data_dict)
-    raise ValueError(f"Cannot create ToolInvocationApprovalRequestedData from {type(approval_data_dict)}")
-
-def create_tool_invocation_auto_executing_data(auto_exec_data_dict: Any) -> ToolInvocationAutoExecutingData:
-    if isinstance(auto_exec_data_dict, dict):
-        return ToolInvocationAutoExecutingData(**auto_exec_data_dict)
-    raise ValueError(f"Cannot create ToolInvocationAutoExecutingData from {type(auto_exec_data_dict)}")
-
-# NEW FACTORY FUNCTION
-def create_system_task_notification_data(notification_data_dict: Any) -> SystemTaskNotificationData:
-    if isinstance(notification_data_dict, dict):
-        return SystemTaskNotificationData(**notification_data_dict)
-    raise ValueError(f"Cannot create SystemTaskNotificationData from {type(notification_data_dict)}")
-
-def create_todo_list_update_data(todo_data_dict: Any) -> ToDoListUpdateData:
-    if isinstance(todo_data_dict, dict):
-        todos_payload = todo_data_dict.get('todos', [])
-        if not isinstance(todos_payload, list):
-            raise ValueError("Expected 'todos' to be a list when creating ToDoListUpdateData.")
-        todo_items = []
-        for todo_entry in todos_payload:
-            if not isinstance(todo_entry, dict):
-                logger.warning(f"Skipping non-dict todo entry when creating ToDoListUpdateData: {todo_entry!r}")
-                continue
-            try:
-                todo_items.append(ToDoItemData(**todo_entry))
-            except Exception as exc:
-                logger.warning(f"Failed to parse todo entry into ToDoItemData: {todo_entry!r}; error: {exc}")
-        return ToDoListUpdateData(todos=todo_items)
-    raise ValueError(f"Cannot create ToDoListUpdateData from {type(todo_data_dict)}")
+"""Compatibility shim for stream event payloads."""
+from .events.stream_event_payloads import *