Your Gemini Live API session forgets the conversation every time it reconnects — field notes on token refresh and session resumption

// app/api/live/token/route.ts
import { NextRequest, NextResponse } from "next/server";
 
const TOKEN_ENDPOINT =
  "https://generativelanguage.googleapis.com/v1alpha/ephemeralTokens:create";
 
export async function POST(req: NextRequest) {
  // Always check your own auth first. Skip it and this becomes an open token vending machine.
  const session = await getServerSession(req);
  if (!session?.user) {
    return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
  }
 
  const apiKey = process.env.GEMINI_API_KEY;
  if (!apiKey) {
    return NextResponse.json({ error: "Server misconfigured" }, { status: 500 });
  }
 
  const res = await fetch(`${TOKEN_ENDPOINT}?key=${apiKey}`, {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
      // Separate the window to open a session (newSessionExpireTime) from the overall lifetime (expireTime).
      uses: 1,
      expireTime: new Date(Date.now() + 30 * 60 * 1000).toISOString(),
      newSessionExpireTime: new Date(Date.now() + 60 * 1000).toISOString(),
      liveConnectConstraints: {
        model: "models/gemini-2.5-flash",
        config: {
          responseModalities: ["AUDIO"],
          systemInstruction: {
            parts: [{ text: "You are this app's dedicated assistant." }],
          },
        },
      },
    }),
  });
 
  if (!res.ok) {
    console.error("token issue failed:", await res.text());
    return NextResponse.json({ error: "Failed to issue token" }, { status: 502 });
  }
 
  const data = await res.json();
  return NextResponse.json({ token: data.name, expiresAt: data.expireTime });
}

// Hand the connector a token-getter, not the token itself.
const getToken = async (): Promise<string> => {
  const res = await fetch("/api/live/token", { method: "POST" });
  if (!res.ok) throw new Error("token fetch failed");
  const { token } = await res.json();
  return token;
};

// lib/LiveSession.ts
type Json = Record<string, unknown>;
 
export class LiveSession {
  private ws: WebSocket | null = null;
  private resumptionHandle: string | null = null;  // latest resumption handle
  private attempts = 0;
  private closedByUser = false;
  private readonly maxAttempts = 6;
  private readonly base = 1000;
 
  constructor(
    private readonly getToken: () => Promise<string>,
    private readonly wsBase: string,
    private readonly onMessage: (m: Json) => void,
  ) {}
 
  async connect() {
    this.closedByUser = false;
    await this.open();
  }
 
  private async open() {
    const token = await this.getToken();  // always a fresh token
    const ws = new WebSocket(`${this.wsBase}?access_token=${token}`);
 
    ws.onopen = () => {
      this.attempts = 0;
      ws.send(JSON.stringify({
        setup: {
          model: "models/gemini-2.5-flash",
          generationConfig: { responseModalities: ["AUDIO"] },
          // Pass the handle if we have one; omit it for a fresh start.
          sessionResumption: this.resumptionHandle
            ? { handle: this.resumptionHandle }
            : {},
        },
      }));
    };
 
    ws.onmessage = (e) => {
      const msg = JSON.parse(e.data) as Json;
      // Overwrite the handle on every update so it stays current.
      const update = msg.sessionResumptionUpdate as
        | { resumable?: boolean; newHandle?: string }
        | undefined;
      if (update?.resumable && update.newHandle) {
        this.resumptionHandle = update.newHandle;
      }
      // Treat the server's disconnect warning as a trigger to reconnect early.
      if ("goAway" in msg) {
        this.reconnectSoon();
        return;
      }
      this.onMessage(msg);
    };
 
    ws.onclose = () => {
      this.ws = null;
      if (!this.closedByUser) this.reconnectSoon();
    };
    ws.onerror = (err) => console.error("ws error", err);
    this.ws = ws;
  }
 
  private reconnectSoon() {
    if (this.attempts >= this.maxAttempts) {
      console.error("reconnect limit reached; prompt the user to resume manually");
      return;
    }
    // Exponential backoff + jitter: 1s, 2s, 4s, ... plus randomness to avoid a thundering herd.
    const delay = this.base * 2 ** this.attempts + Math.random() * 500;
    this.attempts++;
    setTimeout(() => this.open(), delay);
  }
 
  send(data: Json): boolean {
    if (this.ws?.readyState !== WebSocket.OPEN) return false;  // silently drop while disconnected
    this.ws.send(JSON.stringify(data));
    return true;
  }
 
  disconnect() {
    this.closedByUser = true;
    this.ws?.close();
    this.ws = null;
  }
}