Skip to main content

Intégrer le modèle de conversation vocale en temps réel

Demandez à l'outil Agent de créer et d'exécuter un client vocal et de se connecter au modèle de conversation vocale en temps réel Token Plan.

Modèles pris en charge

ModèleCapacité
qwen-audio-3.0-realtime-plusConversation vocale en temps réel
Pour les autres modèles, consultez les modèles de conversation vocale en temps réel pris en charge par Token Plan.

Prérequis

  • Un abonnement Token Plan. Pour l'édition Personnelle, obtenez la clé API sk-sp- dans My Subscription (Personal). Pour l'édition Équipe, attribuez un siège dans Gestion des membres, puis obtenez la clé API.
  • Python 3.9 ou version ultérieure, un microphone et des haut-parleurs.

Étape 1 : Envoyer l'instruction d'intégration à l'outil Agent

Développez l'instruction d'intégration ci-dessous et envoyez-la à l'outil Agent que vous utilisez. Il lit la clé Token Plan déjà configurée, installe les dépendances, crée qwen_realtime_voice.py et l'exécute. Vous n'avez pas besoin de configurer la clé manuellement ni d'écrire du Python.
Configurez le modèle de conversation vocale en temps réel Token Plan qwen-audio-3.0-realtime-plus dans le projet actuel :

1. Utilisez la clé API Token Plan déjà configurée dans l'outil Agent actuel (lire en priorité TOKEN_PLAN_API_KEY, puis ANTHROPIC_AUTH_TOKEN). Si aucune n'est disponible, demandez-moi de configurer d'abord une clé Token Plan dans l'outil Agent. N'affichez pas la clé et ne l'écrivez pas dans des fichiers ou des journaux.
2. Installez les dépendances : pip install "websockets>=15" sounddevice certifi
3. Créez qwen_realtime_voice.py avec le contenu suivant :

```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. Utilisez l'outil Bash pour exécuter python3 qwen_realtime_voice.py avec un timeout de 600000 millisecondes.
5. Une fois le script démarré, invitez l'utilisateur à commencer à parler et à appuyer sur Ctrl+C pour arrêter.
Lors de la première exécution, autorisez l'application qui exécute l'outil Agent (comme Cursor ou Terminal) à accéder au microphone dans les réglages système. Sinon, le script ne reçoit aucun audio. Utilisez un casque pour éviter que l'audio des haut-parleurs soit capté par le microphone et interrompe la réponse.

Étape 2 : Démarrer la conversation vocale

Une fois le script lancé par l'outil Agent, commencez à parler lorsque le message de démarrage apparaît. Le terminal affiche la transcription et la réponse du modèle, et les haut-parleurs diffusent l'audio du modèle. Appuyez sur Ctrl+C pour terminer la session.
L'outil Agent installe les dépendances, crée le script et démarre la session. Les données audio circulent entre le client local et Token Plan et ne passent pas par le modèle textuel de l'outil Agent.

Enregistrer comme extension de l'outil

Pour l'utiliser à nouveau, demandez à l'outil Agent de l'enregistrer en tant que Skill, Slash Command ou configuration d'Agent de votre outil actuel, puis lancez-la via le déclencheur de cet outil. Mécanismes d'extension et chemins pour les outils courants :
OutilMécanisme d'extensionChemin du fichier de configuration
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

Limites

  • Avec des haut-parleurs, l'audio du modèle peut être capté par le microphone et interrompre la réponse. Utilisez un casque.
  • Les appels Bash de l'outil Agent ont un délai d'expiration. Pour les conversations longues, exécutez le script en tant que processus autonome ou encapsulez-le dans un serveur MCP.
  • La solution actuelle gère uniquement l'entrée et la sortie vocales.