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.")

#!/usr/bin/env node
"use strict";

/**
 * Streams microphone audio to the ASR WebSocket API with "thought detection".
 * Prints a message whenever a complete thought is detected. (Ctrl+C to stop)
 *
 * Requires:
 *   - Node 18+ (for global fetch/Blob/FormData/AbortSignal)
 *   - npm i ws mic
 *   - Set your API key below or via env (FENNEC_API_KEY)
 */

const ENABLE_THOUGHT_DETECTION = true;

const WS_BASE = "wss://api.fennec-asr.com/api/v1/transcribe/stream";
const HTTP_TOKEN_URL = "https://api.fennec-asr.com/api/v1/transcribe/streaming-token";
// Prefer env var if available; falls back to placeholder to mirror the Python example.
const API_KEY = process.env.FENNEC_API_KEY || "YOUR_API_KEY";

if (!API_KEY || API_KEY === "YOUR_API_KEY") {
  console.warn("⚠️  Using placeholder API key. Set FENNEC_API_KEY for real requests.");
}

let WEBSOCKET_URL = WS_BASE;

// --- Audio Configuration ---
const SAMPLE_RATE: number = 16_000;
const CHANNELS: number = 1;
const CHUNK_MS: number = 100;
const DTYPE_BYTES: number = 2; // int16 -> 2 bytes/sample
const FRAMES_PER_CHUNK: number = Math.floor(SAMPLE_RATE * (CHUNK_MS / 1000));
const CHUNK_BYTES: number = FRAMES_PER_CHUNK * CHANNELS * DTYPE_BYTES;

// --- WebSocket Start Message (mirrors Python) ---
const 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
  }
};

(async () => {
  const WebSocket = require("ws");
  const mic = require("mic");

  // Exchange API key -> short-lived streaming token
  const resp = await fetch(HTTP_TOKEN_URL, {
    method: "POST",
    headers: { "X-API-Key": API_KEY, "content-type": "application/json" },
    body: JSON.stringify({}),
  });
  if (!resp.ok) {
    const text = await resp.text().catch(() => "");
    throw new Error(`Token request failed: ${resp.status} ${text}`);
  }
  const data = await resp.json().catch(() => ({}));
  const token = data?.token as string | undefined;
  if (!token) throw new Error("Token endpoint returned no token");

  WEBSOCKET_URL = `${WS_BASE}?streaming_token=${encodeURIComponent(token)}`;
  console.log(`Connecting to: ${WEBSOCKET_URL}`);

  const ws = new (WebSocket as any)(WEBSOCKET_URL, {
    perMessageDeflate: false,
    maxPayload: 0,
  });

  // Graceful shutdown
  let shuttingDown = false;
  const shutdown = (micInstance?: any) => {
    if (shuttingDown) return;
    shuttingDown = true;
    try {
      if (ws.readyState === WebSocket.OPEN) ws.send('{"type":"eos"}');
    } catch {}
    try {
      micInstance?.stop();
    } catch {}
    try {
      ws.close();
    } catch {}
  };
  process.on("SIGINT", () => shutdown());

  ws.on("open", async () => {
    try {
      await ws.send(JSON.stringify(START_MSG));
      console.log("✅ WebSocket connected and configured.");

      // Configure mic: raw 16kHz, mono, 16-bit LE PCM
      const micInstance = mic({
        rate: String(SAMPLE_RATE),
        channels: String(CHANNELS),
        bitwidth: "16",
        encoding: "signed-integer",
        endian: "little",
        fileType: "raw",
        exitOnSilence: 0,
        device: process.env.MIC_DEVICE || undefined, // optional override
      });

      const micStream = micInstance.getAudioStream();
      let buffer: Buffer = Buffer.alloc(0);

      console.log("\n🎙️  Streaming mic… speak a full thought and pause. (Ctrl+C to stop)");

      micStream.on("data", (chunk: Buffer) => {
        buffer = Buffer.concat([buffer, chunk]);
        while (buffer.length >= CHUNK_BYTES && ws.readyState === WebSocket.OPEN) {
          const slice = buffer.subarray(0, CHUNK_BYTES);
          ws.send(slice); // binary PCM chunk
          buffer = buffer.subarray(CHUNK_BYTES);
        }
      });

      micStream.on("error", (err: any) => {
        console.error("Mic error:", err?.message || err);
      });

      ws.on("message", (msg: Buffer) => {
        try {
          const data = JSON.parse(msg.toString("utf8"));
          if (data?.type === "complete_thought") {
            const text: string = data.text || "";
            console.log(`\n✅ Thought Complete: ${text}`);
          }
        } catch {
          // ignore non-JSON
        }
      });

      ws.on("close", () => shutdown(micInstance));
      ws.on("error", (e: any) => {
        console.error("WebSocket error:", e?.message || e);
        shutdown(micInstance);
      });

      // Try starting mic; if it immediately errors, surface a helpful message.
      try {
        micInstance.start();
      } catch (e: any) {
        console.error("\n❌ Failed to access microphone. Ensure an input device is available.");
        shutdown(micInstance);
      }
    } catch (e: any) {
      console.error("Startup error:", e?.message || e);
      shutdown();
    }
  });

  ws.on("error", (e: any) => {
    console.error("WebSocket error (pre-open):", e?.message || e);
  });
})();