autobyteus 1.1.0__py3-none-any.whl → 1.1.1__py3-none-any.whl

autobyteus/agent/workspace/workspace_config.py

@@ -0,0 +1,160 @@
+# file: autobyteus/autobyteus/agent/workspace/workspace_config.py
+import logging
+import json
+from typing import Dict, Any, Mapping
+from collections.abc import Mapping as MappingABC
+
+logger = logging.getLogger(__name__)
+
+def _default_serializer(obj: Any) -> Any:
+    """
+    A robust serializer for objects that might not be JSON-serializable,
+    ensuring a stable representation for hashing and comparison.
+    """
+    try:
+        # For common un-serializable collection types, convert to a sorted list
+        # to ensure a stable representation.
+        if isinstance(obj, set):
+            return sorted(list(obj))
+        # For other objects, repr() is often a good choice for a unique,
+        # and often reconstructible, string representation.
+        return repr(obj)
+    except Exception:
+        # Fallback for any object that fails repr() or other serialization.
+        return f"<unrepresentable object of type {type(obj).__name__}>"
+
+
+class WorkspaceConfig:
+    """
+    An immutable, hashable configuration class for agent workspaces.
+
+    This class stores workspace configuration parameters. It is immutable, meaning
+    that methods like `set` or `update` return a new `WorkspaceConfig` instance
+    rather than modifying the existing one.
+
+    This immutability makes `WorkspaceConfig` instances hashable, allowing them to
+    be used as dictionary keys for caching and reusing workspace instances.
+    """
+    _params: Dict[str, Any]
+    _canonical_rep: str
+
+    def __init__(self, params: Mapping[str, Any] = None):
+        """
+        Initializes the WorkspaceConfig.
+
+        Args:
+            params: A dictionary of configuration parameters. A copy is stored.
+        """
+        self._params = dict(params or {})
+        
+        # Pre-compute canonical representation for hashing and equality.
+        try:
+            self._canonical_rep = json.dumps(self._params, sort_keys=True, default=_default_serializer)
+        except Exception as e:
+            logger.error(f"Failed to create canonical representation for WorkspaceConfig: {e}", exc_info=True)
+            # Fallback for extreme cases
+            self._canonical_rep = repr(self._params)
+
+        logger.debug(f"WorkspaceConfig initialized with params keys: {list(self._params.keys())}")
+
+    def __hash__(self) -> int:
+        return hash(self._canonical_rep)
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, WorkspaceConfig):
+            return NotImplemented
+        return self._canonical_rep == other._canonical_rep
+
+    def to_dict(self) -> Dict[str, Any]:
+        """
+        Convert the WorkspaceConfig to a dictionary representation.
+        
+        Returns:
+            Dict[str, Any]: A copy of the configuration parameters.
+        """
+        return self._params.copy()
+
+    @classmethod
+    def from_dict(cls, config_data: Dict[str, Any]) -> 'WorkspaceConfig':
+        """
+        Create a WorkspaceConfig instance from a dictionary.
+        
+        Args:
+            config_data: Dictionary containing configuration parameters.
+            
+        Returns:
+            A new, immutable WorkspaceConfig instance.
+        """
+        if not isinstance(config_data, dict):
+            raise TypeError("config_data must be a dictionary")
+        return cls(params=config_data)
+
+    def merge(self, other: 'WorkspaceConfig') -> 'WorkspaceConfig':
+        """
+        Merge this WorkspaceConfig with another, with the other taking precedence.
+        
+        Args:
+            other: WorkspaceConfig to merge with this one.
+            
+        Returns:
+            A new, merged WorkspaceConfig instance.
+        """
+        if not isinstance(other, WorkspaceConfig):
+            raise TypeError("Can only merge with another WorkspaceConfig instance")
+        
+        merged_params = self._params.copy()
+        merged_params.update(other._params)
+        return WorkspaceConfig(params=merged_params)
+
+    def get(self, key: str, default: Any = None) -> Any:
+        """
+        Get a configuration parameter.
+        
+        Args:
+            key: The parameter key.
+            default: Default value if key doesn't exist.
+            
+        Returns:
+            The parameter value or default.
+        """
+        return self._params.get(key, default)
+
+    def set(self, key: str, value: Any) -> 'WorkspaceConfig':
+        """
+        Return a new WorkspaceConfig with a key set to a new value.
+        
+        Args:
+            key: The parameter key.
+            value: The parameter value.
+
+        Returns:
+            A new WorkspaceConfig instance with the updated parameter.
+        """
+        new_params = self._params.copy()
+        new_params[key] = value
+        return WorkspaceConfig(params=new_params)
+
+    def update(self, params: Mapping[str, Any]) -> 'WorkspaceConfig':
+        """
+        Return a new WorkspaceConfig with multiple updated parameters.
+        
+        Args:
+            params: Dictionary of parameters to update.
+            
+        Returns:
+            A new WorkspaceConfig instance with the updated parameters.
+        """
+        if not isinstance(params, MappingABC):
+            raise TypeError("params must be a mapping (e.g., a dictionary)")
+        new_params = self._params.copy()
+        new_params.update(params)
+        return WorkspaceConfig(params=new_params)
+
+    def __repr__(self) -> str:
+        return f"WorkspaceConfig(params={self._params})"
+
+    def __len__(self) -> int:
+        return len(self._params)
+
+    def __bool__(self) -> bool:
+        return bool(self._params)

autobyteus/agent/workspace/workspace_definition.py

@@ -0,0 +1,36 @@
+"""
+This module defines the WorkspaceDefinition class, which encapsulates the metadata
+for a specific type of agent workspace.
+"""
+import logging
+from typing import Type, Optional, TYPE_CHECKING
+from autobyteus.tools.parameter_schema import ParameterSchema
+
+if TYPE_CHECKING:
+    from autobyteus.agent.workspace.base_workspace import BaseAgentWorkspace
+
+logger = logging.getLogger(__name__)
+
+class WorkspaceDefinition:
+    """Represents the definition of a discoverable and creatable agent workspace type."""
+    def __init__(self,
+                 workspace_type_name: str,
+                 description: str,
+                 workspace_class: Type['BaseAgentWorkspace'],
+                 config_schema: ParameterSchema):
+        if not all([workspace_type_name, description, workspace_class, config_schema is not None]):
+            raise ValueError("All parameters for WorkspaceDefinition are required.")
+
+        self.workspace_type_name = workspace_type_name
+        self.description = description
+        self.workspace_class = workspace_class
+        self.config_schema = config_schema
+        logger.debug(f"WorkspaceDefinition created for type '{workspace_type_name}'.")
+
+    def to_dict(self) -> dict:
+        """Serializes the definition to a dictionary for API exposure."""
+        return {
+            "workspace_type_name": self.workspace_type_name,
+            "description": self.description,
+            "config_schema": self.config_schema.to_dict()
+        }

autobyteus/agent/workspace/workspace_meta.py

@@ -0,0 +1,37 @@
+"""
+This module contains the metaclass for BaseAgentWorkspace for automatic registration.
+"""
+import logging
+from abc import ABCMeta
+from .workspace_registry import default_workspace_registry
+from .workspace_definition import WorkspaceDefinition
+
+logger = logging.getLogger(__name__)
+
+class WorkspaceMeta(ABCMeta):
+    """Metaclass to automatically register concrete BaseAgentWorkspace subclasses."""
+    def __init__(cls, name, bases, dct):
+        super().__init__(name, bases, dct)
+        
+        if name == 'BaseAgentWorkspace' or getattr(cls, "__abstractmethods__", None):
+            logger.debug(f"Skipping registration for abstract workspace class: {name}")
+            return
+
+        try:
+            workspace_type_name = cls.get_workspace_type_name()
+            description = cls.get_description()
+            config_schema = cls.get_config_schema()
+            
+            definition = WorkspaceDefinition(
+                workspace_type_name=workspace_type_name,
+                description=description,
+                workspace_class=cls,
+                config_schema=config_schema
+            )
+            default_workspace_registry.register(definition)
+            config_params_info = f"config_params: {len(config_schema) if config_schema else 0}"
+            logger.info(f"Auto-registered workspace: '{workspace_type_name}' from class {name} ({config_params_info})")
+        except AttributeError as e:
+            logger.error(f"Workspace class {name} is missing a required static/class method ({e}). Skipping registration.")
+        except Exception as e:
+            logger.error(f"Failed to auto-register workspace class {name}: {e}", exc_info=True)

autobyteus/agent/workspace/workspace_registry.py

@@ -0,0 +1,72 @@
+"""
+This module provides a central registry for agent workspace types.
+"""
+import logging
+from typing import Dict, Any, Optional, List, TYPE_CHECKING
+from autobyteus.utils.singleton import SingletonMeta
+from .workspace_definition import WorkspaceDefinition
+from .workspace_config import WorkspaceConfig
+
+if TYPE_CHECKING:
+    from .base_workspace import BaseAgentWorkspace
+
+logger = logging.getLogger(__name__)
+
+class WorkspaceRegistry(metaclass=SingletonMeta):
+    """
+    A singleton registry for WorkspaceDefinition objects. Workspaces are
+    typically auto-registered via WorkspaceMeta.
+    """
+    def __init__(self):
+        self._definitions: Dict[str, WorkspaceDefinition] = {}
+        logger.info("Core WorkspaceRegistry initialized.")
+
+    def register(self, definition: WorkspaceDefinition):
+        """Registers a workspace definition."""
+        if not isinstance(definition, WorkspaceDefinition):
+            raise TypeError("Can only register WorkspaceDefinition objects.")
+        if definition.workspace_type_name in self._definitions:
+            logger.warning(f"Overwriting workspace definition for type '{definition.workspace_type_name}'.")
+        self._definitions[definition.workspace_type_name] = definition
+
+    def get_definition(self, workspace_type_name: str) -> Optional[WorkspaceDefinition]:
+        """Retrieves a workspace definition by its unique type name."""
+        return self._definitions.get(workspace_type_name)
+
+    def get_all_definitions(self) -> List[WorkspaceDefinition]:
+        """Returns a list of all registered workspace definitions."""
+        return list(self._definitions.values())
+
+    def create_workspace(self, workspace_type_name: str, config: WorkspaceConfig) -> 'BaseAgentWorkspace':
+        """
+        Creates an instance of a workspace.
+
+        Args:
+            workspace_type_name (str): The unique type name of the workspace to create.
+            config (WorkspaceConfig): The configuration object for the workspace.
+
+        Returns:
+            An instance of a BaseAgentWorkspace subclass.
+            
+        Raises:
+            ValueError: If the type is unknown or parameters are invalid.
+        """
+        definition = self.get_definition(workspace_type_name)
+        if not definition:
+            raise ValueError(f"Unknown workspace type: '{workspace_type_name}'")
+
+        is_valid, errors = definition.config_schema.validate_config(config.to_dict())
+        if not is_valid:
+            error_str = ", ".join(errors)
+            raise ValueError(f"Invalid parameters for workspace type '{workspace_type_name}': {error_str}")
+
+        try:
+            workspace_class = definition.workspace_class
+            instance = workspace_class(config=config)
+            logger.info(f"Successfully created instance of workspace type '{workspace_type_name}'.")
+            return instance
+        except Exception as e:
+            logger.error(f"Failed to instantiate workspace class '{definition.workspace_class.__name__}': {e}", exc_info=True)
+            raise RuntimeError(f"Workspace instantiation failed for type '{workspace_type_name}': {e}") from e
+
+default_workspace_registry = WorkspaceRegistry()

autobyteus/cli/__init__.py

@@ -2,9 +2,10 @@
 """
 Command-Line Interface (CLI) utilities for interacting with AutoByteUs components.
 """
-from . import agent_cli 
+from .agent_cli import run
+from .cli_display import InteractiveCLIDisplay
 
 __all__ = [
-    "agent_cli", 
+    "run", 
+    "InteractiveCLIDisplay",
 ]
-

autobyteus/cli/agent_cli.py

@@ -1,212 +1,41 @@
 import asyncio
 import logging
 import sys
-from typing import Optional, List, Dict, Any
-import json 
+from typing import Optional
 
 from autobyteus.agent.agent import Agent
-from autobyteus.agent.context.phases import AgentOperationalPhase
 from autobyteus.agent.message.agent_input_user_message import AgentInputUserMessage
 from autobyteus.agent.streaming.agent_event_stream import AgentEventStream
-from autobyteus.agent.streaming.stream_events import StreamEvent, StreamEventType
-from autobyteus.agent.streaming.stream_event_payloads import (
-    AssistantChunkData,
-    AssistantCompleteResponseData,
-    ToolInvocationApprovalRequestedData,
-    ToolInteractionLogEntryData,
-    AgentOperationalPhaseTransitionData,
-    ErrorEventData,
-)
+from .cli_display import InteractiveCLIDisplay
 
 logger = logging.getLogger(__name__) 
 
-class InteractiveCLIManager:
-    """
-    Manages the state and rendering logic for the interactive CLI session.
-    Input reading is handled by the main `run` loop. This class only handles output.
+async def run(agent: Agent, show_tool_logs: bool = True, show_token_usage: bool = False, initial_prompt: Optional[str] = None):
     """
-    def __init__(self, agent_turn_complete_event: asyncio.Event, show_tool_logs: bool, show_token_usage: bool):
-        self.agent_turn_complete_event = agent_turn_complete_event
-        self.show_tool_logs = show_tool_logs
-        self.show_token_usage = show_token_usage
-        self.current_line_empty = True
-        self.agent_has_spoken_this_turn = False
-        self.pending_approval_data: Optional[ToolInvocationApprovalRequestedData] = None
-        self.is_thinking = False
-        self.is_in_content_block = False
-
-    def reset_turn_state(self):
-        """Resets flags that are tracked on a per-turn basis."""
-        self._end_thinking_block()
-        self.agent_has_spoken_this_turn = False
-        self.is_in_content_block = False
-
-    def _ensure_new_line(self):
-        """Ensures the cursor is on a new line if the current one isn't empty."""
-        if not self.current_line_empty:
-            sys.stdout.write("\n")
-            sys.stdout.flush()
-            self.current_line_empty = True
-
-    def _end_thinking_block(self):
-        """Closes the <Thinking> block if it was active."""
-        if self.is_thinking:
-            sys.stdout.write("\n</Thinking>")
-            sys.stdout.flush()
-            self.is_thinking = False
-            self.current_line_empty = False
-
-    def _display_tool_approval_prompt(self):
-        """Displays the tool approval prompt using stored pending data."""
-        if not self.pending_approval_data:
-            return
-            
-        try:
-            args_str = json.dumps(self.pending_approval_data.arguments, indent=2)
-        except TypeError:
-            args_str = str(self.pending_approval_data.arguments)
-
-        self._ensure_new_line()
-        prompt_message = (
-            f"Tool Call: '{self.pending_approval_data.tool_name}' requests permission to run with arguments:\n"
-            f"{args_str}\nApprove? (y/n): "
-        )
-        sys.stdout.write(prompt_message)
-        sys.stdout.flush()
-        self.current_line_empty = False
-
-    async def handle_stream_event(self, event: StreamEvent):
-        """Processes a single StreamEvent and updates the CLI display."""
-        # A block of thinking ends if any event other than a reasoning chunk arrives.
-        is_reasoning_only_chunk = (
-            event.event_type == StreamEventType.ASSISTANT_CHUNK and
-            isinstance(event.data, AssistantChunkData) and
-            bool(event.data.reasoning) and not bool(event.data.content)
-        )
-        if not is_reasoning_only_chunk:
-            self._end_thinking_block()
-
-        # Most events should start on a new line.
-        if event.event_type != StreamEventType.ASSISTANT_CHUNK:
-            self._ensure_new_line()
-
-        if event.event_type in [
-            StreamEventType.AGENT_IDLE,
-            StreamEventType.ERROR_EVENT,
-            StreamEventType.TOOL_INVOCATION_APPROVAL_REQUESTED,
-        ]:
-            self.agent_turn_complete_event.set()
-
-        if event.event_type == StreamEventType.ASSISTANT_CHUNK and isinstance(event.data, AssistantChunkData):
-            # If this is the first output from the agent this turn, print the "Agent: " prefix.
-            if not self.agent_has_spoken_this_turn:
-                self._ensure_new_line()
-                sys.stdout.write("Agent:\n")
-                sys.stdout.flush()
-                self.agent_has_spoken_this_turn = True
-                self.current_line_empty = True
-
-            # Stream reasoning to stdout without logger formatting.
-            if event.data.reasoning:
-                if not self.is_thinking:
-                    sys.stdout.write("<Thinking>\n")
-                    sys.stdout.flush()
-                    self.is_thinking = True
-                    self.current_line_empty = True # We just printed a newline
-                
-                sys.stdout.write(event.data.reasoning)
-                sys.stdout.flush()
-                self.current_line_empty = event.data.reasoning.endswith('\n')
+    Runs an interactive command-line interface for a single agent.
 
-            # Stream content to stdout.
-            if event.data.content:
-                if not self.is_in_content_block:
-                    self._ensure_new_line() # Ensures content starts on a new line after </Thinking>
-                    self.is_in_content_block = True
-                sys.stdout.write(event.data.content)
-                sys.stdout.flush()
-                self.current_line_empty = event.data.content.endswith('\n')
-            
-            if self.show_token_usage and event.data.is_complete and event.data.usage:
-                self._ensure_new_line()
-                usage = event.data.usage
-                logger.info(
-                    f"[Token Usage: Prompt={usage.prompt_tokens}, "
-                    f"Completion={usage.completion_tokens}, Total={usage.total_tokens}]"
-                )
-
-        elif event.event_type == StreamEventType.ASSISTANT_COMPLETE_RESPONSE and isinstance(event.data, AssistantCompleteResponseData):
-            # The reasoning has already been streamed. Do not log it again.
-            
-            if not self.agent_has_spoken_this_turn:
-                # This case handles responses that might not have streamed any content chunks (e.g., only a tool call).
-                # We still need to ensure the agent's turn is visibly terminated with a newline.
-                self._ensure_new_line()
-                
-                # If there's final content that wasn't in a chunk, print it.
-                if event.data.content:
-                    sys.stdout.write(f"Agent: {event.data.content}\n")
-                    sys.stdout.flush()
-
-            if self.show_token_usage and event.data.usage:
-                self._ensure_new_line()
-                usage = event.data.usage
-                logger.info(
-                    f"[Token Usage: Prompt={usage.prompt_tokens}, "
-                    f"Completion={usage.completion_tokens}, Total={usage.total_tokens}]"
-                )
-
-            self.current_line_empty = True
-            self.reset_turn_state() # Reset for next turn
+    This function orchestrates the agent's lifecycle, user input, and event streaming
+    for an interactive session.
 
-        elif event.event_type == StreamEventType.TOOL_INVOCATION_APPROVAL_REQUESTED and isinstance(event.data, ToolInvocationApprovalRequestedData):
-            self.pending_approval_data = event.data
-            self._display_tool_approval_prompt()
-
-        elif event.event_type == StreamEventType.TOOL_INTERACTION_LOG_ENTRY and isinstance(event.data, ToolInteractionLogEntryData):
-            if self.show_tool_logs:
-                logger.info(f"[Tool Log: {event.data.log_entry}]")
-
-        elif event.event_type == StreamEventType.AGENT_OPERATIONAL_PHASE_TRANSITION and isinstance(event.data, AgentOperationalPhaseTransitionData):
-            if event.data.new_phase == AgentOperationalPhase.EXECUTING_TOOL:
-                tool_name = event.data.tool_name or "a tool"
-                sys.stdout.write(f"Agent: Waiting for tool '{tool_name}' to complete...\n")
-                sys.stdout.flush()
-                self.current_line_empty = True
-                self.agent_has_spoken_this_turn = True
-            elif event.data.new_phase == AgentOperationalPhase.BOOTSTRAPPING:
-                logger.info("[Agent is initializing...]")
-            else:
-                phase_msg = f"[Agent Status: {event.data.new_phase.value}"
-                if event.data.tool_name:
-                    phase_msg += f" ({event.data.tool_name})"
-                phase_msg += "]"
-                logger.info(phase_msg)
-
-        elif event.event_type == StreamEventType.ERROR_EVENT and isinstance(event.data, ErrorEventData):
-            logger.error(f"[Error: {event.data.message} (Source: {event.data.source})]")
-
-        elif event.event_type == StreamEventType.AGENT_IDLE:
-            logger.info("[Agent is now idle.]")
-        
-        else:
-            # Add logging for unhandled events for better debugging
-            logger.debug(f"CLI Manager: Unhandled StreamEvent type: {event.event_type.value}")
-
-
-async def run(agent: Agent, show_tool_logs: bool = True, show_token_usage: bool = False, initial_prompt: Optional[str] = None):
+    Args:
+        agent: The agent instance to run.
+        show_tool_logs: If True, displays detailed logs from tool interactions.
+        show_token_usage: If True, displays token usage information after each LLM call.
+        initial_prompt: An optional initial prompt to send to the agent automatically.
+    """
     if not isinstance(agent, Agent):
         raise TypeError(f"Expected an Agent instance, got {type(agent).__name__}")
 
     logger.info(f"Starting interactive CLI session for agent '{agent.agent_id}'.")
     agent_turn_complete_event = asyncio.Event()
-    cli_manager = InteractiveCLIManager(agent_turn_complete_event, show_tool_logs, show_token_usage)
+    cli_display = InteractiveCLIDisplay(agent_turn_complete_event, show_tool_logs, show_token_usage)
     streamer = AgentEventStream(agent)
 
     async def process_agent_events():
+        """Task to continuously process and display events from the agent."""
         try:
             async for event in streamer.all_events():
-                await cli_manager.handle_stream_event(event)
+                await cli_display.handle_stream_event(event)
         except asyncio.CancelledError:
             logger.info("CLI event processing task cancelled.")
         except Exception as e:
@@ -226,35 +55,29 @@ async def run(agent: Agent, show_tool_logs: bool = True, show_token_usage: bool
             await asyncio.wait_for(agent_turn_complete_event.wait(), timeout=30.0)
         except asyncio.TimeoutError:
             logger.error(f"Agent did not become idle within 30 seconds. Exiting.")
-            # Gracefully exit if agent fails to start
             return
 
         if initial_prompt:
             logger.info(f"Initial prompt provided: '{initial_prompt}'")
-            print(f"You: {initial_prompt}") # Mirroring user input is fine with print
+            print(f"You: {initial_prompt}")
             agent_turn_complete_event.clear()
-            cli_manager.reset_turn_state()
+            cli_display.reset_turn_state()
             await agent.post_user_message(AgentInputUserMessage(content=initial_prompt))
             await agent_turn_complete_event.wait()
         
+        # Main input loop
         while True:
             agent_turn_complete_event.clear()
 
-            if cli_manager.pending_approval_data:
-                logger.debug("Waiting for tool approval from user...")
+            if cli_display.pending_approval_data:
                 approval_input = await asyncio.get_event_loop().run_in_executor(None, sys.stdin.readline)
                 approval_input = approval_input.strip().lower()
                 
-                approval_data = cli_manager.pending_approval_data
-                cli_manager.pending_approval_data = None
+                approval_data = cli_display.pending_approval_data
+                cli_display.pending_approval_data = None
                 
                 is_approved = approval_input in ["y", "yes"]
                 reason = "User approved via CLI" if is_approved else "User denied via CLI"
-
-                if is_approved:
-                    logger.info(f"User approved tool invocation '{approval_data.invocation_id}'.")
-                else:
-                    logger.info(f"User denied tool invocation '{approval_data.invocation_id}'.")
                 
                 await agent.post_tool_execution_approval(approval_data.invocation_id, is_approved, reason)
 
@@ -265,35 +88,30 @@ async def run(agent: Agent, show_tool_logs: bool = True, show_token_usage: bool
                 user_input = user_input.rstrip('\n')
 
                 if user_input.lower().strip() in ["/quit", "/exit"]:
-                    logger.info("Exit command received.")
                     break
                 if not user_input.strip():
                     continue
 
-                logger.debug(f"User input received, posting to agent: '{user_input}'")
-                cli_manager.reset_turn_state()
+                cli_display.reset_turn_state()
                 await agent.post_user_message(AgentInputUserMessage(content=user_input))
 
             await agent_turn_complete_event.wait()
-            logger.debug("Agent turn complete, looping.")
 
     except (KeyboardInterrupt, EOFError):
-        logger.info("Exit signal received. Shutting down CLI.")
+        logger.info("Exit signal received.")
     except Exception as e:
         logger.error(f"An unexpected error occurred in the CLI main loop: {e}", exc_info=True)
     finally:
-        logger.info("Cleaning up and shutting down interactive session...")
+        logger.info("Shutting down interactive session...")
         if not event_task.done():
             event_task.cancel()
             try:
                 await event_task
             except asyncio.CancelledError:
-                pass # This is expected
+                pass
         
         if agent.is_running:
-            logger.info("Stopping agent...")
             await agent.stop()
         
-        logger.info("Closing event stream...")
         await streamer.close()
         logger.info("Interactive session finished.")