Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

Hantering av WebSocket-sessioner

Lektion 11 av 14 Uppdaterad 3 november 2026 Utvecklare
På denna sida
  1. Behärska sessionslivscykeln
  2. Sessionslivscykel
  3. Automatisk återanslutning
  4. Hantering av sessionslivslängd
  5. Sessionspool
  6. Metriker att övervaka
  7. Viktiga punkter

Uppdaterat den 3 november 2026, baserat på xAI:s sida för Text to Speech, som nämner en “sessionslicens” på 600 sekunder och en anslutning utan tidsgräns. Återanslutningsstrategin nedan är en försiktighetsåtgärd. Källa: Text to Speech.

Behärska sessionslivscykeln

I produktionsmiljöer är det robust hantering av WebSocket-sessioner som skiljer en prototyp från en pålitlig produkt. TTS-sessioner har specifika begränsningar (livslängd, samtidighetsgränser) som din applikation måste hantera korrekt.

Sessionslivscykel

En TTS WebSocket-session genomgår följande cykel:

  1. Öppning: anslut till wss://api.x.ai/v1/tts med parametrarna
  2. Aktiv: utbyte av meddelanden text.delta/audio.delta
  3. Normal stängning: klienten eller servern stänger anslutningen
  4. Oväntad stängning: ett fel, underhåll eller slutet på den 600-sekunders sessionslicens som dokumentationen nämner

Upptäck stängning

Servern kan stänga anslutningen när som helst (internt fel, underhåll, slutet på sessionslicensen). Din applikation bör alltid hantera händelsen för stängd anslutning:

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")

Automatisk återanslutning

För applikationer som körs under långa perioder bör du implementera återanslutning med exponentiell 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:
            # Återanslut och försök igen
            await self.connect()
            return await self.synthesize(text)

Hantering av sessionslivslängd

xAI:s sida för Text to Speech nämner en “sessionslicens” på 600 sekunder utan att specificera när den startar eller vad som händer när den löper ut, och anger separat att anslutningen saknar tidsgräns. Det mest försiktiga tillvägagångssättet är att räkna från anslutningsögonblicket och förnya sessionen innan denna tidpunkt:

import time

class TTLAwareSession:
    TTL = 600  # sekunder
    REFRESH_MARGIN = 60  # återanslut 60 s före utgång

    def __init__(self):
        self.connected_at = None

    async def connect(self):
        # ... anslutning ...
        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()  # Ny session
        # ... skicka texten ...

Genom att återansluta 60 sekunder före utgången undviker du att bli avbruten mitt i en syntes.

Sessionspool

För applikationer med hög trafik bör du hålla en pool av återanvändbara sessioner:

class SessionPool:
    def __init__(self, api_key, pool_size=10):
        self.api_key = api_key
        self.pool_size = min(pool_size, 50)  # Max 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

        # Vänta på att en session ska bli ledig
        return await self.available.get()

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

Håll poolstorleken till en bråkdel av gränsen på 50 sessioner för att lämna utrymme för dina andra tjänster i applikationen.

Metriker att övervaka

För att hålla sessionerna friska i produktion bör du övervaka:

  • Antal aktiva sessioner: får inte överstiga 50
  • Återanslutningsfrekvens: en hög frekvens tyder på nätverksproblem eller problem med livslängden
  • Latens för första audio.delta: mäter hur responsiv tjänsten är
  • WebSocket-fel: onormala stängningskoder (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)

Viktiga punkter

  • Dokumentationen nämner en sessionslicens på 600 sekunder: för att vara på den säkra sidan, räkna från anslutningsögonblicket
  • Implementera automatisk återanslutning med exponentiell backoff
  • Förnya sessionen innan denna tidpunkt (med en marginal på 60 sekunder)
  • Använd en sessionspool för applikationer med hög trafik
  • Håll dig inom gränsen på 50 samtidiga sessioner per team
  • Övervaka anslutningsmetriker i produktion