@k2b/cloud 0.23.0 → 0.25.0

package/src/ai/client/live-connection.ts

@@ -1,141 +0,0 @@
-import {
-  createLiveWebSocket,
-  type LiveWebSocket,
-  type LiveWebSocketClose,
-  type LiveWebSocketError,
-  type LiveWebSocketStatus,
-} from "../../browser/live-websocket";
-import { AI_LIVE_WS_TYPE, type AiLiveServerMessage, parseAiLiveServerMessage } from "../live-events";
-import type { AiConversationStreamTransport, AiStreamConnectionStatus } from "./transport";
-
-type TurnSubscription = {
-  conversationId: string;
-  generation: number;
-  onEvent: Parameters<AiConversationStreamTransport["subscribe"]>[0]["onEvent"];
-  onStatus?: Parameters<AiConversationStreamTransport["subscribe"]>[0]["onStatus"];
-  onError?: Parameters<AiConversationStreamTransport["subscribe"]>[0]["onError"];
-};
-
-export type AiLiveConnection = {
-  connect: () => void;
-  markApplied: (cursor: string | null | undefined) => void;
-  streamTransport: AiConversationStreamTransport;
-  dispose: () => void;
-};
-
-export type CreateAiLiveConnectionOptions = {
-  url?: string;
-  initialCursor: string;
-  onLiveMessage: (message: AiLiveServerMessage) => void;
-  onLiveStatus?: (status: LiveWebSocketStatus) => void;
-  onFatal?: (error: LiveWebSocketError) => void;
-};
-
-const reconnectableAiClose = (close: LiveWebSocketClose): LiveWebSocketError | null =>
-  close.code === 1008 ? { code: close.reason || "access_denied", message: "Live access changed or expired." } : null;
-
-const streamStatus = (status: LiveWebSocketStatus): AiStreamConnectionStatus | null => {
-  if (status === "connecting" || status === "reconnecting") return status;
-  if (status === "paused") return "reconnecting";
-  return null;
-};
-
-/** One browser connection for AI invalidations and the currently visible turn. */
-export const createAiLiveConnection = (options: CreateAiLiveConnectionOptions): AiLiveConnection => {
-  let socket: LiveWebSocket;
-  let turn: TurnSubscription | null = null;
-  let turnGeneration = 0;
-  let connected = false;
-  let disposed = false;
-  let liveSubscribeCount = 0;
-
-  const sendTurnSubscription = () => {
-    if (!connected || !turn) return;
-    if (
-      !socket.send({
-        type: AI_LIVE_WS_TYPE.turnSubscribe,
-        payload: { conversationId: turn.conversationId },
-      })
-    ) {
-      turn.onStatus?.("reconnecting");
-    }
-  };
-
-  socket = createLiveWebSocket<AiLiveServerMessage>({
-    url: options.url ?? "/api/ai/live",
-    activity: "always",
-    initialCursor: options.initialCursor,
-    subscribe: (cursor) => ({
-      type: AI_LIVE_WS_TYPE.subscribe,
-      payload: { fromCursor: cursor, recover: liveSubscribeCount++ > 0 },
-    }),
-    parse: parseAiLiveServerMessage,
-    classifyClose: reconnectableAiClose,
-    onOpen: sendTurnSubscription,
-    onStatus: (status) => {
-      connected = status === "open";
-      options.onLiveStatus?.(status);
-      const next = streamStatus(status);
-      if (next) turn?.onStatus?.(next);
-    },
-    onMessage: (message) => {
-      if (message.type === AI_LIVE_WS_TYPE.turnEvent) {
-        if (!turn || turn.conversationId !== message.payload.conversationId) return;
-        if (message.payload.event.type === "state") turn.onStatus?.("open");
-        turn.onEvent(message.payload.event);
-        return;
-      }
-      if (message.type === AI_LIVE_WS_TYPE.turnError) {
-        if (!turn || turn.conversationId !== message.payload.conversationId) return;
-        const current = turn;
-        turn = null;
-        current.onError?.(new Error(message.payload.message));
-        return;
-      }
-      options.onLiveMessage(message);
-    },
-    onFatal: (error) => {
-      connected = false;
-      const current = turn;
-      turn = null;
-      current?.onError?.(new Error(error.message));
-      options.onFatal?.(error);
-    },
-  });
-
-  const streamTransport: AiConversationStreamTransport = {
-    subscribe: ({ conversationId, onEvent, onStatus, onError }) => {
-      const generation = ++turnGeneration;
-      const subscription: TurnSubscription = { conversationId, generation, onEvent, onStatus, onError };
-      turn = subscription;
-      onStatus?.("connecting");
-      sendTurnSubscription();
-      return {
-        close: () => {
-          if (turn?.generation !== generation) return;
-          turn = null;
-          if (connected) {
-            socket.send({
-              type: AI_LIVE_WS_TYPE.turnUnsubscribe,
-              payload: { conversationId },
-            });
-          }
-        },
-      };
-    },
-  };
-
-  return {
-    connect: () => {
-      if (!disposed) socket.connect();
-    },
-    markApplied: (cursor) => socket.markApplied(cursor),
-    streamTransport,
-    dispose: () => {
-      if (disposed) return;
-      disposed = true;
-      turn = null;
-      socket.dispose();
-    },
-  };
-};

package/src/ai/live-messages.ts

@@ -1,45 +0,0 @@
-import { i18n } from "@k2b/stdlib";
-
-const catalog = i18n.define({
-  baseLocale: "en",
-  messages: {
-    en: {
-      loginRequired: "Login required",
-      conversationAccessChanged: "Conversation access changed or expired",
-      capacityExceeded: "AI updates exceeded the connection capacity",
-      authorizationRefreshFailed: "AI live authorization refresh failed",
-      invalidStreamData: "AI event stream contains invalid data",
-      eventStreamEnded: "AI event stream ended",
-      eventStreamFailed: "AI event stream failed",
-      subscriptionFailed: "AI live subscription failed",
-      conversationStreamEnded: "AI conversation stream ended",
-      conversationStreamFailed: "AI conversation stream failed",
-      liveSubscriptionRequired: "AI live subscription required before a turn subscription",
-      conversationNotFound: "Conversation not found",
-      invalidJson: "Invalid JSON payload",
-      invalidSubscription: "Invalid AI live subscription",
-      tooManyMessages: "Too many pending AI live messages",
-    },
-    de: {
-      loginRequired: "Anmeldung erforderlich",
-      conversationAccessChanged: "Der Zugriff auf die Unterhaltung wurde geändert oder ist abgelaufen",
-      capacityExceeded: "Die AI-Updates haben die Kapazität der Verbindung überschritten",
-      authorizationRefreshFailed: "Die Zugriffsprüfung für AI Live ist fehlgeschlagen",
-      invalidStreamData: "Der AI-Ereignisstrom enthält ungültige Daten",
-      eventStreamEnded: "Der AI-Ereignisstrom wurde beendet",
-      eventStreamFailed: "Der AI-Ereignisstrom ist fehlgeschlagen",
-      subscriptionFailed: "Die Anmeldung für AI Live ist fehlgeschlagen",
-      conversationStreamEnded: "Der AI-Unterhaltungsstrom wurde beendet",
-      conversationStreamFailed: "Der AI-Unterhaltungsstrom ist fehlgeschlagen",
-      liveSubscriptionRequired: "Vor dem Abonnieren eines Durchlaufs ist eine Anmeldung für AI Live erforderlich",
-      conversationNotFound: "Die Unterhaltung wurde nicht gefunden",
-      invalidJson: "Die JSON-Daten sind ungültig",
-      invalidSubscription: "Die Anmeldung für AI Live ist ungültig",
-      tooManyMessages: "Zu viele ausstehende Nachrichten für AI Live",
-    },
-  },
-});
-
-export type AiLiveMessages = ReturnType<typeof catalog.resolve>["t"];
-export const aiLiveMessages = (locale?: string | null) => catalog.resolve(locale ? [locale] : []).t;
-export const checkAiLiveMessages = () => catalog.check();

package/src/ai/live-outbox.ts

@@ -1,102 +0,0 @@
-import type { sql } from "bun";
-import { lazySync } from "../_internal/process-sync";
-import { createPgOutbox } from "../services/outbox";
-import { toPgTextArray } from "../services/postgres";
-import { latestTopicCursor } from "../services/topic-cursor";
-import type { AiInvalidation, AiInvalidationDomain } from "./live-events";
-
-const RETENTION_MS = 24 * 60 * 60 * 1_000;
-const RECONCILE_INTERVAL_MS = 1_000;
-const MAX_ATTEMPTS = 20;
-
-type SqlClient = typeof sql;
-
-export type AiLiveOutboxRow = {
-  id: string;
-  change_id: string;
-  audience_user_id: string;
-  conversation_short_id: string | null;
-  project_short_id: string | null;
-  domains: AiInvalidationDomain[];
-  attempts: number;
-  created_at: Date | string;
-};
-
-const invalidationTopic = lazySync((sync) =>
-  sync.topic<AiInvalidation>({
-    id: "cloud-ai-invalidations",
-    owner: "cloud",
-    retention: { maxAgeMs: RETENTION_MS, maxBytes: 64 * 1024 * 1024 },
-    maxPayloadBytes: 9_024,
-  }),
-);
-
-const tenantId = (userId: string): string => userId;
-
-export const enqueueAiInvalidation = async (
-  db: SqlClient,
-  input: {
-    audienceUserId: string;
-    domains: AiInvalidationDomain[];
-    conversationId?: string | null;
-    projectId?: string | null;
-    changeId?: string;
-  },
-): Promise<string> => {
-  const [row] = await db<{ id: string }[]>`
-    INSERT INTO ai.live_invalidation_outbox (
-      change_id, audience_user_id, conversation_short_id, project_short_id, domains
-    )
-    VALUES (
-      ${input.changeId ?? crypto.randomUUID()}::uuid,
-      ${input.audienceUserId}::uuid,
-      ${input.conversationId ?? null},
-      ${input.projectId ?? null},
-      ${toPgTextArray([...new Set(input.domains)])}::text[]
-    )
-    RETURNING id::text
-  `;
-  if (!row) throw new Error("AI live invalidation insert returned no id");
-  return row.id;
-};
-
-const publishAiInvalidation = (row: AiLiveOutboxRow): Promise<unknown> => {
-  const event: AiInvalidation = {
-    type: "ai.invalidated",
-    changeId: row.change_id,
-    conversationId: row.conversation_short_id,
-    projectId: row.project_short_id,
-    domains: row.domains,
-    at: new Date(row.created_at).toISOString(),
-  };
-  return invalidationTopic().publish({
-    tenantId: tenantId(row.audience_user_id),
-    orderingKey: row.conversation_short_id ?? row.project_short_id ?? row.audience_user_id,
-    idempotencyKey: row.change_id,
-    data: event,
-  });
-};
-
-const outbox = createPgOutbox<AiLiveOutboxRow>({
-  table: "ai.live_invalidation_outbox",
-  name: "ai:live-outbox",
-  publish: publishAiInvalidation,
-  reconcileIntervalMs: RECONCILE_INTERVAL_MS,
-  orderBy: "audience_user_id",
-  maxAttempts: MAX_ATTEMPTS,
-});
-
-export const claimAiInvalidationBatch = outbox.claim;
-export const dispatchAiInvalidation = outbox.dispatch;
-export const reconcileAiInvalidations = outbox.reconcile;
-export const notifyAiInvalidations = outbox.notify;
-export const startAiInvalidationRuntime = outbox.start;
-export const stopAiInvalidationRuntime = outbox.stop;
-
-export const liveAiInvalidations = (input: { userId: string; after?: string | null; signal?: AbortSignal }) =>
-  invalidationTopic()
-    .hub({ tenantId: tenantId(input.userId) })
-    .subscribe({ after: input.after ?? undefined, signal: input.signal });
-
-export const latestAiInvalidationCursor = (userId: string): Promise<string> =>
-  latestTopicCursor({ topic: invalidationTopic(), resourceId: "cloud-ai-invalidations", tenantId: tenantId(userId) });

package/src/ai/live-routes.ts

@@ -1,412 +0,0 @@
-import type { ServerWebSocket } from "bun";
-import { Hono } from "hono";
-import { upgradeWebSocket } from "hono/bun";
-import { type AuthContext, auth, getLocale } from "../server";
-import { logger } from "../services/logging";
-import {
-  AI_LIVE_WS_TYPE,
-  type AiInvalidation,
-  AiInvalidationSchema,
-  AiLiveClientMessageSchema,
-  AiLiveCursorSchema,
-  type AiLiveErrorCode,
-  type AiLiveServerMessage,
-  aiTurnEventMessage,
-} from "./live-events";
-import { type AiLiveMessages, aiLiveMessages } from "./live-messages";
-import { latestAiInvalidationCursor, liveAiInvalidations } from "./live-outbox";
-import type { AiStreamEvent } from "./protocol";
-import { aiConversations } from "./store";
-import { streamAiConversationEvents } from "./stream";
-import type { AiConversation } from "./types";
-
-const log = logger("ai:live-routes");
-const AUTH_REFRESH_INTERVAL_MS = 5_000;
-const MAX_CLIENT_MESSAGE_LENGTH = 8_000;
-const MAX_PENDING_MESSAGES = 8;
-const MAX_BUFFERED_BYTES = 4 * 1024 * 1024;
-
-export const isAiLiveClientMessageFrame = (data: unknown): data is string =>
-  typeof data === "string" && data.length <= MAX_CLIENT_MESSAGE_LENGTH;
-
-type LiveUser = { id: string };
-type WsPhase = "open" | "subscribed" | "closing";
-
-type WsContext = {
-  socket: ServerWebSocket<unknown>;
-  sessionToken: string | null;
-  messages: AiLiveMessages;
-  phase: WsPhase;
-  userId: string | null;
-  invalidationAbort: AbortController | null;
-  turnAbort: AbortController | null;
-  turnConversationId: string | null;
-  authRefreshTimer: ReturnType<typeof setTimeout> | null;
-  scopeVersion: string | null;
-};
-
-export type AiLiveRoutesConfig = {
-  resolveLiveUser?: (sessionToken: string | null) => Promise<LiveUser | null>;
-  resolveScopeVersion?: (userId: string) => Promise<string>;
-  resolveConversation?: (conversationId: string, userId: string) => Promise<AiConversation | null>;
-  streamConversation?: (input: { conversation: AiConversation; signal: AbortSignal }) => AsyncIterable<AiStreamEvent>;
-};
-
-export const resolveAiLiveSessionUser = async (
-  sessionToken: string | null,
-  authenticate: typeof auth.session.authenticate = auth.session.authenticate,
-): Promise<LiveUser | null> => {
-  if (!sessionToken) return null;
-  const authenticated = await authenticate(sessionToken);
-  return authenticated ? { id: authenticated.user.id } : null;
-};
-
-const isClosing = (ctx: WsContext): boolean => ctx.phase === "closing";
-
-export const isAiLiveSubscriptionCurrent = (state: Pick<WsContext, "phase" | "userId">, userId: string, signal: AbortSignal): boolean =>
-  !signal.aborted && state.phase === "subscribed" && state.userId === userId;
-
-export const isAiTurnSubscriptionCurrent = (
-  state: Pick<WsContext, "phase" | "turnConversationId">,
-  conversationId: string,
-  signal: AbortSignal,
-): boolean => !signal.aborted && state.phase === "subscribed" && state.turnConversationId === conversationId;
-
-export const sendAiLiveMessage = (socket: ServerWebSocket<unknown>, message: AiLiveServerMessage): boolean => {
-  try {
-    const payload = JSON.stringify(message);
-    socket.send(payload);
-    // Bun 1.3 can report 0 after a larger frame already reached the peer.
-    // The bounded socket queue is the reliable overload signal here.
-    return socket.getBufferedAmount() <= MAX_BUFFERED_BYTES;
-  } catch {
-    return false;
-  }
-};
-
-const stopInvalidationSubscription = (ctx: WsContext) => {
-  ctx.invalidationAbort?.abort();
-  ctx.invalidationAbort = null;
-};
-
-const stopTurnSubscription = (ctx: WsContext) => {
-  ctx.turnAbort?.abort();
-  ctx.turnAbort = null;
-  ctx.turnConversationId = null;
-};
-
-const stopSubscriptions = (ctx: WsContext) => {
-  stopInvalidationSubscription(ctx);
-  stopTurnSubscription(ctx);
-  if (ctx.authRefreshTimer) clearTimeout(ctx.authRefreshTimer);
-  ctx.authRefreshTimer = null;
-  ctx.userId = null;
-  ctx.scopeVersion = null;
-};
-
-const closeWithError = (ctx: WsContext, code: AiLiveErrorCode, message: string, closeCode: number) => {
-  if (isClosing(ctx)) return;
-  ctx.phase = "closing";
-  stopSubscriptions(ctx);
-  sendAiLiveMessage(ctx.socket, { type: AI_LIVE_WS_TYPE.error, payload: { code, message } });
-  ctx.socket.close(closeCode, code);
-};
-
-const revoke = (ctx: WsContext, code: "login_required" | "access_denied", message: string) => {
-  if (isClosing(ctx)) return;
-  ctx.phase = "closing";
-  stopSubscriptions(ctx);
-  sendAiLiveMessage(ctx.socket, { type: AI_LIVE_WS_TYPE.revoked, payload: { code, message } });
-  ctx.socket.close(1008, code);
-};
-
-export const resolveAiLiveCursor = async (
-  userId: string,
-  fromCursor: string | null,
-  recover: boolean,
-  latest: (userId: string) => Promise<string> = latestAiInvalidationCursor,
-): Promise<string> => AiLiveCursorSchema.parse(recover || !fromCursor ? await latest(userId) : fromCursor);
-
-export const parseAiLiveReplayEvent = (item: { cursor: unknown; data: unknown }): { cursor: string; event: AiInvalidation } | null => {
-  const cursor = AiLiveCursorSchema.safeParse(item.cursor);
-  const event = AiInvalidationSchema.safeParse(item.data);
-  return cursor.success && event.success ? { cursor: cursor.data, event: event.data } : null;
-};
-
-const buildAiLiveRoutes = (config: AiLiveRoutesConfig = {}) => {
-  const resolveLiveUser = config.resolveLiveUser ?? resolveAiLiveSessionUser;
-  const resolveConversation =
-    config.resolveConversation ??
-    ((conversationId: string, userId: string) =>
-      aiConversations.getConversationByShortId({ shortId: conversationId, ownerUserId: userId }));
-  const streamConversation = config.streamConversation ?? streamAiConversationEvents;
-
-  const currentUser = async (ctx: WsContext): Promise<LiveUser | null> => {
-    const user = await resolveLiveUser(ctx.sessionToken);
-    return user && (!ctx.userId || user.id === ctx.userId) ? user : null;
-  };
-
-  const startAuthRefresh = (ctx: WsContext, userId: string) => {
-    if (ctx.authRefreshTimer) clearTimeout(ctx.authRefreshTimer);
-    ctx.authRefreshTimer = setTimeout(async () => {
-      if (ctx.phase !== "subscribed" || ctx.userId !== userId) return;
-      try {
-        if (!(await currentUser(ctx))) {
-          revoke(ctx, "login_required", ctx.messages.loginRequired);
-          return;
-        }
-        const activeConversationId = ctx.turnConversationId;
-        if (activeConversationId && !(await resolveConversation(activeConversationId, userId))) {
-          if (ctx.turnConversationId !== activeConversationId) {
-            startAuthRefresh(ctx, userId);
-            return;
-          }
-          const conversationId = activeConversationId;
-          stopTurnSubscription(ctx);
-          if (
-            !sendAiLiveMessage(ctx.socket, {
-              type: AI_LIVE_WS_TYPE.turnError,
-              payload: { conversationId, code: "access_denied", message: ctx.messages.conversationAccessChanged },
-            })
-          ) {
-            closeWithError(ctx, "backpressure", ctx.messages.capacityExceeded, 1013);
-            return;
-          }
-        }
-        if (config.resolveScopeVersion) {
-          const version = await config.resolveScopeVersion(userId);
-          if (ctx.phase !== "subscribed" || ctx.userId !== userId) return;
-          if (ctx.scopeVersion !== null && version !== ctx.scopeVersion) {
-            if (!sendAiLiveMessage(ctx.socket, { type: AI_LIVE_WS_TYPE.scopeChanged, payload: { at: new Date().toISOString() } })) {
-              closeWithError(ctx, "backpressure", ctx.messages.capacityExceeded, 1013);
-              return;
-            }
-          }
-          ctx.scopeVersion = version;
-        }
-        startAuthRefresh(ctx, userId);
-      } catch (error) {
-        log.error("AI live authorization refresh failed", {
-          userId,
-          error: error instanceof Error ? error.message : String(error),
-        });
-        closeWithError(ctx, "internal_error", ctx.messages.authorizationRefreshFailed, 1011);
-      }
-    }, AUTH_REFRESH_INTERVAL_MS);
-  };
-
-  const startInvalidationStream = (ctx: WsContext, userId: string, after: string) => {
-    ctx.invalidationAbort?.abort();
-    const abort = new AbortController();
-    ctx.invalidationAbort = abort;
-    void (async () => {
-      try {
-        for await (const item of liveAiInvalidations({ userId, after, signal: abort.signal })) {
-          if (!isAiLiveSubscriptionCurrent(ctx, userId, abort.signal)) break;
-          if (!(await currentUser(ctx))) {
-            revoke(ctx, "login_required", ctx.messages.loginRequired);
-            return;
-          }
-          if (!isAiLiveSubscriptionCurrent(ctx, userId, abort.signal)) break;
-          const replay = parseAiLiveReplayEvent(item);
-          if (!replay) {
-            closeWithError(ctx, "stream_failed", ctx.messages.invalidStreamData, 1011);
-            return;
-          }
-          if (!sendAiLiveMessage(ctx.socket, { type: AI_LIVE_WS_TYPE.event, payload: replay })) {
-            closeWithError(ctx, "backpressure", ctx.messages.capacityExceeded, 1013);
-            return;
-          }
-        }
-        if (isAiLiveSubscriptionCurrent(ctx, userId, abort.signal))
-          closeWithError(ctx, "stream_failed", ctx.messages.eventStreamEnded, 1012);
-      } catch (error) {
-        if (abort.signal.aborted || isClosing(ctx)) return;
-        log.error("AI live event stream failed", {
-          userId,
-          error: error instanceof Error ? error.message : String(error),
-        });
-        closeWithError(ctx, "stream_failed", ctx.messages.eventStreamFailed, 1012);
-      } finally {
-        if (ctx.invalidationAbort === abort) ctx.invalidationAbort = null;
-      }
-    })();
-  };
-
-  const handleLiveSubscribe = async (ctx: WsContext, fromCursor: string | null, recover: boolean) => {
-    if (isClosing(ctx)) return;
-    const user = await currentUser(ctx);
-    if (isClosing(ctx)) return;
-    if (!user) {
-      revoke(ctx, "login_required", ctx.messages.loginRequired);
-      return;
-    }
-    let cursor: string;
-    let scopeVersion: string | null;
-    try {
-      cursor = await resolveAiLiveCursor(user.id, fromCursor, recover);
-      scopeVersion = config.resolveScopeVersion ? await config.resolveScopeVersion(user.id) : null;
-    } catch (error) {
-      log.error("AI live subscription setup failed", {
-        userId: user.id,
-        error: error instanceof Error ? error.message : String(error),
-      });
-      closeWithError(ctx, "stream_failed", ctx.messages.subscriptionFailed, 1012);
-      return;
-    }
-    if (isClosing(ctx)) return;
-    stopInvalidationSubscription(ctx);
-    ctx.phase = "subscribed";
-    ctx.userId = user.id;
-    ctx.scopeVersion = scopeVersion;
-    if (!sendAiLiveMessage(ctx.socket, { type: AI_LIVE_WS_TYPE.ready, payload: { cursor, recovered: recover } })) {
-      closeWithError(ctx, "backpressure", ctx.messages.capacityExceeded, 1013);
-      return;
-    }
-    startInvalidationStream(ctx, user.id, cursor);
-    startAuthRefresh(ctx, user.id);
-  };
-
-  const startTurnStream = (ctx: WsContext, conversation: AiConversation) => {
-    stopTurnSubscription(ctx);
-    const abort = new AbortController();
-    const conversationId = conversation.shortId;
-    ctx.turnAbort = abort;
-    ctx.turnConversationId = conversationId;
-    void (async () => {
-      try {
-        for await (const event of streamConversation({ conversation, signal: abort.signal })) {
-          if (!isAiTurnSubscriptionCurrent(ctx, conversationId, abort.signal)) return;
-          if (!sendAiLiveMessage(ctx.socket, aiTurnEventMessage(conversationId, event))) {
-            closeWithError(ctx, "backpressure", ctx.messages.capacityExceeded, 1013);
-            return;
-          }
-        }
-        if (isAiTurnSubscriptionCurrent(ctx, conversationId, abort.signal)) {
-          closeWithError(ctx, "stream_failed", ctx.messages.conversationStreamEnded, 1012);
-        }
-      } catch (error) {
-        if (abort.signal.aborted || isClosing(ctx)) return;
-        log.error("AI conversation stream failed", {
-          conversationId: conversation.id,
-          error: error instanceof Error ? error.message : String(error),
-        });
-        closeWithError(ctx, "stream_failed", ctx.messages.conversationStreamFailed, 1012);
-      } finally {
-        if (ctx.turnAbort === abort) {
-          ctx.turnAbort = null;
-          ctx.turnConversationId = null;
-        }
-      }
-    })();
-  };
-
-  const handleTurnSubscribe = async (ctx: WsContext, conversationId: string) => {
-    if (ctx.phase !== "subscribed" || !ctx.userId) {
-      closeWithError(ctx, "invalid_message", ctx.messages.liveSubscriptionRequired, 1008);
-      return;
-    }
-    const conversation = await resolveConversation(conversationId, ctx.userId);
-    if (isClosing(ctx)) return;
-    if (!conversation) {
-      stopTurnSubscription(ctx);
-      if (
-        !sendAiLiveMessage(ctx.socket, {
-          type: AI_LIVE_WS_TYPE.turnError,
-          payload: { conversationId, code: "not_found", message: ctx.messages.conversationNotFound },
-        })
-      ) {
-        closeWithError(ctx, "backpressure", ctx.messages.capacityExceeded, 1013);
-      }
-      return;
-    }
-    startTurnStream(ctx, conversation);
-  };
-
-  const handleTurnUnsubscribe = (ctx: WsContext, conversationId: string) => {
-    if (ctx.turnConversationId === conversationId) stopTurnSubscription(ctx);
-  };
-
-  const handleMessage = async (ctx: WsContext, raw: string) => {
-    let parsed: unknown;
-    try {
-      parsed = JSON.parse(raw);
-    } catch {
-      closeWithError(ctx, "invalid_json", ctx.messages.invalidJson, 1008);
-      return;
-    }
-    const message = AiLiveClientMessageSchema.safeParse(parsed);
-    if (!message.success) {
-      closeWithError(ctx, "invalid_message", ctx.messages.invalidSubscription, 1008);
-      return;
-    }
-    if (message.data.type === AI_LIVE_WS_TYPE.subscribe) {
-      await handleLiveSubscribe(ctx, message.data.payload.fromCursor, message.data.payload.recover);
-      return;
-    }
-    if (message.data.type === AI_LIVE_WS_TYPE.turnSubscribe) {
-      await handleTurnSubscribe(ctx, message.data.payload.conversationId);
-      return;
-    }
-    handleTurnUnsubscribe(ctx, message.data.payload.conversationId);
-  };
-
-  return new Hono<AuthContext>().get(
-    "/",
-    upgradeWebSocket(async (c) => {
-      const sessionToken = await auth.session.resolveToken(c);
-      const messages = aiLiveMessages(getLocale(c));
-      let ctx: WsContext | null = null;
-      let processing: Promise<void> = Promise.resolve();
-      let pendingMessages = 0;
-      return {
-        onOpen(_, ws) {
-          ctx = {
-            socket: ws.raw as ServerWebSocket<unknown>,
-            sessionToken,
-            messages,
-            phase: "open",
-            userId: null,
-            invalidationAbort: null,
-            turnAbort: null,
-            turnConversationId: null,
-            authRefreshTimer: null,
-            scopeVersion: null,
-          };
-        },
-        onMessage(event) {
-          if (!ctx || isClosing(ctx)) return;
-          if (!isAiLiveClientMessageFrame(event.data)) {
-            closeWithError(ctx, "invalid_message", ctx.messages.invalidSubscription, 1008);
-            return;
-          }
-          if (pendingMessages >= MAX_PENDING_MESSAGES) {
-            closeWithError(ctx, "backpressure", ctx.messages.tooManyMessages, 1013);
-            return;
-          }
-          const current = ctx;
-          const raw = event.data;
-          pendingMessages++;
-          processing = processing
-            .then(() => handleMessage(current, raw))
-            .catch((error) => {
-              log.error("AI live message handling failed", { error: error instanceof Error ? error.message : String(error) });
-              closeWithError(current, "internal_error", current.messages.subscriptionFailed, 1011);
-            })
-            .finally(() => {
-              pendingMessages = Math.max(0, pendingMessages - 1);
-            });
-        },
-        async onClose() {
-          if (!ctx) return;
-          ctx.phase = "closing";
-          stopSubscriptions(ctx);
-          await processing.catch(() => undefined);
-        },
-      };
-    }),
-  );
-};
-
-export const aiLiveRoutes = buildAiLiveRoutes();
-export type AiLiveRoutes = typeof aiLiveRoutes;