实时音频WS

# pip install "websockets>=13" requests
import asyncio
import base64
import json
import os
import uuid

import requests
from websockets.asyncio.client import connect

API_KEY = os.environ["TOKENTOSEA_API_KEY"]
MODEL = "qwen3-tts-flash-realtime"


async def main() -> None:
    request_key = str(uuid.uuid4())
    audio = bytearray()
    async with connect(
        f"wss://api.tokentosea.com/v1/realtime?model={MODEL}",
        additional_headers={"Authorization": f"Bearer {API_KEY}", "Idempotency-Key": request_key},
        max_size=8 * 1024 * 1024,
    ) as ws:
        await ws.send(json.dumps({"type": "session.update", "session": {
            "voice": "Cherry", "mode": "commit", "language_type": "Chinese",
            "response_format": "pcm", "sample_rate": 24000,
        }}))
        async for raw in ws:
            event = json.loads(raw)
            kind = event.get("type")
            if kind == "session.updated":
                await ws.send(json.dumps({"type": "input_text_buffer.append", "text": "你好，欢迎使用语音服务。"}))
                await ws.send(json.dumps({"type": "input_text_buffer.commit"}))
            elif kind == "response.audio.delta":  # 事件名以厂商文档为准
                audio += base64.b64decode(event["delta"])
            elif kind == "response.done":
                await ws.send(json.dumps({"type": "session.finish"}))
            elif kind in ("session.finished", "error"):
                print(event)
                break
    with open("speech.pcm", "wb") as file:  # ffmpeg -f s16le -ar 24000 -ac 1 -i speech.pcm speech.wav
        file.write(audio)
    result = requests.get(
        f"https://api.tokentosea.com/v1/results/{request_key}",
        headers={"Authorization": f"Bearer {API_KEY}"}, timeout=30,
    ).json()
    print("result:", result["status"], result.get("billing_status"))


asyncio.run(main())

// npm install ws
import WebSocket from 'ws';
import { randomUUID } from 'node:crypto';
import { writeFile } from 'node:fs/promises';

const apiKey = process.env.TOKENTOSEA_API_KEY;
const model = 'qwen3-tts-flash-realtime';
const requestKey = randomUUID();
const audio = [];

const ws = new WebSocket(`wss://api.tokentosea.com/v1/realtime?model=${model}`, {
  headers: { Authorization: `Bearer ${apiKey}`, 'Idempotency-Key': requestKey },
  maxPayload: 8 * 1024 * 1024,
});
const send = (event) => ws.send(JSON.stringify(event));

ws.on('open', () => send({
  type: 'session.update',
  session: { voice: 'Cherry', mode: 'commit', language_type: 'Chinese', response_format: 'pcm', sample_rate: 24000 },
}));
ws.on('message', (raw) => {
  const event = JSON.parse(raw.toString());
  if (event.type === 'session.updated') {
    send({ type: 'input_text_buffer.append', text: '你好，欢迎使用语音服务。' });
    send({ type: 'input_text_buffer.commit' });
  } else if (event.type === 'response.audio.delta') { // 事件名以厂商文档为准
    audio.push(Buffer.from(event.delta, 'base64'));
  } else if (event.type === 'response.done') {
    send({ type: 'session.finish' });
  } else if (['session.finished', 'error', 'tokentosea.session.closed'].includes(event.type)) {
    console.log(event);
    ws.close();
  }
});
ws.on('close', async () => {
  await writeFile('speech.pcm', Buffer.concat(audio)); // ffmpeg -f s16le -ar 24000 -ac 1 -i speech.pcm speech.wav
  const result = await fetch(`https://api.tokentosea.com/v1/results/${requestKey}`, {
    headers: { Authorization: `Bearer ${apiKey}` },
  }).then((r) => r.json());
  console.log('result:', result.status, result.billing_status);
});
ws.on('error', (error) => console.error(error.message));

# pip install "websockets>=13" requests
import asyncio
import base64
import json
import os
import uuid

import requests
from websockets.asyncio.client import connect

API_KEY = os.environ["TOKENTOSEA_API_KEY"]
MODEL = "qwen3-asr-flash-realtime"
CHUNK = 3200  # 100 ms：16000 Hz × 2 字节 × 0.1 s


async def stream_audio(ws) -> None:
    pcm = open("audio.pcm", "rb").read()
    for offset in range(0, len(pcm), CHUNK):
        chunk = base64.b64encode(pcm[offset:offset + CHUNK]).decode()
        await ws.send(json.dumps({"type": "input_audio_buffer.append", "audio": chunk}))
        await asyncio.sleep(0.1)
    await ws.send(json.dumps({"type": "input_audio_buffer.commit"}))


async def main() -> None:
    request_key = str(uuid.uuid4())
    async with connect(
        f"wss://api.tokentosea.com/v1/realtime?model={MODEL}",
        additional_headers={"Authorization": f"Bearer {API_KEY}", "Idempotency-Key": request_key},
        max_size=8 * 1024 * 1024,
    ) as ws:
        await ws.send(json.dumps({"type": "session.update", "session": {"input_audio_format": "pcm", "sample_rate": 16000}}))
        sender = None
        async for raw in ws:
            event = json.loads(raw)
            kind = event.get("type")
            if kind == "session.updated" and sender is None:
                sender = asyncio.create_task(stream_audio(ws))
            elif kind == "conversation.item.input_audio_transcription.completed":
                print("transcript:", event.get("transcript"))
                break
            elif kind == "error":
                print(event)
                break
    result = requests.get(
        f"https://api.tokentosea.com/v1/results/{request_key}",
        headers={"Authorization": f"Bearer {API_KEY}"}, timeout=30,
    ).json()
    print("result:", result["status"], result.get("billing_status"))


asyncio.run(main())

// npm install ws
import WebSocket from 'ws';
import { randomUUID } from 'node:crypto';
import { readFile } from 'node:fs/promises';

const apiKey = process.env.TOKENTOSEA_API_KEY;
const model = 'qwen3-asr-flash-realtime';
const requestKey = randomUUID();
const CHUNK = 3200; // 100 ms：16000 Hz × 2 字节 × 0.1 s
const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

const ws = new WebSocket(`wss://api.tokentosea.com/v1/realtime?model=${model}`, {
  headers: { Authorization: `Bearer ${apiKey}`, 'Idempotency-Key': requestKey },
  maxPayload: 8 * 1024 * 1024,
});
const send = (event) => ws.send(JSON.stringify(event));
let started = false;

async function streamAudio() {
  const pcm = await readFile('audio.pcm');
  for (let offset = 0; offset < pcm.length && ws.readyState === WebSocket.OPEN; offset += CHUNK) {
    send({ type: 'input_audio_buffer.append', audio: pcm.subarray(offset, offset + CHUNK).toString('base64') });
    await sleep(100);
  }
  send({ type: 'input_audio_buffer.commit' });
}

ws.on('open', () => send({ type: 'session.update', session: { input_audio_format: 'pcm', sample_rate: 16000 } }));
ws.on('message', (raw) => {
  const event = JSON.parse(raw.toString());
  if (event.type === 'session.updated' && !started) { started = true; void streamAudio(); }
  if (event.type === 'conversation.item.input_audio_transcription.completed') {
    console.log('transcript:', event.transcript);
    ws.close();
  }
  if (event.type === 'error') { console.error(event); ws.close(); }
});
ws.on('close', async () => {
  const result = await fetch(`https://api.tokentosea.com/v1/results/${requestKey}`, {
    headers: { Authorization: `Bearer ${apiKey}` },
  }).then((r) => r.json());
  console.log('result:', result.status, result.billing_status);
});