qwen-audio-3.0-realtime-plus

Modelo de diálogo de voz em tempo real que recebe fala e texto e responde por voz ou texto. Concebido para um ritmo natural de conversa e para interação com ferramentas.

Ailoot · Voz em tempo real GET /v1/realtime?model=qwen-audio-3.0-realtime-plus qwen-audio-3.0-realtime-plus

Sobre o modelo

Esta descrição apresenta as capacidades do modelo. As entradas, saídas e opções disponíveis no Ailoot para o método selecionado estão indicadas abaixo.

Qwen-Audio-3.0-Realtime-Plus é um modelo da Alibaba para diálogo de voz em tempo real. Recebe fala e texto, responde com áudio e texto e suporta uma conversa bidirecional com uma troca natural de intervenções. O som pode ser enviado e recebido por partes, permitindo que a interação evolua durante a conversa.

Quando o interlocutor termina a ideia

Estão previstas várias formas de determinar os limites de uma intervenção: pela atividade sonora, pela conclusão semântica e por controlo explícito. No fabricante, o modo é escolhido antes de enviar o primeiro áudio; para o alterar depois de começar a conversa, é necessária uma nova ligação. O suporte deste controlo depende do método selecionado. O modo semântico considera pausas e hesitações: uma breve dúvida não significa necessariamente que o utilizador terminou a ideia. Uma nova intervenção do utilizador pode interromper a resposta em formação, permitindo continuar a conversa com a intervenção seguinte em conta. No modo semântico, o reconhecimento pode ser orientado por uma amostra de fala do interlocutor escolhido, para reduzir a influência de outras vozes e do ruído de fundo.

As instruções definem o papel do assistente e o estilo de comunicação. A expressão vocal pode considerar o tom, o ritmo e a emoção; a versão 3.0 prevê cinco vozes de sistema e vozes baseadas numa amostra de fala. O modelo suporta 11 línguas, incluindo russo, bem como as variantes dialetais chinesas indicadas pelo fabricante. No fabricante, a voz é definida na primeira atualização das configurações da sessão; o envio posterior de outra voz na mesma conversa é ignorado. Estas configurações exigem suporte do meio de acesso escolhido.

Ferramentas e histórico da conversa

É suportada a chamada de funções. O modelo formula a ação necessária, a aplicação ligada executa-a e devolve o resultado ao diálogo. Isto permite construir a conversa em torno de dados factuais e continuá-la após a operação realizada. Um assistente de voz pode apoiar-se nos resultados das ferramentas, mantendo o contexto da conversa. As capacidades do fabricante incluem também pesquisa na Web integrada, se esta for disponibilizada pelo método escolhido. A pesquisa na Web e as chamadas de funções não podem ser ativadas em simultâneo na mesma sessão.

Por predefinição, o histórico contém 20 turnos de conversa, estando previsto um intervalo entre um e 50. Para o áudio acumulado, existe um limite de 300 segundos; as partes mais antigas do histórico são eliminadas quando os limites são ultrapassados. Isto é diferente da duração de uma intervenção individual: o histórico determina que material anterior continua disponível quando o diálogo prossegue.

Contexto textual e som

O contexto formal é de 40 960 tokens. O comprimento máximo da entrada é de 16 384 tokens e o da saída é de 8192; os mesmos limites de entrada e saída são indicados para o modo de raciocínio, com um limite separado de 1024 tokens para a cadeia de raciocínio.

Para áudio em streaming, está previsto PCM de canal único com representação de 16 bits: 16 kHz na entrada e 24 kHz na saída. Os dados textuais e de áudio pertencem à mesma conversa. Não estão anunciadas entrada visual nem geração de imagens para este modelo específico; a sua especialização é fala, texto e interação por voz.

Ailoot · Voz em tempo real 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

Introdução

Modelo de diálogo de voz em tempo real que recebe fala e texto e responde por voz ou texto. Concebido para um ritmo natural de conversa e para interação com ferramentas.

Entradas aceites: Texto · Áudio
Resultados: Texto · Áudio

Disponível no Ailoot · entradas e métodos

Ailoot · Voz em tempo real GET /v1/realtime?model=qwen-audio-3.0-realtime-plus

Entrada: text, audio
Saída: text, audio
Formato de saída: eventos da sessão

Campo	Tipo	Requisito	Valores e limites	Predefinição
Campo`query.model`	Tipo`string`	RequisitoObrigatório	Valores e limites qwen-audio-3.0-realtime-plus	Predefinição—
Campo`session.input_audio_format`	Tipo`string`	RequisitoOpcional	Valores e limites pcm16, pcm	Predefinição—
Campo`session.output_audio_format`	Tipo`string`	RequisitoOpcional	Valores e limites pcm16, pcm	Predefinição—
Campo`session.instructions`	Tipo`string`	RequisitoOpcional	Valores e limites O limite aplica-se a: política de sessão selecionada	Predefinição—
Campo`session.max_history_turns`	Tipo`integer`	RequisitoOpcional	Valores e limites Mínimo: 1 O limite aplica-se a: política de sessão selecionada	Predefinição—
Campo`input_audio_buffer.append.audio`	Tipo`base64_string`	RequisitoObrigatório	Valores e limites Conteúdo de entrada: PCM16 mono; entrada de 16 kHz, saída de 24 kHz; comprimento em bytes não vazio e par	Predefinição—

Combinações de materiais de entrada

realtime_text_audio

Parâmetros e ciclo de vida do método

Parâmetro	Contrato
Parâmetro`material_types`	Contratotext, audio
Parâmetro`required`	Contratonull
Parâmetro`optional_controls`	Contratonull
Parâmetro`content_type`	ContratoWebSocket

Ciclo de vida: exact retained published method

As estruturas dos métodos e os ID são exatos; a capacidade do fornecedor é distinta da admissão dos pedidos.

Tarifários

Tarifas dos métodos Ailoot

Ailoot Voz em tempo realGET /v1/realtime?model=qwen-audio-3.0-realtime-plus

Entrada: 0,0008 US$ / 1K
Saída: 0,0064 US$ / 1K
Entrada: 0,0048 US$ por minuto de áudio
Saída: 0,018 US$ por minuto de áudio de saída

O Ailoot reserva um montante estimado antes de um pedido. Após o resultado, liquida o custo final com base na utilização medida. No streaming, a liquidação usa o registo final de utilização. Como funcionam a reserva e a liquidação →

Exemplos de pedidos

Ailoot · Voz em tempo real

Python WebSocket · textoPython WebSocket · áudio

# 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)

Receber e guardar os resultados

Ailoot · Voz em tempo real

eventos da sessão

Guardar todos os resultados concluídos

Guarde cada resposta, ficheiro e parte de conteúdo devolvidos na íntegra.

Reúna todos os fragmentos incrementais de áudio devolvidos e todos os resultados de texto/eventos para cada ID real de resposta.

Se for necessário verificar a resposta original

Conserve os IDs reais de sessão/resposta/evento e os comprovativos.

Erros e passos seguintes

Resposta	Condição	Passo seguinte
Resposta426 · `invalid_request_error`	CondiçãoSem mudança de protocolo para WebSocket	Passo seguinteUtilize um cliente WebSocket com Upgrade: websocket.

Aliases

Aliases do modelo

Ailoot qwen-audio-3.0-realtime-plus

Aliases dos caminhos dos métodos

Use os caminhos dos métodos indicados acima.

IDs de chamada relacionados

qwen-audio-3.0-realtime-plus

FAQ · qwen-audio-3.0-realtime-plus

Que entradas e resultados estão disponíveis?: GET /v1/realtime?model=qwen-audio-3.0-realtime-plus · qwen-audio-3.0-realtime-plus: text, audio → text, audio
Que limites se aplicam?: 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