Stream synthesis

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

async def speak(sentences, lang="hi", voice="default_female", rate=24000):
    async with connect("wss://tts.navana.ai/v1") as socket:
        await socket.send(json.dumps({
            "type": "hello",
            "lang": lang,
            "voice": voice,
            "output_format": f"{rate}:pcm16",
            "auth_token": os.environ["BODHI_API_KEY"],
        }))

        ready = json.loads(await socket.recv())
        sample_rate = ready["sample_rate"]

        for seq, sentence in enumerate(sentences):
            await socket.send(json.dumps({
                "type": "text", "seq": seq, "target_text": sentence,
            }))
        await socket.send(json.dumps({"type": "end"}))

        audio = bytearray()
        async for message in socket:
            if isinstance(message, (bytes, bytearray)):
                audio += message
                continue
            frame = json.loads(message)
            if frame["type"] == "error":
                raise RuntimeError(frame)
            if frame["type"] == "done":
                break

        return bytes(audio), sample_rate

import WebSocket from 'ws'

export function speak(
  sentences: string[],
  { lang = 'hi', voice = 'default_female', rate = 24000 } = {},
): Promise<{ audio: Buffer; sampleRate: number }> {
  const socket = new WebSocket('wss://tts.navana.ai/v1')
  const chunks: Buffer[] = []
  let sampleRate = rate

  return new Promise((resolve, reject) => {
    socket.on('error', reject)

    socket.on('open', () => {
      socket.send(JSON.stringify({
        type: 'hello',
        lang,
        voice,
        output_format: `${rate}:pcm16`,
        auth_token: process.env.BODHI_API_KEY,
      }))
    })

    socket.on('message', (data, isBinary) => {
      if (isBinary) {
        chunks.push(data as Buffer)
        return
      }
      const frame = JSON.parse(String(data))
      switch (frame.type) {
        case 'ready':
          sampleRate = frame.sample_rate
          sentences.forEach((target_text, seq) =>
            socket.send(JSON.stringify({ type: 'text', seq, target_text })))
          socket.send(JSON.stringify({ type: 'end' }))
          break
        case 'error':
          reject(new Error(JSON.stringify(frame)))
          break
        case 'done':
          socket.close()
          resolve({ audio: Buffer.concat(chunks), sampleRate })
          break
      }
    })
  })
}

package main

// go get github.com/gorilla/websocket
import (
	"encoding/json"
	"fmt"
	"net/http"
	"os"
	"strconv"

	"github.com/gorilla/websocket"
)

func speak(sentences []string, lang, voice string, rate int) ([]byte, int, error) {
	header := http.Header{} // no auth header: the key goes in the hello frame
	conn, _, err := websocket.DefaultDialer.Dial("wss://tts.navana.ai/v1", header)
	if err != nil {
		return nil, 0, err
	}
	defer conn.Close()

	if err := conn.WriteJSON(map[string]any{
		"type":          "hello",
		"lang":          lang,
		"voice":         voice,
		"output_format": strconv.Itoa(rate) + ":pcm16",
		"auth_token":    os.Getenv("BODHI_API_KEY"),
	}); err != nil {
		return nil, 0, err
	}

	var ready struct {
		Type       string `json:"type"`
		SampleRate int    `json:"sample_rate"`
	}
	if err := conn.ReadJSON(&ready); err != nil {
		return nil, 0, err
	}

	for seq, text := range sentences {
		conn.WriteJSON(map[string]any{"type": "text", "seq": seq, "target_text": text})
	}
	conn.WriteJSON(map[string]string{"type": "end"})

	var audio []byte
	for {
		msgType, data, err := conn.ReadMessage()
		if err != nil {
			return nil, 0, err
		}
		if msgType == websocket.BinaryMessage {
			audio = append(audio, data...)
			continue
		}
		var frame struct {
			Type string `json:"type"`
		}
		json.Unmarshal(data, &frame)
		if frame.Type == "error" {
			return nil, 0, fmt.Errorf("server error: %s", data)
		}
		if frame.Type == "done" {
			return audio, ready.SampleRate, nil
		}
	}
}

func main() {
	audio, rate, err := speak(
		[]string{"आपके खाते में पाँच हज़ार रुपये हैं।"}, "hi", "default_female", 24000)
	if err != nil {
		panic(err)
	}
	fmt.Println(len(audio), "bytes at", rate, "Hz")
}