fix: relay confirmation interrupts past muted input

backend/tests/test_brains.py

@@ -1541,9 +1541,6 @@ class WorkflowBrainTests(unittest.IsolatedAsyncioTestCase):
             ):
                 events.append("message_completed")
 
-        async def wait_for_output_stopped():
-            events.append("output_stopped")
-
         class OrderedCallEnd(FakeCallEnd):
             def __init__(self):
                 super().__init__()
@@ -1580,7 +1577,6 @@ class WorkflowBrainTests(unittest.IsolatedAsyncioTestCase):
             call_end=call_end,
             client_tools=client_tools,
             set_input_enabled=input_states.append,
-            wait_for_output_stopped=wait_for_output_stopped,
         )
         brain._message_stages.set_client_tools(client_tools)
 
@@ -1606,7 +1602,7 @@ class WorkflowBrainTests(unittest.IsolatedAsyncioTestCase):
         self.assertEqual(result.action, "confirmed")
         self.assertFalse(call_end.playback_completion.done())
         self.assertEqual(input_states, [False, True])
-        self.assertEqual(events[-2:], ["output_stopped", "message_completed"])
+        self.assertEqual(events[-1], "message_completed")
 
     async def test_speech_only_message_waits_for_transport_playback(self):
         brain = WorkflowBrain(

backend/tests/test_client_tools.py

@@ -138,7 +138,52 @@ class ClientToolExecutorTests(unittest.IsolatedAsyncioTestCase):
 
 
 class ClientToolBrokerTests(unittest.IsolatedAsyncioTestCase):
-    async def test_interrupts_before_resolving_configured_result(self):
+    async def test_uses_configured_downstream_interrupt_handler(self):
+        broker = ClientToolBroker()
+        outbound = []
+        interruptions = []
+
+        async def push_frame(frame, direction=FrameDirection.DOWNSTREAM):
+            outbound.append((frame, direction))
+
+        async def interrupt_after_muted_input():
+            interruptions.append("downstream")
+
+        broker.push_frame = push_frame
+        broker.set_interrupt_handler(interrupt_after_muted_input)
+        call = asyncio.create_task(
+            broker.call(
+                "show_message",
+                {},
+                timeout_seconds=1,
+                response_wait_mode="session",
+                interrupt_on_result=True,
+            )
+        )
+        await asyncio.sleep(0)
+        message = outbound[0][0].message
+
+        await broker.process_frame(
+            InputTransportMessageFrame(
+                message={
+                    "type": "client-tool-result",
+                    "tool_call_id": message["tool_call_id"],
+                    "status": "ok",
+                    "data": {"action": "confirmed"},
+                }
+            ),
+            FrameDirection.DOWNSTREAM,
+        )
+
+        self.assertEqual(interruptions, ["downstream"])
+        self.assertFalse(call.done())
+        broker.on_interruption_processed()
+        self.assertEqual(
+            await call,
+            {"status": "ok", "data": {"action": "confirmed"}},
+        )
+
+    async def test_resolves_configured_result_after_interruption_processed(self):
         broker = ClientToolBroker()
         outbound = []
         observed_future_states = []
@@ -178,6 +223,10 @@ class ClientToolBrokerTests(unittest.IsolatedAsyncioTestCase):
         )
 
         self.assertEqual(observed_future_states, [[False]])
+        self.assertFalse(call.done())
+
+        broker.on_interruption_processed()
+
         self.assertEqual(
             await call,
             {"status": "ok", "data": {"action": "confirmed"}},

backend/tests/test_pipeline_events.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import asyncio
 import unittest
 from types import SimpleNamespace
 from unittest.mock import AsyncMock, patch
@@ -11,7 +10,6 @@ from pipecat.frames.frames import (
     OutputTransportMessageUrgentFrame,
 )
 from services.pipecat.pipeline_events import bind_cascade_pipeline_events
-from services.pipecat.pipeline import _wait_for_output_stop
 
 
 class _EventSource:
@@ -82,25 +80,37 @@ class _Brain:
 
 
 class PipelineEventTest(unittest.IsolatedAsyncioTestCase):
-    async def test_interrupted_output_waits_for_transport_stop(self):
-        events = []
+    async def test_interruption_acknowledges_deferred_client_tool_result(self):
+        transport = _EventSource()
+        text_input = _EventSource()
+        user_aggregator = _EventSource()
+        assistant_aggregator = _EventSource()
+        worker = _Worker()
+        brain = _Brain(worker)
+        acknowledgements = []
+        client_tools = SimpleNamespace(
+            on_interruption_processed=lambda: acknowledgements.append(True)
+        )
 
-        async def wait_until_stopped():
-            events.append("stopped")
+        bind_cascade_pipeline_events(
+            transport=transport,
+            worker=worker,
+            brain=brain,
+            context=SimpleNamespace(),
+            text_input=text_input,
+            user_aggregator=user_aggregator,
+            assistant_aggregator=assistant_aggregator,
+            greeting="",
+            vision_enabled=False,
+            vision_state={"client_id": None},
+            client_tools=client_tools,
+        )
 
-        await _wait_for_output_stop(wait_until_stopped)
+        await assistant_aggregator.handlers["on_interruption_processed"](
+            assistant_aggregator
+        )
 
-        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,
-            )
+        self.assertEqual(acknowledgements, [True])
 
     async def test_greeting_keeps_playback_timestamp_until_client_ready(self):
         transport = _EventSource()