Streaming

from kugelaudio import AudioChunk

# Synchronous streaming
for item in client.tts.stream(
    text="Hello, this is streaming audio.",
    model_id="kugel-3.5",
    voice_id=1071,
):
    if isinstance(item, AudioChunk):
        # Process audio chunk immediately
        print(f"Chunk {item.index}: {len(item.audio)} bytes, {item.samples} samples")
        play_audio(item.audio)
    elif isinstance(item, dict) and item.get('final'):
        # Final stats
        print(f"Total duration: {item.get('dur_ms', 0):.0f}ms")
        print(f"Generation time: {item.get('gen_ms', 0):.0f}ms")

await client.tts.stream(
  {
    text: 'Hello, this is streaming audio.',
    modelId: 'kugel-3.5',
    voiceId: 1071,
  },
  {
    onOpen: () => {
      console.log('WebSocket connected');
    },
    onChunk: (chunk) => {
      console.log(`Chunk ${chunk.index}: ${chunk.samples} samples`);
      // chunk.audio uses chunk.encoding ('pcm_s16le', 'mulaw', or 'alaw')
      playAudioChunk(chunk);
    },
    onFinal: (stats) => {
      console.log(`Total duration: ${stats.durationMs}ms`);
      console.log(`Generation time: ${stats.generationMs}ms`);
      console.log(`RTF: ${stats.rtf}`);
    },
    onError: (error) => {
      console.error('TTS error:', error);
    },
    onClose: () => {
      console.log('WebSocket closed');
    },
  }
);

import com.kugelaudio.sdk.GenerateRequest;
import com.kugelaudio.sdk.StreamCallbacks;
import com.kugelaudio.sdk.AudioChunk;

client.tts().stream(
    GenerateRequest.builder("Hello, this is streaming audio.")
        .modelId("kugel-3.5")
        .voiceId(1071)
        .language("en")
        .build(),
    new StreamCallbacks() {
        @Override
        public void onChunk(AudioChunk chunk) {
            System.out.printf("Chunk %d: %d bytes, %d samples%n",
                chunk.getIndex(), chunk.getAudio().length, chunk.getSamples());
            // playAudio(chunk.getAudio());
        }

        @Override
        public void onComplete(AudioResponse response) {
            System.out.printf("Total duration: %.0fms%n", response.getDurationMs());
            System.out.printf("Generation time: %.0fms%n", response.getGenerationMs());
        }

        @Override
        public void onError(com.kugelaudio.sdk.KugelAudioException error) {
            System.err.println("TTS error: " + error.getMessage());
        }
    }
);

use futures_util::StreamExt;
use kugelaudio::{StreamEvent, TtsRequest};

let request = TtsRequest::new("Hello, this is streaming audio.")
    .model_id("kugel-3.5")
    .voice_id(1071)
    .language("en");
let mut stream = client.tts().stream(&request).await?;
while let Some(event) = stream.next().await {
    match event? {
        StreamEvent::Audio(chunk) => {
            // Process audio chunk immediately
            println!("Chunk {}: {} bytes, {} samples", chunk.index, chunk.audio.len(), chunk.samples);
            play_audio(&chunk.audio);
        }
        StreamEvent::Final(stats) => {
            // Final stats
            println!("Total duration: {:?}ms", stats.duration_ms);
            println!("Generation time: {:?}ms", stats.generation_ms);
        }
        _ => {}
    }
}

kugelaudio::GenerateRequest request;
request.text = "Hello, this is streaming audio.";
request.model_id = "kugel-3.5";
request.voice_id = 1071;
request.language = "en";

kugelaudio::StreamCallbacks callbacks;
callbacks.on_audio = [](const kugelaudio::AudioChunk& chunk) {
  // Process audio chunk immediately
  std::cout << "Chunk " << chunk.index << ": " << chunk.audio.size() << " bytes, "
            << chunk.samples << " samples\n";
  play_audio(chunk.audio);
};

// Blocks until the request is done; returns the collected audio and final stats
kugelaudio::AudioResponse result = client.tts().stream(request, callbacks);
std::cout << "Total duration: " << result.duration_ms << "ms\n";
std::cout << "Generation time: " << result.generation_ms << "ms\n";

final stream = client.tts.stream(
  text: 'Hello, this is streaming audio.',
  modelId: 'kugel-3.5',
  voiceId: 1071,
  language: 'en',
);
await for (final chunk in stream) {
  // Process audio chunk immediately
  print('Chunk ${chunk.index}: ${chunk.audio.length} bytes, ${chunk.samples} samples');
  playAudio(chunk.audio);
}

// Final stats
final stats = await stream.result;
print('Total duration: ${stats.durationMs}ms');
print('Generation time: ${stats.generationMs}ms');

import asyncio

async def stream_from_llm():
    # Simulate LLM token stream
    llm_tokens = ["Hello, ", "this ", "is ", "a ", "streamed ", "response."]

    async with client.tts.streaming_session(
        voice_id=1071,
        cfg_scale=2.0,
        flush_timeout_ms=500,  # Server-side auto-flush timeout
    ) as session:
        # Send tokens as they arrive from LLM
        for token in llm_tokens:
            async for chunk in session.send(token):
                # Play audio chunk immediately
                play_audio(chunk.audio)

        # Flush any remaining text
        async for chunk in session.flush():
            play_audio(chunk.audio)

asyncio.run(stream_from_llm())

const session = client.tts.streamingSession(
  {
    voiceId: 1071,
    modelId: 'kugel-3.5',
  },
  {
    onChunk: (chunk) => playAudio(chunk.audio),
    onChunkComplete: (chunkId, audioSecs, genMs) => {
      console.log(`Chunk ${chunkId}: ${audioSecs.toFixed(2)}s audio in ${genMs}ms`);
    },
    onSessionClosed: (totalSecs) => {
      console.log(`Session complete: ${totalSecs.toFixed(2)}s total audio`);
    },
    onError: (err) => console.error('TTS error:', err),
  }
);

await session.connect();

// Simulated LLM token stream: send tokens as they arrive
const llmTokens = ['Hello, ', 'this ', 'is ', 'a ', 'streamed ', 'response.'];
for (const token of llmTokens) {
  session.send(token);
}

// Flush remaining buffer, deliver the remaining audio, and close
await session.close();

import com.kugelaudio.sdk.StreamConfig;
import com.kugelaudio.sdk.StreamCallbacks;
import com.kugelaudio.sdk.StreamingSession;
import com.kugelaudio.sdk.AudioChunk;

StreamConfig config = StreamConfig.builder()
    .voiceId(1071)
    .modelId("kugel-3.5")
    .language("en")
    .flushTimeoutMs(500)  // Server-side auto-flush timeout
    .build();

// Simulate LLM token stream
String[] tokens = {"Hello, ", "this ", "is ", "a ", "streamed ", "response."};

try (StreamingSession session = client.streamingSession(config, new StreamCallbacks() {
    @Override
    public void onChunk(AudioChunk chunk) {
        playAudio(chunk.getAudio());
    }

    @Override
    public void onSessionClosed(double totalAudioSeconds, int totalTextChunks,
                                int totalAudioChunks) {
        System.out.printf("Done: %.2fs%n", totalAudioSeconds);
    }
})) {
    // Send tokens as they arrive from LLM
    for (String token : tokens) {
        session.send(token);
    }
    // Leaving the block calls close(), which flushes the remaining text,
    // waits for the audio, and fires onSessionClosed once.
}

use futures_util::StreamExt;
use kugelaudio::StreamConfig;

// Simulate LLM token stream
let llm_tokens = ["Hello, ", "this ", "is ", "a ", "streamed ", "response."];

let mut session = client.tts().streaming_session(
    StreamConfig::new(1071)
        .model_id("kugel-3.5")
        .language("en")
        .flush_timeout_ms(500), // Server-side auto-flush timeout
);
session.connect().await?;

// Send tokens as they arrive from LLM
for token in llm_tokens {
    let mut audio = session.send(token, false);
    while let Some(chunk) = audio.next().await {
        // Play audio chunk immediately
        play_audio(&chunk?.audio);
    }
}

// Flush the remaining text: ends the turn and yields its audio
let mut tail = session.flush();
while let Some(chunk) = tail.next().await {
    play_audio(&chunk?.audio);
}
drop(tail);
session.close().await?;

kugelaudio::StreamConfig config;
config.voice_id = 1071;
config.model_id = "kugel-3.5";
config.language = "en";
config.flush_timeout_ms = 500;  // Server-side auto-flush timeout

auto play_chunk = [](const kugelaudio::AudioChunk& chunk) { play_audio(chunk.audio); };

// Simulate LLM token stream
const std::vector<std::string> llm_tokens = {"Hello, ", "this ", "is ", "a ", "streamed ", "response."};

kugelaudio::StreamingSession session = client.tts().streaming_session(config);
session.connect();

// Send tokens as they arrive from LLM; each call returns the audio ready so far
for (const std::string& token : llm_tokens) {
  session.send(token, /*flush=*/false, play_chunk);
}

// Flush the remaining text: ends the turn and delivers its audio
session.flush(play_chunk);
session.close();

final session = client.tts.streamingSession(
  StreamConfig(
    voiceId: 1071,
    modelId: 'kugel-3.5',
    language: 'en',
    flushTimeoutMs: 500, // Server-side auto-flush timeout
  ),
);
// Audio of every turn arrives on one stream; listen before sending
session.audio.listen((chunk) => playAudio(chunk.audio));
await session.connect();

// Simulate LLM token stream: send tokens as they arrive
final llmTokens = ['Hello, ', 'this ', 'is ', 'a ', 'streamed ', 'response.'];
for (final token in llmTokens) {
  await session.send(token);
}

// Flush the remaining text: completes once the turn's audio was delivered
await session.flush();
await session.close();

async with client.tts.streaming_session(voice_id=1071) as session:
    # Session 1
    async for chunk in session.send("Hello from voice one.", flush=True):
        play_audio(chunk.audio)
    async for chunk in session.drain():  # receive the tail audio
        play_audio(chunk.audio)
    await session.end_session()  # Keeps WebSocket open

    # Session 2: no reconnection needed
    session.update_config(voice_id=1072)
    async for chunk in session.send("Hello from voice two.", flush=True):
        play_audio(chunk.audio)
    async for chunk in session.drain():
        play_audio(chunk.audio)
# Leaving the block closes the session and the WebSocket

const session = client.tts.streamingSession(
  { voiceId: 1071 },
  { onChunk: (chunk) => playAudio(chunk.audio) }
);
await session.connect();

// Session 1
session.send('Hello from voice one.');
await session.endSession(); // Delivers the remaining audio, keeps WebSocket open

// Session 2: no reconnection needed
session.updateConfig({ voiceId: 1072 });
session.send('Hello from voice two.');

await session.close(); // Closes session + WebSocket

StreamingSession session = client.streamingSession(config, callbacks);
session.connect();

// Session 1
session.send("Hello from voice one.");
session.flush();
session.endSession(); // Keeps WebSocket open

// Session 2: no reconnection needed; the same StreamConfig is re-sent
session.send("Hello from the next turn.");
session.flush();

session.close(); // Closes session + WebSocket

let mut session = client.tts().streaming_session(StreamConfig::new(1071).language("en"));
session.connect().await?;

// Session 1
let mut audio = session.send("Hello from voice one.", true);
while let Some(chunk) = audio.next().await {
    play_audio(&chunk?.audio);
}
drop(audio);
let mut tail = session.drain(); // receive the tail audio
while let Some(chunk) = tail.next().await {
    play_audio(&chunk?.audio);
}
drop(tail);
session.end_session().await?; // Keeps WebSocket open

// Session 2: no reconnection needed
session.update_config(StreamConfig::new(1072).language("en"));
let mut audio = session.send("Hello from voice two.", true);
while let Some(chunk) = audio.next().await {
    play_audio(&chunk?.audio);
}
drop(audio);

session.close().await?; // Closes session + WebSocket

auto play_chunk = [](const kugelaudio::AudioChunk& chunk) { play_audio(chunk.audio); };

kugelaudio::StreamConfig config;
config.voice_id = 1071;
config.language = "en";
kugelaudio::StreamingSession session = client.tts().streaming_session(config);
session.connect();

// Session 1
session.send("Hello from voice one.", /*flush=*/true, play_chunk);
session.drain(play_chunk);  // receive the tail audio; keeps WebSocket open

// Session 2: no reconnection needed
config.voice_id = 1072;
session.update_config(config);
session.send("Hello from voice two.", /*flush=*/true, play_chunk);
session.drain(play_chunk);

session.close();  // Closes session + WebSocket

final session = client.tts.streamingSession(StreamConfig(voiceId: 1071, language: 'en'));
session.audio.listen((chunk) => playAudio(chunk.audio));
await session.connect();

// Session 1
await session.send('Hello from voice one.');
await session.flush(); // Delivers the remaining audio, keeps WebSocket open

// Session 2: no reconnection needed
session.updateConfig(StreamConfig(voiceId: 1072, language: 'en'));
await session.send('Hello from voice two.');
await session.flush();

await session.close(); // Closes session + WebSocket

session = client.tts.streaming_session(voice_id=1071)

async for chunk in session.send("This is a very long answer the user talks over"):
    play_audio(chunk.audio)

# VAD detected the user speaking: barge in
await session.cancel_current()

# Socket still open: next turn starts immediately
async for chunk in session.send("Sure, what would you like instead?", flush=True):
    play_audio(chunk.audio)

const session = client.tts.streamingSession(
  { voiceId: 1071 },
  {
    onChunk: (chunk) => playAudio(chunk.audio),
    onInterrupted: () => stopLocalPlayback(),
  }
);
await session.connect();

session.send('This is a very long answer the user talks over');

// VAD detected the user speaking: barge in
await session.cancelCurrent();

// Socket still open: next turn starts immediately
session.send('Sure, what would you like instead?', true);

StreamCallbacks callbacks = new StreamCallbacks() {
    @Override public void onChunk(AudioChunk chunk) { playAudio(chunk); }
    @Override public void onInterrupted() { stopLocalPlayback(); }
};

StreamingSession session = client.streamingSession(config, callbacks);
session.connect();

session.send("This is a very long answer the user talks over");

// VAD detected the user speaking: barge in
session.cancelCurrent();

// Socket still open: next turn starts immediately
session.send("Sure, what would you like instead?", true);

let mut session = client.tts().streaming_session(StreamConfig::new(1071).language("en"));

let mut audio = session.send("This is a very long answer the user talks over", false);
while let Some(chunk) = audio.next().await {
    play_audio(&chunk?.audio);
}
drop(audio);

// VAD detected the user speaking: barge in
stop_local_playback();
session.cancel().await?;

// Socket still open: next turn starts immediately
let mut audio = session.send("Sure, what would you like instead?", true);
while let Some(chunk) = audio.next().await {
    play_audio(&chunk?.audio);
}

#include <thread>

auto play_chunk = [](const kugelaudio::AudioChunk& chunk) { play_audio(chunk.audio); };
kugelaudio::StreamingSession session = client.tts().streaming_session(config);

// The agent speaks on its own thread
std::thread speaker([&] {
  session.send("This is a very long answer the user talks over", /*flush=*/true, play_chunk);
});

// VAD detected the user speaking: barge in from this thread
stop_local_playback();
session.cancel();  // the blocked send() returns early without the cancelled audio
speaker.join();

// Socket still open: next turn starts immediately
session.send("Sure, what would you like instead?", /*flush=*/true, play_chunk);

final session = client.tts.streamingSession(StreamConfig(voiceId: 1071, language: 'en'));
session.audio.listen((chunk) => playAudio(chunk.audio));

await session.send('This is a very long answer the user talks over');

// VAD detected the user speaking: barge in
stopLocalPlayback();
await session.cancel(); // a pending flush() completes with null

// Socket still open: next turn starts immediately
await session.flush('Sure, what would you like instead?');

session = client.tts.streaming_session(voice_id=1071, cfg_scale=2.0)

async for chunk in session.send("Default voicing.", flush=True):
    play_audio(chunk.audio)

# Change cfg_scale / speed / temperature for the next turn:
effective = await session.update_settings(cfg_scale=1.5, speed=1.1)
# -> {"cfg_scale": 1.5, "temperature": ..., "speed": 1.1, ...}

async for chunk in session.send("Now a bit faster and softer.", flush=True):
    play_audio(chunk.audio)

const effective = await session.updateSettings({ cfgScale: 1.5, speed: 1.1 });
// -> { cfgScale: 1.5, temperature: ..., speed: 1.1, ... }

session.send('Now a bit faster and softer.', true);

import com.kugelaudio.sdk.EffectiveSettings;
import com.kugelaudio.sdk.SettingsUpdate;

EffectiveSettings effective = session.updateSettings(
        SettingsUpdate.builder().cfgScale(1.5).speed(1.1).build());
// effective.getCfgScale() == 1.5, effective.getSpeed() == 1.1, ...

session.send("Now a bit faster and softer.", true);

use kugelaudio::SettingsUpdate;

let effective = session
    .update_settings(&SettingsUpdate::new().cfg_scale(1.5).speed(1.1))
    .await?;
// effective.cfg_scale == Some(1.5), effective.speed == Some(1.1), ...

let mut audio = session.send("Now a bit faster and softer.", true);
while let Some(chunk) = audio.next().await {
    play_audio(&chunk?.audio);
}

kugelaudio::GenerationSettings change;
change.cfg_scale = 1.5;
change.speed = 1.1;
kugelaudio::GenerationSettings effective = session.update_settings(change);
// *effective.cfg_scale == 1.5, *effective.speed == 1.1, ...

session.send("Now a bit faster and softer.", /*flush=*/true, play_chunk);

final effective = await session.updateSettings(cfgScale: 1.5, speed: 1.1);
// -> {cfg_scale: 1.5, temperature: ..., speed: 1.1, ...}

await session.flush('Now a bit faster and softer.');

async with client.tts.streaming_session(voice_id=1071) as session:
    async for chunk in session.send("Hello!", flush=True):
        play_audio(chunk.audio)

usage = session.last_usage  # None before the first session closes
if usage is not None:
    print(f"audio: {usage.audio_seconds:.1f}s")
    if usage.cost_available:
        print(f"charged: {usage.cost_cents:.2f} {usage.currency} ct")

await session.close();

const usage = session.lastUsage; // null before the first session closes
if (usage) {
  console.log(`audio: ${usage.audioSeconds.toFixed(1)}s`);
  if (usage.costAvailable) {
    console.log(`charged: ${usage.costCents!.toFixed(2)} ${usage.currency} ct`);
  }
}

import com.kugelaudio.sdk.SessionUsage;

SessionUsage usage = session.getLastUsage();
if (usage != null) {
    System.out.printf("audio: %.1fs%n", usage.getAudioSeconds());
    if (usage.isCostAvailable()) {
        System.out.printf("charged: %.2f %s ct%n",
                usage.getCostCents(), usage.getCurrency());
    }
}

// None before the first turn closes
if let Some(usage) = session.last_usage() {
    println!("audio: {:.1}s", usage.audio_seconds);
    if let Some(cost) = usage.cost_cents {
        println!("charged: {:.2} {} ct", cost, usage.currency.as_deref().unwrap_or(""));
    }
}

// std::nullopt before the first turn closes
if (std::optional<kugelaudio::SessionUsage> usage = session.last_usage()) {
  std::cout << "audio: " << usage->audio_seconds << "s\n";
  if (usage->cost_available()) {
    std::cout << "charged: " << *usage->cost_cents << ' ' << usage->currency.value_or("")
              << " ct\n";
  }
}

final turn = await session.flush();
final usage = turn?.usage ?? session.lastUsage; // null before the first turn ends
if (usage != null) {
  print('audio: ${usage.audioSeconds.toStringAsFixed(1)}s');
  if (usage.costAvailable) {
    print('charged: ${usage.costCents!.toStringAsFixed(2)} ${usage.currency} ct');
  }
}

async with client.tts.multi_context_session(language="en") as session:
    # Create contexts, optionally with different voices
    await session.create_context("narrator", voice_id=1071)
    await session.create_context("character", voice_id=1072)

    # Send text to a specific context
    async for chunk in session.send("narrator", "The story begins."):
        play_audio(chunk.audio)

    async for chunk in session.send("character", "Hello there!", flush=True):
        play_audio(chunk.audio)

    # Drain remaining audio and close one context
    async for chunk in session.close_context("narrator"):
        play_audio(chunk.audio)

const session = client.tts.createMultiContextSession({
  defaultVoiceId: 1071,
  language: 'en',
});

// Resolve a promise per context when the server reports it closed
const closed = new Map<string, () => void>();
const whenClosed = (id: string) =>
  new Promise<void>((resolve) => closed.set(id, resolve));

await session.connect({
  onChunk: (chunk) => {
    // chunk.contextId tells you which speaker this audio belongs to
    playAudio(chunk.contextId, chunk.audio);
  },
  onContextClosed: (contextId, usage) => {
    // `usage` carries this conversation's audio time + amount charged (EUR cents)
    console.log(`${contextId} finished`, usage);
    closed.get(contextId)?.();
  },
  onError: (err, contextId) => console.error(contextId, err),
});

// Create contexts, optionally with different voices
session.createContext('narrator', { voiceId: 1071 });
session.createContext('character', { voiceId: 1072 });
const done = Promise.all([whenClosed('narrator'), whenClosed('character')]);

// Send text to a specific context
session.send('narrator', 'The story begins.');
session.send('character', 'Hello there!', true); // flush

// A graceful close lets each context finish its audio
session.closeContext('narrator');
session.closeContext('character');
await done;

session.close();

import com.kugelaudio.sdk.MultiContextConfig;
import com.kugelaudio.sdk.MultiContextSession;
import com.kugelaudio.sdk.MultiContextCallbacks;
import com.kugelaudio.sdk.CreateContextOptions;
import com.kugelaudio.sdk.AudioChunk;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;

MultiContextConfig config = MultiContextConfig.builder()
    .language("en")
    .sampleRate(24000)
    .build();

CountDownLatch bothClosed = new CountDownLatch(2);

try (MultiContextSession session = client.multiContextSession(config)) {
    session.connect(new MultiContextCallbacks() {
        @Override
        public void onChunk(String contextId, AudioChunk chunk) {
            playAudio(contextId, chunk.getAudio());
        }

        @Override
        public void onContextClosed(String contextId) {
            // Per-context usage (audio time + amount charged): each
            // context is billed independently.
            System.out.println("[" + contextId + "] usage: " + session.getUsageFor(contextId));
            bothClosed.countDown();
        }

        @Override
        public void onError(String contextId, com.kugelaudio.sdk.KugelAudioException error) {
            System.err.println("[" + contextId + "] Error: " + error.getMessage());
        }
    });

    session.createContext("speaker-a", CreateContextOptions.builder().voiceId(101).build());
    session.createContext("speaker-b", CreateContextOptions.builder().voiceId(202).build());

    session.send("speaker-a", "Hello from speaker A!", true);
    session.send("speaker-b", "And greetings from speaker B!", true);

    // Graceful close: queued text finishes, then context_closed arrives.
    session.closeContext("speaker-a");
    session.closeContext("speaker-b");

    // close() cancels every live context, so wait for both before leaving the block.
    bothClosed.await(30, TimeUnit.SECONDS);
}

use futures_util::StreamExt;
use kugelaudio::MultiContextConfig;

let mut session = client
    .tts()
    .multi_context_session(MultiContextConfig::default().language("en"));
session.connect().await?;

// Create contexts, optionally with different voices
session.create_context("narrator", Some(1071.into())).await?;
session.create_context("character", Some(1072.into())).await?;

// Send text to a specific context and receive its audio
for (context, text) in [("narrator", "The story begins."), ("character", "Hello there!")] {
    let mut audio = session.send(context, text, true, None);
    while let Some(chunk) = audio.next().await {
        play_audio(&chunk?.audio);
    }
}

// A graceful close lets each context finish its audio
for context in ["narrator", "character"] {
    let mut tail = session.close_context(context, false);
    while let Some(chunk) = tail.next().await {
        play_audio(&chunk?.audio);
    }
    drop(tail);
    println!("{context} usage: {:?}", session.usage_for(context));
}

session.close().await;

kugelaudio::MultiContextConfig config;
config.language = "en";
kugelaudio::MultiContextSession session = client.tts().multi_context_session(config);
session.connect();

// Create contexts, optionally with different voices
session.create_context("narrator", 1071);
session.create_context("character", 1072);

auto play_chunk = [](const kugelaudio::AudioChunk& chunk) {
  // chunk.context_id tells you which speaker this audio belongs to
  play_audio(*chunk.context_id, chunk.audio);
};

// Send text to a specific context and receive its audio
session.send("narrator", "The story begins.", /*flush=*/true, play_chunk);
session.send("character", "Hello there!", /*flush=*/true, play_chunk);

// A graceful close lets each context finish its audio
session.close_context("narrator", /*immediate=*/false, play_chunk);
session.close_context("character", /*immediate=*/false, play_chunk);
if (auto usage = session.usage_for("narrator")) {
  std::cout << "narrator usage: " << usage->audio_seconds << "s\n";
}

session.close();

final session = client.tts.multiContextSession(MultiContextConfig(language: 'en'));

// Audio of every context arrives on one stream; chunk.contextId names the speaker
session.audio.listen((chunk) => playAudio(chunk.contextId!, chunk.audio));
await session.connect();

// Create contexts, optionally with different voices
await session.createContext('narrator', voiceId: 1071);
await session.createContext('character', voiceId: 1072);

// Send text to a specific context; flush() waits for its audio
await session.send('narrator', 'The story begins.');
await session.flush('character', 'Hello there!');

// A graceful close lets each context finish its audio and returns its usage
final narratorUsage = await session.closeContext('narrator');
await session.closeContext('character');
print('narrator usage: ${narratorUsage?.audioSeconds}s');

await session.close();

async for chunk in session.close_context("narrator", immediate=True):
    play_audio(chunk.audio)

session.closeContext('narrator', true); // immediate = true

session.closeContext("speaker-a", true); // immediate = true

let mut tail = session.close_context("narrator", true); // immediate = true
while let Some(chunk) = tail.next().await {
    play_audio(&chunk?.audio);
}

session.close_context("narrator", /*immediate=*/true, play_chunk);

await session.closeContext('narrator', immediate: true);

from kugelaudio import AudioChunk, WordTimestamp

# Timestamps are yielded as list[WordTimestamp] items between audio chunks
for item in client.tts.stream(
    text="Hello, how are you today?",
    model_id="kugel-3.5",
    voice_id=1071,
    word_timestamps=True,
):
    if isinstance(item, AudioChunk):
        play_audio(item.audio)
    elif isinstance(item, list) and item and isinstance(item[0], WordTimestamp):
        for ts in item:
            print(f"{ts.word}: {ts.start_ms}-{ts.end_ms}ms")

await client.tts.stream(
  {
    text: 'Hello, how are you today?',
    modelId: 'kugel-3.5',
    voiceId: 1071,
    wordTimestamps: true,
  },
  {
    onChunk: (chunk) => {
      playAudio(chunk.audio);
    },
    onWordTimestamps: (timestamps) => {
      for (const ts of timestamps) {
        console.log(`${ts.word}: ${ts.startMs}-${ts.endMs}ms`);
      }
    },
    onFinal: (stats) => {
      console.log(`Done: ${stats.durationMs}ms`);
    },
  }
);

client.tts().stream(
    GenerateRequest.builder("Hello, how are you today?")
        .modelId("kugel-3.5")
        .voiceId(1071)
        .language("en")
        .wordTimestamps(true)
        .build(),
    new StreamCallbacks() {
        @Override
        public void onChunk(AudioChunk chunk) {
            playAudio(chunk.getAudio());
        }

        @Override
        public void onWordTimestamps(java.util.List<WordTimestamp> timestamps) {
            for (WordTimestamp ts : timestamps) {
                System.out.printf("%s: %dms-%dms%n",
                    ts.getWord(), ts.getStartMs(), ts.getEndMs());
            }
        }
    }
);

// Timestamps arrive as StreamEvent::WordTimestamps between audio events
let request = TtsRequest::new("Hello, how are you today?")
    .model_id("kugel-3.5")
    .voice_id(1071)
    .word_timestamps(true);
let mut stream = client.tts().stream(&request).await?;
while let Some(event) = stream.next().await {
    match event? {
        StreamEvent::Audio(chunk) => play_audio(&chunk.audio),
        StreamEvent::WordTimestamps(words) => {
            for ts in words {
                println!("{}: {}-{}ms", ts.word, ts.start_ms, ts.end_ms);
            }
        }
        StreamEvent::Final(stats) => println!("Done: {:?}ms", stats.duration_ms),
        _ => {}
    }
}

kugelaudio::GenerateRequest request;
request.text = "Hello, how are you today?";
request.model_id = "kugel-3.5";
request.voice_id = 1071;
request.word_timestamps = true;

kugelaudio::StreamCallbacks callbacks;
callbacks.on_audio = [](const kugelaudio::AudioChunk& chunk) { play_audio(chunk.audio); };
callbacks.on_word_timestamps = [](const std::vector<kugelaudio::WordTimestamp>& stamps) {
  for (const auto& ts : stamps) {
    std::cout << ts.word << ": " << ts.start_ms << "-" << ts.end_ms << "ms\n";
  }
};
kugelaudio::AudioResponse result = client.tts().stream(request, callbacks);
// result.word_timestamps holds all of them

final stream = client.tts.stream(
  text: 'Hello, how are you today?',
  modelId: 'kugel-3.5',
  voiceId: 1071,
  wordTimestamps: true,
  onWordTimestamps: (timestamps) {
    for (final ts in timestamps) {
      print('${ts.word}: ${ts.startMs}-${ts.endMs}ms');
    }
  },
);
await for (final chunk in stream) {
  playAudio(chunk.audio);
}
print('Done: ${(await stream.result).durationMs}ms');
// stream.wordTimestamps holds all of them

async with client.tts.streaming_session(
    voice_id=1071,
    word_timestamps=True,
) as session:
    async for chunk in session.send("Hello, how are you today?"):
        play_audio(chunk.audio)

    async for chunk in session.flush():
        play_audio(chunk.audio)

    # Access the latest word timestamps
    timestamps = session.last_word_timestamps
    for ts in timestamps:
        print(f"{ts.word}: {ts.start_ms}ms - {ts.end_ms}ms (score: {ts.score:.2f})")

# Or register a callback to process timestamps as they arrive
def on_timestamps(timestamps):
    for ts in timestamps:
        print(f"  {ts.word} [{ts.start_ms}-{ts.end_ms}ms]")

async with client.tts.streaming_session(
    voice_id=1071,
    on_word_timestamps=on_timestamps,
) as session:
    async for chunk in session.send("Hello world!"):
        play_audio(chunk.audio)
    async for chunk in session.flush():
        play_audio(chunk.audio)

const session = client.tts.streamingSession(
  { voiceId: 1071, wordTimestamps: true },
  {
    onChunk: (chunk) => playAudio(chunk.audio),
    onWordTimestamps: (timestamps) => {
      for (const ts of timestamps) {
        console.log(`  ${ts.word} [${ts.startMs}-${ts.endMs}ms]`);
      }
    },
  }
);
await session.connect();
session.send('Hello, how are you today?');
await session.close();

StreamConfig config = StreamConfig.builder()
    .voiceId(1071)
    .wordTimestamps(true)
    .build();

try (StreamingSession session = client.streamingSession(config, new StreamCallbacks() {
    @Override
    public void onChunk(AudioChunk chunk) {
        playAudio(chunk.getAudio());
    }

    @Override
    public void onWordTimestamps(java.util.List<WordTimestamp> timestamps) {
        for (WordTimestamp ts : timestamps) {
            System.out.printf("  %s [%d-%dms]%n", ts.getWord(), ts.getStartMs(), ts.getEndMs());
        }
    }
})) {
    session.send("Hello, how are you today?");
}

let mut session = client
    .tts()
    .streaming_session(StreamConfig::new(1071).word_timestamps(true));

// Register a callback to process timestamps as they arrive
session.on_word_timestamps(|timestamps| {
    for ts in timestamps {
        println!("  {} [{}-{}ms]", ts.word, ts.start_ms, ts.end_ms);
    }
});

let mut audio = session.send("Hello, how are you today?", true);
while let Some(chunk) = audio.next().await {
    play_audio(&chunk?.audio);
}
drop(audio);

// Or read the latest word timestamps
for ts in session.last_word_timestamps() {
    println!("{}: {}ms - {}ms", ts.word, ts.start_ms, ts.end_ms);
}
session.close().await?;

kugelaudio::StreamConfig config;
config.voice_id = 1071;
config.word_timestamps = true;

kugelaudio::StreamingSessionCallbacks callbacks;
callbacks.on_word_timestamps = [](const std::vector<kugelaudio::WordTimestamp>& stamps) {
  for (const auto& ts : stamps) {
    std::cout << "  " << ts.word << " [" << ts.start_ms << "-" << ts.end_ms << "ms]\n";
  }
};

auto session = client.tts().streaming_session(config, callbacks);
session.send("Hello, how are you today?", /*flush=*/true,
             [](const kugelaudio::AudioChunk& chunk) { play_audio(chunk.audio); });
// session.last_word_timestamps() holds the latest frame
session.close();

final session = client.tts.streamingSession(
  StreamConfig(voiceId: 1071, wordTimestamps: true),
);
session.audio.listen((chunk) => playAudio(chunk.audio));
session.wordTimestamps.listen((timestamps) {
  for (final ts in timestamps) {
    print('  ${ts.word} [${ts.startMs}-${ts.endMs}ms]');
  }
});

final turn = await session.flush('Hello, how are you today?');
// turn?.wordTimestamps holds the turn's timestamps
await session.close();