qwen-audio-3.0-realtime-plus

Model na živý hlasový dialóg, ktorý prijíma reč aj text a odpovedá hlasom alebo textom. Je navrhnutý pre prirodzené tempo komunikácie a spoluprácu s nástrojmi.

Ailoot · Hlas v reálnom čase GET /v1/realtime?model=qwen-audio-3.0-realtime-plus qwen-audio-3.0-realtime-plus

O modeli

Tento opis pokrýva možnosti modelu. Dostupné vstupy, výstupy a voľby v Ailoot sú uvedené nižšie pre vybranú metódu.

Qwen-Audio-3.0-Realtime-Plus je model spoločnosti Alibaba na živý hlasový dialóg. Prijíma reč a text, odpovedá zvukom a textom a podporuje obojstrannú konverzáciu s prirodzeným striedaním replík. Zvuk možno odovzdávať a prijímať po častiach, takže interakcia sa rozvíja počas rozhovoru.

Keď partner dokončí myšlienku

K dispozícii je viacero spôsobov určovania hraníc repliky: podľa zvukovej aktivity, podľa významového ukončenia a pomocou výslovného riadenia. U výrobcu sa režim vyberá pred odovzdaním prvého zvuku; jeho zmena po začatí rozhovoru vyžaduje nové spojenie. Podpora tohto riadenia závisí od zvolenej metódy. Významový režim zohľadňuje pauzy aj výplňové slová: krátke zaváhanie nemusí znamenať, že používateľ dokončil myšlienku. Nová reč používateľa môže prerušiť vznikajúcu odpoveď, aby rozhovor pokračoval so zohľadnením nasledujúcej repliky. Vo významovom režime možno rozpoznávanie orientovať na hlasovú vzorku vybraného partnera, aby ho menej rušili cudzie hlasy a hluk v pozadí.

Inštrukcie určujú rolu asistenta a štýl komunikácie. Hlasový prejav môže zohľadňovať tón, tempo a emócie; verzia 3.0 ponúka päť systémových hlasov a hlasy podľa hlasovej vzorky. Model podporuje 11 jazykov vrátane ruštiny a výrobcom uvedené čínske dialektové varianty. U výrobcu sa hlas zadáva pri prvej aktualizácii nastavení relácie; neskoršie odovzdanie nového hlasu v tej istej konverzácii sa ignoruje. Tieto nastavenia vyžadujú podporu zvoleného spôsobu prístupu.

Nástroje a história rozhovoru

Podporované je volanie funkcií. Model navrhne potrebnú akciu, pripojená aplikácia ju vykoná a vráti výsledok do dialógu. Konverzáciu tak možno postaviť na faktických údajoch a pokračovať v nej po vykonanej operácii. Hlasový asistent sa môže opierať o výsledky nástrojov a zachovávať kontext rozhovoru. Možnosti výrobcu zahŕňajú aj vstavané vyhľadávanie na webe, ak ho poskytuje zvolená metóda. Vyhľadávanie na webe a volania funkcií nemožno súčasne zapnúť v jednej relácii.

História štandardne obsahuje 20 kôl rozhovoru; povolený je rozsah od jedného do 50. Pre nahromadený zvuk je stanovený limit 300 sekúnd; pri prekročení obmedzení sa staré časti histórie odstránia. To sa líši od dĺžky samostatnej repliky: história určuje, ktoré predchádzajúce materiály zostávajú dostupné pri pokračovaní dialógu.

Textový kontext a zvuk

Formálny kontext je 40 960 tokenov. Maximálna dĺžka vstupu je 16 384 tokenov a výstupu 8192; rovnaké limity vstupu a výstupu sú uvedené pre režim uvažovania, so samostatným limitom reťazca uvažovania 1024 tokenov.

Pre streamovaný zvuk je k dispozícii jednokanálové PCM so 16-bitovým zápisom: na vstupe 16 kHz a na výstupe 24 kHz. Textové a zvukové údaje patria do jednej konverzácie. Vizuálny vstup a výstup obrázkov pre tento konkrétny model nie sú deklarované; jeho špecializáciou je reč, text a hlasová interakcia.

Ailoot · Hlas v reálnom čase GET /v1/realtime?model=qwen-audio-3.0-realtime-plus qwen-audio-3.0-realtime-plus

qwen-audio-3.0-realtime-plus

Alibaba /qwen-audio-3.0-realtime-plus

Úvod

Model na živý hlasový dialóg, ktorý prijíma reč aj text a odpovedá hlasom alebo textom. Je navrhnutý pre prirodzené tempo komunikácie a spoluprácu s nástrojmi.

Povolené vstupy: Text · Audio
Výsledky: Text · Audio

Dostupné v Ailoot · vstupy a metódy

Ailoot · Hlas v reálnom čase GET /v1/realtime?model=qwen-audio-3.0-realtime-plus

Vstup: text, audio
Výstup: text, audio
Výstupný formát: udalosti relácie

Pole	Typ	Požiadavka	Hodnoty a limity	Predvolené
Pole`query.model`	Typ`string`	PožiadavkaPovinné	Hodnoty a limity qwen-audio-3.0-realtime-plus	Predvolené—
Pole`session.input_audio_format`	Typ`string`	PožiadavkaVoliteľné	Hodnoty a limity pcm16, pcm	Predvolené—
Pole`session.output_audio_format`	Typ`string`	PožiadavkaVoliteľné	Hodnoty a limity pcm16, pcm	Predvolené—
Pole`session.instructions`	Typ`string`	PožiadavkaVoliteľné	Hodnoty a limity Limit sa vzťahuje na: vybraná politika relácie	Predvolené—
Pole`session.max_history_turns`	Typ`integer`	PožiadavkaVoliteľné	Hodnoty a limity Minimum: 1 Limit sa vzťahuje na: vybraná politika relácie	Predvolené—
Pole`input_audio_buffer.append.audio`	Typ`base64_string`	PožiadavkaPovinné	Hodnoty a limity Vstupný obsah: PCM16 mono; vstup 16 kHz, výstup 24 kHz; neprázdna párna dĺžka v bajtoch	Predvolené—

Kombinácie vstupných podkladov

realtime_text_audio

Parametre a životný cyklus metódy

Parameter	Špecifikácia
Parameter`material_types`	Špecifikáciatext, audio
Parameter`required`	Špecifikácianull
Parameter`optional_controls`	Špecifikácianull
Parameter`content_type`	ŠpecifikáciaWebSocket

Životný cyklus: exact retained published method

Štruktúry metód a ID sú presné; možnosti dodávateľa sa posudzujú oddelene od prijatia požiadavky.

Cenník

Sadzby metód Ailoot

Ailoot Hlas v reálnom časeGET /v1/realtime?model=qwen-audio-3.0-realtime-plus

Vstup: 0,0008 USD / 1K
Výstup: 0,0064 USD / 1K
Vstup: 0,0048 USD za minútu audia
Výstup: 0,018 USD za minútu výstupného audia

Ailoot pred požiadavkou rezervuje odhadovanú sumu. Po získaní výsledku vyúčtuje konečný poplatok podľa nameraného využitia. Pri streamovaní sa vyúčtovanie riadi konečným záznamom využitia. Ako funguje rezervácia a vyúčtovanie →

Príklady požiadaviek

Ailoot · Hlas v reálnom čase

Python WebSocket · textPython WebSocket · audio

# Install the documented client once: python3 -m pip install websockets
import base64, json, os, time, wave
from pathlib import Path
from websockets.sync.client import connect

key = os.environ.get("AILOOT_API_KEY", "")
if not key.strip():
    raise SystemExit("Set your AILOOT_API_KEY before connecting")
file = Path(os.environ.get("AILOOT_TEXT_FILE", ""))
if not file.is_file(): raise SystemExit("Set AILOOT_TEXT_FILE to your actual UTF-8 material")
material = file.read_text(encoding="utf-8")
if not material.strip(): raise SystemExit("Text material must not be empty")
out = Path("realtime-results")
out.mkdir(exist_ok=True)
audio, texts, complete = {}, {}, []
current_response = None
pending = False
deadline = time.monotonic() + 570  # Local client bound; lower server/session limits still apply.

def receive(ws, log):
    global current_response, pending
    left = deadline - time.monotonic()
    if left <= 0:
        raise TimeoutError("Client session limit; preserve IDs and partial results, do not replay")
    event = json.loads(ws.recv(timeout=min(60, left)))
    log.write(json.dumps(event, ensure_ascii=False) + "\n")
    log.flush()
    kind = event.get("type")
    if kind == "error":
        raise RuntimeError(json.dumps(event, ensure_ascii=False))
    if kind == "response.created":
        current_response = event["response"]["id"]
    if kind in {"response.audio.delta", "response.output_audio.delta", "response.text.delta", "response.output_text.delta", "response.audio_transcript.delta", "response.output_audio_transcript.delta", "response.text.done", "response.audio_transcript.done"}:
        identity = (event["response_id"], event["item_id"], event["output_index"], event["content_index"])
        if kind in {"response.audio.delta", "response.output_audio.delta"}:
            raw = base64.b64decode(event["delta"], validate=True)
            if len(raw) % 2: raise ValueError("Output PCM16 chunk must have an even byte length")
            audio.setdefault(identity, bytearray()).extend(raw)
        elif kind.endswith(".done"):
            texts[identity] = event.get("text", event.get("transcript", ""))
        else:
            texts[identity] = texts.get(identity, "") + event["delta"]
            print(event["delta"], end="", flush=True)
    if kind == "response.done":
        response = event["response"]
        complete.append(response)
        if current_response is None: current_response = response["id"]
        if response["id"] == current_response: pending = False
    return event

def wait_for(ws, log, kind):
    while True:
        event = receive(ws, log)
        if event.get("type") == kind: return event

def send(ws, event):
    ws.send(json.dumps(event, ensure_ascii=False))

try:
    # One exact model query; no reconnect/retry loop and no provider credentials.
    with connect("wss://api.ailoot.ai/v1/realtime?model=qwen-audio-3.0-realtime-plus", additional_headers={"Authorization": "Bearer " + key}) as ws:
        with (out / "events.jsonl").open("w", encoding="utf-8") as log:
            wait_for(ws, log, "session.created")
            send(ws, {"type":"session.update", "session":{"modalities":["audio","text"], "input_audio_format":"pcm", "output_audio_format":"pcm", "turn_detection":None}})
            wait_for(ws, log, "session.updated")
            send(ws, {"type":"conversation.item.create", "item":{"type":"message", "role":"user", "content":[{"type":"input_text", "text":material}]}})
            send(ws, {"type":"response.create"})
            pending = True
            try:
                while pending: receive(ws, log)
            except KeyboardInterrupt:
                # Cancel the actual current inference, then preserve its returned status.
                send(ws, {"type":"response.cancel"})
                while pending: receive(ws, log)
    if not complete or complete[-1].get("status") != "completed":
        raise RuntimeError("Response did not complete normally; inspect saved events and status")
finally:
    manifest = {"responses":complete, "parts":[]}
    for number, identity in enumerate(dict.fromkeys(list(audio) + list(texts))):
        record = {"response_id":identity[0], "item_id":identity[1], "output_index":identity[2], "content_index":identity[3]}
        if identity in audio:
            raw = bytes(audio[identity])
            pcm_file = out / ("audio-" + str(number) + ".pcm")
            wav_file = out / ("audio-" + str(number) + ".wav")
            pcm_file.write_bytes(raw)
            with wave.open(str(wav_file), "wb") as wav:
                wav.setnchannels(1); wav.setsampwidth(2); wav.setframerate(24000); wav.writeframes(raw)
            record.update({"pcm":str(pcm_file), "wav":str(wav_file), "sample_rate_hz":24000})
        if identity in texts:
            text_file = out / ("text-" + str(number) + ".txt")
            text_file.write_text(texts[identity], encoding="utf-8")
            record["text"] = str(text_file)
        manifest["parts"].append(record)
    (out / "results.json").write_text(json.dumps(manifest, ensure_ascii=False, indent=2), encoding="utf-8")
    print("\nSaved every received event and result in", out)

# Install the documented client once: python3 -m pip install websockets
import base64, json, os, time, wave
from pathlib import Path
from websockets.sync.client import connect

key = os.environ.get("AILOOT_API_KEY", "")
if not key.strip():
    raise SystemExit("Set your AILOOT_API_KEY before connecting")
file = Path(os.environ.get("AILOOT_AUDIO_FILE", ""))
if not file.is_file(): raise SystemExit("Set AILOOT_AUDIO_FILE to your raw PCM16 mono 16-kHz recording")
material = file.read_bytes()
if not material or len(material) % 2 or material.startswith(b"RIFF"):
    raise SystemExit("Use nonempty signed little-endian PCM16 mono 16-kHz bytes, not a WAV header")
out = Path("realtime-results")
out.mkdir(exist_ok=True)
audio, texts, complete = {}, {}, []
current_response = None
pending = False
deadline = time.monotonic() + 570  # Local client bound; lower server/session limits still apply.

def receive(ws, log):
    global current_response, pending
    left = deadline - time.monotonic()
    if left <= 0:
        raise TimeoutError("Client session limit; preserve IDs and partial results, do not replay")
    event = json.loads(ws.recv(timeout=min(60, left)))
    log.write(json.dumps(event, ensure_ascii=False) + "\n")
    log.flush()
    kind = event.get("type")
    if kind == "error":
        raise RuntimeError(json.dumps(event, ensure_ascii=False))
    if kind == "response.created":
        current_response = event["response"]["id"]
    if kind in {"response.audio.delta", "response.output_audio.delta", "response.text.delta", "response.output_text.delta", "response.audio_transcript.delta", "response.output_audio_transcript.delta", "response.text.done", "response.audio_transcript.done"}:
        identity = (event["response_id"], event["item_id"], event["output_index"], event["content_index"])
        if kind in {"response.audio.delta", "response.output_audio.delta"}:
            raw = base64.b64decode(event["delta"], validate=True)
            if len(raw) % 2: raise ValueError("Output PCM16 chunk must have an even byte length")
            audio.setdefault(identity, bytearray()).extend(raw)
        elif kind.endswith(".done"):
            texts[identity] = event.get("text", event.get("transcript", ""))
        else:
            texts[identity] = texts.get(identity, "") + event["delta"]
            print(event["delta"], end="", flush=True)
    if kind == "response.done":
        response = event["response"]
        complete.append(response)
        if current_response is None: current_response = response["id"]
        if response["id"] == current_response: pending = False
    return event

def wait_for(ws, log, kind):
    while True:
        event = receive(ws, log)
        if event.get("type") == kind: return event

def send(ws, event):
    ws.send(json.dumps(event, ensure_ascii=False))

try:
    # One exact model query; no reconnect/retry loop and no provider credentials.
    with connect("wss://api.ailoot.ai/v1/realtime?model=qwen-audio-3.0-realtime-plus", additional_headers={"Authorization": "Bearer " + key}) as ws:
        with (out / "events.jsonl").open("w", encoding="utf-8") as log:
            wait_for(ws, log, "session.created")
            send(ws, {"type":"session.update", "session":{"modalities":["audio","text"], "input_audio_format":"pcm", "output_audio_format":"pcm", "turn_detection":None}})
            wait_for(ws, log, "session.updated")
            for offset in range(0, len(material), 640):
                send(ws, {"type":"input_audio_buffer.append", "audio":base64.b64encode(material[offset:offset+640]).decode("ascii")})
                time.sleep(0.02)
            send(ws, {"type":"input_audio_buffer.commit"})
            wait_for(ws, log, "input_audio_buffer.committed")
            send(ws, {"type":"response.create"})
            pending = True
            try:
                while pending: receive(ws, log)
            except KeyboardInterrupt:
                # Cancel the actual current inference, then preserve its returned status.
                send(ws, {"type":"response.cancel"})
                while pending: receive(ws, log)
    if not complete or complete[-1].get("status") != "completed":
        raise RuntimeError("Response did not complete normally; inspect saved events and status")
finally:
    manifest = {"responses":complete, "parts":[]}
    for number, identity in enumerate(dict.fromkeys(list(audio) + list(texts))):
        record = {"response_id":identity[0], "item_id":identity[1], "output_index":identity[2], "content_index":identity[3]}
        if identity in audio:
            raw = bytes(audio[identity])
            pcm_file = out / ("audio-" + str(number) + ".pcm")
            wav_file = out / ("audio-" + str(number) + ".wav")
            pcm_file.write_bytes(raw)
            with wave.open(str(wav_file), "wb") as wav:
                wav.setnchannels(1); wav.setsampwidth(2); wav.setframerate(24000); wav.writeframes(raw)
            record.update({"pcm":str(pcm_file), "wav":str(wav_file), "sample_rate_hz":24000})
        if identity in texts:
            text_file = out / ("text-" + str(number) + ".txt")
            text_file.write_text(texts[identity], encoding="utf-8")
            record["text"] = str(text_file)
        manifest["parts"].append(record)
    (out / "results.json").write_text(json.dumps(manifest, ensure_ascii=False, indent=2), encoding="utf-8")
    print("\nSaved every received event and result in", out)

Prijať a uložiť výsledky

Ailoot · Hlas v reálnom čase

udalosti relácie

Uchovať všetky dokončené výsledky

Uložte každú úplnú vrátenú odpoveď, súbor a časť obsahu.

Zostavte všetky vrátené zvukové prírastky a výsledky textu alebo udalostí pre každé skutočné ID odpovede.

Ak treba overiť pôvodnú odpoveď

Zachovajte skutočné ID relácií, odpovedí a udalostí aj záznamy o nich.

Chyby a ďalšie kroky

Odpoveď	Podmienka	Ďalší krok
Odpoveď426 · `invalid_request_error`	PodmienkaBez prepnutia protokolu na WebSocket	Ďalší krokPoužite klienta WebSocket s Upgrade: websocket.

Aliasy

Aliasy modelov

Ailoot qwen-audio-3.0-realtime-plus

Aliasy ciest metód

Použite cesty metód uvedené vyššie.

Súvisiace ID na volanie

qwen-audio-3.0-realtime-plus

FAQ · qwen-audio-3.0-realtime-plus

Aké vstupy a výsledky sú dostupné?: GET /v1/realtime?model=qwen-audio-3.0-realtime-plus · qwen-audio-3.0-realtime-plus: text, audio → text, audio
Aké limity platia?: GET /v1/realtime?model=qwen-audio-3.0-realtime-plus · qwen-audio-3.0-realtime-plus: session.max_history_turns.minimum: 1

qwen-audio-3.0-realtime-plus