autobyteus 1.2.0__py3-none-any.whl → 1.2.3__py3-none-any.whl

autobyteus/agent/streaming/adapters/__init__.py

@@ -0,0 +1,18 @@
+"""Shared adapters for streaming output."""
+
+from .invocation_adapter import ToolInvocationAdapter
+from .tool_syntax_registry import (
+    ToolSyntaxSpec,
+    get_tool_syntax_spec,
+    tool_syntax_registry_items,
+)
+from .tool_call_parsing import parse_json_tool_call, parse_xml_arguments
+
+__all__ = [
+    "ToolInvocationAdapter",
+    "ToolSyntaxSpec",
+    "get_tool_syntax_spec",
+    "tool_syntax_registry_items",
+    "parse_json_tool_call",
+    "parse_xml_arguments",
+]

autobyteus/agent/streaming/adapters/invocation_adapter.py

@@ -0,0 +1,184 @@
+"""
+ToolInvocation Adapter: Converts tool SegmentEvents into ToolInvocation objects.
+
+This adapter serves as the bridge between the streaming parser (which emits SegmentEvents)
+and the agent's tool execution system (which expects ToolInvocation objects).
+
+Key Design: The segment_id from the parser becomes the invocationId, ensuring
+consistent ID tracking from parse time through approval and execution.
+"""
+from typing import Optional, List, Dict, Any, TYPE_CHECKING
+import logging
+
+from ..segments.segment_events import SegmentEvent, SegmentType, SegmentEventType
+from .tool_syntax_registry import get_tool_syntax_spec
+from .tool_call_parsing import parse_json_tool_call, parse_xml_arguments
+from autobyteus.agent.tool_invocation import ToolInvocation
+
+logger = logging.getLogger(__name__)
+
+if TYPE_CHECKING:
+    from ..parser.json_parsing_strategies.base import JsonToolParsingStrategy
+
+
+class ToolInvocationAdapter:
+    """
+    Converts tool call SegmentEvents into ToolInvocation objects.
+    
+    Usage:
+        adapter = ToolInvocationAdapter()
+        
+        for event in parser.feed(chunk):
+            result = adapter.process_event(event)
+            if result:
+                # Got a complete ToolInvocation
+                enqueue_tool_invocation(result)
+    """
+    
+    def __init__(self, json_tool_parser: Optional["JsonToolParsingStrategy"] = None):
+        # Track active tool segments: segment_id -> accumulated data
+        self._active_segments: Dict[str, Dict[str, Any]] = {}
+        self._json_tool_parser = json_tool_parser
+    
+    def process_event(self, event: SegmentEvent) -> Optional[ToolInvocation]:
+        """
+        Process a SegmentEvent and return a ToolInvocation if complete.
+        
+        Args:
+            event: A SegmentEvent from the streaming parser.
+            
+        Returns:
+            ToolInvocation if a tool segment just completed, None otherwise.
+        """
+        if event.event_type == SegmentEventType.START:
+            return self._handle_start(event)
+        elif event.event_type == SegmentEventType.CONTENT:
+            return self._handle_content(event)
+        elif event.event_type == SegmentEventType.END:
+            return self._handle_end(event)
+        return None
+    
+    def _handle_start(self, event: SegmentEvent) -> None:
+        """Handle SEGMENT_START events."""
+        if event.segment_type != SegmentType.TOOL_CALL and get_tool_syntax_spec(event.segment_type) is None:
+            return None
+        
+        # Initialize tracking for this tool segment
+        metadata = event.payload.get("metadata", {})
+        tool_name = metadata.get("tool_name")
+        syntax_spec = get_tool_syntax_spec(event.segment_type)
+        if syntax_spec:
+            tool_name = syntax_spec.tool_name
+
+        self._active_segments[event.segment_id] = {
+            "segment_type": event.segment_type,
+            "tool_name": tool_name,
+            "content_buffer": "",
+            "arguments": {},
+            "syntax_spec": syntax_spec,
+            "metadata": metadata,
+        }
+        
+        logger.debug(f"ToolInvocationAdapter: Started tracking segment {event.segment_id}")
+        return None
+    
+    def _handle_content(self, event: SegmentEvent) -> None:
+        """Handle SEGMENT_CONTENT events."""
+        if event.segment_id not in self._active_segments:
+            return None
+        
+        # Accumulate content (for display purposes)
+        delta = event.payload.get("delta", "")
+        self._active_segments[event.segment_id]["content_buffer"] += delta
+        return None
+    
+    def _handle_end(self, event: SegmentEvent) -> Optional[ToolInvocation]:
+        """
+        Handle SEGMENT_END events.
+        
+        When a tool segment ends, create and return a ToolInvocation.
+        """
+        if event.segment_id not in self._active_segments:
+            return None
+        
+        segment_data = self._active_segments.pop(event.segment_id)
+        
+        # Extract metadata from END event (display metadata only)
+        metadata = event.payload.get("metadata", {})
+        segment_type = segment_data.get("segment_type")
+        tool_name = metadata.get("tool_name") or segment_data.get("tool_name")
+        arguments: Dict[str, Any] = segment_data.get("arguments", {})
+        content_buffer = segment_data.get("content_buffer", "")
+        start_metadata = segment_data.get("metadata", {})
+        syntax_spec = segment_data.get("syntax_spec")
+
+        if syntax_spec:
+            tool_name = syntax_spec.tool_name
+            args = syntax_spec.build_arguments(
+                {**start_metadata, **metadata},
+                content_buffer,
+            )
+            if args is None:
+                logger.warning(
+                    f"Tool segment {event.segment_id} ended without required arguments for {tool_name}"
+                )
+                return None
+            arguments = args
+        elif segment_type == SegmentType.TOOL_CALL:
+            content = content_buffer
+            stripped = content.lstrip()
+            parsed_call = None
+            
+            # Check if arguments were provided in metadata (e.g. Sentinel parser)
+            # First check start_metadata, then end metadata
+            if start_metadata.get("arguments"):
+                arguments = start_metadata["arguments"]
+            elif metadata.get("arguments"):
+                arguments = metadata["arguments"]
+            elif stripped.startswith("{") or stripped.startswith("["):
+                parsed_call = parse_json_tool_call(stripped, self._json_tool_parser)
+            else:
+                arguments = parse_xml_arguments(content)
+
+            if parsed_call:
+                tool_name = tool_name or parsed_call.get("name")
+                arguments = parsed_call.get("arguments") or {}
+
+        if not tool_name:
+            logger.warning(f"Tool segment {event.segment_id} ended without tool_name")
+            return None
+        
+        # Create ToolInvocation with segment_id as the invocation id
+        invocation = ToolInvocation(
+            name=tool_name,
+            arguments=arguments,
+            id=event.segment_id  # Key: segment_id becomes invocationId
+        )
+        
+        logger.info(f"ToolInvocationAdapter: Created invocation {invocation.id} for tool {tool_name}")
+        return invocation
+    
+    def process_events(self, events: List[SegmentEvent]) -> List[ToolInvocation]:
+        """
+        Process multiple events and return all completed ToolInvocations.
+        
+        Args:
+            events: List of SegmentEvents from the parser.
+            
+        Returns:
+            List of ToolInvocations for any completed tool segments.
+        """
+        invocations = []
+        for event in events:
+            result = self.process_event(event)
+            if result:
+                invocations.append(result)
+        return invocations
+    
+    def reset(self) -> None:
+        """Clear all tracking state."""
+        self._active_segments.clear()
+    
+    def get_active_segment_ids(self) -> List[str]:
+        """Get IDs of currently tracked tool segments."""
+        return list(self._active_segments.keys())

autobyteus/agent/streaming/adapters/tool_call_parsing.py

@@ -0,0 +1,163 @@
+"""
+Utility parsers for tool call argument extraction.
+
+These functions are intentionally decoupled from streaming states so the
+ToolInvocationAdapter can be the single source of truth for arguments.
+"""
+from __future__ import annotations
+
+import json
+import re
+import xml.etree.ElementTree as ET
+from typing import Any, Dict, Optional
+
+from ..parser.json_parsing_strategies.base import JsonToolParsingStrategy
+
+_ARGS_OPEN = "<arguments>"
+_ARGS_CLOSE = "</arguments>"
+_TAG_SPLIT_PATTERN = re.compile(r"(<[A-Za-z!/][^>]*>)")
+_ENTITY_PATTERN = re.compile(r"&(?!(?:amp|lt|gt|quot|apos|#\d+|#x[0-9a-fA-F]+);)")
+
+
+def parse_xml_arguments(content: str) -> Dict[str, Any]:
+    """
+    Parse XML tool arguments from a tool-call content body.
+
+    Supports:
+    1) <arguments><arg name="x">...</arg></arguments>
+    2) <arguments><path>...</path></arguments>
+    3) Direct content without <arguments> wrapper
+    """
+    args_match = re.search(
+        rf"{_ARGS_OPEN}(.*?){_ARGS_CLOSE}",
+        content,
+        re.IGNORECASE | re.DOTALL,
+    )
+    if args_match:
+        args_content = args_match.group(1)
+    else:
+        args_content = content.strip()
+
+    if not args_content:
+        return {}
+
+    try:
+        root = ET.fromstring(f"<root>{args_content}</root>")
+        return _parse_xml_children(root)
+    except ET.ParseError:
+        sanitized = _sanitize_xml_fragment(args_content)
+        try:
+            root = ET.fromstring(f"<root>{sanitized}</root>")
+            return _parse_xml_children(root)
+        except ET.ParseError:
+            return _parse_legacy_arguments(args_content)
+
+
+def parse_json_tool_call(
+    json_str: str,
+    parser: Optional[JsonToolParsingStrategy] = None,
+) -> Optional[Dict[str, Any]]:
+    """
+    Parse a JSON string into tool call info.
+
+    Returns dict with 'name' and 'arguments', or None if invalid.
+    """
+    if parser is not None:
+        parsed_calls = parser.parse(json_str)
+        if parsed_calls:
+            return parsed_calls[0]
+        return None
+
+    try:
+        data = json.loads(json_str)
+
+        if isinstance(data, list) and data:
+            data = data[0]
+
+        if isinstance(data, dict):
+            name = (
+                data.get("name")
+                or data.get("tool")
+                or data.get("function", {}).get("name")
+                or "unknown"
+            )
+            arguments = (
+                data.get("arguments")
+                or data.get("parameters")
+                or data.get("function", {}).get("arguments")
+                or {}
+            )
+            if isinstance(arguments, str):
+                try:
+                    arguments = json.loads(arguments)
+                except json.JSONDecodeError:
+                    pass
+            return {"name": name, "arguments": arguments}
+    except json.JSONDecodeError:
+        return None
+
+    return None
+
+
+def _parse_xml_children(element: ET.Element) -> Dict[str, Any]:
+    arguments: Dict[str, Any] = {}
+    for child in element:
+        name = child.attrib.get("name") or child.tag
+        if not name:
+            continue
+        arguments[name] = _parse_xml_value(child)
+    return arguments
+
+
+def _parse_xml_value(element: ET.Element) -> Any:
+    items = [child for child in element if child.tag == "item"]
+    if items:
+        return [_parse_item_value(item) for item in items]
+
+    arg_children = [child for child in element if child.tag == "arg"]
+    if arg_children:
+        return _parse_xml_children(element)
+
+    other_children = [child for child in element if child.tag not in {"arg", "item"}]
+    if other_children:
+        return _parse_xml_children(element)
+
+    text = element.text or ""
+    return text.strip()
+
+
+def _parse_item_value(element: ET.Element) -> Any:
+    arg_children = [child for child in element if child.tag == "arg"]
+    if arg_children:
+        return _parse_xml_children(element)
+    other_children = [child for child in element if child.tag not in {"arg", "item"}]
+    if other_children:
+        return _parse_xml_children(element)
+    text = element.text or ""
+    return text.strip()
+
+
+def _parse_legacy_arguments(args_content: str) -> Dict[str, Any]:
+    arguments: Dict[str, Any] = {}
+    arg_pattern = re.compile(r"<(\\w+)>(.*?)</\\1>", re.DOTALL)
+    for match in arg_pattern.finditer(args_content):
+        arg_name = match.group(1)
+        arg_value = match.group(2).strip()
+        arguments[arg_name] = arg_value
+    return arguments
+
+
+def _sanitize_xml_fragment(fragment: str) -> str:
+    """Escape raw text to make fragment XML-safe without touching tags."""
+    parts = _TAG_SPLIT_PATTERN.split(fragment)
+    sanitized_parts = []
+    for part in parts:
+        if not part:
+            continue
+        if part.startswith("<") and part.endswith(">"):
+            sanitized_parts.append(part)
+            continue
+        escaped = _ENTITY_PATTERN.sub("&amp;", part)
+        escaped = escaped.replace("<", "&lt;")
+        sanitized_parts.append(escaped)
+    return "".join(sanitized_parts)

autobyteus/agent/streaming/adapters/tool_syntax_registry.py

@@ -0,0 +1,67 @@
+"""
+Registry for mapping segment syntaxes to tool invocations.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Callable, Dict, Optional, Tuple
+
+from ..segments.segment_events import SegmentType
+
+ToolArgsBuilder = Callable[[dict, str], Optional[dict]]
+
+
+@dataclass(frozen=True)
+class ToolSyntaxSpec:
+    """Defines how a segment type maps to a tool invocation."""
+
+    tool_name: str
+    build_arguments: ToolArgsBuilder
+
+
+def _build_write_file_args(metadata: dict, content: str) -> Optional[dict]:
+    path = metadata.get("path")
+    if not path:
+        return None
+    return {"path": path, "content": content}
+
+
+def _build_run_bash_args(metadata: dict, content: str) -> Optional[dict]:
+    command = content or metadata.get("cmd") or ""
+    if not command:
+        return None
+    return {"command": command}
+
+
+def _build_patch_file_args(metadata: dict, content: str) -> Optional[dict]:
+    path = metadata.get("path")
+    if not path:
+        return None
+    # 'content' here is the accumulated patch delta from the stream
+    return {"path": path, "patch": content}
+
+
+_TOOL_SYNTAX_REGISTRY: Dict[SegmentType, ToolSyntaxSpec] = {
+    SegmentType.WRITE_FILE: ToolSyntaxSpec(
+        tool_name="write_file",
+        build_arguments=_build_write_file_args,
+    ),
+    SegmentType.RUN_BASH: ToolSyntaxSpec(
+        tool_name="run_bash",
+        build_arguments=_build_run_bash_args,
+    ),
+    SegmentType.PATCH_FILE: ToolSyntaxSpec(
+        tool_name="patch_file",
+        build_arguments=_build_patch_file_args,
+    ),
+}
+
+
+def get_tool_syntax_spec(segment_type: SegmentType) -> Optional[ToolSyntaxSpec]:
+    """Return tool syntax spec for a segment type if registered."""
+    return _TOOL_SYNTAX_REGISTRY.get(segment_type)
+
+
+def tool_syntax_registry_items() -> Tuple[Tuple[SegmentType, ToolSyntaxSpec], ...]:
+    """Expose registry items for inspection/testing."""
+    return tuple(_TOOL_SYNTAX_REGISTRY.items())

autobyteus/agent/streaming/agent_event_stream.py

@@ -1,179 +1,4 @@
-# file: autobyteus/autobyteus/agent/streaming/agent_event_stream.py
-import asyncio
-import logging
-import traceback
-import functools 
-import queue as standard_queue
-from typing import AsyncIterator, Dict, Any, TYPE_CHECKING, List, Optional, Callable, Union
+"""Compatibility shim for AgentEventStream."""
+from .streams.agent_event_stream import AgentEventStream
 
-from autobyteus.llm.utils.response_types import ChunkResponse, CompleteResponse
-from autobyteus.agent.streaming.stream_events import StreamEvent, StreamEventType 
-from autobyteus.agent.streaming.stream_event_payloads import ( 
-    create_assistant_chunk_data,
-    create_assistant_complete_response_data,
-    create_tool_interaction_log_entry_data,
-    create_agent_operational_phase_transition_data, 
-    create_error_event_data,
-    create_tool_invocation_approval_requested_data,
-    create_tool_invocation_auto_executing_data,
-    create_system_task_notification_data, # NEW
-    AssistantChunkData,
-    AssistantCompleteResponseData,
-    ToolInteractionLogEntryData,
-    AgentOperationalPhaseTransitionData,
-    ToolInvocationApprovalRequestedData,
-    ToolInvocationAutoExecutingData,
-    ErrorEventData,
-    SystemTaskNotificationData, # NEW
-    EmptyData,
-    StreamDataPayload,
-)
-from .queue_streamer import stream_queue_items 
-from autobyteus.events.event_types import EventType 
-from autobyteus.events.event_emitter import EventEmitter 
-
-if TYPE_CHECKING:
-    from autobyteus.agent.agent import Agent
-    from autobyteus.agent.events.notifiers import AgentExternalEventNotifier
-
-logger = logging.getLogger(__name__)
-
-_AES_INTERNAL_SENTINEL = object()
-
-class AgentEventStream(EventEmitter): 
-    def __init__(self, agent: 'Agent'):
-        super().__init__() 
-        
-        from autobyteus.agent.agent import Agent as ConcreteAgent 
-        if not isinstance(agent, ConcreteAgent):
-            raise TypeError(f"AgentEventStream requires an Agent instance, got {type(agent).__name__}.")
-
-        self.agent_id: str = agent.agent_id
-        
-        self._loop = asyncio.get_event_loop() 
-        self._generic_stream_event_internal_q: standard_queue.Queue[Union[StreamEvent, object]] = standard_queue.Queue()
-
-        self._notifier: Optional['AgentExternalEventNotifier'] = None
-        if agent.context and agent.context.phase_manager: 
-            self._notifier = agent.context.phase_manager.notifier
-        
-        if not self._notifier:
-            logger.error(f"AgentEventStream for '{self.agent_id}': Notifier not available. No events will be streamed.")
-            return
-
-        self._register_listeners()
-        
-        logger.info(f"AgentEventStream (ID: {self.object_id}) initialized for agent_id '{self.agent_id}'. Subscribed to notifier.")
-
-    def _register_listeners(self):
-        """Subscribes this instance's handler to all relevant events from the notifier."""
-        all_agent_event_types = [et for et in EventType if et.name.startswith("AGENT_")]
-        
-        for event_type in all_agent_event_types:
-            self.subscribe_from(self._notifier, event_type, self._handle_notifier_event_sync)
-
-    def _handle_notifier_event_sync(self, event_type: EventType, payload: Optional[Any] = None, object_id: Optional[str] = None, **kwargs):
-        event_agent_id = kwargs.get("agent_id", self.agent_id) 
-        
-        typed_payload_for_stream_event: Optional[StreamDataPayload] = None
-        stream_event_type_for_generic_stream: Optional[StreamEventType] = None
-
-        try: 
-            if event_type == EventType.AGENT_PHASE_IDLE_ENTERED:
-                typed_payload_for_stream_event = create_agent_operational_phase_transition_data(payload)
-                stream_event_type_for_generic_stream = StreamEventType.AGENT_IDLE
-            elif event_type.name.startswith("AGENT_PHASE_"):
-                typed_payload_for_stream_event = create_agent_operational_phase_transition_data(payload)
-                stream_event_type_for_generic_stream = StreamEventType.AGENT_OPERATIONAL_PHASE_TRANSITION
-            elif event_type == EventType.AGENT_DATA_ASSISTANT_CHUNK:
-                typed_payload_for_stream_event = create_assistant_chunk_data(payload)
-                stream_event_type_for_generic_stream = StreamEventType.ASSISTANT_CHUNK
-            elif event_type == EventType.AGENT_DATA_ASSISTANT_COMPLETE_RESPONSE:
-                typed_payload_for_stream_event = create_assistant_complete_response_data(payload)
-                stream_event_type_for_generic_stream = StreamEventType.ASSISTANT_COMPLETE_RESPONSE
-            elif event_type == EventType.AGENT_DATA_TOOL_LOG:
-                typed_payload_for_stream_event = create_tool_interaction_log_entry_data(payload)
-                stream_event_type_for_generic_stream = StreamEventType.TOOL_INTERACTION_LOG_ENTRY
-            elif event_type == EventType.AGENT_REQUEST_TOOL_INVOCATION_APPROVAL:
-                typed_payload_for_stream_event = create_tool_invocation_approval_requested_data(payload)
-                stream_event_type_for_generic_stream = StreamEventType.TOOL_INVOCATION_APPROVAL_REQUESTED
-            elif event_type == EventType.AGENT_TOOL_INVOCATION_AUTO_EXECUTING:
-                typed_payload_for_stream_event = create_tool_invocation_auto_executing_data(payload)
-                stream_event_type_for_generic_stream = StreamEventType.TOOL_INVOCATION_AUTO_EXECUTING
-            elif event_type == EventType.AGENT_ERROR_OUTPUT_GENERATION:
-                typed_payload_for_stream_event = create_error_event_data(payload)
-                stream_event_type_for_generic_stream = StreamEventType.ERROR_EVENT
-            # NEW MAPPING
-            elif event_type == EventType.AGENT_DATA_SYSTEM_TASK_NOTIFICATION_RECEIVED:
-                typed_payload_for_stream_event = create_system_task_notification_data(payload)
-                stream_event_type_for_generic_stream = StreamEventType.SYSTEM_TASK_NOTIFICATION
-            
-            elif event_type in [EventType.AGENT_DATA_ASSISTANT_CHUNK_STREAM_END, EventType.AGENT_DATA_TOOL_LOG_STREAM_END]:
-                 pass 
-            else:
-                 logger.debug(f"AgentEventStream received internal event '{event_type.name}' with no direct stream mapping.")
-        
-        except Exception as e:
-            logger.error(f"AgentEventStream error processing payload for event '{event_type.name}': {e}", exc_info=True)
-
-        if typed_payload_for_stream_event and stream_event_type_for_generic_stream:
-            stream_event = StreamEvent(
-                agent_id=event_agent_id, 
-                event_type=stream_event_type_for_generic_stream, 
-                data=typed_payload_for_stream_event
-            )
-            self._generic_stream_event_internal_q.put(stream_event)
-
-    async def close(self):
-        logger.info(f"AgentEventStream (ID: {self.object_id}) for '{self.agent_id}': close() called. Unsubscribing all listeners and signaling.")
-        self.unsubscribe_all_listeners()
-        await self._loop.run_in_executor(None, self._generic_stream_event_internal_q.put, _AES_INTERNAL_SENTINEL)
-
-    async def all_events(self) -> AsyncIterator[StreamEvent]:
-        """The primary method to consume all structured events from the agent."""
-        async for event in stream_queue_items(self._generic_stream_event_internal_q, _AES_INTERNAL_SENTINEL, f"agent_{self.agent_id}_all_events"):
-            yield event
-
-    # --- Convenience Stream Methods ---
-
-    async def stream_assistant_chunks(self) -> AsyncIterator[AssistantChunkData]:
-        """A convenience async generator that yields only assistant content/reasoning chunks."""
-        async for event in self.all_events():
-            if event.event_type == StreamEventType.ASSISTANT_CHUNK and isinstance(event.data, AssistantChunkData):
-                yield event.data
-
-    async def stream_assistant_final_response(self) -> AsyncIterator[AssistantCompleteResponseData]:
-        """A convenience async generator that yields only the final, complete assistant responses."""
-        async for event in self.all_events():
-            if event.event_type == StreamEventType.ASSISTANT_COMPLETE_RESPONSE and isinstance(event.data, AssistantCompleteResponseData):
-                yield event.data
-
-    async def stream_tool_logs(self) -> AsyncIterator[ToolInteractionLogEntryData]:
-        """A convenience async generator that yields only tool interaction log entries."""
-        async for event in self.all_events():
-            if event.event_type == StreamEventType.TOOL_INTERACTION_LOG_ENTRY and isinstance(event.data, ToolInteractionLogEntryData):
-                yield event.data
-    
-    async def stream_phase_transitions(self) -> AsyncIterator[AgentOperationalPhaseTransitionData]:
-        """A convenience async generator that yields only agent phase transition data."""
-        async for event in self.all_events():
-            if event.event_type == StreamEventType.AGENT_OPERATIONAL_PHASE_TRANSITION and isinstance(event.data, AgentOperationalPhaseTransitionData):
-                yield event.data
-
-    async def stream_tool_approval_requests(self) -> AsyncIterator[ToolInvocationApprovalRequestedData]:
-        """A convenience async generator that yields only requests for tool invocation approval."""
-        async for event in self.all_events():
-            if event.event_type == StreamEventType.TOOL_INVOCATION_APPROVAL_REQUESTED and isinstance(event.data, ToolInvocationApprovalRequestedData):
-                yield event.data
-
-    async def stream_tool_auto_executing(self) -> AsyncIterator[ToolInvocationAutoExecutingData]:
-        """A convenience async generator that yields only events for tools being auto-executed."""
-        async for event in self.all_events():
-            if event.event_type == StreamEventType.TOOL_INVOCATION_AUTO_EXECUTING and isinstance(event.data, ToolInvocationAutoExecutingData):
-                yield event.data
-
-    async def stream_errors(self) -> AsyncIterator[ErrorEventData]:
-        """A convenience async generator that yields only error events."""
-        async for event in self.all_events():
-            if event.event_type == StreamEventType.ERROR_EVENT and isinstance(event.data, ErrorEventData):
-                yield event.data
+__all__ = ["AgentEventStream"]

autobyteus/agent/streaming/api_tool_call/__init__.py

@@ -0,0 +1,16 @@
+"""API tool call streaming helpers."""
+
+from .json_string_field_extractor import JsonStringFieldExtractor, FieldExtractionResult
+from .file_content_streamer import (
+    FileContentStreamUpdate,
+    WriteFileContentStreamer,
+    PatchFileContentStreamer,
+)
+
+__all__ = [
+    "JsonStringFieldExtractor",
+    "FieldExtractionResult",
+    "FileContentStreamUpdate",
+    "WriteFileContentStreamer",
+    "PatchFileContentStreamer",
+]