Thought Detection

import asyncio
import json
import signal
import sounddevice as sd
import websockets
import httpx
import os

ENABLE_THOUGHT_DETECTION = True

WS_BASE = "wss://api.fennec-asr.com/api/v1/transcribe/stream"
HTTP_TOKEN_URL = "https://api.fennec-asr.com/api/v1/transcribe/streaming-token"
API_KEY = os.getenv("FENNEC_API_KEY") or "YOUR_API_KEY"

SAMPLE_RATE = 16_000
CHANNELS = 1
DTYPE = "int16"
CHUNK_MS = 100
FRAMES_PER_CHUNK = int(SAMPLE_RATE * (CHUNK_MS / 1000.0))

START_MSG = {
    "type": "start",
    "sample_rate": 16000,
    "channels": 1,
    "single_utterance": False,
    "detect_thoughts": True,
    "end_thought_eagerness": "medium",   # "low" | "medium" | "high"
    "force_complete_time": 2.0,          # 1–60 seconds
    # "context": "optional correction context string",
    "vad": {
        "threshold": 0.45,
        "min_silence_ms": 400,
        "speech_pad_ms": 200,
        "final_silence_s": 0,
        "start_trigger_ms": 30,
        "min_voiced_ms": 100,
        "min_chars": 1,
        "min_words": 1,
        "amp_extend": 1200
    }
}

shutdown_event = asyncio.Event()

def _handle_sigint(*_):
    shutdown_event.set()

async def audio_sender(ws, stream):
    print("\n🎙️  Streaming mic… speak a full thought and pause. (Ctrl+C to stop)", flush=True)
    while not shutdown_event.is_set():
        try:
            data, _ = await asyncio.to_thread(stream.read, FRAMES_PER_CHUNK)
            await ws.send(bytes(data))
        except websockets.exceptions.ConnectionClosed:
            break
    try:
        if not ws.closed:
            await ws.send('{"type":"eos"}')
    except websockets.exceptions.ConnectionClosed:
        pass

async def message_receiver(ws):
    """Listens for messages and handles them based on the selected mode."""
    async for msg in ws:
        try:
            data = json.loads(msg)
            if data.get("type") == "complete_thought":
                text = data.get("text", "")
                print(f"\n✅ Thought Complete: {text}", flush=True)
        except Exception:
            # Ignore non-JSON messages
            pass

async def fetch_streaming_token() -> str:
    """
    Exchanges your API key for a short-lived streaming token.
    Send the token via ?streaming_token=... in the WS URL.
    """
    if not API_KEY or API_KEY == "YOUR_API_KEY":
        raise RuntimeError("Set FENNEC_API_KEY (or replace API_KEY).")
    async with httpx.AsyncClient(timeout=10) as client:
        resp = await client.post(
            HTTP_TOKEN_URL,
            headers={"X-API-Key": API_KEY, "content-type": "application/json"},
            json={},  # body not required; header is what matters
        )
        resp.raise_for_status()
        data = resp.json()
        token = data.get("token")
        if not token:
            raise RuntimeError(f"Token endpoint returned no token: {data}")
        return token

async def main():
    print("Fetching streaming token…")
    token = await fetch_streaming_token()
    WEBSOCKET_URL = f"{WS_BASE}?streaming_token={token}"
    print(f"Connecting to: {WEBSOCKET_URL}")
    try:
        async with websockets.connect(
                WEBSOCKET_URL,
                max_size=None,
                ping_interval=5
            ) as ws:
            await ws.send(json.dumps(START_MSG))
            print("✅ WebSocket connected and configured.")

            with sd.RawInputStream(
                samplerate=SAMPLE_RATE, channels=CHANNELS, dtype=DTYPE, blocksize=FRAMES_PER_CHUNK
            ) as stream:
                sender = asyncio.create_task(audio_sender(ws, stream))
                receiver = asyncio.create_task(message_receiver(ws))
                await asyncio.wait([sender, receiver], return_when=asyncio.FIRST_COMPLETED)
    except Exception as e:
        print(f"❌ An error occurred: {e}")

if __name__ == "__main__":
    if sd.query_devices(kind='input'):
        signal.signal(signal.SIGINT, _handle_sigint)
        asyncio.run(main())
    else:
        print("\n❌ No input microphone found.")