Stream transcription

import asyncio, json, os, uuid, wave
from websockets.asyncio.client import connect

CHUNK_MS = 100   # frame size is up to you; 100 ms is a reasonable default

async def transcribe(path: str) -> str:
    wf = wave.open(path, "rb")
    chunk_frames = int(wf.getframerate() * CHUNK_MS / 1000)

    async with connect(
        "wss://stt.navana.ai",
        additional_headers={"X-Api-Key": os.environ["BODHI_API_KEY"]},
    ) as socket:
        await socket.send(json.dumps({"config": {
            "sample_rate": wf.getframerate(),
            "transaction_id": str(uuid.uuid4()),
            "model": "hi-banking-v2-8khz",
            "aux": True,
        }}))

        segments: dict[int, str] = {}

        async def send_audio():
            while chunk := wf.readframes(chunk_frames):
                await socket.send(chunk)
                await asyncio.sleep(CHUNK_MS / 1000)   # pace like live capture
            await socket.send(json.dumps({"eof": 1}))

        async def receive():
            async for raw in socket:
                frame = json.loads(raw)
                if "error" in frame:
                    raise RuntimeError(frame)
                segments[frame["segment_id"]] = frame["text"]
                if frame.get("eos"):
                    return

        await asyncio.gather(send_audio(), receive())
        return " ".join(segments[k] for k in sorted(segments))

import WebSocket from 'ws'
import { randomUUID } from 'node:crypto'
import { readFile } from 'node:fs/promises'

const CHUNK_MS = 100 // frame size is up to you; 100 ms is a reasonable default

// Walk the RIFF chunks for the sample rate and the start of the samples. Don't
// assume a fixed 44-byte header: any WAV carrying an extra chunk, such as a
// LIST, puts the audio elsewhere, and the misalignment turns into a garbled
// transcript rather than an error.
function readWav(buf: Buffer): { sampleRate: number; samples: Buffer } {
  let offset = 12
  let sampleRate = 0
  while (offset < buf.length) {
    const id = buf.toString('ascii', offset, offset + 4)
    const size = buf.readUInt32LE(offset + 4)
    const body = offset + 8
    if (id === 'fmt ') sampleRate = buf.readUInt32LE(body + 4)
    if (id === 'data') return { sampleRate, samples: buf.subarray(body, body + size) }
    offset = body + size + (size % 2)
  }
  throw new Error('no data chunk in WAV')
}

export async function transcribe(path: string): Promise<string> {
  const { sampleRate, samples } = readWav(await readFile(path))
  const bytesPerChunk = (sampleRate * 2 * CHUNK_MS) / 1000
  const segments = new Map<number, string>()

  const socket = new WebSocket('wss://stt.navana.ai', {
    headers: { 'X-Api-Key': process.env.BODHI_API_KEY! },
  })

  const transcript = () =>
    [...segments].sort((a, b) => a[0] - b[0]).map(([, t]) => t).join(' ')

  return new Promise<string>((resolve, reject) => {
    socket.on('error', reject)
    // Settle on whichever comes first, `eos` or the socket closing.
    socket.on('close', () => resolve(transcript()))

    socket.on('open', async () => {
      socket.send(JSON.stringify({ config: {
        sample_rate: sampleRate,
        transaction_id: randomUUID(),
        model: 'hi-banking-v2-8khz',
        aux: true,
      }}))

      for (let i = 0; i < samples.length; i += bytesPerChunk) {
        socket.send(samples.subarray(i, i + bytesPerChunk))
        await new Promise((r) => setTimeout(r, CHUNK_MS)) // pace like live capture
      }
      socket.send(JSON.stringify({ eof: 1 }))
    })

    socket.on('message', (raw) => {
      const frame = JSON.parse(String(raw))
      if (frame.error) return reject(new Error(JSON.stringify(frame)))
      segments.set(frame.segment_id, frame.text)
      if (frame.eos) {
        socket.close()
        resolve(transcript())
      }
    })
  })
}

package main

// go get github.com/gorilla/websocket
import (
	"encoding/binary"
	"io"
	"net/http"
	"os"
	"time"

	"github.com/google/uuid"
	"github.com/gorilla/websocket"
)

const chunkMS = 100 // frame size is up to you; 100 ms is a reasonable default

// openWAV walks the RIFF chunks to find the sample rate and the start of the
// samples. Don't skip a fixed 44 bytes: any WAV carrying an extra chunk, such
// as a LIST, puts the audio somewhere else, and the misalignment turns into a
// garbled transcript rather than an error.
func openWAV(path string) (*os.File, int, error) {
	f, err := os.Open(path)
	if err != nil {
		return nil, 0, err
	}
	var riff [12]byte
	if _, err := io.ReadFull(f, riff[:]); err != nil {
		return nil, 0, err
	}
	sampleRate := 0
	for {
		var ch [8]byte
		if _, err := io.ReadFull(f, ch[:]); err != nil {
			return nil, 0, err
		}
		id, size := string(ch[:4]), int64(binary.LittleEndian.Uint32(ch[4:]))
		switch id {
		case "fmt ":
			fmtChunk := make([]byte, size)
			if _, err := io.ReadFull(f, fmtChunk); err != nil {
				return nil, 0, err
			}
			sampleRate = int(binary.LittleEndian.Uint32(fmtChunk[4:8]))
		case "data":
			return f, sampleRate, nil // positioned at the first sample
		default:
			if _, err := f.Seek(size+size%2, io.SeekCurrent); err != nil {
				return nil, 0, err
			}
		}
	}
}

func main() {
	// PCM16 LE mono. Take the rate from the file rather than hardcoding it, so
	// `config` always matches the audio you actually send.
	f, sampleRate, err := openWAV("recording.wav")
	if err != nil {
		panic(err)
	}
	defer f.Close()

	header := http.Header{}
	header.Set("X-Api-Key", os.Getenv("BODHI_API_KEY"))

	conn, _, err := websocket.DefaultDialer.Dial("wss://stt.navana.ai", header)
	if err != nil {
		panic(err)
	}
	defer conn.Close()

	conn.WriteJSON(map[string]any{"config": map[string]any{
		"sample_rate":    sampleRate,
		"transaction_id": uuid.NewString(),
		"model":          "hi-banking-v2-8khz",
		"aux":            true,
	}})

	segments := map[int]string{}

	go func() {
		for {
			var frame struct {
				SegmentID int    `json:"segment_id"`
				Type      string `json:"type"`
				Text      string `json:"text"`
				Error     string `json:"error"`
				EOS       bool   `json:"eos"`
			}
			if err := conn.ReadJSON(&frame); err != nil {
				return
			}
			if frame.Error != "" {
				return
			}
			segments[frame.SegmentID] = frame.Text
			if frame.EOS {
				return
			}
		}
	}()

	chunk := make([]byte, sampleRate*2*chunkMS/1000)
	for {
		n, err := io.ReadFull(f, chunk)
		if n > 0 {
			conn.WriteMessage(websocket.BinaryMessage, chunk[:n])
			time.Sleep(chunkMS * time.Millisecond) // pace like live capture
		}
		if err != nil {
			break
		}
	}

	conn.WriteJSON(map[string]int{"eof": 1})
}