realtime socket

import asyncio, base64, json, requests, websockets

API_KEY = "rk_live_•••••••••"
BASE = "https://silk-api.rumik.ai"
AGENT = "ua_fe3277d8"
RATE, FRAME = 24000, 480          # 20 ms of 24 kHz mono

async def main():
    # 1. mint a single-use token on the server
    reg = requests.post(f"{BASE}/v1/register-call",
                        headers={"Authorization": f"Bearer {API_KEY}"},
                        json={"agent_id": AGENT}).json()

    url = f'{BASE.replace("https", "wss")}/v1/agent/connect?token={reg["access_token"]}'
    async with websockets.connect(url) as ws:
        reply = json.loads(await ws.recv())
        assert reply["type"] == "session.created", reply
        print("call", reply["call_id"], "at", reply["sample_rate"], "Hz")

        async def send_mic():
            # replace with real capture; here: 10 s of silence, correctly framed
            for _ in range(50 * 10):
                pcm = b"\x00\x00" * FRAME
                await ws.send(json.dumps({
                    "type": "input_audio_buffer.append",
                    "audio": base64.b64encode(pcm).decode(),
                }))
                await asyncio.sleep(0.02)
            await ws.send(json.dumps({"type": "session.close"}))

        async def receive():
            speech = bytearray()
            async for raw in ws:
                event = json.loads(raw)
                if event["type"] == "output_audio.delta":
                    speech.extend(base64.b64decode(event["audio"]))
                elif event["type"] in ("transcript", "transcript.delta"):
                    print(f'{event["role"]}: {event["text"]}')
                elif event["type"] == "session.closed":
                    print("closed:", event["reason"])
                    break
                elif event["type"] == "error":
                    print("error:", event["code"], event["message"])
            return bytes(speech)      # 24 kHz mono PCM — write a WAV header to save

        _, audio = await asyncio.gather(send_mic(), receive())
        print(f"{len(audio) / (RATE * 2):.1f}s of agent audio")

asyncio.run(main())

// The page never sees the API key — your server mints the token.
const { access_token } = await fetch("/api/agent-token", { method: "POST" }).then((r) => r.json());
const ws = new WebSocket(`wss://silk-api.rumik.ai/v1/agent/connect?token=${access_token}`);

const RATE = 24000;
const play = new AudioContext({ sampleRate: RATE });
let playhead = 0;

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

  if (msg.type === "session.created") {
    startMic(ws);                                   // see below
  } else if (msg.type === "output_audio.delta") {
    // schedule each chunk back-to-back so playback is gapless
    const bytes = Uint8Array.from(atob(msg.audio), (c) => c.charCodeAt(0));
    const pcm = new Int16Array(bytes.buffer);
    const buffer = play.createBuffer(1, pcm.length, RATE);
    const channel = buffer.getChannelData(0);
    for (let i = 0; i < pcm.length; i++) channel[i] = pcm[i] / 32768;

    const src = play.createBufferSource();
    src.buffer = buffer;
    src.connect(play.destination);
    const at = Math.max(play.currentTime + 0.05, playhead);
    src.start(at);
    playhead = at + buffer.duration;
  } else if (msg.type === "transcript") {
    console.log(`${msg.role}: ${msg.text}`);
  } else if (msg.type === "session.closed") {
    console.log("closed:", msg.reason);
  }
};

async function startMic(ws) {
  const stream = await navigator.mediaDevices.getUserMedia({ audio: { channelCount: 1 } });
  const ctx = new AudioContext({ sampleRate: RATE });
  const source = ctx.createMediaStreamSource(stream);

  // A worklet keeps capture off the main thread.
  const code = `class Tap extends AudioWorkletProcessor {
    process(inputs) { const c = inputs[0]?.[0]; if (c) this.port.postMessage(new Float32Array(c)); return true; }
  } registerProcessor('tap', Tap);`;
  await ctx.audioWorklet.addModule(URL.createObjectURL(new Blob([code], { type: "application/javascript" })));

  const tap = new AudioWorkletNode(ctx, "tap");
  tap.port.onmessage = (e) => {
    if (ws.readyState !== WebSocket.OPEN) return;
    const pcm = new Int16Array(e.data.length);
    for (let i = 0; i < e.data.length; i++) {
      const s = Math.max(-1, Math.min(1, e.data[i]));
      pcm[i] = s < 0 ? s * 0x8000 : s * 0x7fff;
    }
    const bytes = new Uint8Array(pcm.buffer);
    let bin = "";
    for (const b of bytes) bin += String.fromCharCode(b);
    ws.send(JSON.stringify({ type: "input_audio_buffer.append", audio: btoa(bin) }));
  };
  source.connect(tap).connect(ctx.destination);
}