Stream Input

import asyncio
import websockets
import json
import base64

async def stream_from_llm(llm_tokens):
    uri = "wss://api.kugelaudio.com/ws/tts/stream?api_key=YOUR_API_KEY"

    async with websockets.connect(uri) as ws:
        # Send config
        await ws.send(json.dumps({
            "voice_id": 1071,
            "model_id": "kugel-3",
            "cfg_scale": 2.0,
        }))

        # Stream tokens
        for token in llm_tokens:
            await ws.send(json.dumps({"text": token}))

            # Check for audio (non-blocking)
            try:
                message = await asyncio.wait_for(ws.recv(), timeout=0.01)
                data = json.loads(message)
                if "audio" in data:
                    audio_bytes = base64.b64decode(data["audio"])
                    play_audio(audio_bytes)
            except asyncio.TimeoutError:
                pass

        # Flush ends the turn (emits session_closed); close_socket ends the connection.
        # For a multi-turn conversation, skip close_socket and just send the next
        # turn's text after session_closed — the config above stays in effect.
        await ws.send(json.dumps({"flush": True}))
        await ws.send(json.dumps({"close_socket": True}))

        # Receive remaining audio
        async for message in ws:
            data = json.loads(message)
            if "audio" in data:
                audio_bytes = base64.b64decode(data["audio"])
                play_audio(audio_bytes)
            if data.get("session_closed"):
                usage = data.get("usage", {})
                # Per-session usage: audio time + actual charge (EUR cents)
                print(f"Usage: {usage.get('audio_seconds')}s, {usage.get('cost_cents')} ct")
                break

# Example usage
tokens = ["Hello, ", "this ", "is ", "streaming ", "from ", "an ", "LLM."]
asyncio.run(stream_from_llm(tokens))

const API_KEY = 'YOUR_API_KEY';
const WS_URL = 'wss://api.kugelaudio.com';

async function streamFromLLM(tokens) {
  const ws = new WebSocket(`${WS_URL}/ws/tts/stream?api_key=${API_KEY}`);

  ws.onopen = () => {
    // Send config
    ws.send(JSON.stringify({
      voice_id: 1071,
      model_id: 'kugel-3',
      cfg_scale: 2.0,
    }));

    // Stream tokens
    for (const token of tokens) {
      ws.send(JSON.stringify({ text: token }));
    }

    // Flush ends the turn (emits session_closed); close_socket ends the connection.
    // For a multi-turn conversation, skip close_socket and send the next turn's
    // text after session_closed — the config above stays in effect.
    ws.send(JSON.stringify({ flush: true }));
    ws.send(JSON.stringify({ close_socket: true }));
  };

  ws.onmessage = (event) => {
    const data = JSON.parse(event.data);

    if (data.audio) {
      const binary = atob(data.audio);
      const bytes = new Uint8Array(binary.length);
      for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
      playAudio(bytes);
    }

    if (data.session_closed) {
      // Per-session usage: audio time + actual charge (EUR cents)
      console.log('Session closed; usage:', data.usage);
      ws.close();
    }
  };
}

streamFromLLM(['Hello, ', 'this ', 'is ', 'streaming ', 'from ', 'an ', 'LLM.']);

# Install wscat: npm install -g wscat
wscat -c "wss://api.kugelaudio.com/ws/tts/stream?api_key=YOUR_API_KEY"

# 1. Send config
> {"voice_id": 1071, "model_id": "kugel-3", "cfg_scale": 2.0}

# 2. Stream tokens
> {"text": "Hello, "}
> {"text": "this "}
> {"text": "is "}
> {"text": "streaming "}
> {"text": "from "}
> {"text": "an "}
> {"text": "LLM."}

# 3. Flush and close
> {"flush": true}
> {"close": true}