WebSocketi seansside haldamine
Sellel lehel
Uuendatud 3. novembril 2026, tuginedes xAI Text to Speech lehele, mis mainib 600-sekundilist „seansi luba“ ja ühendust ilma aegumiseta. Allpool kirjeldatud uuendusstrateegia on ettevaatusabinõu. Allikas: Text to Speech.
Valda seansi elutsüklit
Tootmiskeskkonnas eristab töökindlat toodet prototüübist just robustne WebSocketi seansihaldus. TTS-seanssidel on konkreetsed piirangud (kehtivusaeg, samaaegsuse limiidid), mida sinu rakendus peab korrektselt käsitlema.
Seansi elutsükkel
TTS-i WebSocketi seanss läbib järgmist tsüklit:
- Avamine: ühendumine aadressiga
wss://api.x.ai/v1/ttskoos parameetritega - Aktiivne: sõnumite
text.delta/audio.deltavahetamine - Normaalne sulgemine: klient või server sulgeb ühenduse
- Ootamatu sulgemine: viga, hooldustööd või dokumentatsioonis mainitud 600-sekundilise seansi loa lõppemine
Sulgemise tuvastamine
Server võib ühenduse igal ajal sulgeda (sisemine viga, hooldustööd, seansi loa lõppemine). Sinu rakendus peaks alati käsitlema sulgemissündmust:
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")
Automaatne uuesti ühendumine
Pikaajaliste rakenduste jaoks rakenda uuesti ühendumine eksponentsiaalse taganemisega (exponential 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:
# Ühendu uuesti ja proovi uuesti
await self.connect()
return await self.synthesize(text)
Seansi kehtivusaja haldamine
xAI Text to Speech leht mainib 600-sekundilist „seansi luba“, täpsustamata, millal see algab või mis juhtub selle lõppedes, ning eraldi väidab, et ühendusel puudub aegumine. Ettevaatlikum lähenemine on lugeda aega alates ühenduse loomisest ja uuendada seanss enne selle punkti saavutamist:
import time
class TTLAwareSession:
TTL = 600 # sekundit
REFRESH_MARGIN = 60 # ühendu uuesti 60 s enne aegumist
def __init__(self):
self.connected_at = None
async def connect(self):
# ... ühendus ...
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() # Uus seanss
# ... saada tekst ...
Uuesti ühendumine 60 sekundit enne aegumist hoiab ära katkestuse sünteesi keskel.
Seansipuhver
Suure liiklusega rakenduste jaoks hoia alles taaskasutatavate seansside puhvrit:
class SessionPool:
def __init__(self, api_key, pool_size=10):
self.api_key = api_key
self.pool_size = min(pool_size, 50) # Maks 50 meeskonna kohta
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
# Oota, kuni seanss vabaneb
return await self.available.get()
async def release(self, session):
await self.available.put(session)
Hoia puhvri suurus murdosana 50-seansilisest limiidist, et jätta varu rakenduse muudele teenustele.
Jälgitavad mõõdikud
Seansside tervise säilitamiseks tootmiskeskkonnas jälgi järgmist:
- Aktiivsete seansside arv: ei tohi ületada 50
- Uuesti ühendumise määr: kõrge määr viitab võrgu- või kehtivusajaprobleemile
- Esimese audio.delta latentsus: mõõdab teenuse reageerimisvõimet
- WebSocketi vead: ebanormaalsed sulgemiskoodid (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)
Peamised punktid
- Dokumentatsioon mainib 600-sekundilist seansi luba: ohutuse mõttes loe seda alates ühenduse loomisest
- Rakenda automaatne uuesti ühendumine eksponentsiaalse taganemisega
- Uuenda seanss enne selle punkti saavutamist (60-sekundilise varuga)
- Kasuta suure liiklusega rakenduste jaoks seansipuhvrit
- Püsi 50 samaaegse seansi piiris meeskonna kohta
- Jälgi tootmiskeskkonnas ühenduse mõõdikuid