LLM Sessions

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")
    .language("en")
    .flushTimeoutMs(500)  // Auto-flush after 500ms of no input
    .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.
}

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

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);

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);

StreamConfig config = StreamConfig.builder()
    .voiceId(1071)
    .modelId("kugel-3")
    .language("en")
    .temperature(0.5)
    .speed(1.0)
    .flushTimeoutMs(500)  // server-side auto-flush timeout
    .build();

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());
    }
}

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);
}

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