Realtime Speech To Speech

import asyncio
import os
import wave

from camb.client import CambAI
from camb.realtime import ServerEventType
from camb.live_transcription import FileAudioSource


async def main():
    client = CambAI(api_key=os.environ["CAMB_API_KEY"])
    session = await client.realtime.connect(
        source_language="en-us",
        target_language="de-de",
    )

    out_audio = bytearray()

    @session.on(ServerEventType.TEXT_DONE)
    def _(event):
        print("translation:", event.text)

    @session.on(ServerEventType.AUDIO_DELTA)
    def _(event):
        out_audio.extend(event.data)  # raw PCM16 mono 24 kHz

    async with session:
        await session.wait_until_ready()
        # Input WAV must be 16-bit PCM, mono, 24 kHz.
        await session.stream_audio(FileAudioSource("input_24k_mono.wav", real_time=True))

    with wave.open("translated.wav", "wb") as out:
        out.setnchannels(1)
        out.setsampwidth(2)
        out.setframerate(24000)
        out.writeframes(bytes(out_audio))


asyncio.run(main())

import fs from "node:fs";

import { CambClient, RealtimeServerEventType } from "@camb-ai/sdk";

const client = new CambClient({ apiKey: process.env.CAMB_API_KEY });
const session = await client.realtime.connect({
  sourceLanguage: "en-us",
  targetLanguage: "de-de",
});

const outChunks = [];
let resolveDone;
const audioDone = new Promise((r) => (resolveDone = r));

session.on(RealtimeServerEventType.TextDone, (event) =>
  console.log("translation:", event.text),
);
session.on(RealtimeServerEventType.AudioDelta, (event) =>
  outChunks.push(Buffer.from(event.data)), // raw PCM16 mono 24 kHz
);
session.on(RealtimeServerEventType.AudioDone, () => resolveDone());

await session.waitUntilReady();

// Input WAV must be 16-bit PCM, mono, 24 kHz. This skips the standard 44-byte
// header and streams the PCM data at real-time pace in 100 ms slices.
const data = fs.readFileSync("input_24k_mono.wav").subarray(44);
const chunkSize = 24000 * 2 * 0.1;
for (let i = 0; i < data.length; i += chunkSize) {
  await session.sendAudio(data.subarray(i, i + chunkSize));
  await new Promise((r) => setTimeout(r, 100));
}

await Promise.race([audioDone, new Promise((r) => setTimeout(r, 30_000))]);
await session.close();

// Raw PCM16 mono 24 kHz; wrap in a WAV header to play it (see the tutorial).
fs.writeFileSync("translated.pcm", Buffer.concat(outChunks));

{
  "type": "session.update",
  "session": {
    "source_language": "en-us",
    "target_language": "de-de",
    "output_modalities": ["text", "audio"]
  },
  "auth": {
    "api_key": "<YOUR_API_KEY>"
  }
}

session = await client.realtime.connect(
    source_language="en-us",
    target_language="de-de",
    voice_id=147320,
)

const session = await client.realtime.connect({
  sourceLanguage: "en-us",
  targetLanguage: "de-de",
  voiceId: 147320,
});