@neta-art/cohub 1.1.0 → 1.2.1

package/dist/environment.d.ts

@@ -0,0 +1,22 @@
+export type CohubEnvironment = "prod" | "dev";
+export 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";
+    };
+};
+export declare const resolveCohubEnvironment: (env?: CohubEnvironment) => CohubEnvironment;
+export declare const normalizeBaseUrl: (url: string) => string;
+export declare const normalizeWebsocketUrl: (input: string) => string;
+export declare const resolveApiBaseUrl: (options?: {
+    baseUrl?: string;
+    env?: CohubEnvironment;
+}) => string;
+export declare const resolveWebsocketUrl: (options?: {
+    url?: string;
+    env?: CohubEnvironment;
+}) => string;

package/dist/environment.js

@@ -0,0 +1,37 @@
+export const COHUB_ENVIRONMENTS = {
+    prod: {
+        apiBaseUrl: "https://api.cohub.run",
+        websocketUrl: "wss://gateway.cohub.run/ws",
+    },
+    dev: {
+        apiBaseUrl: "https://api-dev.cohub.run",
+        websocketUrl: "wss://gateway-dev.cohub.run/ws",
+    },
+};
+const readRuntimeEnv = () => {
+    const runtime = globalThis;
+    return runtime.process?.env?.ENV;
+};
+export const resolveCohubEnvironment = (env) => {
+    if (env)
+        return env;
+    return readRuntimeEnv() === "dev" ? "dev" : "prod";
+};
+export const normalizeBaseUrl = (url) => url.trim().replace(/\/+$/, "");
+export const normalizeWebsocketUrl = (input) => {
+    const trimmed = normalizeBaseUrl(input);
+    const withProtocol = trimmed
+        .replace(/^http:/, "ws:")
+        .replace(/^https:/, "wss:");
+    return withProtocol.endsWith("/ws") ? withProtocol : `${withProtocol}/ws`;
+};
+export const resolveApiBaseUrl = (options = {}) => {
+    if (options.baseUrl)
+        return normalizeBaseUrl(options.baseUrl);
+    return COHUB_ENVIRONMENTS[resolveCohubEnvironment(options.env)].apiBaseUrl;
+};
+export const resolveWebsocketUrl = (options = {}) => {
+    if (options.url)
+        return normalizeWebsocketUrl(options.url);
+    return COHUB_ENVIRONMENTS[resolveCohubEnvironment(options.env)].websocketUrl;
+};

package/dist/http.d.ts

@@ -6,6 +6,7 @@ import { SessionAccessApi } from "./apis/session-access.js";
 import { SpaceClient, SpacesApi } from "./apis/spaces.js";
 import { TasksApi } from "./apis/tasks.js";
 import { UserApi } from "./apis/user.js";
+import { PublicInviteApi } from "./apis/invitations.js";
 import { HttpTransport, HttpError, type CohubClientOptions, type Fetch } from "./transport.js";
 export declare class CohubHttpClient {
     readonly spaces: SpacesApi;
@@ -16,6 +17,7 @@ export declare class CohubHttpClient {
     readonly sessionAccess: SessionAccessApi;
     readonly tasks: TasksApi;
     readonly cronJobs: CronJobsApi;
+    readonly invite: PublicInviteApi;
     private readonly transport;
     constructor(options?: CohubClientOptions);
     space(spaceId: string): SpaceClient;

package/dist/http.js

@@ -6,7 +6,9 @@ import { SessionAccessApi } from "./apis/session-access.js";
 import { SpaceClient, SpacesApi } from "./apis/spaces.js";
 import { TasksApi } from "./apis/tasks.js";
 import { UserApi } from "./apis/user.js";
+import { PublicInviteApi } from "./apis/invitations.js";
 import { HttpTransport, HttpError } from "./transport.js";
+import { resolveApiBaseUrl } from "./environment.js";
 export class CohubHttpClient {
     spaces;
     channels;
@@ -16,17 +18,20 @@ export class CohubHttpClient {
     sessionAccess;
     tasks;
     cronJobs;
+    invite;
     transport;
     constructor(options = {}) {
+        const apiBaseUrl = resolveApiBaseUrl(options);
         this.transport = new HttpTransport(options);
         this.spaces = new SpacesApi(this.transport);
         this.channels = new ChannelsApi(this.transport);
-        this.user = new UserApi(this.transport, options.baseUrl ?? "", options.setStoredAuthToken, options.clearStoredAuthToken);
-        this.models = new ModelsApi(options.fetch ?? fetch, options.baseUrl ?? "");
-        this.prompts = new PromptsApi(options.fetch ?? fetch, options.baseUrl ?? "");
+        this.user = new UserApi(this.transport, apiBaseUrl, options.setStoredAuthToken, options.clearStoredAuthToken);
+        this.models = new ModelsApi(this.transport);
+        this.prompts = new PromptsApi(options.fetch ?? fetch, apiBaseUrl);
         this.sessionAccess = new SessionAccessApi(this.transport);
         this.tasks = new TasksApi(this.transport);
         this.cronJobs = new CronJobsApi(this.transport);
+        this.invite = new PublicInviteApi(this.transport);
     }
     space(spaceId) {
         return new SpaceClient(spaceId, this.transport, null);

package/dist/index.d.ts

@@ -1,7 +1,11 @@
 export { CohubHttpClient, createHttpClient } from "./http.js";
 export { CohubClient, createCohubClient } from "./client.js";
 export { WebsocketClient, createWebsocketClient } from "./websocket.js";
+export { SessionPatchReducer, createSessionPatchReducer } from "./session-patch-reducer.js";
 export { HttpError } from "./transport.js";
+export { COHUB_ENVIRONMENTS, normalizeBaseUrl, normalizeWebsocketUrl, resolveApiBaseUrl, resolveCohubEnvironment, resolveWebsocketUrl, } from "./environment.js";
 export type { CohubClientOptions, Fetch } from "./transport.js";
+export type { CohubEnvironment } from "./environment.js";
+export type { SessionPatchApplyInput, SessionPatchApplyResult, SessionPatchState, SessionPatchStatus, } from "./session-patch-reducer.js";
 export * from "./types.js";
-export type { SessionEventName, SessionSubscriptionHandlers, SpaceEventName, WebSocketConnectionState } from "./apis/spaces.js";
+export type { SessionEventName, SessionSubscriptionHandlers, SpaceChannelBindingRecord, SpaceEventName, WebSocketConnectionState } from "./apis/spaces.js";

package/dist/index.js

@@ -1,5 +1,7 @@
 export { CohubHttpClient, createHttpClient } from "./http.js";
 export { CohubClient, createCohubClient } from "./client.js";
 export { WebsocketClient, createWebsocketClient } from "./websocket.js";
+export { SessionPatchReducer, createSessionPatchReducer } from "./session-patch-reducer.js";
 export { HttpError } from "./transport.js";
+export { COHUB_ENVIRONMENTS, normalizeBaseUrl, normalizeWebsocketUrl, resolveApiBaseUrl, resolveCohubEnvironment, resolveWebsocketUrl, } from "./environment.js";
 export * from "./types.js";

package/dist/realtime.js

@@ -1,4 +1,7 @@
 export function ensureRealtimeConnected(websocketClient) {
+    if (websocketClient.state === "open" || websocketClient.state === "connecting" || websocketClient.state === "reconnecting") {
+        return;
+    }
     void websocketClient.connect().catch((error) => {
         console.error("[CohubClient] Failed to connect realtime websocket:", error);
     });

package/dist/session-patch-reducer.d.ts

@@ -0,0 +1,49 @@
+import type { ContentBlock } from "@neta-art/cohub-protocol/core";
+import type { RealtimePatchOperation, SessionTurnPatchEvent } from "@neta-art/cohub-protocol/realtime";
+export type SessionPatchStatus = "idle" | "pending" | "streaming" | "completed" | "failed";
+export type SessionPatchState = {
+    spaceId: string | null;
+    sessionId: string;
+    status: SessionPatchStatus;
+    contentBlocks: ContentBlock[];
+    anchorUserMessageId: string | null;
+    patchSeq: number;
+    turnId: string | null;
+    appendPath: string | null;
+};
+export type SessionPatchApplyInput = {
+    spaceId?: string | null;
+    sessionId: string;
+    turnId?: string | null;
+    seq: number;
+    baseSeq: number;
+    ops: RealtimePatchOperation[];
+    anchorUserMessageId?: string | null;
+};
+export type SessionPatchApplyResult = {
+    applied: true;
+    state: SessionPatchState;
+} | {
+    applied: false;
+    reason: "duplicate" | "version_mismatch" | "invalid";
+    state: SessionPatchState;
+};
+type SessionPatchKeyInput = {
+    spaceId?: string | null;
+    sessionId: string;
+    turnId?: string | null;
+};
+export declare class SessionPatchReducer {
+    private readonly states;
+    private key;
+    get(input: SessionPatchKeyInput): SessionPatchState;
+    start(input: SessionPatchKeyInput): SessionPatchState;
+    complete(input: SessionPatchKeyInput): SessionPatchState;
+    fail(input: SessionPatchKeyInput): SessionPatchState;
+    reset(input: SessionPatchKeyInput): void;
+    resetAll(): void;
+    applyEvent(event: SessionTurnPatchEvent): SessionPatchApplyResult;
+    applyPatch(input: SessionPatchApplyInput): SessionPatchApplyResult;
+}
+export declare const createSessionPatchReducer: () => SessionPatchReducer;
+export {};

package/dist/session-patch-reducer.js

@@ -0,0 +1,273 @@
+const blockTextPathPattern = /^\/message\/content\/blocks\/(\d+)\/(text|thinking)$/;
+const blockPathPattern = /^\/message\/content\/blocks\/(\d+)$/;
+const blockMetaPathPattern = /^\/message\/content\/blocks\/(\d+)\/_meta$/;
+const blockSignaturePathPattern = /^\/message\/content\/blocks\/(\d+)\/signature$/;
+const createIdleState = (input) => ({
+    spaceId: input.spaceId ?? null,
+    sessionId: input.sessionId,
+    status: "idle",
+    contentBlocks: [],
+    anchorUserMessageId: null,
+    patchSeq: 0,
+    turnId: null,
+    appendPath: null,
+});
+function cloneBlock(block) {
+    return structuredClone(block);
+}
+function getStreamIndex(block) {
+    const value = block._meta?.streamIndex;
+    return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function findBlockByStreamIndex(blocks, streamIndex) {
+    return blocks.findIndex((block) => getStreamIndex(block) === streamIndex);
+}
+function sortBlocksByStreamIndex(blocks) {
+    return [...blocks].sort((a, b) => {
+        const aIndex = getStreamIndex(a);
+        const bIndex = getStreamIndex(b);
+        if (aIndex == null && bIndex == null)
+            return 0;
+        if (aIndex == null)
+            return 1;
+        if (bIndex == null)
+            return -1;
+        return aIndex - bIndex;
+    });
+}
+function isContentBlock(value) {
+    return Boolean(value && typeof value === "object" && "type" in value);
+}
+function ensureTextLikeBlock(blocks, streamIndex, field) {
+    const existingIndex = findBlockByStreamIndex(blocks, streamIndex);
+    const existing = existingIndex >= 0 ? blocks[existingIndex] : undefined;
+    if (field === "text") {
+        if (existing?.type === "text")
+            return existing;
+        const block = {
+            type: "text",
+            text: "",
+            _meta: { streamIndex },
+        };
+        blocks.push(block);
+        return block;
+    }
+    if (existing?.type === "thinking")
+        return existing;
+    const block = {
+        type: "thinking",
+        thinking: "",
+        _meta: { streamIndex },
+    };
+    blocks.push(block);
+    return block;
+}
+function appendTextLikeValue(blocks, path, value) {
+    const match = path.match(blockTextPathPattern);
+    if (!match || typeof value !== "string")
+        return false;
+    const streamIndex = Number(match[1]);
+    const field = match[2];
+    const block = ensureTextLikeBlock(blocks, streamIndex, field);
+    if (field === "text" && block.type === "text") {
+        block.text += value;
+    }
+    if (field === "thinking" && block.type === "thinking") {
+        block.thinking += value;
+    }
+    return true;
+}
+function applyPatchOpsToBlocks(current, ops, initialAppendPath) {
+    const next = current.map(cloneBlock);
+    let anchorUserMessageId;
+    let appendPath = initialAppendPath;
+    let failed = false;
+    for (const op of ops) {
+        if (!op.o && !op.p) {
+            if (!appendPath || !appendTextLikeValue(next, appendPath, op.v)) {
+                failed = true;
+                break;
+            }
+            continue;
+        }
+        if (op.o === "merge" && op.p === "/message/metadata") {
+            const anchor = op.v.anchorUserMessageId;
+            if (typeof anchor === "string" && anchor.trim()) {
+                anchorUserMessageId = anchor;
+            }
+            continue;
+        }
+        if (op.o === "append") {
+            if (!appendTextLikeValue(next, op.p, op.v)) {
+                failed = true;
+                break;
+            }
+            appendPath = op.p;
+            continue;
+        }
+        if (op.o === "merge") {
+            const match = op.p.match(blockMetaPathPattern);
+            if (!match)
+                continue;
+            const streamIndex = Number(match[1]);
+            const blockIndex = findBlockByStreamIndex(next, streamIndex);
+            const block = blockIndex >= 0 ? next[blockIndex] : undefined;
+            if (!block)
+                continue;
+            block._meta = { ...(block._meta ?? {}), ...op.v };
+            continue;
+        }
+        if (op.o === "replace") {
+            const match = op.p.match(blockSignaturePathPattern);
+            if (match) {
+                if (typeof op.v !== "string")
+                    continue;
+                const blockIndex = findBlockByStreamIndex(next, Number(match[1]));
+                const block = blockIndex >= 0 ? next[blockIndex] : undefined;
+                if (block?.type === "thinking")
+                    block.signature = op.v;
+                continue;
+            }
+        }
+        if (op.o === "replace" || op.o === "add") {
+            const match = op.p.match(blockPathPattern);
+            if (!match || !isContentBlock(op.v))
+                continue;
+            const streamIndex = Number(match[1]);
+            const block = cloneBlock(op.v);
+            block._meta = { ...(block._meta ?? {}), streamIndex };
+            const blockIndex = findBlockByStreamIndex(next, streamIndex);
+            if (blockIndex >= 0) {
+                next[blockIndex] = block;
+            }
+            else {
+                next.push(block);
+            }
+            continue;
+        }
+        if (op.o === "remove") {
+            const match = op.p.match(blockPathPattern);
+            if (!match)
+                continue;
+            const blockIndex = findBlockByStreamIndex(next, Number(match[1]));
+            if (blockIndex >= 0)
+                next.splice(blockIndex, 1);
+        }
+    }
+    return {
+        failed,
+        contentBlocks: sortBlocksByStreamIndex(next),
+        anchorUserMessageId,
+        appendPath,
+    };
+}
+export class SessionPatchReducer {
+    states = new Map();
+    key(input) {
+        return `${input.spaceId ?? ""}:${input.sessionId}`;
+    }
+    get(input) {
+        const key = this.key(input);
+        return this.states.get(key) ?? createIdleState(input);
+    }
+    start(input) {
+        const state = {
+            ...this.get(input),
+            status: "pending",
+            contentBlocks: [],
+            anchorUserMessageId: null,
+            patchSeq: 0,
+            turnId: null,
+            appendPath: null,
+        };
+        this.states.set(this.key(input), state);
+        return state;
+    }
+    complete(input) {
+        const current = this.get(input);
+        const state = {
+            ...current,
+            turnId: input.turnId ?? current.turnId,
+            status: "completed",
+            contentBlocks: [],
+            anchorUserMessageId: null,
+        };
+        this.states.set(this.key(input), state);
+        return state;
+    }
+    fail(input) {
+        const current = this.get(input);
+        const state = {
+            ...current,
+            turnId: input.turnId ?? current.turnId,
+            status: "failed",
+            contentBlocks: [],
+            anchorUserMessageId: null,
+        };
+        this.states.set(this.key(input), state);
+        return state;
+    }
+    reset(input) {
+        this.states.delete(this.key(input));
+    }
+    resetAll() {
+        this.states.clear();
+    }
+    applyEvent(event) {
+        return this.applyPatch({
+            spaceId: event.spaceId,
+            sessionId: event.sessionId,
+            turnId: event.payload.turnId,
+            seq: event.payload.seq,
+            baseSeq: event.payload.baseSeq,
+            ops: event.payload.ops,
+            anchorUserMessageId: event.payload.anchorUserMessageId,
+        });
+    }
+    applyPatch(input) {
+        const current = this.get(input);
+        const currentTurnId = current.turnId;
+        const inputTurnId = input.turnId ?? null;
+        const isDifferentKnownTurn = Boolean(currentTurnId && inputTurnId && currentTurnId !== inputTurnId);
+        const isFreshKnownTurn = isDifferentKnownTurn && input.baseSeq === 0;
+        const currentSeq = isFreshKnownTurn ? 0 : current.patchSeq;
+        const isTerminalSameTurn = (current.status === "completed" || current.status === "failed") &&
+            Boolean(currentTurnId) &&
+            currentTurnId === inputTurnId;
+        if (isTerminalSameTurn) {
+            return { applied: false, reason: "duplicate", state: current };
+        }
+        if (isDifferentKnownTurn && !isFreshKnownTurn) {
+            return { applied: false, reason: "version_mismatch", state: current };
+        }
+        if (input.seq <= currentSeq) {
+            return { applied: false, reason: "duplicate", state: current };
+        }
+        if (input.baseSeq !== currentSeq) {
+            return { applied: false, reason: "version_mismatch", state: current };
+        }
+        const startingFresh = input.baseSeq === 0 || isFreshKnownTurn;
+        const baseBlocks = startingFresh ? [] : current.contentBlocks;
+        const patched = applyPatchOpsToBlocks(baseBlocks, input.ops, startingFresh ? null : current.appendPath);
+        if (patched.failed) {
+            return { applied: false, reason: "version_mismatch", state: current };
+        }
+        const next = {
+            ...current,
+            spaceId: input.spaceId ?? current.spaceId ?? null,
+            sessionId: input.sessionId,
+            status: "streaming",
+            contentBlocks: patched.contentBlocks,
+            anchorUserMessageId: patched.anchorUserMessageId ??
+                input.anchorUserMessageId ??
+                current.anchorUserMessageId ??
+                null,
+            patchSeq: input.seq,
+            turnId: input.turnId ?? current.turnId ?? null,
+            appendPath: patched.appendPath,
+        };
+        this.states.set(this.key(next), next);
+        return { applied: true, state: next };
+    }
+}
+export const createSessionPatchReducer = () => new SessionPatchReducer();

package/dist/transport.d.ts

@@ -1,6 +1,8 @@
+import type { CohubEnvironment } from "./environment.js";
 import type { WebsocketClientOptions } from "./websocket.js";
 export type Fetch = typeof globalThis.fetch;
 export type CohubClientOptions = {
+    env?: CohubEnvironment;
     baseUrl?: string;
     getAccessToken?: () => Promise<string | null> | string | null;
     onUnauthorized?: () => Promise<void> | void;

package/dist/transport.js

@@ -1,3 +1,4 @@
+import { resolveApiBaseUrl } from "./environment.js";
 export class HttpError extends Error {
     status;
     body;
@@ -14,7 +15,7 @@ export class HttpTransport {
     getAccessToken;
     onUnauthorized;
     constructor(options = {}) {
-        this.baseUrl = options.baseUrl ?? "";
+        this.baseUrl = resolveApiBaseUrl(options);
         this.fetcher = options.fetch ?? fetch;
         this.getAccessToken = options.getAccessToken;
         this.onUnauthorized = options.onUnauthorized;

package/dist/types.d.ts

@@ -40,6 +40,22 @@ export type SpaceFsMoveInput = {
     fromPath: string;
     toPath: string;
 };
+export type SpaceFsUploadEntry = {
+    path: string;
+    name: string;
+    size: number;
+    mimeType: string | null;
+    mtimeMs: number;
+};
+export type SpaceFsUploadError = {
+    name: string;
+    code: "file_too_large" | "name_invalid" | "write_failed";
+    message: string;
+};
+export type SpaceFsUploadResponse = {
+    uploaded: SpaceFsUploadEntry[];
+    errors: SpaceFsUploadError[];
+};
 export type SessionBindingRecord = ProtocolSessionBindingRecord;
 export type SessionRecord = ProtocolSessionRecord & {
     bindings?: SessionBindingRecord[];
@@ -49,6 +65,10 @@ export type SessionRecord = ProtocolSessionRecord & {
     totalOutputTokens?: number;
     totalCost?: string | number | null;
 };
+export type SpaceGitInfo = {
+    giteaHost: string;
+    giteaUsername: string;
+};
 export type SpaceRecord = {
     id: string;
     userUuid: string;
@@ -69,6 +89,7 @@ export type SpaceRecord = {
         status: string;
     }[];
     accessLevel?: "minimal";
+    gitInfo?: SpaceGitInfo | null;
 };
 export type SpaceBootstrapSource = {
     type: "blank";
@@ -89,6 +110,10 @@ export type SessionMessagesResponse = {
     session: SessionRecord;
     messages: MessageRecord[];
 };
+export type SessionMessageResponse = {
+    session: SessionRecord;
+    message: MessageRecord;
+};
 export type SessionMessagesPaginatedResponse = {
     session: SessionRecord;
     messages: MessageRecord[];
@@ -134,6 +159,10 @@ export type SpaceChannelBindingInput = {
 };
 export type SpaceSessionsResponse = {
     sessions: SessionRecord[];
+    pageInfo?: {
+        hasMore: boolean;
+        nextCursor: string | null;
+    };
 };
 export type UserSshKey = {
     id: string;
@@ -223,6 +252,10 @@ export type SpaceUsageHourlyStat = {
     outputTokens: number;
     cacheReadTokens: number;
     cacheWriteTokens: number;
+    costInput: number;
+    costOutput: number;
+    costCacheRead: number;
+    costCacheWrite: number;
     costTotal: number;
     requestCount: number;
     successCount: number;
@@ -235,6 +268,10 @@ export type SpaceUsageSummary = {
     outputTokens: number;
     cacheReadTokens: number;
     cacheWriteTokens: number;
+    costInput: number;
+    costOutput: number;
+    costCacheRead: number;
+    costCacheWrite: number;
     costTotal: number;
     requestCount: number;
     successCount: number;
@@ -245,3 +282,36 @@ export type SpaceUsageResponse = {
     summary: SpaceUsageSummary;
     days: number;
 };
+export type SpaceInvitation = {
+    token: string;
+    role: SpaceRole;
+    status: "active" | "revoked" | "exhausted";
+    useCount: number;
+    maxUses: number | null;
+    createdAt: string | null;
+    expiresInSeconds: number | null;
+};
+export type CreateInvitationInput = {
+    role?: SpaceRole;
+    ttlSeconds?: number;
+    maxUses?: number;
+};
+export type CreateInvitationResponse = {
+    token: string;
+    role: SpaceRole;
+    expiresAt: string;
+    maxUses: number | null;
+};
+export type InvitationDetail = {
+    token: string;
+    spaceId: string;
+    spaceName: string;
+    role: SpaceRole;
+    expiresInSeconds: number | null;
+};
+export type AcceptInvitationResponse = {
+    ok: true;
+    spaceId: string;
+    spaceName: string;
+    role: SpaceRole;
+};

package/dist/websocket.d.ts

@@ -1,5 +1,6 @@
 import { type ChannelEnvelope } from "@neta-art/cohub-protocol/realtime";
 import type { ContentBlock } from "@neta-art/cohub-protocol/core";
+import type { CohubEnvironment } from "./environment.js";
 export type WebsocketEventPayload = ChannelEnvelope;
 export type WebSocketLike = {
     readonly readyState: number;
@@ -12,6 +13,7 @@ export type WebSocketLike = {
 };
 export type WebSocketConstructor = new (url: string) => WebSocketLike;
 export type WebsocketClientOptions = {
+    env?: CohubEnvironment;
     url?: string;
     autoReconnect?: boolean;
     reconnectBaseDelayMs?: number;
@@ -22,8 +24,18 @@ export type WebsocketClientOptions = {
     getAccessToken?: () => Promise<string | null> | string | null;
     WebSocketImpl?: WebSocketConstructor;
 };
-export type WebsocketClientState = "idle" | "connecting" | "open" | "closed";
+export type WebsocketClientState = "idle" | "connecting" | "reconnecting" | "open" | "closed";
 export type WebsocketClientEvents = {
+    connecting: {
+        isReconnect: boolean;
+        attempt: number;
+    };
+    reconnecting: {
+        attempt: number;
+        delayMs: number;
+        reason?: string;
+        code?: number;
+    };
     open: {
         connectionId?: string | null;
     };
@@ -34,6 +46,7 @@ export type WebsocketClientEvents = {
     };
     error: {
         error: unknown;
+        recoverable: boolean;
     };
     event: WebsocketEventPayload;
     ready: {
@@ -75,6 +88,7 @@ export declare class WebsocketClient {
     private ws;
     private pingTimer;
     private reconnectTimer;
+    private reconnectTimerResolver;
     private reconnectAttempt;
     private manuallyClosed;
     private connectPromise;
@@ -82,6 +96,7 @@ export declare class WebsocketClient {
     private awaitingPong;
     private lastPingRequestId;
     private pongDeadlineAt;
+    private readonly compactStreamContexts;
     state: WebsocketClientState;
     connectionId: string | null;
     private readonly listeners;
@@ -110,6 +125,8 @@ export declare class WebsocketClient {
     private resolveAuthWaiter;
     private rejectAuthWaiter;
     private handleMessage;
+    private rememberCompactStreamContext;
+    private handleCompactFrame;
     private startPingLoop;
     private stopPingLoop;
     private clearReconnectTimer;