Valdymas WebSocket sesijomis
Šiame puslapyje
Atnaujinta 2026 m. lapkričio 3 d., remiantis xAI Text to Speech puslapiu, kuriame minima 600 sekundžių „sesijos leidimas“ ir ryšys be laiko limito. Toliau pateikta atnaujinimo strategija yra atsargumo priemonė. Šaltinis: Text to Speech.
Įvaldyk sesijos gyvavimo ciklą
Gaminiuose būtent patikimas WebSocket sesijų valdymas atskiria prototipą nuo patikimo produkto. TTS sesijos turi specifinių apribojimų (gyvavimo trukmė, vienalaikiškumo limitai), kuriuos tavo programa turi tinkamai apdoroti.
Sesijos gyvavimo ciklas
TTS WebSocket sesija pereina šį ciklą:
- Atidarymas: prisijungimas prie
wss://api.x.ai/v1/ttssu parametrais - Aktyvus: keitimasis
text.delta/audio.deltažinutėmis - Normalus uždarymas: klientas arba serveris užveria ryšį
- Netikėtas uždarymas: klaida, techninė priežiūra arba dokumentacijoje minimo 600 sekundžių sesijos leidimo pabaiga
Aptikti uždarymą
Serveris gali bet kada nutraukti ryšį (vidinė klaida, techninė priežiūra, sesijos leidimo pabaiga). Tavo programa visada turi apdoroti uždarymo įvykį:
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")
Automatinis prisijungimas iš naujo
Ilgo veikimo programoms įgyvendink prisijungimą iš naujo naudodamas eksponentinį delsą:
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:
# Prisijungti iš naujo ir bandyti dar kartą
await self.connect()
return await self.synthesize(text)
Sesijos gyvavimo trukmės valdymas
xAI Text to Speech puslapyje minimas 600 sekundžių „sesijos leidimas“, tačiau nenurodoma, kada jis prasideda ir kas nutinka jam pasibaigus, o atskirai teigiama, kad ryšys neturi laiko limito. Saugiausias būdas – skaičiuoti laiką nuo prisijungimo momento ir atnaujinti sesiją prieš tai įvykstant:
import time
class TTLAwareSession:
TTL = 600 # sekundės
REFRESH_MARGIN = 60 # prisijungti iš naujo likus 60 s iki galiojimo pabaigos
def __init__(self):
self.connected_at = None
async def connect(self):
# ... prisijungimas ...
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() # Nauja sesija
# ... siųsti tekstą ...
Prisijungimas iš naujo likus 60 sekundžių iki galiojimo pabaigos apsaugo tave nuo nutraukimo sintezės viduryje.
Sesijų telkinys
Didelio srauto programoms laikyk pakartotinai naudojamų sesijų telkinį:
class SessionPool:
def __init__(self, api_key, pool_size=10):
self.api_key = api_key
self.pool_size = min(pool_size, 50) # Maks. 50 vienai komandai
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
# Laukti, kol atsiras laisva sesija
return await self.available.get()
async def release(self, session):
await self.available.put(session)
Laikyk telkinio dydį mažesniu nei 50 sesijų limitas, kad liktų rezervos kitoms tavo programos tarnyboms.
Stebimi rodikliai
Kad sesijos veiktų sklandžiai gaminiuose, stebėk:
- Aktyvių sesijų skaičius: negali viršyti 50
- Prisijungimų iš naujo dažnis: didelis rodiklis rodo tinklo arba gyvavimo trukmės problemą
- Pirmojo audio.delta delsos laikas: parodo, kaip greitai reaguoja tarnyba
- WebSocket klaidos: neįprasti uždarymo kodai (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)
Svarbiausi punktai
- Dokumentacijoje minimas 600 sekundžių sesijos leidimas: saugumo sumetimais skaičiuok jį nuo prisijungimo momento
- Įgyvendink automatinį prisijungimą iš naujo su eksponentiniu delsos laiku
- Atnaujink sesiją prieš jai pasibaigiant (su 60 sekundžių atsarga)
- Didelio srauto programoms naudok sesijų telkinį
- Laikykitės 50 vienalaikių sesijų vienai komandai limito
- Gaminiuose stebėk ryšio rodiklius