@finalai/websockets 0.1.0

package/README.md

@@ -0,0 +1,10 @@
+# @finalai/websockets
+
+Client for Final WebSockets channels, realtime, presence, RPC, and related public
+wire operations. The default client supports browser and Node transports.
+
+`/channel-transport` is a portable channel transport with an injected asynchronous
+socket opener, renewal, reconnect, and cursor recovery. Agent relay adapters use
+this transport and own their separate agent framing.
+
+`/node-client-tls` provides optional Node mutual-TLS transport helpers.

package/dist/modules/channel-transport.d.mts

@@ -0,0 +1,56 @@
+import { type WebsocketGatewayData } from '@finalai/websocket-gateway-protocol';
+export interface SocketEventIface {
+    data?: unknown;
+    code?: number;
+    reason?: string;
+}
+export interface WebSocketLikeIface {
+    readyState: number;
+    send(data: string): void;
+    close(code?: number, reason?: string): void;
+    addEventListener(type: string, listener: (event: SocketEventIface) => void): void;
+}
+export interface ChannelTransportIface {
+    send(data: WebsocketGatewayData): boolean;
+    onFrame(listener: (data: WebsocketGatewayData) => void): () => void;
+    onOpen(listener: () => void): () => void;
+    onClose(listener: (info: {
+        code?: number;
+        reason?: string;
+    }) => void): () => void;
+    readonly isOpen: boolean;
+    close(reason?: string): void;
+}
+export interface ChannelTransportTokenIface {
+    token: string;
+    expiresAt: string;
+}
+export declare enum ChannelTransportStage {
+    SocketOpen = "socket-open",
+    Hello = "hello",
+    Subscribed = "subscribed"
+}
+export interface ChannelTransportOptionsIface {
+    gatewayUrl: string;
+    token: ChannelTransportTokenIface;
+    inbound: string;
+    outbound: string;
+    messageName: string;
+    initialCursor?: string;
+    openWebSocket: (args: {
+        url: string;
+        headers: Record<string, string>;
+        signal: AbortSignal;
+    }) => Promise<WebSocketLikeIface>;
+    renewToken?: () => Promise<ChannelTransportTokenIface>;
+    renewBeforeMs?: number;
+    subscribeAfter?: Promise<void>;
+    onStage?: (stage: ChannelTransportStage) => void;
+    now?: () => number;
+    sleep?: (ms: number, signal: AbortSignal) => Promise<void>;
+    log?: (event: string, fields: Record<string, string | number | boolean | null>) => void;
+}
+export declare const GATEWAY_PROTOCOL_VERSION = 1;
+export declare const compareGatewayCursors: (left: string, right: string) => number;
+export declare const gatewayConnectUrl: (gatewayUrl: string) => string;
+export declare const createChannelTransport: (options: ChannelTransportOptionsIface) => ChannelTransportIface;

package/dist/modules/channel-transport.mjs

@@ -0,0 +1,269 @@
+import * as z from "zod";
+import {
+  websocketGatewayServerFrameSchema,
+  compareWebsocketGatewayCursors
+} from "@finalai/websocket-gateway-protocol";
+const backoffDelayMs = (args) => Math.min(args.maxDelayMs, args.minDelayMs * 2 ** Math.max(0, args.attempt - 1));
+var ChannelTransportStage = /* @__PURE__ */ ((ChannelTransportStage2) => {
+  ChannelTransportStage2["SocketOpen"] = "socket-open";
+  ChannelTransportStage2["Hello"] = "hello";
+  ChannelTransportStage2["Subscribed"] = "subscribed";
+  return ChannelTransportStage2;
+})(ChannelTransportStage || {});
+const GATEWAY_PROTOCOL_VERSION = 1;
+const DEFAULT_RENEW_BEFORE_MS = 2 * 60 * 1e3;
+const PING_INTERVAL_MS = 2e4;
+const RENEW_CHECK_MS = 15e3;
+const SOCKET_OPEN = 1;
+const gatewayServerFrameSchema = websocketGatewayServerFrameSchema;
+const parseServerFrame = (event) => {
+  const text = z.string().safeParse(event.data);
+  if (!text.success) return null;
+  try {
+    const parsed = gatewayServerFrameSchema.safeParse(JSON.parse(text.data));
+    return parsed.success ? parsed.data : null;
+  } catch {
+    return null;
+  }
+};
+const compareGatewayCursors = compareWebsocketGatewayCursors;
+const abortableSleep = (ms, signal) => new Promise((resolve) => {
+  if (signal.aborted) {
+    resolve();
+    return;
+  }
+  const timer = setTimeout(resolve, ms);
+  signal.addEventListener(
+    "abort",
+    () => {
+      clearTimeout(timer);
+      resolve();
+    },
+    { once: true }
+  );
+});
+const gatewayConnectUrl = (gatewayUrl) => {
+  const url = new URL(gatewayUrl);
+  const path = url.pathname.replace(/\/+$/, "");
+  url.pathname = path.endsWith("/connect") ? path : `${path}/connect`;
+  url.searchParams.set("protocolVersion", String(GATEWAY_PROTOCOL_VERSION));
+  return url.toString();
+};
+const createChannelTransport = (options) => {
+  const { inbound, outbound } = options;
+  const now = options.now ?? Date.now;
+  const sleep = options.sleep ?? abortableSleep;
+  const log = options.log ?? (() => void 0);
+  const stage = (reached) => {
+    try {
+      options.onStage?.(reached);
+    } catch {
+    }
+  };
+  const renewBeforeMs = options.renewBeforeMs ?? DEFAULT_RENEW_BEFORE_MS;
+  let subscribeAllowed = options.subscribeAfter == null;
+  options.subscribeAfter?.then(
+    () => {
+      subscribeAllowed = true;
+    },
+    () => void 0
+  );
+  const lifetime = new AbortController();
+  const frameListeners = /* @__PURE__ */ new Set();
+  const openListeners = /* @__PURE__ */ new Set();
+  const closeListeners = /* @__PURE__ */ new Set();
+  let token = options.token;
+  let socket = null;
+  let subscribed = false;
+  let lastCursor = null;
+  let requestCounter = 0;
+  let attempt = 0;
+  let renewing = false;
+  const nextId = (prefix) => {
+    requestCounter += 1;
+    return `${prefix}-${requestCounter}`;
+  };
+  const sendRaw = (target, frame) => {
+    if (target.readyState !== SOCKET_OPEN) return false;
+    try {
+      target.send(JSON.stringify(frame));
+      return true;
+    } catch {
+      return false;
+    }
+  };
+  const takeCursor = (cursor) => {
+    if (cursor == null) return;
+    if (lastCursor == null || compareGatewayCursors(cursor, lastCursor) > 0) lastCursor = cursor;
+  };
+  const renew = async () => {
+    if (renewing || options.renewToken == null) return;
+    const expiresAtMs = Date.parse(token.expiresAt);
+    if (Number.isFinite(expiresAtMs) && expiresAtMs - now() > renewBeforeMs) return;
+    renewing = true;
+    try {
+      token = await options.renewToken();
+      if (socket != null) sendRaw(socket, { type: "auth", id: nextId("auth"), token: token.token });
+    } catch (cause) {
+      log("websockets.channel.renew_failed", {
+        error: cause instanceof Error ? cause.message : String(cause)
+      });
+    } finally {
+      renewing = false;
+    }
+  };
+  const connectOnce = async () => {
+    await renew();
+    const url = gatewayConnectUrl(options.gatewayUrl);
+    let next;
+    try {
+      next = await options.openWebSocket({
+        url,
+        headers: { authorization: `Bearer ${token.token}` },
+        signal: lifetime.signal
+      });
+    } catch (cause) {
+      log("websockets.channel.connect_failed", {
+        error: cause instanceof Error ? cause.message : String(cause)
+      });
+      return false;
+    }
+    if (lifetime.signal.aborted) {
+      next.close(1e3, "closed");
+      return true;
+    }
+    stage("socket-open" /* SocketOpen */);
+    socket = next;
+    subscribed = false;
+    const current = next;
+    const timers = [];
+    const closed = new Promise((resolve) => {
+      current.addEventListener("close", (event) => {
+        for (const timer of timers) clearInterval(timer);
+        if (socket === current) {
+          socket = null;
+          const wasSubscribed = subscribed;
+          subscribed = false;
+          if (wasSubscribed) {
+            for (const listener of [...closeListeners]) {
+              listener({ code: event.code, reason: event.reason });
+            }
+          }
+        }
+        resolve();
+      });
+    });
+    let subscribeId = null;
+    const subscribe = () => {
+      if (socket !== current || subscribeId != null) return;
+      subscribeId = nextId("subscribe");
+      const frame = {
+        type: "channel.subscribe",
+        id: subscribeId,
+        channel: inbound
+      };
+      if (lastCursor != null) frame.afterCursor = lastCursor;
+      else if (options.initialCursor != null) frame.afterCursor = options.initialCursor;
+      sendRaw(current, frame);
+    };
+    current.addEventListener("message", (event) => {
+      if (socket !== current) return;
+      const frame = parseServerFrame(event);
+      if (frame == null) return;
+      switch (frame.type) {
+        case "hello": {
+          stage("hello" /* Hello */);
+          if (subscribeAllowed) subscribe();
+          else options.subscribeAfter?.then(subscribe, () => void 0);
+          return;
+        }
+        case "ack": {
+          if (frame.operation === "channel.subscribe" && frame.requestId === subscribeId) {
+            takeCursor(frame.cursor);
+            subscribed = true;
+            attempt = 0;
+            stage("subscribed" /* Subscribed */);
+            for (const listener of [...openListeners]) listener();
+          }
+          return;
+        }
+        case "error": {
+          log("websockets.channel.gateway_error", { code: frame.code, message: frame.message });
+          if (frame.requestId === subscribeId) current.close(4e3, "subscribe failed");
+          return;
+        }
+        case "channel.message": {
+          if (frame.message.channel !== inbound) return;
+          takeCursor(frame.message.cursor);
+          if (frame.message.name !== options.messageName) return;
+          for (const listener of [...frameListeners]) listener(frame.message.data);
+          return;
+        }
+        case "pong":
+          return;
+      }
+    });
+    timers.push(
+      setInterval(() => {
+        sendRaw(current, { type: "ping", nonce: nextId("ping") });
+      }, PING_INTERVAL_MS),
+      setInterval(() => {
+        void renew();
+      }, RENEW_CHECK_MS)
+    );
+    await closed;
+    return true;
+  };
+  const loop = async () => {
+    while (!lifetime.signal.aborted) {
+      await connectOnce();
+      if (lifetime.signal.aborted) return;
+      attempt += 1;
+      await sleep(backoffDelayMs({ attempt, minDelayMs: 1e3, maxDelayMs: 4e3 }), lifetime.signal);
+    }
+  };
+  void loop();
+  return {
+    send: (frame) => {
+      if (socket == null || !subscribed) return false;
+      return sendRaw(socket, {
+        type: "channel.publish",
+        id: nextId("publish"),
+        channel: outbound,
+        name: options.messageName,
+        data: frame,
+        retain: true
+      });
+    },
+    onFrame: (listener) => {
+      frameListeners.add(listener);
+      return () => frameListeners.delete(listener);
+    },
+    onOpen: (listener) => {
+      openListeners.add(listener);
+      return () => openListeners.delete(listener);
+    },
+    onClose: (listener) => {
+      closeListeners.add(listener);
+      return () => closeListeners.delete(listener);
+    },
+    get isOpen() {
+      return socket != null && subscribed && socket.readyState === SOCKET_OPEN;
+    },
+    close: (reason) => {
+      lifetime.abort();
+      const current = socket;
+      socket = null;
+      subscribed = false;
+      current?.close(1e3, reason ?? "closed");
+    }
+  };
+};
+export {
+  ChannelTransportStage,
+  GATEWAY_PROTOCOL_VERSION,
+  compareGatewayCursors,
+  createChannelTransport,
+  gatewayConnectUrl
+};
+//# sourceMappingURL=channel-transport.mjs.map

package/dist/modules/channel-transport.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/channel-transport.ts"],
+  "sourcesContent": ["import * as z from 'zod';\n\nimport {\n  websocketGatewayServerFrameSchema,\n  compareWebsocketGatewayCursors,\n  type WebsocketGatewayData,\n} from '@finalai/websocket-gateway-protocol';\nexport interface SocketEventIface {\n  data?: unknown;\n  code?: number;\n  reason?: string;\n}\nexport interface WebSocketLikeIface {\n  readyState: number;\n  send(data: string): void;\n  close(code?: number, reason?: string): void;\n  addEventListener(type: string, listener: (event: SocketEventIface) => void): void;\n}\nexport interface ChannelTransportIface {\n  send(data: WebsocketGatewayData): boolean;\n  onFrame(listener: (data: WebsocketGatewayData) => void): () => void;\n  onOpen(listener: () => void): () => void;\n  onClose(listener: (info: { code?: number; reason?: string }) => void): () => void;\n  readonly isOpen: boolean;\n  close(reason?: string): void;\n}\nconst backoffDelayMs = (args: { attempt: number; minDelayMs: number; maxDelayMs: number }) =>\n  Math.min(args.maxDelayMs, args.minDelayMs * 2 ** Math.max(0, args.attempt - 1));\n\nexport interface ChannelTransportTokenIface {\n  token: string;\n  expiresAt: string;\n}\n\n// Points of each link's setup, for latency traces.\nexport enum ChannelTransportStage {\n  SocketOpen = 'socket-open',\n  // The gateway's hello arrived.\n  Hello = 'hello',\n  // The gateway acknowledged the subscribe: the link is up.\n  Subscribed = 'subscribed',\n}\n\nexport interface ChannelTransportOptionsIface {\n  // The gateway's WebSocket base URL (wss://\u2026); `/connect?protocolVersion=1` is appended.\n  gatewayUrl: string;\n  token: ChannelTransportTokenIface;\n  // Separate inbound and outbound channels allow bidirectional integrations.\n  inbound: string;\n  outbound: string;\n  messageName: string;\n  initialCursor?: string;\n  openWebSocket: (args: {\n    url: string;\n    headers: Record<string, string>;\n    signal: AbortSignal;\n  }) => Promise<WebSocketLikeIface>;\n  // Supply a fresh token before expiry.\n  renewToken?: () => Promise<ChannelTransportTokenIface>;\n  renewBeforeMs?: number;\n  // Delay subscriptions until the caller is ready to receive retained frames.\n  subscribeAfter?: Promise<void>;\n  onStage?: (stage: ChannelTransportStage) => void;\n  now?: () => number;\n  sleep?: (ms: number, signal: AbortSignal) => Promise<void>;\n  log?: (event: string, fields: Record<string, string | number | boolean | null>) => void;\n}\n\nexport const GATEWAY_PROTOCOL_VERSION = 1;\n// websocket-gateway's subscribe cursor for \"no retained history\".\nconst DEFAULT_RENEW_BEFORE_MS = 2 * 60 * 1000;\nconst PING_INTERVAL_MS = 20_000;\nconst RENEW_CHECK_MS = 15_000;\nconst SOCKET_OPEN = 1;\n\nconst gatewayServerFrameSchema = websocketGatewayServerFrameSchema;\n\n// The client frames this transport sends.\ninterface GatewayClientFrameIface {\n  type: 'auth' | 'channel.subscribe' | 'channel.publish' | 'ping';\n  id?: string;\n  token?: string;\n  channel?: string;\n  afterCursor?: string;\n  name?: string;\n  data?: WebsocketGatewayData;\n  retain?: boolean;\n  nonce?: string;\n}\n\nconst parseServerFrame = (\n  event: SocketEventIface,\n): z.infer<typeof gatewayServerFrameSchema> | null => {\n  const text = z.string().safeParse(event.data);\n  if (!text.success) return null;\n  try {\n    const parsed = gatewayServerFrameSchema.safeParse(JSON.parse(text.data));\n    return parsed.success ? parsed.data : null;\n  } catch {\n    return null;\n  }\n};\n\n// Gateway cursors are Redis stream ids `<ms>-<seq>`.\nexport const compareGatewayCursors = compareWebsocketGatewayCursors;\n\nconst abortableSleep = (ms: number, signal: AbortSignal): Promise<void> =>\n  new Promise((resolve) => {\n    if (signal.aborted) {\n      resolve();\n      return;\n    }\n    const timer = setTimeout(resolve, ms);\n    signal.addEventListener(\n      'abort',\n      () => {\n        clearTimeout(timer);\n        resolve();\n      },\n      { once: true },\n    );\n  });\n\n// Deployments configure the gateway as either its origin or its `/connect`\n// endpoint; both dial `/connect`.\nexport const gatewayConnectUrl = (gatewayUrl: string): string => {\n  const url = new URL(gatewayUrl);\n  const path = url.pathname.replace(/\\/+$/, '');\n  url.pathname = path.endsWith('/connect') ? path : `${path}/connect`;\n  url.searchParams.set('protocolVersion', String(GATEWAY_PROTOCOL_VERSION));\n  return url.toString();\n};\n\nexport const createChannelTransport = (\n  options: ChannelTransportOptionsIface,\n): ChannelTransportIface => {\n  const { inbound, outbound } = options;\n  const now = options.now ?? Date.now;\n  const sleep = options.sleep ?? abortableSleep;\n  const log = options.log ?? ((): void => undefined);\n  const stage = (reached: ChannelTransportStage): void => {\n    try {\n      options.onStage?.(reached);\n    } catch {\n      // Stage listeners are informational.\n    }\n  };\n  const renewBeforeMs = options.renewBeforeMs ?? DEFAULT_RENEW_BEFORE_MS;\n  let subscribeAllowed = options.subscribeAfter == null;\n  options.subscribeAfter?.then(\n    () => {\n      subscribeAllowed = true;\n    },\n    () => undefined,\n  );\n  const lifetime = new AbortController();\n  const frameListeners = new Set<(frame: WebsocketGatewayData) => void>();\n  const openListeners = new Set<() => void>();\n  const closeListeners = new Set<(info: { code?: number; reason?: string }) => void>();\n  let token = options.token;\n  let socket: WebSocketLikeIface | null = null;\n  let subscribed = false;\n  // Newest retained cursor taken from the inbound channel; a reconnect resumes after it.\n  let lastCursor: string | null = null;\n  let requestCounter = 0;\n  let attempt = 0;\n  let renewing = false;\n\n  const nextId = (prefix: string): string => {\n    requestCounter += 1;\n    return `${prefix}-${requestCounter}`;\n  };\n\n  const sendRaw = (target: WebSocketLikeIface, frame: GatewayClientFrameIface): boolean => {\n    if (target.readyState !== SOCKET_OPEN) return false;\n    try {\n      target.send(JSON.stringify(frame));\n      return true;\n    } catch {\n      return false;\n    }\n  };\n\n  const takeCursor = (cursor: string | null | undefined): void => {\n    if (cursor == null) return;\n    if (lastCursor == null || compareGatewayCursors(cursor, lastCursor) > 0) lastCursor = cursor;\n  };\n\n  const renew = async (): Promise<void> => {\n    if (renewing || options.renewToken == null) return;\n    const expiresAtMs = Date.parse(token.expiresAt);\n    if (Number.isFinite(expiresAtMs) && expiresAtMs - now() > renewBeforeMs) return;\n    renewing = true;\n    try {\n      token = await options.renewToken();\n      if (socket != null) sendRaw(socket, { type: 'auth', id: nextId('auth'), token: token.token });\n    } catch (cause) {\n      log('websockets.channel.renew_failed', {\n        error: cause instanceof Error ? cause.message : String(cause),\n      });\n    } finally {\n      renewing = false;\n    }\n  };\n\n  const connectOnce = async (): Promise<boolean> => {\n    await renew();\n    const url = gatewayConnectUrl(options.gatewayUrl);\n    let next: WebSocketLikeIface;\n    try {\n      next = await options.openWebSocket({\n        url,\n        headers: { authorization: `Bearer ${token.token}` },\n        signal: lifetime.signal,\n      });\n    } catch (cause) {\n      log('websockets.channel.connect_failed', {\n        error: cause instanceof Error ? cause.message : String(cause),\n      });\n      return false;\n    }\n    if (lifetime.signal.aborted) {\n      next.close(1000, 'closed');\n      return true;\n    }\n    stage(ChannelTransportStage.SocketOpen);\n    socket = next;\n    subscribed = false;\n    const current = next;\n    const timers: ReturnType<typeof setInterval>[] = [];\n    const closed = new Promise<void>((resolve) => {\n      current.addEventListener('close', (event) => {\n        for (const timer of timers) clearInterval(timer);\n        if (socket === current) {\n          socket = null;\n          const wasSubscribed = subscribed;\n          subscribed = false;\n          if (wasSubscribed) {\n            for (const listener of [...closeListeners]) {\n              listener({ code: event.code, reason: event.reason });\n            }\n          }\n        }\n        resolve();\n      });\n    });\n    let subscribeId: string | null = null;\n    const subscribe = (): void => {\n      if (socket !== current || subscribeId != null) return;\n      subscribeId = nextId('subscribe');\n      const frame: GatewayClientFrameIface = {\n        type: 'channel.subscribe',\n        id: subscribeId,\n        channel: inbound,\n      };\n      // Resume after the newest received cursor; initial replay is caller-configured.\n      if (lastCursor != null) frame.afterCursor = lastCursor;\n      else if (options.initialCursor != null) frame.afterCursor = options.initialCursor;\n      sendRaw(current, frame);\n    };\n    current.addEventListener('message', (event) => {\n      if (socket !== current) return;\n      const frame = parseServerFrame(event);\n      if (frame == null) return;\n      switch (frame.type) {\n        case 'hello': {\n          stage(ChannelTransportStage.Hello);\n          if (subscribeAllowed) subscribe();\n          else options.subscribeAfter?.then(subscribe, () => undefined);\n          return;\n        }\n        case 'ack': {\n          if (frame.operation === 'channel.subscribe' && frame.requestId === subscribeId) {\n            takeCursor(frame.cursor);\n            subscribed = true;\n            attempt = 0;\n            stage(ChannelTransportStage.Subscribed);\n            for (const listener of [...openListeners]) listener();\n          }\n          return;\n        }\n        case 'error': {\n          log('websockets.channel.gateway_error', { code: frame.code, message: frame.message });\n          if (frame.requestId === subscribeId) current.close(4000, 'subscribe failed');\n          return;\n        }\n        case 'channel.message': {\n          if (frame.message.channel !== inbound) return;\n          takeCursor(frame.message.cursor);\n          if (frame.message.name !== options.messageName) return;\n          for (const listener of [...frameListeners]) listener(frame.message.data);\n          return;\n        }\n        case 'pong':\n          return;\n      }\n    });\n    timers.push(\n      setInterval(() => {\n        sendRaw(current, { type: 'ping', nonce: nextId('ping') });\n      }, PING_INTERVAL_MS),\n      setInterval(() => {\n        void renew();\n      }, RENEW_CHECK_MS),\n    );\n    await closed;\n    return true;\n  };\n\n  const loop = async (): Promise<void> => {\n    while (!lifetime.signal.aborted) {\n      await connectOnce();\n      if (lifetime.signal.aborted) return;\n      attempt += 1;\n      await sleep(backoffDelayMs({ attempt, minDelayMs: 1000, maxDelayMs: 4000 }), lifetime.signal);\n    }\n  };\n  void loop();\n\n  return {\n    send: (frame) => {\n      if (socket == null || !subscribed) return false;\n      return sendRaw(socket, {\n        type: 'channel.publish',\n        id: nextId('publish'),\n        channel: outbound,\n        name: options.messageName,\n        data: frame,\n        retain: true,\n      });\n    },\n    onFrame: (listener) => {\n      frameListeners.add(listener);\n      return () => frameListeners.delete(listener);\n    },\n    onOpen: (listener) => {\n      openListeners.add(listener);\n      return () => openListeners.delete(listener);\n    },\n    onClose: (listener) => {\n      closeListeners.add(listener);\n      return () => closeListeners.delete(listener);\n    },\n    get isOpen() {\n      return socket != null && subscribed && socket.readyState === SOCKET_OPEN;\n    },\n    close: (reason) => {\n      lifetime.abort();\n      const current = socket;\n      socket = null;\n      subscribed = false;\n      current?.close(1000, reason ?? 'closed');\n    },\n  };\n};\n"],
+  "mappings": "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",
+  "names": ["ChannelTransportStage"]
+}

package/dist/modules/index.d.mts

@@ -0,0 +1,295 @@
+import { type WebsocketGatewayAction as WebsocketsAction, type WebsocketGatewayCapability as WebsocketsCapability, type WebsocketGatewayClientFrame as WebsocketsClientFrame, type WebsocketGatewayData as WebsocketsData, type WebsocketGatewayMessage as WebsocketsMessage, type WebsocketGatewayPresenceMember as WebsocketsPresenceMember, type WebsocketGatewayProxyUpstreamDescriptor as WebsocketsProxyUpstreamDescriptor, type WebsocketGatewayRealtimeMessage as WebsocketsRealtimeMessage, type WebsocketGatewayServerFrame as WebsocketsServerFrame } from '@finalai/websocket-gateway-protocol';
+export type { WebsocketGatewayAction as WebsocketsAction, WebsocketGatewayCapability as WebsocketsCapability, WebsocketGatewayClientFrame as WebsocketsClientFrame, WebsocketGatewayData as WebsocketsData, WebsocketGatewayMessage as WebsocketsMessage, WebsocketGatewayPresenceMember as WebsocketsPresenceMember, WebsocketGatewayProxyPayload as WebsocketsProxyPayload, WebsocketGatewayProxyUpstreamDescriptor as WebsocketsProxyUpstreamDescriptor, WebsocketGatewayRealtimeMessage as WebsocketsRealtimeMessage, WebsocketGatewayServerFrame as WebsocketsServerFrame, } from '@finalai/websocket-gateway-protocol';
+export type GatewayAuthProvider = string | (() => string | Promise<string>);
+export type GatewayFrameHandler = (frame: WebsocketsServerFrame) => void;
+export type WebsocketsProxyTarget = string | Pick<WebsocketsProxyUpstreamDescriptor, 'id'>;
+export type WebsocketsProxySendData = string | ArrayBuffer | ArrayBufferView;
+export type WebsocketsErrorFrame = Extract<WebsocketsServerFrame, {
+    type: 'error';
+}>;
+export interface WebsocketsProxyHandlers {
+    onOpen?: (upstream: string) => void;
+    onMessage?: (data: string | ArrayBuffer) => void;
+    onClose?: (event: {
+        code?: number;
+        reason?: string;
+    }) => void;
+}
+export interface WebsocketsChannelPublishOptions {
+    name?: string;
+    idempotencyKey?: string;
+    retain?: boolean;
+}
+export interface WebsocketsChannelSubscribeOptionsIface {
+    afterCursor?: string;
+    onError?: (error: WebsocketsErrorFrame) => void;
+    onSubscribed?: () => void;
+}
+export interface WebsocketsRealtimeSubscribeOptionsIface {
+    afterCursor?: string;
+    onError?: (error: {
+        code: string;
+        message: string;
+        retryable: boolean;
+    }) => void;
+    onResyncRequired?: () => void;
+    onSubscribed?: () => void;
+}
+export interface WebsocketsRealtimePresenceEventIface {
+    action: 'enter' | 'update' | 'leave';
+    member: WebsocketsPresenceMember;
+    topic: string;
+}
+export interface WebsocketsRealtimePresenceIface {
+    enter: (data?: WebsocketsData) => void;
+    update: (data?: WebsocketsData) => void;
+    leave: () => void;
+    get: (options?: WebsocketsPresenceGetOptionsIface) => Promise<WebsocketsPresenceMember[]>;
+    subscribe: (handler: (event: WebsocketsRealtimePresenceEventIface) => void) => () => void;
+}
+export interface WebsocketsPresenceGetOptionsIface {
+    signal?: AbortSignal;
+}
+export interface WebsocketsClientOptions {
+    url: string;
+    auth: GatewayAuthProvider;
+    WebSocketCtor?: typeof WebSocket;
+    reconnect?: boolean;
+    onReconnect?: () => void;
+    heartbeatIntervalMs?: number;
+    ackTimeoutMs?: number;
+    maxQueuedFrames?: number;
+}
+export interface WebsocketsChannelSubscriptionDiagnosticsIface {
+    bufferedBytes: number;
+    bufferedBytesHighWater: number;
+    bufferedFrames: number;
+    bufferedFramesHighWater: number;
+    channel: string;
+    pendingGapFill: boolean;
+    pendingSubscribeAck: boolean;
+    receivedBytes: number;
+    receivedFrames: number;
+}
+export interface WebsocketsConnectionDiagnosticsIface {
+    bufferedBytes: number;
+    bufferedBytesHighWater: number;
+    bufferedFrames: number;
+    bufferedFramesHighWater: number;
+    bufferLimitFlushes: number;
+    channelMessageBytes: number;
+    channelMessageFrames: number;
+    channelStreams: WebsocketsChannelSubscriptionDiagnosticsIface[];
+    channelSubscriptions: number;
+    gapFillErrors: number;
+    gapFillRequests: number;
+    gapFillResponses: number;
+    gapFillSendErrors: number;
+    gapFillTimeouts: number;
+    frameHandlers: number;
+    frameHandlersHighWater: number;
+    lastCloseCode: number | null;
+    lastCloseReason: string | null;
+    pendingGapFills: number;
+    pendingSubscribeAcks: number;
+    queuedBytes: number;
+    queuedFrames: number;
+    realtimeMessageBytes: number;
+    realtimeMessageFrames: number;
+    realtimeSubscriptions: number;
+    receivedBytes: number;
+    receivedFrames: number;
+    reconnects: number;
+    rpcCallBytes: number;
+    rpcCallFrames: number;
+    sentBytes: number;
+    sentFrames: number;
+    socketBufferedBytes: number;
+    socketBufferedBytesHighWater: number;
+    socketCloses: number;
+    socketOpens: number;
+    subscribeAcks: number;
+    subscribeErrors: number;
+    subscribeRequests: number;
+    subscribeSuperseded: number;
+    subscribeTimeouts: number;
+}
+interface RegisterChannelSubscriptionArgsIface {
+    afterCursor?: string;
+    channel: string;
+    onError?: (error: WebsocketsErrorFrame) => void;
+    onSubscribed?: () => void;
+}
+export declare class WebsocketsConnection {
+    private readonly options;
+    private socket;
+    private handlers;
+    private replayRegistrations;
+    private heartbeatTimer;
+    private channelSubscriptions;
+    private realtimeSubscriptions;
+    private realtimeSubscribeQueue;
+    private realtimeSubscribeQueued;
+    private realtimeUnsubscribeQueue;
+    private realtimeUnsubscribeQueued;
+    private socketAuthToken;
+    private authenticated;
+    private queuedFrames;
+    private queuedBytes;
+    private manuallyClosed;
+    private hasAuthenticated;
+    private diagnostics;
+    constructor(options: WebsocketsClientOptions);
+    connect(): Promise<void>;
+    private openSocket;
+    private resolveSocketUrlAndAuth;
+    private authenticateInitialSocket;
+    private startHeartbeat;
+    private clearHeartbeat;
+    private routeIncomingFrame;
+    private dispatchableSubscriptionDeliveries;
+    private settleSubscriptionBuffer;
+    private bufferSubscriptionDelivery;
+    private currentBufferDiagnostics;
+    private clearSubscriptionGapFill;
+    private beginSubscriptionGapFill;
+    private channelFrames;
+    private dispatchRealtimeDeliveries;
+    private beginRealtimeGapFill;
+    private beginChannelGapFill;
+    private resubscribeChannels;
+    private resubscribeRealtimeTopics;
+    private queueRealtimeSubscribe;
+    private sendRealtimeSubscribeBatches;
+    private queueRealtimeUnsubscribe;
+    private sendSubscribeFrame;
+    auth: {
+        authorize: (args: {
+            token: string;
+        }) => Promise<void>;
+    };
+    onFrame(handler: GatewayFrameHandler): () => void;
+    registerReplay(key: string, replay: () => void): () => void;
+    waitForAck(requestId: string, operation: string): Promise<void>;
+    channel(name: string): WebsocketsChannel;
+    realtime(topic: string): WebsocketsRealtimeTopic;
+    registerRealtimeSubscription(args: {
+        topic: string;
+        handler: (message: WebsocketsRealtimeMessage) => void;
+        options?: WebsocketsRealtimeSubscribeOptionsIface;
+    }): () => void;
+    registerChannelSubscription(args: RegisterChannelSubscriptionArgsIface): () => void;
+    rpc(name: string): WebsocketsRpc;
+    bridge(name: string): WebsocketsBridge;
+    proxy(upstream: WebsocketsProxyTarget): WebsocketsProxy;
+    send(frame: WebsocketsClientFrame): void;
+    getDiagnostics(): WebsocketsConnectionDiagnosticsIface;
+    private sendAuthFrame;
+    private sendEncodedFrame;
+    private flushQueuedFrames;
+    ping(nonce?: string): void;
+    close(code?: number, reason?: string): void;
+}
+export declare class WebsocketsChannel {
+    private readonly connection;
+    private readonly name;
+    constructor(connection: WebsocketsConnection, name: string);
+    subscribe(handler: (message: WebsocketsMessage) => void, options?: string | WebsocketsChannelSubscribeOptionsIface): () => void;
+    publish(data: WebsocketsData, options?: string | WebsocketsChannelPublishOptions): void;
+    history(args?: {
+        afterCursor?: string;
+        limit?: number;
+    }): Promise<WebsocketsMessage[]>;
+    presence(): WebsocketsPresence;
+}
+export declare class WebsocketsRealtimeTopic {
+    private readonly connection;
+    private readonly topic;
+    constructor(connection: WebsocketsConnection, topic: string);
+    subscribe(handler: (message: WebsocketsRealtimeMessage) => void, options?: WebsocketsRealtimeSubscribeOptionsIface): () => void;
+    presence(): WebsocketsRealtimePresenceIface;
+}
+export declare class WebsocketsPresence {
+    private readonly connection;
+    private readonly channel;
+    private unregisterPresenceReplay;
+    private data;
+    constructor(connection: WebsocketsConnection, channel: string);
+    enter(data?: WebsocketsData): void;
+    update(data?: WebsocketsData): void;
+    leave(): void;
+    get(options?: WebsocketsPresenceGetOptionsIface): Promise<WebsocketsPresenceMember[]>;
+    subscribe(handler: (event: {
+        channel: string;
+        action: 'enter' | 'update' | 'leave';
+        member: WebsocketsPresenceMember;
+    }) => void): () => void;
+}
+export declare class WebsocketsRpc {
+    private readonly connection;
+    private readonly name;
+    constructor(connection: WebsocketsConnection, name: string);
+    connect(handler: (data: WebsocketsData) => WebsocketsData | Promise<WebsocketsData>): () => void;
+    call(data: WebsocketsData, timeoutMs?: number, signal?: AbortSignal): Promise<WebsocketsData | undefined>;
+}
+export declare class WebsocketsBridge {
+    private readonly connection;
+    private readonly name;
+    constructor(connection: WebsocketsConnection, name: string);
+    join(role: string, handler?: (data: WebsocketsData) => void): () => void;
+    joinReady(role: string, handler?: (data: WebsocketsData) => void): Promise<() => void>;
+    send(data: WebsocketsData): void;
+}
+export declare class WebsocketsProxy {
+    private readonly connection;
+    private readonly upstreamId;
+    constructor(connection: WebsocketsConnection, upstream: WebsocketsProxyTarget);
+    connect(handlers?: WebsocketsProxyHandlers): () => void;
+    send(data: WebsocketsProxySendData): void;
+    close(code?: number, reason?: string): void;
+}
+export declare class WebsocketsWorker {
+    private readonly connection;
+    private helloArgs;
+    private inFlightLeases;
+    private pendingTerminalLeaseOperations;
+    private unregisterHelloReplay;
+    private unregisterTerminalOperationReplay;
+    constructor(connection: WebsocketsConnection);
+    hello(args: {
+        workerId: string;
+        namespace?: string;
+        appVersion?: string;
+        queues: string[];
+        maxConcurrency?: number;
+        inFlightLeaseIds?: string[];
+        inFlightLeases?: Array<{
+            leaseId: string;
+            queue: string;
+        }>;
+    }): void;
+    private sendHello;
+    onOffer(handler: (offer: {
+        queue: string;
+        leaseId: string;
+        payload: WebsocketsData;
+    }) => void): () => void;
+    accept(leaseId: string): Promise<void>;
+    heartbeat(leaseId: string): Promise<void>;
+    complete(leaseId: string, result?: WebsocketsData): Promise<void>;
+    fail(leaseId: string, error: string): Promise<void>;
+    drain(reason?: string): Promise<void>;
+    close(code?: number, reason?: string): void;
+    private sendTerminalLeaseOperation;
+    private clearPendingTerminalLeaseOperation;
+    private replayPendingTerminalLeaseOperations;
+    private sendTerminalLeaseOperationFrame;
+    private sendLeaseOperation;
+}
+export declare const client: {
+    connect: (options: WebsocketsClientOptions) => Promise<WebsocketsConnection>;
+};
+export declare const worker: {
+    connect: (options: WebsocketsClientOptions) => Promise<WebsocketsWorker>;
+};
+export declare const capability: (channels: string[], actions: WebsocketsAction[]) => WebsocketsCapability;