WebSocket-sessies beheren
Op deze pagina
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:
- Openen: verbinding maken met
wss://api.x.ai/v1/ttsmet de parameters - Actief: uitwisselen van
text.delta/audio.delta-berichten - Normaal sluiten: de client of de server sluit de verbinding
- 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