feat(voice): add controlled emotive ack layer

tests/test_ai_voice_media_runtime.py

@@ -30,8 +30,14 @@ class _StubASRProvider(ASRProvider):
 class _StubTTSProvider(TTSProvider):
     name = "stub-tts"
 
-    def synthesize(self, text: str, *, language: str | None = None) -> TTSSynthesis:
-        del language
+    def synthesize(
+        self,
+        text: str,
+        *,
+        language: str | None = None,
+        style_hints: dict[str, object] | None = None,
+    ) -> TTSSynthesis:
+        del language, style_hints
         assert text
         return TTSSynthesis(
             text=text,
@@ -276,8 +282,14 @@ def test_media_runtime_sends_keepalive_while_tts_is_slow():
     class _SlowTTSProvider(TTSProvider):
         name = "slow-stub-tts"
 
-        def synthesize(self, text: str, *, language: str | None = None) -> TTSSynthesis:
-            del language
+        def synthesize(
+            self,
+            text: str,
+            *,
+            language: str | None = None,
+            style_hints: dict[str, object] | None = None,
+        ) -> TTSSynthesis:
+            del language, style_hints
             assert text
             time.sleep(1.2)
             return TTSSynthesis(
@@ -501,8 +513,14 @@ def test_media_runtime_starts_handoff_before_handoff_tts_finishes():
             frame_bytes=320,
         )
 
-        async def _fake_speak_text(current_actor, text: str, *, is_greeting: bool) -> None:
-            del current_actor, text, is_greeting
+        async def _fake_speak_text(
+            current_actor,
+            text: str,
+            *,
+            is_greeting: bool,
+            style_hints: dict[str, object] | None = None,
+        ) -> None:
+            del current_actor, text, is_greeting, style_hints
             events.append("speak_start")
             await asyncio.sleep(0)
             assert handoff_started.wait(timeout=0.5)
@@ -671,8 +689,14 @@ def test_media_runtime_voice_v2_uses_partial_asr_to_start_ack_before_full_asr():
         handle_media_error=lambda session_id, message, metadata: None,
     )
 
-    async def _fake_speak_text(current_actor, text: str, *, is_greeting: bool) -> None:
-        del current_actor, is_greeting
+    async def _fake_speak_text(
+        current_actor,
+        text: str,
+        *,
+        is_greeting: bool,
+        style_hints: dict[str, object] | None = None,
+    ) -> None:
+        del current_actor, is_greeting, style_hints
         speak_events.append((text, time.monotonic()))
         await asyncio.sleep(0)
 
@@ -776,8 +800,14 @@ def test_media_runtime_voice_v2_emits_generic_ack_before_full_asr_without_partia
         handle_media_error=lambda session_id, message, metadata: None,
     )
 
-    async def _fake_speak_text(current_actor, text: str, *, is_greeting: bool) -> None:
-        del current_actor, is_greeting
+    async def _fake_speak_text(
+        current_actor,
+        text: str,
+        *,
+        is_greeting: bool,
+        style_hints: dict[str, object] | None = None,
+    ) -> None:
+        del current_actor, is_greeting, style_hints
         speak_events.append((text, time.monotonic()))
         await asyncio.sleep(0)
 
@@ -814,3 +844,187 @@ def test_media_runtime_voice_v2_emits_generic_ack_before_full_asr_without_partia
     assert speak_events
     assert speak_events[0][0] == runtime._ack_text("ru", "generic")
     assert speak_events[0][1] < timings["full_finished"]
+
+
+def test_media_runtime_voice_v2_emotive_ack_uses_ru_variants_and_style_hints_only_for_ack():
+    synth_calls: list[tuple[str, dict[str, object] | None]] = []
+
+    class _RecordingTTSProvider(TTSProvider):
+        name = "recording-tts"
+
+        def synthesize(
+            self,
+            text: str,
+            *,
+            language: str | None = None,
+            style_hints: dict[str, object] | None = None,
+        ) -> TTSSynthesis:
+            del language
+            synth_calls.append((text, style_hints))
+            return TTSSynthesis(text=text, audio_bytes=(b"\x10\x00" * 960), sample_rate_hz=24000)
+
+    class _ScheduleASRProvider(ASRProvider):
+        name = "schedule-asr"
+
+        def transcribe(self, audio_bytes: bytes, *, language_hint: str | None = None) -> ASRTranscription:
+            del audio_bytes
+            return ASRTranscription(text="Хочу узнать график работы", language=language_hint or "ru", confidence=0.9)
+
+    runtime = AudioSocketMediaRuntime(
+        enabled=True,
+        host="127.0.0.1",
+        port=0,
+        frame_ms=20,
+        idle_timeout_seconds=2.0,
+        registration_wait_timeout_seconds=0.5,
+        min_speech_ms=40,
+        trailing_silence_ms=40,
+        max_turn_ms=400,
+        asr_provider=_ScheduleASRProvider(),
+        tts_provider=_RecordingTTSProvider(),
+        load_registration_by_media_uuid=lambda value: None,
+        mark_media_connected=lambda session_id, value: None,
+        mark_media_ended=lambda session_id, reason: None,
+        touch_media_frame=lambda session_id: None,
+        set_state=lambda session_id, state, handoff_reason, metadata: None,
+        get_pending_greeting=lambda session_id: None,
+        mark_reply_delivered=lambda session_id, text, is_greeting: None,
+        plan_reply=lambda session_id, text, metadata, kind: None,
+        process_turn=lambda session_id, transcript_text, language, barge_in, metadata: (
+            time.sleep(0.25)
+            or VoiceAITurnDecisionOut(
+                language=language or "ru",
+                intent="clarification",
+                reply_text="Подскажите, пожалуйста, какой город вас интересует?",
+                confidence=0.9,
+                needs_handoff=False,
+                handoff_reason=None,
+                case_action="keep_open",
+                kb_refs=[],
+                summary_text="reply ready",
+                model="stub-voice",
+                latency_ms=1,
+                status="active",
+                metadata={"early_intent": "schedule", "ack_kind": "understanding"},
+            )
+        ),
+        request_handoff=lambda session_id, customer_request_text, decision: None,
+        handle_media_error=lambda session_id, message, metadata: None,
+    )
+
+    async def _fake_write_audio_packet(current_actor, pcm_frame: bytes) -> None:
+        del current_actor, pcm_frame
+
+    runtime._write_audio_packet = _fake_write_audio_packet  # type: ignore[method-assign]
+
+    async def _scenario() -> None:
+        actor = MediaActor(
+            registration=MediaRegistration(
+                voice_session_id="avs_media_runtime_v2_emotive_ack",
+                call_id="call_media_runtime_v2_emotive_ack",
+                interaction_id="int_media_runtime_v2_emotive_ack",
+                ai_session_id="ais_media_runtime_v2_emotive_ack",
+                language="ru",
+                media_uuid=str(uuid.uuid4()),
+                queue_code="voice_lab_ai",
+                queue_id="que_voice_lab_ai",
+                agent_profile="voice_support",
+                voice_v2_enabled=True,
+                voice_v2_ack_mode="immediate_short",
+                voice_v2_streaming_tts=False,
+                voice_v2_partial_asr=False,
+                voice_v2_emotive_ack=True,
+                voice_v2_emotive_ack_ru_only=True,
+            ),
+            reader=asyncio.StreamReader(),
+            writer=None,  # type: ignore[arg-type]
+            vad=EnergyVAD(frame_ms=20, min_speech_ms=40, trailing_silence_ms=40, max_turn_ms=400),
+            frame_ms=20,
+            frame_bytes=320,
+        )
+        pcm_frame = (1000).to_bytes(2, "little", signed=True) * 160
+        await runtime._process_utterance(actor, pcm_frame, False)
+
+    asyncio.run(_scenario())
+
+    assert len(synth_calls) == 2
+    assert synth_calls[0][0] in runtime._base_ack_variants("ru", "understanding")
+    assert synth_calls[0][1] == {"role": "good"}
+    assert synth_calls[1][0] == "Подскажите, пожалуйста, какой город вас интересует?"
+    assert synth_calls[1][1] is None
+
+
+def test_media_runtime_voice_v2_emotive_ack_avoids_same_variant_back_to_back():
+    async def _scenario() -> tuple[str, str, AudioSocketMediaRuntime]:
+        runtime = AudioSocketMediaRuntime(
+            enabled=True,
+            host="127.0.0.1",
+            port=0,
+            frame_ms=20,
+            idle_timeout_seconds=2.0,
+            registration_wait_timeout_seconds=0.5,
+            min_speech_ms=40,
+            trailing_silence_ms=40,
+            max_turn_ms=400,
+            asr_provider=_StubASRProvider(),
+            tts_provider=_StubTTSProvider(),
+            load_registration_by_media_uuid=lambda value: None,
+            mark_media_connected=lambda session_id, value: None,
+            mark_media_ended=lambda session_id, reason: None,
+            touch_media_frame=lambda session_id: None,
+            set_state=lambda session_id, state, handoff_reason, metadata: None,
+            get_pending_greeting=lambda session_id: None,
+            mark_reply_delivered=lambda session_id, text, is_greeting: None,
+            plan_reply=lambda session_id, text, metadata, kind: None,
+            process_turn=lambda session_id, transcript_text, language, barge_in, metadata: VoiceAITurnDecisionOut(
+                language=language or "ru",
+                intent="clarification",
+                reply_text="reply",
+                confidence=0.9,
+                needs_handoff=False,
+                handoff_reason=None,
+                case_action="keep_open",
+                kb_refs=[],
+                summary_text="reply ready",
+                model="stub-voice",
+                latency_ms=1,
+                status="active",
+            ),
+            request_handoff=lambda session_id, customer_request_text, decision: None,
+            handle_media_error=lambda session_id, message, metadata: None,
+        )
+
+        actor = MediaActor(
+            registration=MediaRegistration(
+                voice_session_id="avs_media_runtime_v2_repeat_guard",
+                call_id="call_media_runtime_v2_repeat_guard",
+                interaction_id="int_media_runtime_v2_repeat_guard",
+                ai_session_id="ais_media_runtime_v2_repeat_guard",
+                language="ru",
+                media_uuid=str(uuid.uuid4()),
+                queue_code="voice_lab_ai",
+                queue_id="que_voice_lab_ai",
+                agent_profile="voice_support",
+                voice_v2_enabled=True,
+                voice_v2_ack_mode="immediate_short",
+                voice_v2_emotive_ack=True,
+                voice_v2_emotive_ack_ru_only=True,
+            ),
+            reader=asyncio.StreamReader(),
+            writer=None,  # type: ignore[arg-type]
+            vad=EnergyVAD(frame_ms=20, min_speech_ms=40, trailing_silence_ms=40, max_turn_ms=400),
+            frame_ms=20,
+            frame_bytes=320,
+        )
+        actor.response_plan_id = "rsp_same_seed"
+
+        first_text, _, _ = runtime._select_ack_payload(actor, language="ru", ack_kind="understanding")
+        actor.response_plan_id = "rsp_same_seed"
+        second_text, _, _ = runtime._select_ack_payload(actor, language="ru", ack_kind="understanding")
+        return first_text, second_text, runtime
+
+    first_text, second_text, runtime = asyncio.run(_scenario())
+
+    assert first_text in runtime._base_ack_variants("ru", "understanding")
+    assert second_text in runtime._base_ack_variants("ru", "understanding")
+    assert first_text != second_text

tests/test_ai_voice_tts_provider.py

@@ -138,6 +138,40 @@ def test_yandex_tts_provider_posts_lpcm_with_api_key(tmp_path, monkeypatch):
     assert list(Path(tmp_path).rglob("*.json"))
 
 
+def test_yandex_tts_provider_prefers_per_utterance_role_hint_over_global_role(tmp_path, monkeypatch):
+    calls: list[dict] = []
+    encoded_audio = base64.b64encode(b"\x12\x00\x34\x00").decode("ascii")
+
+    class _DummyClient:
+        def __init__(self, *, timeout: float) -> None:
+            self.timeout = timeout
+
+        def __enter__(self) -> _DummyClient:
+            return self
+
+        def __exit__(self, exc_type, exc, tb) -> None:
+            return None
+
+        def post(self, url: str, *, headers: dict[str, str], json: dict) -> _DummyResponse:
+            calls.append({"url": url, "headers": headers, "json": json, "timeout": self.timeout})
+            return _DummyResponse(json_payload={"result": {"audioChunk": {"data": encoded_audio}}})
+
+    monkeypatch.setenv("AI_VOICE_TTS_YANDEX_API_KEY", "yandex-test-key")
+    monkeypatch.setenv("AI_VOICE_TTS_YANDEX_API_BASE", "https://tts.example.test")
+    monkeypatch.setenv("AI_VOICE_TTS_YANDEX_VOICE", "jane")
+    monkeypatch.setenv("AI_VOICE_TTS_YANDEX_ROLE", "neutral")
+    monkeypatch.setenv("AI_VOICE_TTS_CACHE_ENABLED", "0")
+    monkeypatch.setattr(tts_module.httpx, "Client", _DummyClient)
+
+    provider = tts_module.YandexTTSProvider()
+    synthesis = provider.synthesize("Эмоциональный быстрый отклик", language="ru", style_hints={"role": "good"})
+
+    assert synthesis.audio_bytes == b"\x12\x00\x34\x00"
+    assert len(calls) == 1
+    assert calls[0]["json"]["hints"][0]["voice"] == "jane"
+    assert calls[0]["json"]["hints"][2]["role"] == "good"
+
+
 def test_yandex_tts_provider_uses_iam_token_with_folder_id(tmp_path, monkeypatch):
     calls: list[dict] = []
     encoded_audio = base64.b64encode(b"\x30\x00\x40\x00").decode("ascii")