@gravity-rail/sdk 0.22.0 → 0.32.0

package/dist/realtime.d.ts

@@ -1,41 +1,193 @@
-import { R as RealtimeAuthSession, a as ChannelListener, U as Unsubscribe, O as OperatorSessionState, b as OperatorCallPhase, C as ChannelEvent } from './types-DkYyrvoC.js';
-export { i as isActiveCallPhase } from './types-DkYyrvoC.js';
+import { R as RealtimeSessionBase, a as ChannelListener, U as Unsubscribe, b as RealtimeAuthSession, A as AccountRealtimeSession, O as OperatorSessionState, c as OperatorCallPhase, C as ChannelEvent } from './types-0c6_NGU4.js';
+export { d as ACCOUNT_ACTIVITY_CHANNEL, e as ACCOUNT_PRESENCE_CHANNEL, f as ACTIVITY_CHANNEL, g as ACTIVITY_MEMBER_CHANNEL, h as ActivityChannelName, i as ActivityInvalidationEvent, P as PRESENCE_CHANNEL, j as isActiveCallPhase, k as isActivityInvalidation } from './types-0c6_NGU4.js';
 
 /**
- * Unified workspace WebSocket client for real-time events.
+ * The realtime socket state machine, shared by both mounts.
  *
- * Mirrors `/api/v2/w/{wid}/ws/realtime`: login with OAuth access token,
- * subscribe to channels, receive AGUI events.
+ * Two sockets speak the same protocol — `/api/v2/w/{wid}/ws/realtime` and
+ * `/api/v2/ws/realtime` — and differ in exactly two places: the URL they open,
+ * and the identity `protocol.init` hands back. Everything else (login,
+ * heartbeat, reconnect with backoff, per-channel subscribe retry, listener
+ * fan-out, deferred close) is one implementation here rather than two that
+ * drift.
+ *
+ * That matters more than it sounds. The subscribe-retry and reconnect logic is
+ * where the sharp edges live, and a second copy of it would be a second place
+ * for a fix to be applied once.
  *
  * Protocol:
- *   Client → Server: subscribe, unsubscribe, heartbeat, message
- *   Server → Client: protocol.init, subscribed, unsubscribed, event, error
+ *   Client → Server: login, subscribe, unsubscribe, heartbeat, message
+ *   Server → Client: protocol.init, subscribed, subscribe_error, unsubscribed,
+ *                    event, error
  */
 
-/** Build the workspace realtime WebSocket URL from session config. */
-declare function buildWorkspaceWsUrl(session: RealtimeAuthSession): string;
-declare class WorkspaceRealtimeClient {
+/** The `protocol.init` frame, before either subclass narrows it. */
+interface ProtocolInitMessage {
+    memberId?: unknown;
+    accountUuid?: unknown;
+    workspaceUuids?: unknown;
+}
+declare abstract class RealtimeSocketClient<TSession extends RealtimeSessionBase> {
     private session;
     private readonly getSessionFn;
     private readonly state;
     private readonly connectionListeners;
-    constructor(config?: RealtimeAuthSession | (() => RealtimeAuthSession | null));
-    private resolveSession;
+    constructor(config?: TSession | (() => TSession | null));
+    /** The WebSocket URL this mount connects to. */
+    protected abstract buildUrl(session: TSession): string;
+    /**
+     * Record whatever identity `protocol.init` carried for this mount.
+     *
+     * Called before the connection is announced, so a `onConnection` listener
+     * that immediately reads the identity always sees the new one.
+     */
+    protected abstract readProtocolInit(msg: ProtocolInitMessage): void;
+    /** Forget the identity on a deliberate close. See {@link closeConnection}. */
+    protected abstract clearIdentity(): void;
+    /**
+     * Whether replacing `previous` with `next` invalidates the open socket.
+     *
+     * The token always does; the rest is mount-specific — a workspace client
+     * changing workspace is a different socket, and an account client has no
+     * such axis.
+     */
+    protected sessionRequiresReconnect(previous: TSession | null, next: TSession): boolean;
+    protected resolveSession(): TSession | null;
     private notifyConnectionListeners;
     private clearCloseTimer;
-    setSession(session: RealtimeAuthSession): void;
+    private clearSubscriptionRetry;
+    private scheduleSubscriptionRetry;
+    setSession(session: TSession): void;
     subscribe(channel: string, listener: ChannelListener): Unsubscribe;
     send(channel: string, data: unknown): void;
     onConnection(listener: (connected: boolean) => void): () => void;
     isConnected(): boolean;
-    private ensureConnection;
-    private closeConnection;
+    /**
+     * Whether the server has acknowledged this channel subscription.
+     *
+     * This is stricter than having a local listener: it becomes true only after
+     * a `subscribed` frame, returns to false on disconnect or server-driven
+     * unsubscribe, and stays false while automatic subscribe retry is pending.
+     * Consumers that must order a command after subscription admission should
+     * observe {@link getSubscriptionRevision} and re-read this method.
+     */
+    isSubscribed(channel: string): boolean;
+    /**
+     * Monotonic local revision of acknowledged subscription state.
+     *
+     * It increments when `subscribed` or `unsubscribed` changes the server-
+     * acknowledged set. It is not a protocol sequence number and resets with a
+     * new client instance; its purpose is external-store invalidation before a
+     * consumer calls {@link isSubscribed} again.
+     */
+    getSubscriptionRevision(): number;
+    /**
+     * A socket is open or opening and has not yet said `protocol.init`.
+     *
+     * Real state, read off the state machine. Consumers used to report a
+     * literal `false` here and render "Available" over a socket that had never
+     * connected; a toggle that cannot distinguish "not live" from "cannot tell
+     * yet" is the shape of that bug.
+     */
+    isConnecting(): boolean;
+    /** The last failure the socket gave up on, or null. See {@link SocketState.lastError}. */
+    getLastError(): string | null;
+    protected ensureConnection(): void;
+    protected closeConnection(): void;
+}
+
+/**
+ * Unified workspace WebSocket client for real-time events.
+ *
+ * Mirrors `/api/v2/w/{wid}/ws/realtime`: login with OAuth access token,
+ * subscribe to channels, receive AGUI events.
+ *
+ * The socket state machine — login, heartbeat, reconnect, subscribe retry —
+ * lives in {@link RealtimeSocketClient}, shared with the account client. This
+ * file is what is specific to the workspace mount: its URL, and the member id
+ * `protocol.init` hands back.
+ */
+
+/** Build the workspace realtime WebSocket URL from session config. */
+declare function buildWorkspaceWsUrl(session: RealtimeAuthSession): string;
+declare class WorkspaceRealtimeClient extends RealtimeSocketClient<RealtimeAuthSession> {
+    private memberId;
+    protected buildUrl(session: RealtimeAuthSession): string;
+    protected readProtocolInit(msg: ProtocolInitMessage): void;
+    protected clearIdentity(): void;
+    protected sessionRequiresReconnect(previous: RealtimeAuthSession | null, next: RealtimeAuthSession): boolean;
+    /**
+     * Member id the server authenticated this socket as, or null before
+     * `protocol.init` arrives.
+     *
+     * Channels whose Redis key is workspace-wide can carry events addressed to
+     * one member (presence acks, for example). Consumers compare the event's
+     * addressee against this so a reply meant for another operator cannot be
+     * applied locally.
+     */
+    getMemberId(): number | null;
 }
 declare function initWorkspaceSocket(session: RealtimeAuthSession): void;
 declare function subscribeWorkspaceChannel(channel: string, listener: ChannelListener): Unsubscribe;
 declare function onWorkspaceSocketConnection(listener: (connected: boolean) => void): () => void;
 declare function isWorkspaceSocketConnected(): boolean;
 
+/**
+ * Account WebSocket client — one socket per tab, rooted at the Account.
+ *
+ * Mirrors `/api/v2/ws/realtime`. No workspace in the URL and none in the
+ * session: the token is the whole identity, and what the socket may see comes
+ * from the server's grant map, refreshed there.
+ *
+ * See `docs/projects/active/account-socket.md`. The point is not a second
+ * socket — it is *one*. An operator covering four workspaces holds four
+ * `WorkspaceRealtimeClient`s today, which is four connections, four
+ * heartbeats, and no place to stand for "what is happening across my estate".
+ * Workspace-scoped channels are reached here by qualifying their names, so the
+ * same channel handlers serve both mounts and the per-workspace socket can be
+ * deleted at cutover rather than lived alongside.
+ *
+ * ```ts
+ * const client = new AccountRealtimeClient({ apiUrl, accessToken });
+ * client.subscribe(workspaceChannel(wid, 'activity'), onInvalidate);
+ * client.subscribe(ACCOUNT_ACTIVITY_CHANNEL, onInvalidate);
+ * ```
+ */
+
+/** Build the account realtime WebSocket URL from session config. */
+declare function buildAccountWsUrl(session: AccountRealtimeSession): string;
+/**
+ * Qualify a workspace-scoped channel name for the account socket.
+ *
+ * `chat:42:monitor` in workspace `W` is `w/W/chat:42:monitor` here. Exported
+ * as a function rather than left to callers' template strings for the reason
+ * every channel name constant in this package exists: the server matches
+ * exactly, so a typo subscribes successfully to nothing.
+ */
+declare function workspaceChannel(workspaceUuid: string, channel: string): string;
+declare class AccountRealtimeClient extends RealtimeSocketClient<AccountRealtimeSession> {
+    private accountUuid;
+    private workspaceUuids;
+    protected buildUrl(session: AccountRealtimeSession): string;
+    protected readProtocolInit(msg: ProtocolInitMessage): void;
+    protected clearIdentity(): void;
+    /** Account uuid the server authenticated this socket as, or null. */
+    getAccountUuid(): string | null;
+    /**
+     * Workspaces the server's grant map admitted at `protocol.init`.
+     *
+     * A **hint for rendering**, never an authorization decision: the server
+     * re-checks its own map on every subscribe, and refreshes it on a floor, so
+     * this snapshot can be stale in either direction. Use it to decide which
+     * panes are worth opening, not which data a viewer may see.
+     */
+    getWorkspaceUuids(): readonly string[];
+}
+declare function initAccountSocket(session: AccountRealtimeSession): void;
+declare function subscribeAccountChannel(channel: string, listener: ChannelListener): Unsubscribe;
+declare function onAccountSocketConnection(listener: (connected: boolean) => void): () => void;
+declare function isAccountSocketConnected(): boolean;
+
 /**
  * Human operator session WebSocket client.
  *
@@ -98,7 +250,7 @@ declare class OperatorSessionClient {
      * microphone before sending so the operator's audio is flowing the instant
      * the bridge registers.
      */
-    answerCall(interactionId: string): Promise<void>;
+    answerCall(interactionId: string, answerToken: string): Promise<void>;
     /**
      * Mute or unmute the operator's outbound microphone. Muting gates mic frames
      * locally (the caller stops hearing the operator) while callee audio keeps
@@ -117,4 +269,4 @@ declare class OperatorSessionClient {
     disconnect(): Promise<void>;
 }
 
-export { ChannelEvent, ChannelListener, OperatorCallPhase, OperatorSessionClient, type OperatorSessionHandlers, OperatorSessionState, RealtimeAuthSession, Unsubscribe, WorkspaceRealtimeClient, buildWorkspaceWsUrl, initWorkspaceSocket, isWorkspaceSocketConnected, onWorkspaceSocketConnection, subscribeWorkspaceChannel };
+export { AccountRealtimeClient, AccountRealtimeSession, ChannelEvent, ChannelListener, OperatorCallPhase, OperatorSessionClient, type OperatorSessionHandlers, OperatorSessionState, type ProtocolInitMessage, RealtimeAuthSession, RealtimeSessionBase, RealtimeSocketClient, Unsubscribe, WorkspaceRealtimeClient, buildAccountWsUrl, buildWorkspaceWsUrl, initAccountSocket, initWorkspaceSocket, isAccountSocketConnected, isWorkspaceSocketConnected, onAccountSocketConnection, onWorkspaceSocketConnection, subscribeAccountChannel, subscribeWorkspaceChannel, workspaceChannel };

package/dist/realtime.js

@@ -9,19 +9,37 @@ import {
 function isActiveCallPhase(phase) {
   return phase === "dialing" || phase === "live" || phase === "onHold";
 }
+var ACTIVITY_CHANNEL = "activity";
+var ACTIVITY_MEMBER_CHANNEL = "activity:me";
+var ACCOUNT_ACTIVITY_CHANNEL = "account:activity";
+var ACCOUNT_PRESENCE_CHANNEL = "account:presence";
+var PRESENCE_CHANNEL = "presence";
+function isActivityInvalidation(event) {
+  if (event.type !== "invalidate") return false;
+  const data = event.data;
+  if (typeof data !== "object" || data === null) return false;
+  const scope = data.scope;
+  return scope === "workspace" || scope === "member" || scope === "account";
+}
 
-// src/realtime/workspace-client.ts
+// src/realtime/socket-client.ts
 var HEARTBEAT_INTERVAL_MS = 3e4;
 var RECONNECT_DELAY_MS = 3e3;
 var MAX_RECONNECT_ATTEMPTS = 5;
 var CLOSE_DELAY_MS = 1e3;
+var MAX_SUBSCRIBE_RETRY_DELAY_MS = 3e4;
 function createSocketState() {
   return {
     ws: null,
     connected: false,
     connecting: false,
+    lastError: null,
     listeners: /* @__PURE__ */ new Map(),
     subscribedChannels: /* @__PURE__ */ new Set(),
+    subscriptionRevision: 0,
+    subscriptionRetryChannels: /* @__PURE__ */ new Set(),
+    subscriptionRetryAttempts: 0,
+    subscriptionRetryTimer: null,
     reconnectAttempts: 0,
     reconnectTimer: null,
     heartbeatTimer: null,
@@ -29,12 +47,7 @@ function createSocketState() {
     intentionalClose: false
   };
 }
-function buildWorkspaceWsUrl(session) {
-  const isSsl = session.apiUrl.startsWith("https");
-  const host = session.apiUrl.replace(/^https?:\/\//, "");
-  return `${isSsl ? "wss" : "ws"}://${host}/api/v2/w/${session.workspaceUuid}/ws/realtime`;
-}
-var WorkspaceRealtimeClient = class {
+var RealtimeSocketClient = class {
   session = null;
   getSessionFn;
   state = createSocketState();
@@ -49,6 +62,16 @@ var WorkspaceRealtimeClient = class {
       }
     }
   }
+  /**
+   * Whether replacing `previous` with `next` invalidates the open socket.
+   *
+   * The token always does; the rest is mount-specific — a workspace client
+   * changing workspace is a different socket, and an account client has no
+   * such axis.
+   */
+  sessionRequiresReconnect(previous, next) {
+    return previous?.accessToken !== next.accessToken || previous?.apiUrl !== next.apiUrl;
+  }
   resolveSession() {
     return this.session ?? this.getSessionFn?.() ?? null;
   }
@@ -63,8 +86,54 @@ var WorkspaceRealtimeClient = class {
       this.state.closeTimer = null;
     }
   }
+  clearSubscriptionRetry(channel) {
+    if (channel) {
+      this.state.subscriptionRetryChannels.delete(channel);
+    } else {
+      this.state.subscriptionRetryChannels.clear();
+    }
+    if (this.state.subscriptionRetryChannels.size > 0) return;
+    if (this.state.subscriptionRetryTimer) {
+      clearTimeout(this.state.subscriptionRetryTimer);
+      this.state.subscriptionRetryTimer = null;
+    }
+    this.state.subscriptionRetryAttempts = 0;
+  }
+  scheduleSubscriptionRetry(channels) {
+    for (const channel of channels) {
+      if (this.state.listeners.has(channel) && !this.state.subscribedChannels.has(channel)) {
+        this.state.subscriptionRetryChannels.add(channel);
+      }
+    }
+    if (this.state.subscriptionRetryChannels.size === 0 || this.state.subscriptionRetryTimer) {
+      return;
+    }
+    this.state.subscriptionRetryAttempts += 1;
+    const delay = Math.min(
+      RECONNECT_DELAY_MS * this.state.subscriptionRetryAttempts,
+      MAX_SUBSCRIBE_RETRY_DELAY_MS
+    );
+    this.state.subscriptionRetryTimer = setTimeout(() => {
+      this.state.subscriptionRetryTimer = null;
+      const retryChannels = Array.from(this.state.subscriptionRetryChannels).filter(
+        (channel) => this.state.listeners.has(channel) && !this.state.subscribedChannels.has(channel)
+      );
+      for (const channel of this.state.subscriptionRetryChannels) {
+        if (!retryChannels.includes(channel)) {
+          this.state.subscriptionRetryChannels.delete(channel);
+        }
+      }
+      if (retryChannels.length === 0) {
+        this.state.subscriptionRetryAttempts = 0;
+        return;
+      }
+      if (this.state.connected && this.state.ws?.readyState === WebSocket.OPEN) {
+        this.state.ws.send(JSON.stringify({ type: "subscribe", channels: retryChannels }));
+      }
+    }, delay);
+  }
   setSession(session) {
-    const changed = this.session?.accessToken !== session.accessToken || this.session?.workspaceUuid !== session.workspaceUuid || this.session?.apiUrl !== session.apiUrl;
+    const changed = this.sessionRequiresReconnect(this.session, session);
     this.session = session;
     if (changed && this.state.ws) {
       this.closeConnection();
@@ -91,6 +160,7 @@ var WorkspaceRealtimeClient = class {
       if (channelListeners && channelListeners.size === 0) {
         this.state.listeners.delete(channel);
         this.state.subscribedChannels.delete(channel);
+        this.clearSubscriptionRetry(channel);
         if (this.state.connected && this.state.ws?.readyState === WebSocket.OPEN) {
           this.state.ws.send(JSON.stringify({ type: "unsubscribe", channels: [channel] }));
         }
@@ -118,6 +188,44 @@ var WorkspaceRealtimeClient = class {
   isConnected() {
     return this.state.connected;
   }
+  /**
+   * Whether the server has acknowledged this channel subscription.
+   *
+   * This is stricter than having a local listener: it becomes true only after
+   * a `subscribed` frame, returns to false on disconnect or server-driven
+   * unsubscribe, and stays false while automatic subscribe retry is pending.
+   * Consumers that must order a command after subscription admission should
+   * observe {@link getSubscriptionRevision} and re-read this method.
+   */
+  isSubscribed(channel) {
+    return this.state.subscribedChannels.has(channel);
+  }
+  /**
+   * Monotonic local revision of acknowledged subscription state.
+   *
+   * It increments when `subscribed` or `unsubscribed` changes the server-
+   * acknowledged set. It is not a protocol sequence number and resets with a
+   * new client instance; its purpose is external-store invalidation before a
+   * consumer calls {@link isSubscribed} again.
+   */
+  getSubscriptionRevision() {
+    return this.state.subscriptionRevision;
+  }
+  /**
+   * A socket is open or opening and has not yet said `protocol.init`.
+   *
+   * Real state, read off the state machine. Consumers used to report a
+   * literal `false` here and render "Available" over a socket that had never
+   * connected; a toggle that cannot distinguish "not live" from "cannot tell
+   * yet" is the shape of that bug.
+   */
+  isConnecting() {
+    return this.state.connecting;
+  }
+  /** The last failure the socket gave up on, or null. See {@link SocketState.lastError}. */
+  getLastError() {
+    return this.state.lastError;
+  }
   ensureConnection() {
     const session = this.resolveSession();
     if (!session) return;
@@ -126,17 +234,21 @@ var WorkspaceRealtimeClient = class {
     this.clearCloseTimer();
     this.state.connecting = true;
     this.state.intentionalClose = false;
-    const ws = new WebSocket(buildWorkspaceWsUrl(session));
+    this.notifyConnectionListeners();
+    const ws = new WebSocket(this.buildUrl(session));
     ws.onopen = () => {
       ws.send(JSON.stringify({ type: "login", token: session.accessToken }));
     };
     ws.onmessage = (event) => {
+      if (this.state.ws !== null && this.state.ws !== ws) return;
       try {
         const msg = JSON.parse(String(event.data));
         if (msg.type === "protocol.init" && !this.state.connected) {
           this.state.connected = true;
+          this.readProtocolInit(msg);
           this.state.connecting = false;
           this.state.reconnectAttempts = 0;
+          this.state.lastError = null;
           if (this.state.heartbeatTimer) clearInterval(this.state.heartbeatTimer);
           this.state.heartbeatTimer = setInterval(() => {
             if (this.state.ws?.readyState === WebSocket.OPEN) {
@@ -157,13 +269,40 @@ var WorkspaceRealtimeClient = class {
         if (msg.type === "subscribed" && Array.isArray(msg.channels)) {
           for (const ch of msg.channels) {
             this.state.subscribedChannels.add(ch);
+            this.clearSubscriptionRetry(ch);
           }
+          this.state.subscriptionRevision += 1;
+          this.notifyConnectionListeners();
+          return;
+        }
+        if (msg.type === "subscribe_error" && Array.isArray(msg.errors)) {
+          const retryableChannels = [];
+          for (const rawError of msg.errors) {
+            if (!rawError || typeof rawError !== "object") continue;
+            const error = rawError;
+            if (typeof error.channel !== "string") continue;
+            if (error.retryable === true) {
+              retryableChannels.push(error.channel);
+            } else {
+              this.clearSubscriptionRetry(error.channel);
+            }
+          }
+          this.scheduleSubscriptionRetry(retryableChannels);
           return;
         }
         if (msg.type === "unsubscribed" && Array.isArray(msg.channels)) {
           for (const ch of msg.channels) {
             this.state.subscribedChannels.delete(ch);
           }
+          this.state.subscriptionRevision += 1;
+          this.notifyConnectionListeners();
+          this.scheduleSubscriptionRetry(msg.channels);
+          return;
+        }
+        if (msg.type === "error") {
+          const message = msg.message;
+          this.state.lastError = typeof message === "string" && message ? message : "Realtime error";
+          this.notifyConnectionListeners();
           return;
         }
         if (msg.type === "event" && msg.channel && msg.event) {
@@ -182,16 +321,22 @@ var WorkspaceRealtimeClient = class {
       }
     };
     ws.onclose = () => {
+      if (this.state.ws !== null && this.state.ws !== ws) return;
       this.state.connected = false;
       this.state.connecting = false;
       this.state.ws = null;
       this.state.subscribedChannels.clear();
+      this.clearSubscriptionRetry();
       if (this.state.heartbeatTimer) {
         clearInterval(this.state.heartbeatTimer);
         this.state.heartbeatTimer = null;
       }
+      const willRetry = !this.state.intentionalClose && this.state.listeners.size > 0 && this.state.reconnectAttempts < MAX_RECONNECT_ATTEMPTS;
+      if (!willRetry && !this.state.intentionalClose && this.state.listeners.size > 0) {
+        this.state.lastError = "Realtime connection lost";
+      }
       this.notifyConnectionListeners();
-      if (!this.state.intentionalClose && this.state.listeners.size > 0 && this.state.reconnectAttempts < MAX_RECONNECT_ATTEMPTS) {
+      if (willRetry) {
         this.state.reconnectAttempts += 1;
         this.state.reconnectTimer = setTimeout(() => {
           this.ensureConnection();
@@ -216,11 +361,47 @@ var WorkspaceRealtimeClient = class {
     this.state.ws?.close();
     this.state.ws = null;
     this.state.connected = false;
+    this.clearIdentity();
     this.state.connecting = false;
     this.state.subscribedChannels.clear();
+    this.clearSubscriptionRetry();
     this.notifyConnectionListeners();
   }
 };
+
+// src/realtime/workspace-client.ts
+function buildWorkspaceWsUrl(session) {
+  const isSsl = session.apiUrl.startsWith("https");
+  const host = session.apiUrl.replace(/^https?:\/\//, "");
+  return `${isSsl ? "wss" : "ws"}://${host}/api/v2/w/${session.workspaceUuid}/ws/realtime`;
+}
+var WorkspaceRealtimeClient = class extends RealtimeSocketClient {
+  memberId = null;
+  buildUrl(session) {
+    return buildWorkspaceWsUrl(session);
+  }
+  readProtocolInit(msg) {
+    this.memberId = typeof msg.memberId === "number" ? msg.memberId : null;
+  }
+  clearIdentity() {
+    this.memberId = null;
+  }
+  sessionRequiresReconnect(previous, next) {
+    return super.sessionRequiresReconnect(previous, next) || previous?.workspaceUuid !== next.workspaceUuid;
+  }
+  /**
+   * Member id the server authenticated this socket as, or null before
+   * `protocol.init` arrives.
+   *
+   * Channels whose Redis key is workspace-wide can carry events addressed to
+   * one member (presence acks, for example). Consumers compare the event's
+   * addressee against this so a reply meant for another operator cannot be
+   * applied locally.
+   */
+  getMemberId() {
+    return this.memberId;
+  }
+};
 var defaultClient = new WorkspaceRealtimeClient();
 function initWorkspaceSocket(session) {
   defaultClient.setSession(session);
@@ -235,6 +416,59 @@ function isWorkspaceSocketConnected() {
   return defaultClient.isConnected();
 }
 
+// src/realtime/account-client.ts
+function buildAccountWsUrl(session) {
+  const isSsl = session.apiUrl.startsWith("https");
+  const host = session.apiUrl.replace(/^https?:\/\//, "");
+  return `${isSsl ? "wss" : "ws"}://${host}/api/v2/ws/realtime`;
+}
+function workspaceChannel(workspaceUuid, channel) {
+  return `w/${workspaceUuid}/${channel}`;
+}
+var AccountRealtimeClient = class extends RealtimeSocketClient {
+  accountUuid = null;
+  workspaceUuids = [];
+  buildUrl(session) {
+    return buildAccountWsUrl(session);
+  }
+  readProtocolInit(msg) {
+    this.accountUuid = typeof msg.accountUuid === "string" ? msg.accountUuid : null;
+    this.workspaceUuids = Array.isArray(msg.workspaceUuids) ? msg.workspaceUuids.filter((value) => typeof value === "string") : [];
+  }
+  clearIdentity() {
+    this.accountUuid = null;
+    this.workspaceUuids = [];
+  }
+  /** Account uuid the server authenticated this socket as, or null. */
+  getAccountUuid() {
+    return this.accountUuid;
+  }
+  /**
+   * Workspaces the server's grant map admitted at `protocol.init`.
+   *
+   * A **hint for rendering**, never an authorization decision: the server
+   * re-checks its own map on every subscribe, and refreshes it on a floor, so
+   * this snapshot can be stale in either direction. Use it to decide which
+   * panes are worth opening, not which data a viewer may see.
+   */
+  getWorkspaceUuids() {
+    return this.workspaceUuids;
+  }
+};
+var defaultClient2 = new AccountRealtimeClient();
+function initAccountSocket(session) {
+  defaultClient2.setSession(session);
+}
+function subscribeAccountChannel(channel, listener) {
+  return defaultClient2.subscribe(channel, listener);
+}
+function onAccountSocketConnection(listener) {
+  return defaultClient2.onConnection(listener);
+}
+function isAccountSocketConnected() {
+  return defaultClient2.isConnected();
+}
+
 // src/realtime/operator-session-client.ts
 var OperatorSessionClient = class {
   constructor(handlers = {}) {
@@ -439,7 +673,7 @@ var OperatorSessionClient = class {
    * microphone before sending so the operator's audio is flowing the instant
    * the bridge registers.
    */
-  async answerCall(interactionId) {
+  async answerCall(interactionId, answerToken) {
     if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
       throw new Error("Operator session WebSocket is not connected");
     }
@@ -447,7 +681,10 @@ var OperatorSessionClient = class {
       throw new Error("Operator session is not ready");
     }
     await this.startMicrophone();
-    this.sendCustom("operator.call.answer", { interaction_id: interactionId });
+    this.sendCustom("operator.call.answer", {
+      interaction_id: interactionId,
+      answer_token: answerToken
+    });
   }
   /**
    * Mute or unmute the operator's outbound microphone. Muting gates mic frames
@@ -611,13 +848,27 @@ var OperatorSessionClient = class {
   }
 };
 export {
+  ACCOUNT_ACTIVITY_CHANNEL,
+  ACCOUNT_PRESENCE_CHANNEL,
+  ACTIVITY_CHANNEL,
+  ACTIVITY_MEMBER_CHANNEL,
+  AccountRealtimeClient,
   OperatorSessionClient,
+  PRESENCE_CHANNEL,
+  RealtimeSocketClient,
   WorkspaceRealtimeClient,
+  buildAccountWsUrl,
   buildWorkspaceWsUrl,
+  initAccountSocket,
   initWorkspaceSocket,
+  isAccountSocketConnected,
   isActiveCallPhase,
+  isActivityInvalidation,
   isWorkspaceSocketConnected,
+  onAccountSocketConnection,
   onWorkspaceSocketConnection,
-  subscribeWorkspaceChannel
+  subscribeAccountChannel,
+  subscribeWorkspaceChannel,
+  workspaceChannel
 };
 //# sourceMappingURL=realtime.js.map