Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

WebSocket-sessies beheren

Les 11 van 14 Bijgewerkt op 3 november 2026 Ontwikkelaar
Op deze pagina
  1. Beheers de levenscyclus van de sessie
  2. Levenscyclus van de sessie
  3. Automatisch opnieuw verbinden
  4. Levensduur van de sessie beheren
  5. Sessiepool
  6. Te volgen statistieken
  7. Belangrijkste punten

Bijgewerkt op 3 november 2026, gebaseerd op de xAI-pagina Text to Speech, die melding maakt van een “sessietoestemming” van 600 seconden en een verbinding zonder time-out. De onderstaande vernieuwingsstrategie is een voorzorgsmaatregel. Bron: Text to Speech.

Beheers de levenscyclus van de sessie

In een productieomgeving is robuust beheer van WebSocket-sessies het verschil tussen een prototype en een betrouwbaar product. TTS-sessies kennen specifieke beperkingen (levensduur, limieten voor gelijktijdige verbindingen) die uw applicatie correct moet afhandelen.

Levenscyclus van de sessie

Een TTS WebSocket-sessie doorloopt de volgende cyclus:

  1. Openen: verbinding maken met wss://api.x.ai/v1/tts met de parameters
  2. Actief: uitwisselen van text.delta/audio.delta-berichten
  3. Normaal sluiten: de client of de server sluit de verbinding
  4. Onverwacht sluiten: een fout, onderhoud, of het einde van de in de documentatie genoemde sessietoestemming van 600 seconden

Sluiting detecteren

De server kan de verbinding op elk moment verbreken (interne fout, onderhoud, einde van de sessietoestemming). Uw applicatie moet de sluitgebeurtenis altijd afhandelen:

async def managed_session(api_key, language="en", voice="eve"):
    uri = f"wss://api.x.ai/v1/tts?language={language}&voice={voice}"
    headers = {"Authorization": f"Bearer {api_key}"}

    try:
        async with websockets.connect(uri, additional_headers=headers) as ws:
            yield ws
    except websockets.ConnectionClosed as e:
        print(f"Connection closed: code={e.code}, reason={e.reason}")
    except websockets.ConnectionClosedError:
        print("Connection lost unexpectedly")

Automatisch opnieuw verbinden

Voor langlopende applicaties implementeert u opnieuw verbinden met exponentiële backoff:

import asyncio
import random

class TTSSessionManager:
    def __init__(self, api_key, language="en", voice="eve"):
        self.api_key = api_key
        self.language = language
        self.voice = voice
        self.ws = None
        self.max_retries = 5

    async def connect(self):
        uri = f"wss://api.x.ai/v1/tts?language={self.language}&voice={self.voice}"
        headers = {"Authorization": f"Bearer {self.api_key}"}

        for attempt in range(self.max_retries):
            try:
                self.ws = await websockets.connect(uri, additional_headers=headers)
                print(f"Connected (attempt {attempt + 1})")
                return
            except Exception as e:
                wait = min(2 ** attempt + random.random(), 30)
                print(f"Connection failed: {e}. Retrying in {wait:.1f}s")
                await asyncio.sleep(wait)

        raise ConnectionError("Could not connect after 5 attempts")

    async def ensure_connected(self):
        if self.ws is None or self.ws.closed:
            await self.connect()

    async def synthesize(self, text):
        await self.ensure_connected()

        try:
            await self.ws.send(json.dumps({
                "type": "text.delta",
                "delta": text
            }))
            await self.ws.send(json.dumps({"type": "text.done"}))

            audio_chunks = []
            async for msg in self.ws:
                data = json.loads(msg)
                if data["type"] == "audio.delta":
                    audio_chunks.append(base64.b64decode(data["delta"]))
                elif data["type"] == "audio.done":
                    break
                elif data["type"] == "error":
                    raise Exception(data["message"])

            return b"".join(audio_chunks)

        except websockets.ConnectionClosed:
            # Opnieuw verbinden en opnieuw proberen
            await self.connect()
            return await self.synthesize(text)

Levensduur van de sessie beheren

De xAI-pagina Text to Speech noemt een “sessietoestemming” van 600 seconden zonder aan te geven wanneer deze start of wat er gebeurt bij afloop, en stelt apart dat de verbinding geen time-out heeft. De meest voorzichtige aanpak is om de tijd te meten vanaf het moment van verbinden en de sessie voor dat tijdstip te vernieuwen:

import time

class TTLAwareSession:
    TTL = 600  # seconden
    REFRESH_MARGIN = 60  # opnieuw verbinden 60 s voor afloop

    def __init__(self):
        self.connected_at = None

    async def connect(self):
        # ... verbinding ...
        self.connected_at = time.time()

    def should_refresh(self):
        if self.connected_at is None:
            return True
        elapsed = time.time() - self.connected_at
        return elapsed >= (self.TTL - self.REFRESH_MARGIN)

    async def synthesize(self, text):
        if self.should_refresh():
            await self.connect()  # Nieuwe sessie
        # ... tekst verzenden ...

Door 60 seconden voor afloop opnieuw verbinding te maken, voorkomt u dat u midden in de synthese wordt onderbroken.

Sessiepool

Voor applicaties met veel verkeer houdt u een pool van herbruikbare sessies aan:

class SessionPool:
    def __init__(self, api_key, pool_size=10):
        self.api_key = api_key
        self.pool_size = min(pool_size, 50)  # Maximaal 50 per team
        self.available = asyncio.Queue()
        self.active_count = 0

    async def acquire(self):
        if not self.available.empty():
            session = await self.available.get()
            if not session.should_refresh():
                return session

        if self.active_count < self.pool_size:
            session = TTSSessionManager(self.api_key)
            await session.connect()
            self.active_count += 1
            return session

        # Wachten tot een sessie vrijkomt
        return await self.available.get()

    async def release(self, session):
        await self.available.put(session)

Houd de grootte van de pool beperkt tot een fractie van de limiet van 50 sessies om ruimte over te houden voor andere services van uw applicatie.

Te volgen statistieken

Om sessies in productie gezond te houden, monitort u:

  • Aantal actieve sessies: mag niet hoger zijn dan 50
  • Percentage opnieuw verbindingen: een hoog percentage wijst op een netwerkprobleem of een probleem met de levensduur
  • Latentie van de eerste audio.delta: meet hoe responsief de service is
  • WebSocket-fouten: abnormale sluitcodes (1006, 1011)
class MetricsCollector:
    def __init__(self):
        self.connections = 0
        self.reconnections = 0
        self.errors = 0
        self.first_audio_latencies = []

    def record_connection(self):
        self.connections += 1

    def record_reconnection(self):
        self.reconnections += 1

    def record_first_audio(self, latency_ms):
        self.first_audio_latencies.append(latency_ms)

Belangrijkste punten

  • De documentatie noemt een sessietoestemming van 600 seconden: tel voor de zekerheid vanaf het moment van verbinden
  • Implementeer automatisch opnieuw verbinden met exponentiële backoff
  • Vernieuw de sessie voor dat tijdstip (met een marge van 60 seconden)
  • Gebruik een sessiepool voor applicaties met veel verkeer
  • Blijf binnen de limiet van 50 gelijktijdige sessies per team
  • Monitor verbindingsstatistieken in productie