Update method names imports for io.py and audio.py and their dependencies

Author: mehtarac

src/strands/experimental/bidirectional_streaming/__init__.py

@@ -3,6 +3,9 @@
 # Main components - Primary user interface
 from .agent.agent import BidirectionalAgent
 
+# IO channels - Hardware abstraction
+from .io.audio import AudioIO
+
 # Model interface (for custom implementations)
 from .models.bidirectional_model import BidirectionalModel
 
@@ -27,7 +30,8 @@
 __all__ = [
     # Main interface
     "BidirectionalAgent",
-    
+    # IO channels
+    "AudioIO",
     # Model providers
     "GeminiLiveModel",
     "NovaSonicModel",
@@ -43,7 +47,6 @@
     "BidirectionalStreamEvent",
     "VoiceActivityEvent",
     "UsageMetricsEvent",
-    
     # Model interface
     "BidirectionalModel",
 ]

src/strands/experimental/bidirectional_streaming/agent/agent.py

@@ -350,7 +350,7 @@ async def __aexit__(self, exc_type, exc_val, exc_tb) -> None:
             for adapter in self._current_adapters:
                 if hasattr(adapter, "cleanup"):
                     try:
-                        adapter.cleanup()
+                        adapter.end()
                         logger.debug(f"Cleaned up adapter: {type(adapter).__name__}")
                     except Exception as adapter_error:
                         logger.warning(f"Error cleaning up adapter: {adapter_error}")
@@ -386,7 +386,7 @@ async def run(self, io_channels: list[BidiIO | tuple[Callable, Callable]]) -> No
 
         Args:
             io_channels: List containing either BidiIO instances or (sender, receiver) tuples.
-                - BidiIO: IO channel instance with input_channel(), output_channel(), and cleanup() methods
+                - BidiIO: IO channel instance with send(), receive(), and end() methods
                 - tuple: (sender_callable, receiver_callable) for custom transport
                 
         Example:
@@ -410,7 +410,7 @@ async def run(self, io_channels: list[BidiIO | tuple[Callable, Callable]]) -> No
         transport = io_channels[0]
 
         # Set IO channel tracking for cleanup
-        if hasattr(transport, 'input_channel') and hasattr(transport, 'output_channel'):
+        if hasattr(transport, 'send') and hasattr(transport, 'receive'):
             self._current_adapters = [transport]  # IO channel needs cleanup
         elif isinstance(transport, tuple) and len(transport) == 2:
             self._current_adapters = []  # Tuple needs no cleanup
@@ -433,16 +433,16 @@ async def _run_with_transport(
         async def receive_from_agent():
             """Receive events from agent and send to transport."""
             async for event in self.receive():
-                if hasattr(transport, 'output_channel'):
-                    await transport.output_channel(event)
+                if hasattr(transport, 'receive'):
+                    await transport.receive(event)
                 else:
                     await transport[0](event)
 
         async def send_to_agent():
             """Receive events from transport and send to agent."""
             while self.active:
-                if hasattr(transport, 'input_channel'):
-                    event = await transport.input_channel()
+                if hasattr(transport, 'send'):
+                    event = await transport.send()
                 else:
                     event = await transport[1]()
                 await self.send(event)

src/strands/experimental/bidirectional_streaming/io/audio.py

@@ -66,7 +66,7 @@ def __init__(
         self.output_stream = None
         self.interrupted = False
 
-    def _setup_audio(self) -> None:
+    def start(self) -> None:
         """Setup PyAudio streams for input and output."""
         if self.audio:
             return
@@ -103,33 +103,10 @@ def _setup_audio(self) -> None:
             self._cleanup_audio()
             raise
 
-    def _cleanup_audio(self) -> None:
-        """Clean up PyAudio resources."""
-        try:
-            if self.input_stream:
-                if self.input_stream.is_active():
-                    self.input_stream.stop_stream()
-                self.input_stream.close()
-
-            if self.output_stream:
-                if self.output_stream.is_active():
-                    self.output_stream.stop_stream()
-                self.output_stream.close()
-
-            if self.audio:
-                self.audio.terminate()
-
-            self.input_stream = None
-            self.output_stream = None
-            self.audio = None
-
-        except Exception as e:
-            logger.warning(f"Audio cleanup error: {e}")
-
-    async def input_channel(self) -> dict:
+    async def send(self) -> dict:
         """Read audio from microphone."""
         if not self.input_stream:
-            self._setup_audio()
+            self.start()
 
         try:
             audio_bytes = self.input_stream.read(self.chunk_size, exception_on_overflow=False)
@@ -148,10 +125,10 @@ async def input_channel(self) -> dict:
                 "channels": self.input_channels,
             }
 
-    async def output_channel(self, event: dict) -> None:
+    async def receive(self, event: dict) -> None:
         """Handle audio events with direct stream writing."""
         if not self.output_stream:
-            self._setup_audio()
+            self.start()
 
         # Handle audio output
         if "audioOutput" in event and not self.interrupted:
@@ -199,6 +176,25 @@ async def output_channel(self, event: dict) -> None:
                 elif role.upper() == "USER":
                     print(f"User: {text}")
 
-    def cleanup(self) -> None:
+    def end(self) -> None:
         """Clean up IO channel resources."""
-        self._cleanup_audio()
+        try:
+            if self.input_stream:
+                if self.input_stream.is_active():
+                    self.input_stream.stop_stream()
+                self.input_stream.close()
+
+            if self.output_stream:
+                if self.output_stream.is_active():
+                    self.output_stream.stop_stream()
+                self.output_stream.close()
+
+            if self.audio:
+                self.audio.terminate()
+
+            self.input_stream = None
+            self.output_stream = None
+            self.audio = None
+
+        except Exception as e:
+            logger.warning(f"Audio cleanup error: {e}")

src/strands/experimental/bidirectional_streaming/types/__init__.py

@@ -1,7 +1,6 @@
 """Type definitions for bidirectional streaming."""
 
-from .audio_io import AudioIO
-from .bidirectional_io import BidirectionalIO
+from .io import BidiIO
 from .bidirectional_streaming import (
     DEFAULT_CHANNELS,
     DEFAULT_SAMPLE_RATE,
@@ -22,8 +21,7 @@
 )
 
 __all__ = [
-    "AudioIO",
-    "BidirectionalIO",
+    "BidiIO",
     "AudioInputEvent",
     "AudioOutputEvent",
     "BidirectionalConnectionEndEvent",

src/strands/experimental/bidirectional_streaming/types/io.py

@@ -16,23 +16,28 @@ class BidiIO(Protocol):
     WebSocket, etc.) while the agent handles model communication and logic.
     """
 
-    async def input_channel(self) -> dict:
+    async def start(self) -> dict:
+
+        """Setup IO channels for input and output."""
+        ...
+
+    async def send(self) -> dict:
         """Read input data from the IO channel source.
         
         Returns:
             dict: Input event data to send to the model.
         """
         ...
 
-    async def output_channel(self, event: dict) -> None:
+    async def receive(self, event: dict) -> None:
         """Process output event from the model through the IO channel.
         
         Args:
             event: Output event from the model to handle.
         """
         ...
 
-    def cleanup(self) -> None:
+    def end(self) -> None:
         """Clean up IO channel resources.
         
         Called by the agent during shutdown to ensure proper