Reconnection

{
  "type": "config",
  "audio": { "encoding": "pcm_s16le", "sample_rate": 16000, "channels": 1 },
  "language": "de",
  "chunk": { "strategy": "balanced" },
  "diarization": { "enabled": false },
  "timeline_offset_seconds": 42.6
}

{
  "type": "transcript",
  "seq": 1,
  "segment": { "start": 43.10, "end": 47.35 },
  "language_detected": "de",
  "diarization_enabled": false,
  "text": "and the cough started this morning",
  "words": [ { "w": "and", "start": 43.10, "end": 43.28 } ],
  "processed_until": 47.35
}

class ResilientSession {
  constructor(token, config) {
    this.token = token;
    this.config = config;
    this.processedUntil = 0;   // last durable high-water mark
    this.buffer = [];          // [{ t: absoluteSeconds, pcm: ArrayBuffer }]
  }

  connect() {
    const offset = this.processedUntil;
    const url = `wss://speech.medisync.me/api/v2/ws/transcribe?token=${this.token}`;
    this.ws = new WebSocket(url);
    this.ws.binaryType = "arraybuffer";

    this.ws.onopen = () => this.ws.send(JSON.stringify({
      ...this.config,
      type: "config",
      timeline_offset_seconds: offset,
    }));

    this.ws.onmessage = (event) => {
      if (typeof event.data !== "string") return;
      const msg = JSON.parse(event.data);
      if (msg.type === "session_ready") {
        // resend only the tail the server has NOT consumed
        for (const frame of this.buffer) {
          if (frame.t > this.processedUntil) this.ws.send(frame.pcm);
        }
        this.startMic();
      } else if (msg.type === "transcript" || msg.type === "ack") {
        this.processedUntil = Math.max(this.processedUntil, msg.processed_until);
        this.trimBuffer();
      }
    };

    // 1006/abnormal close, etc. -> reconnect after the socket is fully closed
    this.ws.onclose = () => setTimeout(() => this.connect(), 1000);
  }

  trimBuffer() {
    this.buffer = this.buffer.filter((f) => f.t > this.processedUntil);
  }
}

class ResilientSession:
    def __init__(self, token, config):
        self.token = token
        self.config = config
        self.processed_until = 0.0     # last durable high-water mark
        self.buffer = []               # list of (abs_seconds, pcm_bytes)

    async def run(self):
        import json, websockets
        url = f"wss://speech.medisync.me/api/v2/ws/transcribe?token={self.token}"
        while True:
            try:
                async with websockets.connect(url, max_size=None) as ws:
                    cfg = {**self.config, "type": "config",
                           "timeline_offset_seconds": self.processed_until}
                    await ws.send(json.dumps(cfg))
                    ready = json.loads(await ws.recv())
                    assert ready["type"] == "session_ready"
                    # resend only the tail after the last processed_until
                    for t, pcm in self.buffer:
                        if t > self.processed_until:
                            await ws.send(pcm)
                    await self._pump(ws)
            except websockets.ConnectionClosed:
                continue   # reconnect from the tracked high-water mark

    async def _pump(self, ws):
        import json
        async for message in ws:
            if isinstance(message, (bytes, bytearray)):
                continue
            msg = json.loads(message)
            if msg["type"] in ("transcript", "ack"):
                self.processed_until = max(self.processed_until, msg["processed_until"])
                self.buffer = [(t, p) for (t, p) in self.buffer
                               if t > self.processed_until]