Fix voice STT task cleanup to properly await cancelled tasks

Problem:
The _cleanup_tasks() method in OpenAISTTTranscriptionSession was only calling
task.cancel() on pending tasks (listener, process_events, stream_audio, connection)
but not awaiting them. This could lead to:
1. Unhandled task exception warnings
2. Potential resource leaks (websocket connections, file descriptors)
3. Improper cleanup of background tasks

Evidence:
- Similar to recently fixed guardrail tasks cleanup (PR openai#1976)
- Similar to fixed websocket task cleanup (PR openai#1955)
- asyncio best practices require awaiting cancelled tasks

Solution:
1. Made _cleanup_tasks() async
2. Collect all real asyncio.Task objects that need to be awaited
3. Added await asyncio.gather() with return_exceptions=True to properly
   collect exceptions from cancelled tasks
4. Updated close() method to await _cleanup_tasks()

Testing:
- All existing voice/STT tests pass (17 passed)
- Uses isinstance check to support mock objects in tests
- Follows the same pattern as PR openai#1976 and PR openai#1955

Author: gn00295120

src/agents/voice/models/openai_stt.py

@@ -321,18 +321,37 @@ def _check_errors(self) -> None:
             if exc and isinstance(exc, Exception):
                 self._stored_exception = exc
 
-    def _cleanup_tasks(self) -> None:
+    async def _cleanup_tasks(self) -> None:
+        """Cancel all pending tasks and wait for them to complete.
+
+        This ensures that any exceptions raised by the tasks are properly handled
+        and prevents warnings about unhandled task exceptions.
+        """
+        tasks = []
+
         if self._listener_task and not self._listener_task.done():
             self._listener_task.cancel()
+            if isinstance(self._listener_task, asyncio.Task):
+                tasks.append(self._listener_task)
 
         if self._process_events_task and not self._process_events_task.done():
             self._process_events_task.cancel()
+            if isinstance(self._process_events_task, asyncio.Task):
+                tasks.append(self._process_events_task)
 
         if self._stream_audio_task and not self._stream_audio_task.done():
             self._stream_audio_task.cancel()
+            if isinstance(self._stream_audio_task, asyncio.Task):
+                tasks.append(self._stream_audio_task)
 
         if self._connection_task and not self._connection_task.done():
             self._connection_task.cancel()
+            if isinstance(self._connection_task, asyncio.Task):
+                tasks.append(self._connection_task)
+
+        # Wait for all cancelled tasks to complete and collect exceptions
+        if tasks:
+            await asyncio.gather(*tasks, return_exceptions=True)
 
     async def transcribe_turns(self) -> AsyncIterator[str]:
         self._connection_task = asyncio.create_task(self._process_websocket_connection())
@@ -367,7 +386,7 @@ async def close(self) -> None:
         if self._websocket:
             await self._websocket.close()
 
-        self._cleanup_tasks()
+        await self._cleanup_tasks()
 
 
 class OpenAISTTModel(STTModel):