Try to fix confirm and interrupt

backend/tests/test_pipeline_events.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import asyncio
 import unittest
 from types import SimpleNamespace
 from unittest.mock import AsyncMock, patch
@@ -10,7 +11,7 @@ from pipecat.frames.frames import (
     OutputTransportMessageUrgentFrame,
 )
 from services.pipecat.pipeline_events import bind_cascade_pipeline_events
-from services.pipecat.pipeline import _wait_for_interrupted_output
+from services.pipecat.pipeline import _wait_for_output_stop
 
 
 class _EventSource:
@@ -81,31 +82,25 @@ class _Brain:
 
 
 class PipelineEventTest(unittest.IsolatedAsyncioTestCase):
-    async def test_interrupted_output_waits_for_flush_and_stop(self):
+    async def test_interrupted_output_waits_for_transport_stop(self):
         events = []
 
         async def wait_until_stopped():
             events.append("stopped")
 
-        worker = SimpleNamespace(
-            flush_pipeline=AsyncMock(
-                side_effect=lambda **_kwargs: events.append("flush") or True
+        await _wait_for_output_stop(wait_until_stopped)
+
+        self.assertEqual(events, ["stopped"])
+
+    async def test_interrupted_output_rejects_stop_timeout(self):
+        async def wait_forever():
+            await asyncio.Event().wait()
+
+        with self.assertRaisesRegex(RuntimeError, "语音停止超时"):
+            await _wait_for_output_stop(
+                wait_forever,
+                timeout_seconds=0.001,
             )
-        )
-
-        await _wait_for_interrupted_output(
-            worker,
-            wait_until_stopped=wait_until_stopped,
-        )
-
-        self.assertEqual(events, ["flush", "stopped"])
-        worker.flush_pipeline.assert_awaited_once_with(timeout=2.0)
-
-    async def test_interrupted_output_rejects_flush_timeout(self):
-        worker = SimpleNamespace(flush_pipeline=AsyncMock(return_value=False))
-
-        with self.assertRaisesRegex(RuntimeError, "中断帧"):
-            await _wait_for_interrupted_output(worker)
 
     async def test_greeting_keeps_playback_timestamp_until_client_ready(self):
         transport = _EventSource()

backend/tests/test_service_factory.py

@@ -0,0 +1,59 @@
+from __future__ import annotations
+
+import unittest
+from unittest.mock import patch
+
+from models import AssistantConfig
+from services.pipecat.service_factory import (
+    HTTP_TTS_STOP_FRAME_TIMEOUT_S,
+    WEBSOCKET_TTS_STOP_FRAME_TIMEOUT_S,
+    create_tts,
+)
+
+
+class TTSServiceFactoryTest(unittest.TestCase):
+    def test_http_tts_keeps_wider_audio_chunk_timeout(self):
+        config = AssistantConfig(
+            tts_interface_type="openai-tts",
+            tts_model="test-model",
+            voice="test-voice",
+            tts_api_key="test-key",
+            tts_base_url="https://tts.example.test/v1",
+        )
+
+        with patch(
+            "services.pipecat.service_factory.OpenAITTSService"
+        ) as service_type:
+            create_tts(config)
+
+        self.assertEqual(HTTP_TTS_STOP_FRAME_TIMEOUT_S, 3.0)
+        self.assertEqual(
+            service_type.call_args.kwargs["stop_frame_timeout_s"],
+            HTTP_TTS_STOP_FRAME_TIMEOUT_S,
+        )
+
+    def test_websocket_tts_keeps_short_completion_fallback(self):
+        config = AssistantConfig(
+            tts_interface_type="xfyun-tts",
+            voice="test-voice",
+            tts_secrets={
+                "appId": "test-app",
+                "apiKey": "test-key",
+                "apiSecret": "test-secret",
+            },
+        )
+
+        with patch(
+            "services.pipecat.service_factory.XfyunTTSService"
+        ) as service_type:
+            create_tts(config)
+
+        self.assertEqual(WEBSOCKET_TTS_STOP_FRAME_TIMEOUT_S, 1.0)
+        self.assertEqual(
+            service_type.call_args.kwargs["stop_frame_timeout_s"],
+            WEBSOCKET_TTS_STOP_FRAME_TIMEOUT_S,
+        )
+
+
+if __name__ == "__main__":
+    unittest.main()