@neta-art/cohub 1.9.0 → 1.10.1

package/dist/chunks/websocket.d.ts

@@ -0,0 +1,266 @@
+//#region src/environment.d.ts
+type CohubEnvironment = "prod" | "dev";
+declare const COHUB_ENVIRONMENTS: {
+  readonly prod: {
+    readonly apiBaseUrl: "https://api.cohub.run";
+    readonly websocketUrl: "wss://gateway.cohub.run/ws";
+  };
+  readonly dev: {
+    readonly apiBaseUrl: "https://api-dev.cohub.run";
+    readonly websocketUrl: "wss://gateway-dev.cohub.run/ws";
+  };
+};
+declare const resolveCohubEnvironment: (env?: CohubEnvironment) => CohubEnvironment;
+declare const normalizeBaseUrl: (url: string) => string;
+declare const normalizeWebsocketUrl: (input: string) => string;
+declare const resolveApiBaseUrl: (options?: {
+  baseUrl?: string;
+  env?: CohubEnvironment;
+}) => string;
+declare const resolveWebsocketUrl: (options?: {
+  url?: string;
+  env?: CohubEnvironment;
+}) => string;
+//#endregion
+//#region ../protocol/dist/realtime/types.d.ts
+type RealtimeEnvelope = {
+  id: string;
+  timestamp: number;
+  domain: "system" | "session" | "space";
+  type: string;
+  requestId?: string | null;
+  spaceId?: string | null;
+  sessionId?: string | null;
+  payload: Record<string, unknown>;
+};
+type ChannelEnvelope = RealtimeEnvelope;
+type RealtimePatchOperation = {
+  o: "append";
+  p: string;
+  v: unknown;
+} | {
+  o: "replace";
+  p: string;
+  v: unknown;
+} | {
+  o: "add";
+  p: string;
+  v: unknown;
+} | {
+  o: "merge";
+  p: string;
+  v: Record<string, unknown>;
+} | {
+  o: "remove";
+  p: string;
+} | {
+  v: unknown;
+  o?: undefined;
+  p?: undefined;
+};
+type SessionTurnPatchEvent = {
+  id: string;
+  timestamp: number;
+  domain: "session";
+  type: "session.turn.patch";
+  requestId?: string | null;
+  spaceId: string;
+  sessionId: string;
+  payload: {
+    turnId: string | null;
+    messageId: string | null;
+    messageOrdinal?: number | null;
+    sourceMessageId?: string | null;
+    anchorUserMessageId: string | null;
+    seq: number;
+    baseSeq: number;
+    ops: RealtimePatchOperation[];
+  };
+};
+//#endregion
+//#region ../protocol/src/core/content.d.ts
+type ContentBlockMeta = Record<string, unknown>;
+type ContentBlock = {
+  type: "text";
+  text: string;
+  _meta?: ContentBlockMeta;
+} | {
+  type: "thinking";
+  thinking: string;
+  signature?: string;
+  _meta?: ContentBlockMeta;
+} | {
+  type: "image";
+  source: {
+    type: "url";
+    url: string;
+  } | {
+    type: "base64";
+    media_type: string;
+    data: string;
+  };
+  _meta?: ContentBlockMeta;
+} | {
+  type: "shell_command";
+  command: string;
+  rawText: string;
+  _meta?: ContentBlockMeta;
+} | {
+  type: "tool_use";
+  id: string;
+  name: string;
+  input: Record<string, unknown>;
+  _meta?: ContentBlockMeta;
+} | {
+  type: "tool_result";
+  tool_use_id: string;
+  content: string | ContentBlock[];
+  is_error?: boolean;
+  _meta?: ContentBlockMeta;
+} | {
+  type: "system_note";
+  note_type: "session_created" | "forked" | "compacted" | "info";
+  text: string;
+  _meta?: ContentBlockMeta;
+};
+//#endregion
+//#region src/websocket.d.ts
+type WebsocketEventPayload = ChannelEnvelope;
+type WebSocketLike = {
+  readonly readyState: number;
+  onopen: ((event: Event) => void) | null;
+  onmessage: ((event: MessageEvent) => void) | null;
+  onerror: ((event: Event) => void) | null;
+  onclose: ((event: CloseEvent) => void) | null;
+  send(data: string): void;
+  close(code?: number, reason?: string): void;
+};
+type WebSocketConstructor = new (url: string) => WebSocketLike;
+type WebsocketClientOptions = {
+  env?: CohubEnvironment;
+  url?: string;
+  autoReconnect?: boolean;
+  reconnectBaseDelayMs?: number;
+  reconnectMaxDelayMs?: number;
+  pingIntervalMs?: number;
+  pongTimeoutMs?: number;
+  debug?: boolean;
+  getAccessToken?: () => Promise<string | null> | string | null;
+  WebSocketImpl?: WebSocketConstructor;
+};
+type WebsocketClientState = "idle" | "connecting" | "reconnecting" | "open" | "closed";
+type WebsocketClientEvents = {
+  connecting: {
+    isReconnect: boolean;
+    attempt: number;
+  };
+  reconnecting: {
+    attempt: number;
+    delayMs: number;
+    reason?: string;
+    code?: number;
+  };
+  open: {
+    connectionId?: string | null;
+  };
+  close: {
+    code: number;
+    reason: string;
+    willReconnect: boolean;
+  };
+  error: {
+    error: unknown;
+    recoverable: boolean;
+  };
+  event: WebsocketEventPayload;
+  ready: {
+    connectionId: string;
+  };
+  auth: {
+    connectionId: string;
+    user: Record<string, unknown>;
+  };
+  messageAccepted: {
+    requestId?: string | null;
+    clientMessageId?: string | null;
+    sessionId?: string | null;
+    spaceId?: string | null;
+  };
+  serverError: {
+    code?: string;
+    message?: string;
+    requestId?: string | null;
+    sessionId?: string | null;
+    spaceId?: string | null;
+    clientMessageId?: string | null;
+  };
+  pong: {
+    requestId?: string | null;
+  };
+};
+type EventHandler<T> = (payload: T) => void;
+declare class WebsocketClient {
+  private readonly url;
+  private readonly autoReconnect;
+  private readonly reconnectBaseDelayMs;
+  private readonly reconnectMaxDelayMs;
+  private readonly pingIntervalMs;
+  private readonly pongTimeoutMs;
+  private readonly debug;
+  private readonly getAccessToken?;
+  private readonly WebSocketImpl;
+  private ws;
+  private pingTimer;
+  private reconnectTimer;
+  private reconnectTimerResolver;
+  private reconnectAttempt;
+  private manuallyClosed;
+  private connectPromise;
+  private authWaiter;
+  private awaitingPong;
+  private lastPingRequestId;
+  private pongDeadlineAt;
+  private readonly compactStreamContexts;
+  private readonly patchStreamBuffers;
+  state: WebsocketClientState;
+  connectionId: string | null;
+  private readonly listeners;
+  constructor(options?: WebsocketClientOptions);
+  on<K extends keyof WebsocketClientEvents>(type: K, handler: EventHandler<WebsocketClientEvents[K]>): () => void;
+  off<K extends keyof WebsocketClientEvents>(type: K, handler: EventHandler<WebsocketClientEvents[K]>): void;
+  private emit;
+  private log;
+  connect(): Promise<void>;
+  disconnect(code?: number, reason?: string): Promise<void>;
+  sendMessage(input: {
+    spaceId: string;
+    sessionId: string;
+    content: ContentBlock[];
+    clientMessageId?: string;
+    requestId?: string;
+    model?: string;
+    provider?: string;
+  }): Promise<void>;
+  ack(eventId?: string, requestId?: string): void;
+  ping(requestId?: string): void;
+  private ensureOpen;
+  private send;
+  private authenticate;
+  private createAuthWaiter;
+  private resolveAuthWaiter;
+  private rejectAuthWaiter;
+  private handleMessage;
+  private rememberCompactStreamContext;
+  private getPatchStreamBufferKey;
+  private handlePatchEnvelope;
+  private enforcePatchStreamBufferLimit;
+  private flushPatchStreamBuffer;
+  private handleCompactFrame;
+  private startPingLoop;
+  private stopPingLoop;
+  private clearReconnectTimer;
+  private scheduleReconnect;
+}
+declare const createWebsocketClient: (options?: WebsocketClientOptions) => WebsocketClient;
+//#endregion
+export { resolveCohubEnvironment as _, WebsocketClientOptions as a, createWebsocketClient as c, SessionTurnPatchEvent as d, COHUB_ENVIRONMENTS as f, resolveApiBaseUrl as g, normalizeWebsocketUrl as h, WebsocketClientEvents as i, ContentBlock as l, normalizeBaseUrl as m, WebSocketLike as n, WebsocketClientState as o, CohubEnvironment as p, WebsocketClient as r, WebsocketEventPayload as s, WebSocketConstructor as t, RealtimePatchOperation as u, resolveWebsocketUrl as v };