Live translation and spoken translations

import { createReadStream } from 'node:fs';
import { writeFile } from 'node:fs/promises';
import { VocalStack, applySentence, type SentenceSegment } from '@vocalstack/sdk';

const vs = new VocalStack({ baseUrl: 'https://api.vocalstack.com', apiKey: process.env.VOCALSTACK_API_KEY });

const { voices } = await vs.voices.available('es');
const voice = voices.find((v) => v.default) ?? voices[0];

// A file at full speed here; a microphone works the same (Stream a microphone).
const session = await vs.realtime.connect(
  {
    input: { kind: 'file' },
    spokenLanguage: 'en',
    translate: ['es'],
    sentences: { enabled: true },
    voice: [`es:${voice.id}`],
  },
  {
    // The clips arrive as transcript.voice frames: onFrame sees every frame.
    onFrame: (f) => {
      if (f.type === 'transcript.voice' && f.audio) {
        void writeFile(`es-${f.sentenceId}-${f.part ?? 0}.ogg`, Buffer.from(f.audio, 'base64'));
      }
    },
  },
);
void session.sendFile(createReadStream('./talk.mp3'));

let sentences: SentenceSegment[] = [];
for await (const ev of session) {
  if (ev.type !== 'transcript.sentence') continue;
  sentences = applySentence(sentences, ev.sentence); // upsert by sentenceId
  if (ev.sentence.status === 'closed') console.log(`${ev.sentence.text}\n  es: ${ev.sentence.translations?.es}`);
}
console.log(`${sentences.length} sentences; the Spanish clips are es-<sentence>-<part>.ogg`);

import asyncio
import base64
import os

from vocalstack import VocalStack


async def main() -> None:
    async with VocalStack("https://api.vocalstack.com", api_key=os.environ["VOCALSTACK_API_KEY"]) as vs:
        catalogue = await vs.voices.available("es")
        voice = next((v for v in catalogue.voices if v.default), catalogue.voices[0])

        # A file at full speed here; a microphone works the same (Stream a microphone).
        session = await vs.realtime.connect(
            input={"kind": "file"},
            spoken_language="en",
            translate=["es"],
            sentences={"enabled": True},
            voice=[f"es:{voice.id}"],
        )
        async with session:
            sender = asyncio.create_task(session.send_file("./talk.mp3"))
            async for event in session:
                if event.type == "transcript.sentence" and event.sentence.status == "closed":
                    print(event.sentence.text)
                    print("  es:", (event.sentence.translations or {}).get("es"))
                elif event.type == "transcript.voice" and event.audio:
                    with open(f"es-{event.sentence_id}-{event.part or 0}.ogg", "wb") as f:
                        f.write(base64.b64decode(event.audio))
            await sender


asyncio.run(main())

// No SDK: fetch for the session, the built-in WebSocket for the stream (Node 22 or newer).
import { createReadStream } from 'node:fs';
import { writeFile } from 'node:fs/promises';

const API = 'https://api.vocalstack.com';
const auth = { Authorization: `Bearer ${process.env.VOCALSTACK_API_KEY}` };

const cat = (await (await fetch(`${API}/v1/voices/available?lang=es`, { headers: auth })).json()) as { voices: { id: string; default: boolean }[] };
const voice = cat.voices.find((v) => v.default) ?? cat.voices[0];

const res = await fetch(`${API}/v1/realtime/sessions`, {
  method: 'POST',
  headers: { ...auth, 'Content-Type': 'application/json' },
  body: JSON.stringify({
    input: { kind: 'file' },
    spokenLanguage: 'en',
    translate: ['es'],
    sentences: { enabled: true },
    voice: [`es:${voice.id}`],
  }),
});
if (!res.ok) throw new Error(`${res.status} ${await res.text()}`);
const ws = new WebSocket(((await res.json()) as { streamUrl: string }).streamUrl);

ws.addEventListener('message', async (m: MessageEvent) => {
  if (typeof m.data !== 'string') return;
  const f = JSON.parse(m.data);
  if (f.type === 'session.ready') {
    for await (const chunk of createReadStream('./talk.mp3', { highWaterMark: 256 * 1024 })) ws.send(new Uint8Array(chunk as Buffer));
    ws.send(JSON.stringify({ type: 'eof' }));
  }
  if (f.type === 'transcript.sentence' && f.sentence.status === 'closed') console.log(`${f.sentence.text}\n  es: ${f.sentence.translations?.es}`);
  if (f.type === 'transcript.voice' && f.audio) await writeFile(`es-${f.sentenceId}-${f.part ?? 0}.ogg`, Buffer.from(f.audio, 'base64'));
  if (f.type === 'session.done') ws.close();
});