LLM Sessions

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

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 onComplete(AudioResponse response) {
        System.out.printf("Done: %.0fms%n", response.getDurationMs());
    }
})) {
    // Send tokens as they arrive from LLM
    for (String token : tokens) {
        session.send(token);
    }
    // Flush any remaining text to trigger generation
    session.flush();
}

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
// (send new config on the next send)
session.send("Hello from voice two.");
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);

StreamConfig config = StreamConfig.builder()
    .voiceId(1071)
    .modelId("kugel-3")
    .language("en")
    .temperature(0.5)
    .speed(1.0)
    .flushTimeoutMs(500)                            // server-side auto-flush timeout
    .autoMode(true)                                 // emit at first clean sentence boundary
    .chunkLengthSchedule(List.of(50, 100, 150, 250)) // low-latency schedule
    .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;

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

try (MultiContextSession session = client.multiContextSession(config)) {
    session.connect(new MultiContextCallbacks() {
        @Override
        public void onChunk(String contextId, AudioChunk chunk) {
            System.out.printf("[%s] Chunk %d: %d samples%n",
                contextId, chunk.getIndex(), chunk.getSamples());
            playAudio(contextId, chunk.getAudio());
        }

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

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

    // Create contexts for different speakers
    session.createContext("speaker-a", CreateContextOptions.builder().voiceId(101).build());
    session.createContext("speaker-b", CreateContextOptions.builder().voiceId(202).build());

    // Send text to each context independently
    session.send("speaker-a", "Hello from speaker A!");
    session.send("speaker-b", "And greetings from speaker B!");

    session.flush("speaker-a");
    session.flush("speaker-b");

    // Barge-in: the user spoke over speaker A — cancel just that context's
    // in-flight generation (speaker B and the connection stay open).
    session.closeContext("speaker-a", true);
}