Latency

import asyncio
from kugelaudio import KugelAudio

async def main():
    # create() returns only after the pooled socket is open.
    client = await KugelAudio.create(api_key="...")
    try:
        ...  # handle requests with client.tts.stream_async(...)
    finally:
        await client.aclose()

asyncio.run(main())

const client = new KugelAudio({ apiKey: '...' });
await client.connect();   // pay the handshake here, once

KugelAudio client = KugelAudio.createConnected(
    KugelAudioOptions.builder("...").build()
);   // connects synchronously before returning

audio = client.tts.generate(
    text="Guten Tag!", model_id="kugel-3", voice_id=1071, language="de"
)

import asyncio
import time
from kugelaudio import KugelAudio

async def main():
    client = await KugelAudio.create(api_key="...")  # connects before returning
    try:
        start = time.perf_counter()
        async for chunk in client.tts.stream_async(
            text="Hello from KugelAudio.",
            model_id="kugel-3",
            voice_id=1071,
            language="en",
        ):
            if hasattr(chunk, "audio"):
                ttfa_ms = (time.perf_counter() - start) * 1000
                print(f"TTFA: {ttfa_ms:.1f} ms")
                break
    finally:
        await client.aclose()

asyncio.run(main())

import { KugelAudio } from 'kugelaudio';

const client = new KugelAudio({ apiKey: '...' });
await client.connect();              // handshake paid here, not measured

const start = performance.now();
let first = true;
await client.tts.stream(
  { text: 'Hello from KugelAudio.', modelId: 'kugel-3', voiceId: 1071, language: 'en' },
  {
    onChunk: () => {
      if (first) {
        console.log(`TTFA: ${(performance.now() - start).toFixed(1)} ms`);
        first = false;
      }
    },
  },
);