Skip to content

Instantly share code, notes, and snippets.

@devxMani
Last active June 8, 2026 14:35
Show Gist options
  • Select an option

  • Save devxMani/6ad5a76b41171aa186e20cbddd54a83d to your computer and use it in GitHub Desktop.

Select an option

Save devxMani/6ad5a76b41171aa186e20cbddd54a83d to your computer and use it in GitHub Desktop.
realtime voice runtime
from asyncio import Event
class BargeInController:
def __init__(self):
self.interrupt_event = Event()
async def on_user_speech(self):
self.interrupt_event.set()
async def should_interrupt(self):
return (
self.interrupt_event.is_set()
)
async def reset(self):
self.interrupt_event.clear()
import time
class LatencyTracker:
def __init__(self):
self.metrics = {}
def start(self, key):
self.metrics[key] = time.time()
def stop(self, key):
elapsed = (
time.time()
- self.metrics[key]
)
return round(
elapsed * 1000,
2
)
from dataclasses import dataclass
from enum import Enum
import asyncio
import time
class TurnState(Enum):
IDLE = "idle"
LISTENING = "listening"
THINKING = "thinking"
SPEAKING = "speaking"
@dataclass(slots=True)
class AudioChunk:
data: bytes
timestamp: float
class TurnDetector:
def __init__(
self,
silence_ms: int = 600
):
self.silence_ms = silence_ms
def is_turn_complete(
self,
silence_duration_ms: int
) -> bool:
return (
silence_duration_ms
> self.silence_ms
)
class StreamingSTT:
async def decode_stream(
self,
audio_stream
) -> str:
partials = []
async for chunk in audio_stream:
partials.append(chunk)
return "user transcript"
class StreamingTTS:
async def synthesize(
self,
text: str
):
for idx in range(5):
yield f"audio_chunk_{idx}".encode()
await asyncio.sleep(0.01)
class RealtimeVoiceRuntime:
def __init__(
self,
stt: StreamingSTT,
tts: StreamingTTS,
):
self.stt = stt
self.tts = tts
self.state = TurnState.IDLE
async def handle_turn(
self,
audio_stream
):
self.state = TurnState.LISTENING
transcript = (
await self.stt.decode_stream(
audio_stream
)
)
self.state = TurnState.THINKING
response = (
f"Responding to: {transcript}"
)
self.state = TurnState.SPEAKING
async for audio in (
self.tts.synthesize(response)
):
yield audio
self.state = TurnState.IDLE
from collections import deque
class AudioRingBuffer:
def __init__(
self,
max_chunks: int = 128
):
self.buffer = deque(
maxlen=max_chunks
)
def push(
self,
audio_chunk: bytes
):
self.buffer.append(
audio_chunk
)
def pop(self):
if not self.buffer:
return None
return self.buffer.popleft()
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment