Update runner.py (#2)

Author: Spchdt

src/agent/runner.py

@@ -173,8 +173,8 @@ async def _run_agent_loop(
                 if not self._running:
                     break
 
-                frame = await self._process_event(event)
-                if frame:
+                frames = await self._process_event(event)
+                for frame in frames:
                     await self.ctx.outbound_queue.put(frame)
 
         except asyncio.CancelledError:
@@ -183,79 +183,71 @@ async def _run_agent_loop(
             logger.exception(f"Error in agent loop for {self.session_id}")
             raise
 
-    async def _process_event(self, event: Any) -> OutboundFrame | None:
-        """Process an ADK event and convert to OutboundFrame if applicable.
-
-        Args:
-            event: The ADK Event to process
+    async def _process_event(self, event: Any) -> list[OutboundFrame]:
+        """Process an ADK event and convert to OutboundFrame(s) if applicable."""
 
-        Returns:
-            OutboundFrame if the event should be sent to client, None otherwise
-        """
+        frames = []
         if event.interrupted:
-            return OutboundFrame(
+            frames.append(OutboundFrame(
                 type="INTERRUPTED",
                 payload={},
                 session_id=self.session_id,
-            )
+            ))
 
         if event.turn_complete:
-            return OutboundFrame(
+            frames.append(OutboundFrame(
                 type="TURN_COMPLETE",
                 payload={},
                 session_id=self.session_id,
-            )
+            ))
 
         if event.error_code:
             logger.error(f"Agent error: {event.error_code} - {event.error_message}")
-            return OutboundFrame(
+            frames.append(OutboundFrame(
                 type="ERROR",
                 payload={
                     "code": event.error_code,
                     "message": event.error_message,
                 },
                 session_id=self.session_id,
-            )
+            ))
 
         if event.content:
-            return await self._process_content(event.content)
-
-        return None
+            content_frames = await self._process_content(event.content)
+            frames.extend(content_frames)
 
-    async def _process_content(self, content: types.Content) -> OutboundFrame | None:
-        """Process Content from an event, extracting audio/text.
-
-        Args:
-            content: The Content to process
+        return frames
 
-        Returns:
-            OutboundFrame with audio or text data
-        """
+    async def _process_content(self, content: types.Content) -> list[OutboundFrame]:
+        """Process Content from an event, extracting audio/text."""
+        frames = []
         if not content.parts:
-            return None
+            return frames
 
         for part in content.parts:
             if part.inline_data:
-                return OutboundFrame(
+                frames.append(OutboundFrame(
                     type="AUDIO",
                     payload={
                         "data": part.inline_data.data,
                         "mime_type": part.inline_data.mime_type,
                     },
                     session_id=self.session_id,
-                )
+                ))
 
             if part.text:
-                return OutboundFrame(
+                frames.append(OutboundFrame(
                     type="TEXT",
                     payload={"text": part.text},
                     session_id=self.session_id,
-                )
+                ))
 
             if part.function_call:
-                return await self._handle_function_call(part.function_call)
+                frame = await self._handle_function_call(part.function_call)
+                if frame:
+                    frames.append(frame)
 
-        return None
+        return frames
 
     async def _handle_function_call(
         self, function_call: types.FunctionCall