Skip to main content

Integrar o modelo de conversa por voz em tempo real

Peça à ferramenta Agent para criar e executar um cliente de voz e conectar-se ao modelo de conversa por voz em tempo real do Token Plan.

Modelos suportados

ModeloCapacidade
qwen-audio-3.0-realtime-plusConversa por voz em tempo real
Para outros modelos, consulte modelos de conversa por voz em tempo real suportados pelo Token Plan.

Pré-requisitos

  • Assinatura do Token Plan. Para a Edição Pessoal, obtenha a chave de API sk-sp- em My Subscription (Personal). Para a Edição de Equipe, atribua um assento em Gerenciamento de membros e depois obtenha a chave de API.
  • Python 3.9 ou superior, microfone e alto-falantes.

Etapa 1: Enviar a instrução de integração para a ferramenta Agent

Expanda a instrução de integração abaixo e envie para a ferramenta Agent que você usa. Ela lê a chave do Token Plan já configurada, instala as dependências, cria qwen_realtime_voice.py e o executa. Não é necessário configurar a chave manualmente nem escrever Python.
Configure o modelo de conversa por voz em tempo real do Token Plan qwen-audio-3.0-realtime-plus no projeto atual:

1. Use a chave de API do Token Plan já configurada na ferramenta Agent atual (prefira TOKEN_PLAN_API_KEY e depois ANTHROPIC_AUTH_TOKEN). Se nenhuma estiver disponível, peça que eu configure uma chave do Token Plan na ferramenta Agent primeiro. Não exiba a chave nem a grave em arquivos ou logs.
2. Instale as dependências: pip install "websockets>=15" sounddevice certifi
3. Crie qwen_realtime_voice.py com o seguinte conteúdo:

```python
#!/usr/bin/env python3
import asyncio
import base64
import json
import os
import queue
import ssl
import threading

import certifi
import sounddevice as sd
import websockets

API_KEY = os.environ.get("TOKEN_PLAN_API_KEY") or os.environ.get("ANTHROPIC_AUTH_TOKEN")
if not API_KEY:
    raise SystemExit("Token Plan API Key not found. Configure it in the Agent tool first.")
WS_URL = "wss://token-plan.ap-southeast-1.maas.aliyuncs.com/api-ws/v1/realtime?model=qwen-audio-3.0-realtime-plus"

play_queue = queue.Queue()


def play_audio():
    with sd.RawOutputStream(samplerate=24000, channels=1, dtype="int16") as stream:
        while True:
            chunk = play_queue.get()
            if chunk is None:
                break
            stream.write(chunk)


async def receive(ws):
    transcript = []
    async for message in ws:
        event = json.loads(message)
        event_type = event["type"]
        if event_type == "conversation.item.input_audio_transcription.completed":
            print(f"\n[You] {event.get('transcript', '')}", flush=True)
        elif event_type == "response.audio.delta":
            play_queue.put(base64.b64decode(event["delta"]))
        elif event_type == "response.audio_transcript.delta":
            transcript.append(event.get("delta", ""))
        elif event_type == "response.audio_transcript.done":
            print(f"[AI] {''.join(transcript)}", flush=True)
            transcript.clear()
        elif event_type == "error":
            print(f"[Error] {event}", flush=True)


async def send_mic(ws):
    loop = asyncio.get_running_loop()
    audio_queue = asyncio.Queue()

    def callback(indata, frames, time_info, status):
        loop.call_soon_threadsafe(audio_queue.put_nowait, bytes(indata))

    with sd.RawInputStream(
        samplerate=16000,
        channels=1,
        dtype="int16",
        blocksize=1600,
        callback=callback,
    ):
        print("Start speaking. Press Ctrl+C to stop.", flush=True)
        while True:
            chunk = await audio_queue.get()
            await ws.send(
                json.dumps(
                    {
                        "type": "input_audio_buffer.append",
                        "audio": base64.b64encode(chunk).decode(),
                    }
                )
            )


async def main():
    context = ssl.create_default_context(cafile=certifi.where())
    async with websockets.connect(
        WS_URL,
        ssl=context,
        additional_headers={"Authorization": f"Bearer {API_KEY}"},
        max_size=None,
    ) as ws:
        await ws.recv()
        await ws.send(
            json.dumps(
                {
                    "type": "session.update",
                    "session": {
                        "modalities": ["audio", "text"],
                        "voice": "longanqian",
                        "instructions": "You are a voice assistant. Keep answers concise and natural.",
                        "input_audio_format": "pcm",
                        "output_audio_format": "pcm",
                        "turn_detection": {
                            "type": "server_vad",
                            "threshold": 0.5,
                            "silence_duration_ms": 600,
                        },
                    },
                }
            )
        )
        threading.Thread(target=play_audio, daemon=True).start()
        await asyncio.gather(receive(ws), send_mic(ws))


if __name__ == "__main__":
    try:
        asyncio.run(main())
    except KeyboardInterrupt:
        pass
    finally:
        play_queue.put(None)
```

4. Use a ferramenta Bash para executar python3 qwen_realtime_voice.py com timeout de 600000 milissegundos.
5. Depois que o script iniciar, peça ao usuário para começar a falar e pressionar Ctrl+C para parar.
Na primeira execução, permita que o aplicativo que executa a ferramenta Agent (como Cursor ou Terminal) acesse o microfone nas configurações do sistema. Caso contrário, o script não recebe áudio. Use fones de ouvido para evitar que o áudio dos alto-falantes seja capturado pelo microfone e interrompa a resposta.

Etapa 2: Iniciar a conversa por voz

Depois que a ferramenta Agent iniciar o script, comece a falar quando a mensagem de início aparecer. O terminal mostra a transcrição e a resposta do modelo, e os alto-falantes reproduzem o áudio. Pressione Ctrl+C para encerrar a sessão.
A ferramenta Agent instala as dependências, cria o script e inicia a sessão. Os dados de áudio trafegam entre o cliente local e o Token Plan e não passam pelo modelo de texto da ferramenta Agent.

Salvar como extensão da ferramenta

Para usar novamente, peça à ferramenta Agent para salvar a instrução acima como Skill, Slash Command ou configuração de Agent da ferramenta atual e inicie pelo acionador dessa ferramenta. Mecanismos de extensão e caminhos para ferramentas comuns:
FerramentaMecanismo de extensãoCaminho do arquivo de configuração
Claude CodeSlash Command.claude/commands/voice-chat.md
CodexSkill~/.codex/skills/token-plan-voice/SKILL.md
Qwen CodeSkill~/.qwen/skills/voice-chat/SKILL.md
OpenCodeAgent.opencode/agents/voice-chat.md
OpenClawSkill~/.openclaw/workspace/skills/token-plan-voice/SKILL.md
Hermes AgentSkill~/.hermes/skills/media/voice-chat/SKILL.md
QoderSkill~/.qoder/skills/voice-chat/SKILL.md

Limitações

  • Com alto-falantes, o áudio do modelo pode ser capturado pelo microfone e interromper a resposta. Use fones de ouvido.
  • Chamadas Bash da ferramenta Agent têm um tempo limite. Para conversas longas, execute o script como um processo independente ou empacote-o em um servidor MCP.
  • A solução atual processa apenas entrada e saída de voz.