roomkit 0.76.0__tar.gz → 0.78.0__tar.gz

{roomkit-0.76.0 → roomkit-0.78.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: roomkit
-Version: 0.76.0
+Version: 0.78.0
 Summary: Pure async Python library for multi-channel conversations
 Project-URL: Homepage, https://roomkit.live
 Project-URL: Documentation, https://www.roomkit.live/docs/

roomkit-0.78.0/src/roomkit/_version.py

@@ -0,0 +1 @@
+__version__ = "0.78.0"

{roomkit-0.76.0 → roomkit-0.78.0}/src/roomkit/channels/_realtime_audio.py

@@ -12,7 +12,7 @@ from typing import TYPE_CHECKING, Any, Protocol, runtime_checkable
 from roomkit.models.enums import Access, HookTrigger
 from roomkit.voice.audio_frame import AudioFrame
 from roomkit.voice.base import VoiceSessionState
-from roomkit.voice.utils import rms_db
+from roomkit.voice.utils import pcm16_has_activity, rms_db
 
 if TYPE_CHECKING:
     from roomkit.core.framework import RoomKit
@@ -167,6 +167,7 @@ class RealtimeAudioMixin:
     _playback_position_ms: dict[str, float]
     _playback_buffer: dict[str, tuple[float, float]]
 
+    _note_provider_output: Any
     _track_task: Any  # see RealtimeAudioHost — cross-mixin
     _pipeline_submit_inbound: Any  # see VoicePipelineMixin — cross-mixin
     _flush_and_signal_end: Any  # see RealtimeResponseMixin — cross-mixin
@@ -788,6 +789,8 @@ class RealtimeAudioMixin:
         Each item captures the current generation counter so that chunks
         enqueued before an interrupt are silently discarded.
         """
+        if self._provider.full_duplex and pcm16_has_activity(audio):
+            self._note_provider_output(session.id)
         with self._state_lock:
             if session.id not in self._sessions:
                 return

{roomkit-0.76.0 → roomkit-0.78.0}/src/roomkit/channels/_realtime_delegation.py

@@ -82,6 +82,8 @@ class RealtimeDelegationHost(Protocol):
 
     def _update_idle_event(self, session_id: str) -> None: ...
 
+    def _expect_provider_output(self, session_id: str) -> None: ...
+
 
 class RealtimeDelegationMixin:
     """Reasoning-delegation handling for :class:`RealtimeVoiceChannel`.
@@ -104,6 +106,7 @@ class RealtimeDelegationMixin:
 
     _track_task: Any  # see RealtimeDelegationHost — cross-mixin
     _rt_span_ctx: Any  # see RealtimeDelegationHost — cross-mixin
+    _expect_provider_output: Any
     _update_idle_event: Any  # see RealtimeDelegationHost — cross-mixin
     _telemetry_provider: Any  # see RealtimeDelegationHost — cross-mixin
     _authorize_realtime_tool: Any  # see RealtimeToolsMixin
@@ -275,6 +278,8 @@ class RealtimeDelegationMixin:
                 if not text:
                     continue
                 answered = True
+                if output.spoken:
+                    self._expect_provider_output(session.id)
                 await self._provider.submit_delegation_output(
                     session, delegation_id, text, spoken=output.spoken
                 )
@@ -308,6 +313,7 @@ class RealtimeDelegationMixin:
         if session.state == VoiceSessionState.ENDED:
             return
         try:
+            self._expect_provider_output(session.id)
             await self._provider.submit_delegation_output(
                 session, delegation_id, text, spoken=True
             )

{roomkit-0.76.0 → roomkit-0.78.0}/src/roomkit/channels/_realtime_tools.py

@@ -103,6 +103,8 @@ class RealtimeToolsHost(Protocol):
 
     def _update_idle_event(self, session_id: str) -> None: ...
 
+    def _expect_provider_output(self, session_id: str) -> None: ...
+
 
 class RealtimeToolsMixin:
     """Tool call execution for RealtimeVoiceChannel.
@@ -134,6 +136,7 @@ class RealtimeToolsMixin:
     _telemetry_provider: Any
 
     _track_task: Any  # see RealtimeToolsHost — cross-mixin
+    _expect_provider_output: Any
     _update_idle_event: Any
     _compose_session_prompt: Any
     _compose_session_tools: Any
@@ -503,12 +506,7 @@ class RealtimeToolsMixin:
         """Confirm delivery only while the session remains live."""
         if session.state == VoiceSessionState.ENDED:
             return False
-        self._awaiting_tool_response.add(session.id)
-        # A provider may end the function-call response while its handler
-        # runs. Submission starts the wait for the next provider response;
-        # that earlier boundary cannot make the acknowledgement idle.
-        self._provider_idle[session.id] = False
-        self._update_idle_event(session.id)
+        self._expect_provider_output(session.id)
         await self._provider.submit_tool_result(session, call_id, result)
         return session.state != VoiceSessionState.ENDED
 

{roomkit-0.76.0 → roomkit-0.78.0}/src/roomkit/channels/_realtime_transcription.py

@@ -10,6 +10,7 @@ from typing import TYPE_CHECKING, Any, Protocol, runtime_checkable
 from roomkit.core.exceptions import ChannelNotFoundError
 from roomkit.models.enums import HookTrigger
 from roomkit.models.event import TextContent
+from roomkit.voice.realtime.provider import RealtimeVoiceProvider
 
 if TYPE_CHECKING:
     from roomkit.core.framework import RoomKit
@@ -38,6 +39,7 @@ class RealtimeTranscriptionHost(Protocol):
         _rt_span_ctx: Get the telemetry span context for a session.
     """
 
+    _provider: RealtimeVoiceProvider
     _state_lock: threading.Lock
     _session_rooms: dict[str, str]
     _barge_in_active: set[str]
@@ -62,6 +64,7 @@ class RealtimeTranscriptionMixin:
     Host contract: :class:`RealtimeTranscriptionHost`.
     """
 
+    _provider: RealtimeVoiceProvider
     _state_lock: threading.Lock
     _session_rooms: dict[str, str]
     _barge_in_active: set[str]
@@ -73,6 +76,7 @@ class RealtimeTranscriptionMixin:
     channel_id: str
     provider_name: str | None
 
+    _note_provider_output: Any
     _track_task: Any  # see RealtimeTranscriptionHost — cross-mixin
     _send_client_message: Any  # see RealtimeTranscriptionHost — cross-mixin
     _rt_span_ctx: Any  # see RealtimeTranscriptionHost — cross-mixin
@@ -81,6 +85,8 @@ class RealtimeTranscriptionMixin:
         self, session: VoiceSession, text: str, role: str, is_final: bool
     ) -> Any:
         """Handle transcription from provider."""
+        if self._provider.full_duplex and role == "assistant" and text and not is_final:
+            self._note_provider_output(session.id)
         try:
             loop = asyncio.get_running_loop()
         except RuntimeError:

{roomkit-0.76.0 → roomkit-0.78.0}/src/roomkit/channels/realtime_voice.py

@@ -5,16 +5,18 @@ from __future__ import annotations
 import asyncio
 import contextlib
 import contextvars
+import inspect
 import logging
 import threading
+import time
 from collections.abc import Awaitable, Callable
 from concurrent.futures import ThreadPoolExecutor
 from copy import deepcopy
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, Any
 from uuid import uuid4
 
-from roomkit.channels._realtime_audio import RealtimeAudioMixin
+from roomkit.channels._realtime_audio import _MAX_QUEUED_AUDIO_CHUNKS, RealtimeAudioMixin
 from roomkit.channels._realtime_context import (
     _current_voice_session as _current_voice_session,
 )
@@ -80,6 +82,15 @@ class _ConnectingSession:
 
     task: asyncio.Task[VoiceSession]
     disconnected: bool = False
+    deferred: bool = False
+    callbacks: list[tuple[Callable[..., Any], tuple[Any, ...]]] = field(default_factory=list)
+    audio_bytes: int = 0
+    failure: Exception | None = None
+
+    def fail(self, error: Exception) -> None:
+        self.failure = error
+        if not self.task.done() and not self.task.cancelling():
+            self.task.cancel()
 
 
 class RealtimeVoiceChannel(
@@ -511,16 +522,16 @@ class RealtimeVoiceChannel(
         self._turn_spans: dict[str, str] = {}
 
         # Wire internal callbacks
-        provider.on_audio(self._on_provider_audio)
-        provider.on_transcription(self._on_provider_transcription)
-        provider.on_transcription(self._on_transcript_fragment)
-        provider.on_speech_start(self._on_provider_speech_start)
-        provider.on_speech_end(self._on_provider_speech_end)
-        provider.on_tool_call(self._on_provider_tool_call)
-        provider.on_delegation(self._on_provider_delegation)
-        provider.on_response_start(self._on_provider_response_start)
-        provider.on_response_end(self._on_provider_response_end)
-        provider.on_error(self._on_provider_error)
+        provider.on_audio(self._gate_provider_callback(self._on_provider_audio))
+        provider.on_transcription(self._gate_provider_callback(self._on_provider_transcription))
+        provider.on_transcription(self._gate_provider_callback(self._on_transcript_fragment))
+        provider.on_speech_start(self._gate_provider_callback(self._on_provider_speech_start))
+        provider.on_speech_end(self._gate_provider_callback(self._on_provider_speech_end))
+        provider.on_tool_call(self._gate_provider_callback(self._on_provider_tool_call))
+        provider.on_delegation(self._gate_provider_callback(self._on_provider_delegation))
+        provider.on_response_start(self._gate_provider_callback(self._on_provider_response_start))
+        provider.on_response_end(self._gate_provider_callback(self._on_provider_response_end))
+        provider.on_error(self._on_startup_provider_error)
 
         # Direct audio path: only when no pipeline is configured.
         # When pipeline= is set, _create_pipeline() registers
@@ -614,6 +625,12 @@ class RealtimeVoiceChannel(
         else:
             idle.clear()
 
+    def _expect_provider_output(self, session_id: str) -> None:
+        """Keep idle closed until a submitted result has an assistant continuation."""
+        self._awaiting_tool_response.add(session_id)
+        self._provider_idle[session_id] = False
+        self._update_idle_event(session_id)
+
     def _note_provider_output(self, session_id: str) -> None:
         """A new provider response can continue submitted tool results."""
         if session_id in self._awaiting_tool_response:
@@ -995,7 +1012,16 @@ class RealtimeVoiceChannel(
         Args:
             room_id: The room to join.
             participant_id: The participant's ID.
-            connection: Protocol-specific connection (e.g. WebSocket).
+            connection: Protocol-specific connection (e.g. WebSocket), or an
+                awaitable resolving to it. With an awaitable, provider setup
+                starts while the connection is pending (e.g. SIP ringing).
+                Cancel the start task if the connection will never arrive.
+                Both branches belong to this session and are rolled back on
+                failure. The channel publishes the session only when both are ready.
+                Provider callbacks wait for publication in a bounded startup
+                queue; exceeding 2 MiB of audio or 500 events aborts startup.
+                Monotonic timestamps are written to metadata's
+                ``connection_timing`` for measuring setup and pre-answer cost.
             metadata: Optional session metadata. May include overrides
                 for system_prompt, voice, tools, temperature.
 
@@ -1015,7 +1041,7 @@ class RealtimeVoiceChannel(
         task = asyncio.create_task(
             self._start_session(session, connection), name=f"rt_connect:{session.id}"
         )
-        pending = _ConnectingSession(task)
+        pending = _ConnectingSession(task, deferred=inspect.isawaitable(connection))
         self._connecting_sessions[session.id] = pending
         try:
             return await task
@@ -1030,6 +1056,9 @@ class RealtimeVoiceChannel(
                 await _finish_cleanup(self.end_session(session))
             else:
                 await _finish_cleanup(self._cleanup_failed_start(session))
+            pending = self._connecting_sessions.get(session.id)
+            if pending is not None and pending.failure is not None:
+                raise pending.failure from None
             raise
 
     async def _cleanup_failed_start(self, session: VoiceSession) -> None:
@@ -1081,6 +1110,8 @@ class RealtimeVoiceChannel(
         room_id, participant_id = session.room_id, session.participant_id
         self._session_config_locks[session.id] = asyncio.Lock()
         meta = session.metadata
+        timing: dict[str, float] = {}
+        meta["connection_timing"] = timing
         # Start telemetry session span early so transport/provider connect
         # phases appear as children in Jaeger.
         telemetry = self._telemetry_provider
@@ -1173,56 +1204,89 @@ class RealtimeVoiceChannel(
         if self._pipeline is not None:
             self._pipeline_session_active(session)
 
-        with telemetry.span(
-            SpanKind.BACKEND_CONNECT,
-            "transport.accept",
-            parent_id=session_span_id,
-            session_id=session.id,
-            attributes={Attr.BACKEND_TYPE: self._transport.name},
-        ):
-            await self._transport.accept(session, connection)
-        self._check_connecting_session(session)
-
-        # Connect to provider (with telemetry span).
-        # If provider.connect fails, clean up the already-accepted transport
-        # session to avoid leaking the connection.
-        try:
-            self._prepare_session_audio(session)
+        async def accept_transport() -> None:
+            resolved = await connection if inspect.isawaitable(connection) else connection
+            self._check_connecting_session(session)
             with telemetry.span(
                 SpanKind.BACKEND_CONNECT,
-                "provider.connect",
+                "transport.accept",
                 parent_id=session_span_id,
                 session_id=session.id,
-                attributes={Attr.BACKEND_TYPE: self._provider.name},
+                attributes={Attr.BACKEND_TYPE: self._transport.name},
             ):
-                await self._provider.connect(
-                    session,
-                    system_prompt=system_prompt,
-                    voice=voice,
-                    tools=tools,
-                    temperature=temperature,
-                    input_sample_rate=self._input_sample_rate,
-                    output_sample_rate=self._output_sample_rate,
-                    server_vad=self._provider.full_duplex or not has_pipeline_vad,
-                    provider_config=provider_config,
-                )
-        except (Exception, asyncio.CancelledError) as exc:
-            # CancelledError here is the orchestrator deliberately aborting
-            # a still-handshaking session (e.g. carrier hung up before the
-            # provider WS connected). It's expected control flow, not a
-            # bug — log it as info without a traceback so dashboards stay
-            # quiet. Real failures keep their full stack trace.
-            if isinstance(exc, asyncio.CancelledError):
+                await self._transport.accept(session, resolved)
+            self._check_connecting_session(session)
+            self._prepare_session_audio(session)
+            timing["transport_ready_at"] = time.monotonic()
+
+        async def connect_provider() -> None:
+            # Connect to provider (with telemetry span).
+            # If provider.connect fails, clean up the already-accepted transport
+            # session to avoid leaking the connection.
+            try:
+                timing["provider_connect_started_at"] = time.monotonic()
+                with telemetry.span(
+                    SpanKind.BACKEND_CONNECT,
+                    "provider.connect",
+                    parent_id=session_span_id,
+                    session_id=session.id,
+                    attributes={Attr.BACKEND_TYPE: self._provider.name},
+                ):
+                    await self._provider.connect(
+                        session,
+                        system_prompt=system_prompt,
+                        voice=voice,
+                        tools=tools,
+                        temperature=temperature,
+                        input_sample_rate=self._input_sample_rate,
+                        output_sample_rate=self._output_sample_rate,
+                        server_vad=self._provider.full_duplex or not has_pipeline_vad,
+                        provider_config=provider_config,
+                    )
+                timing["provider_ready_at"] = time.monotonic()
                 logger.info(
-                    "provider.connect cancelled for session %s — transport cleaned up",
-                    session.id,
-                )
-            else:
-                logger.exception(
-                    "provider.connect failed for session %s; cleaned up transport",
+                    "Realtime provider ready: room=%s session=%s connect_ms=%.1f",
+                    room_id,
                     session.id,
+                    (timing["provider_ready_at"] - timing["provider_connect_started_at"]) * 1000,
                 )
-            raise
+            except (Exception, asyncio.CancelledError) as exc:
+                # CancelledError here is the orchestrator deliberately aborting
+                # a still-handshaking session (e.g. carrier hung up before the
+                # provider WS connected). It's expected control flow, not a
+                # bug — log it as info without a traceback so dashboards stay
+                # quiet. Real failures keep their full stack trace.
+                if isinstance(exc, asyncio.CancelledError):
+                    logger.info(
+                        "provider.connect cancelled for session %s — transport cleaned up",
+                        session.id,
+                    )
+                else:
+                    logger.exception(
+                        "provider.connect failed for session %s; cleaned up transport",
+                        session.id,
+                    )
+                raise
+
+        if inspect.isawaitable(connection):
+            # One handshake owns both branches. gather alone would leave its
+            # sibling running after an error; drain both before rollback.
+            branches = [
+                asyncio.create_task(accept_transport(), name=f"rt_transport:{session.id}"),
+                asyncio.create_task(connect_provider(), name=f"rt_provider:{session.id}"),
+            ]
+            try:
+                await asyncio.gather(*branches)
+            finally:
+                for branch in branches:
+                    if not branch.done():
+                        branch.cancel()
+                await asyncio.gather(*branches, return_exceptions=True)
+        else:
+            # Preserve ordinary startup ordering, including codec validation
+            # before any provider connection is opened.
+            await accept_transport()
+            await connect_provider()
 
         self._check_connecting_session(session)
         session.state = VoiceSessionState.ACTIVE
@@ -1231,6 +1295,12 @@ class RealtimeVoiceChannel(
             self._session_rooms[session.id] = room_id
 
         await self._finish_session_start(session, room_id, participant_id)
+        self._check_connecting_session(session)
+        pending = self._connecting_sessions[session.id]
+        pending.deferred = False
+        for callback, args in pending.callbacks:
+            callback(*args)
+        pending.callbacks.clear()
 
         return session
 
@@ -1754,6 +1824,41 @@ class RealtimeVoiceChannel(
 
     # -- Internal callbacks --
 
+    def _gate_provider_callback(self, callback: Callable[..., Any]) -> Callable[..., Any]:
+        """Keep startup events ordered until transport and authorization are ready.
+
+        No application task runs while SIP is ringing. Audio enters the normal
+        send FIFO only after the negotiated codec and binding are available.
+        Rollback discards the journal with its connecting-session owner.
+        """
+
+        def dispatch(session: VoiceSession, *args: Any) -> Any:
+            pending = self._connecting_sessions.get(session.id)
+            if pending is None or not pending.deferred:
+                return callback(session, *args)
+            if pending.failure is not None or pending.task.cancelling():
+                return None
+            size = sum(len(arg) for arg in args if isinstance(arg, bytes))
+            if (
+                len(pending.callbacks) >= _MAX_QUEUED_AUDIO_CHUNKS
+                or pending.audio_bytes + size > 2 * 1024 * 1024
+            ):
+                pending.fail(RuntimeError("Provider startup event buffer exceeded"))
+                return None
+            pending.audio_bytes += size
+            pending.callbacks.append((callback, (session, *args)))
+            return None
+
+        return dispatch
+
+    def _on_startup_provider_error(self, session: VoiceSession, code: str, message: str) -> Any:
+        pending = self._connecting_sessions.get(session.id)
+        if pending is not None and session.state == VoiceSessionState.ENDED:
+            pending.fail(RuntimeError(f"Provider connection failed [{code}]: {message}"))
+            self._announce_provider_error(session, code, message)
+            return None
+        return self._on_provider_error(session, code, message)
+
     def _on_client_disconnected(self, session: VoiceSession) -> Any:
         """Handle client disconnection — end the session."""
         try:

{roomkit-0.76.0 → roomkit-0.78.0}/src/roomkit/core/mixins/voice_ops.py

@@ -122,7 +122,11 @@ class VoiceOpsMixin(HelpersMixin):
                 so the bridge sends audio through the correct transport.
             connection: Protocol-specific connection for realtime voice
                 channels (e.g. WebSocket).  Required when joining a
-                :class:`RealtimeVoiceChannel`.
+                :class:`RealtimeVoiceChannel`. May be an awaitable resolving
+                to that connection: provider setup then overlaps the wait,
+                under the same cancellable join. Bound that wait at the call
+                site (e.g. the dial timeout); no active session or started hook
+                is exposed until both transport and provider are ready.
 
         Returns:
             The voice or video session (created or passed in).

{roomkit-0.76.0 → roomkit-0.78.0}/src/roomkit/providers/openai/live.py

@@ -73,8 +73,8 @@ class OpenAILiveProvider(
     gates the model's audio on user speech, :meth:`interrupt` and
     :meth:`truncate_audio` do nothing, and a pipeline VAD stays in the
     observation role. The wire carries no response or speech boundaries;
-    this provider synthesizes them from the transcript deltas with a quiet
-    gap of ``turn_gap_ms`` per speaker (RFC §12.4.1).
+    this provider synthesizes them from transcript deltas and assistant audio
+    activity, with a quiet gap of ``turn_gap_ms`` per speaker (RFC §12.4.1).
 
     **Transcripts.** Partial transcriptions carry *deltas* for both roles and
     the final carries the whole turn, closed by the gap. A channel that keeps

{roomkit-0.76.0 → roomkit-0.78.0}/src/roomkit/providers/openai/live_handlers.py

@@ -3,7 +3,7 @@
 Translates Live API server events into RoomKit provider callbacks: the
 dispatch table keyed on the wire event type, one handler per event, and the
 turn synthesis a full-duplex wire calls for (RFC §12.4.1) — response and
-speech boundaries closed by a quiet gap on each speaker's transcript. The
+speech boundaries closed by a quiet gap in transcript or assistant audio activity. The
 hosted-delegation envelope (``response.event``) is handled by
 :class:`~roomkit.providers.openai.live_hosted.OpenAILiveHostedDelegationMixin`.
 """
@@ -32,6 +32,7 @@ from roomkit.providers.openai.live_events import (
 from roomkit.telemetry.base import Attr
 from roomkit.voice.base import VoiceSession
 from roomkit.voice.realtime.provider import RealtimeVoiceProvider
+from roomkit.voice.utils import pcm16_has_activity
 
 logger = logging.getLogger("roomkit.providers.openai.live")
 
@@ -114,6 +115,10 @@ class OpenAILiveEventHandlersMixin(RealtimeVoiceProvider):
         audio = base64.b64decode(audio_b64)
         if state.codec is not None:
             audio = state.codec.decode(audio)
+        if pcm16_has_activity(audio):
+            # Open before forwarding audio, including audio-only responses.
+            # Full-duplex silence is still forwarded, but cannot hold a turn open.
+            await state.assistant_turn.feed("")
         await self._fire(self._audio_callbacks, state.session, audio, label="audio")
 
     async def _on_output_transcript_delta(

{roomkit-0.76.0 → roomkit-0.78.0}/src/roomkit/voice/backends/base.py

@@ -361,6 +361,19 @@ class VoiceBackend(ABC):
     def end_of_response(self, session: VoiceSession) -> None:  # noqa: B027
         """Signal end of an AI response for outbound pacing."""
 
+    async def wait_playback(self, session: VoiceSession) -> bool:
+        """Wait for queued response audio to play; return False if discarded.
+
+        Call after the channel is idle (its EOR has reached the transport).
+        Queued transports may override this with a response boundary so that
+        continuous silence after the response does not keep the wait open.
+        """
+        import asyncio
+
+        while self.is_playing(session):
+            await asyncio.sleep(0.02)
+        return True
+
     def is_playing(self, session: VoiceSession) -> bool:
         """Check if audio is currently being sent to the session.
 

{roomkit-0.76.0 → roomkit-0.78.0}/src/roomkit/voice/backends/sip_audio.py

@@ -816,6 +816,13 @@ class SIPAudioMixin:
         state.send_buffer.clear()
         return was_playing
 
+    async def wait_playback(self, session: VoiceSession) -> bool:
+        """Wait through the latest EOR, including its final RTP packet's duration."""
+        state = self._session_states.get(session.id)
+        if state is None or state.pacer is None:
+            return True
+        return await state.pacer.wait_for_response_boundary()
+
     def is_playing(self, session: VoiceSession) -> bool:
         state = self._session_states.get(session.id)
         return state.is_playing if state is not None else False

{roomkit-0.76.0 → roomkit-0.78.0}/src/roomkit/voice/backends/sip_calling.py

@@ -857,6 +857,7 @@ class SIPCallingMixin:
                 )
 
             await out_call.wait_answered(timeout=timeout)
+            sip_answered_at = time.monotonic()
             setup.answered = True
 
             # Map call_id early so re-INVITEs arriving during RTP setup are
@@ -908,6 +909,7 @@ class SIPCallingMixin:
                     "callee": to_uri,
                     "room_id": effective_room_id,
                     "direction": "outbound",
+                    "sip_answered_at": sip_answered_at,
                     "input_sample_rate": actual_codec_rate,
                     "output_sample_rate": actual_codec_rate,
                     "codec_sample_rate": actual_codec_rate,