@neta-art/cohub 1.1.0 → 1.2.1

package/README.md

@@ -13,6 +13,39 @@ npm install @neta-art/cohub @neta-art/cohub-protocol
 ```ts
 import { createCohubClient } from "@neta-art/cohub";
 
+const client = createCohubClient({
+  getAccessToken: async () => localStorage.getItem("token"),
+});
+```
+
+The SDK connects to production by default:
+
+- API: `https://api.cohub.run`
+- WebSocket: `wss://gateway.cohub.run/ws`
+
+Use development with `ENV=dev` in Node.js:
+
+```bash
+ENV=dev node app.js
+```
+
+Or select it explicitly in code:
+
+```ts
+const client = createCohubClient({
+  env: "dev",
+  getAccessToken: async () => localStorage.getItem("token"),
+});
+```
+
+Development uses:
+
+- API: `https://api-dev.cohub.run`
+- WebSocket: `wss://gateway-dev.cohub.run/ws`
+
+Custom endpoints are still supported when needed:
+
+```ts
 const client = createCohubClient({
   baseUrl: "https://api.example.com",
   getAccessToken: async () => localStorage.getItem("token"),
@@ -63,8 +96,23 @@ stop();
 You can also listen with business-oriented event names:
 
 ```ts
+session.on("turn.patch", (event) => {
+  // Streaming state-machine patch: { turnId, seq, baseSeq, ops }.
+  // Consecutive append ops may be compacted to { v }.
+  console.log(event.payload.ops);
+});
+
+session.subscribe({
+  patchState: (result) => {
+    if (result.applied) {
+      console.log(result.state.contentBlocks);
+    }
+  },
+});
+
 session.on("turn.final", (event) => {
-  console.log(event.payload);
+  // Fired when an assistant_final message.persisted event arrives.
+  console.log(event.payload.message);
 });
 
 space.on("message.persisted", (event) => {
@@ -74,7 +122,8 @@ space.on("message.persisted", (event) => {
 
 Supported business event names:
 
-- `turn.progress`
+- `turn.patch`
+- `turn.progress` (legacy compatibility)
 - `turn.final`
 - `turn.error`
 - `message.persisted`
@@ -87,7 +136,6 @@ If you only want HTTP transport, use the dedicated entry:
 import { createHttpClient } from "@neta-art/cohub/http";
 
 const http = createHttpClient({
-  baseUrl: "https://api.example.com",
   getAccessToken: async () => localStorage.getItem("token"),
 });
 
@@ -104,7 +152,6 @@ If you need direct realtime transport access, use the websocket entry:
 import { createWebsocketClient } from "@neta-art/cohub/websocket";
 
 const ws = createWebsocketClient({
-  url: "https://gateway.example.com",
   getAccessToken: async () => localStorage.getItem("token"),
 });
 
@@ -118,15 +165,4 @@ This SDK is intentionally built around Cohub's co-creation model:
 - work with `space(...)` and `session(...)` as the primary creative surface
 - send messages through `session.messages.send(...)`
 - subscribe through `space.subscribe(...)` and `session.subscribe(...)`
-- keep protocol details behind the SDK surface
-
-## Publish checklist
-
-Before publishing:
-
-1. build the protocol package: `pnpm --filter @neta-art/cohub-protocol build`
-2. build this package: `pnpm --filter @neta-art/cohub build`
-3. typecheck the protocol package: `pnpm --filter @neta-art/cohub-protocol typecheck`
-4. typecheck this package: `pnpm --filter @neta-art/cohub typecheck`
-5. verify consuming apps still typecheck
-6. verify `dist/` contains `index`, `http`, and `websocket` outputs
+- keep HTTP and realtime transports separate but coordinated

package/dist/apis/invitations.d.ts

@@ -0,0 +1,20 @@
+import type { HttpTransport } from "../transport.js";
+import type { SpaceInvitation, CreateInvitationInput, CreateInvitationResponse, InvitationDetail, AcceptInvitationResponse } from "../types.js";
+export declare class SpaceInvitationsApi {
+    private readonly transport;
+    private readonly spaceId;
+    constructor(transport: HttpTransport, spaceId: string);
+    list(): Promise<{
+        items: SpaceInvitation[];
+    }>;
+    create(input?: CreateInvitationInput): Promise<CreateInvitationResponse>;
+    revoke(token: string): Promise<{
+        ok: true;
+    }>;
+}
+export declare class PublicInviteApi {
+    private readonly transport;
+    constructor(transport: HttpTransport);
+    get(token: string): Promise<InvitationDetail>;
+    accept(token: string): Promise<AcceptInvitationResponse>;
+}

package/dist/apis/invitations.js

@@ -0,0 +1,36 @@
+export class SpaceInvitationsApi {
+    transport;
+    spaceId;
+    constructor(transport, spaceId) {
+        this.transport = transport;
+        this.spaceId = spaceId;
+    }
+    list() {
+        return this.transport.request(`/api/spaces/${this.spaceId}/invitations`);
+    }
+    create(input) {
+        return this.transport.request(`/api/spaces/${this.spaceId}/invitations`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(input ?? {}),
+        });
+    }
+    revoke(token) {
+        return this.transport.request(`/api/spaces/${this.spaceId}/invitations/${token}`, { method: "DELETE" });
+    }
+}
+// Public invite API (no auth required for viewing)
+export class PublicInviteApi {
+    transport;
+    constructor(transport) {
+        this.transport = transport;
+    }
+    get(token) {
+        return this.transport.request(`/api/invite/${token}`);
+    }
+    accept(token) {
+        return this.transport.request(`/api/invite/${token}/accept`, {
+            method: "POST",
+        });
+    }
+}

package/dist/apis/models.d.ts

@@ -1,8 +1,7 @@
-import type { Fetch } from "../transport.js";
+import type { HttpTransport } from "../transport.js";
 import type { ModelCatalogEntry } from "../types.js";
 export declare class ModelsApi {
-    private readonly fetcher;
-    private readonly baseUrl;
-    constructor(fetcher: Fetch, baseUrl: string);
-    list(customFetch?: Fetch): Promise<Record<string, ModelCatalogEntry[]>>;
+    private readonly transport;
+    constructor(transport: HttpTransport);
+    list(): Promise<Record<string, ModelCatalogEntry[]>>;
 }

package/dist/apis/models.js

@@ -1,17 +1,9 @@
 export class ModelsApi {
-    fetcher;
-    baseUrl;
-    constructor(fetcher, baseUrl) {
-        this.fetcher = fetcher;
-        this.baseUrl = baseUrl;
+    transport;
+    constructor(transport) {
+        this.transport = transport;
     }
-    async list(customFetch) {
-        const fetchImpl = customFetch ?? this.fetcher;
-        const url = this.baseUrl ? `${this.baseUrl}/api/models` : "/api/models";
-        const response = await fetchImpl(url);
-        if (!response.ok) {
-            throw new Error(`Failed to fetch models: ${response.status} ${response.statusText}`);
-        }
-        return response.json();
+    async list() {
+        return this.transport.request("/api/models");
     }
 }

package/dist/apis/spaces.d.ts

@@ -1,14 +1,18 @@
 import type { WebsocketClient, WebsocketEventPayload } from "../websocket.js";
 import type { HttpTransport, Fetch } from "../transport.js";
-import type { CheckpointRecord, ContentBlock, SessionMessagesPaginatedResponse, SessionMessagesResponse, SessionRecord, SpaceAccessPolicy, SpaceBootstrapSource, SpaceChannelBindingInput, SpaceCheckpointDetailResponse, SpaceCreateResponse, SpaceEnvInput, SpaceFsFileResponse, SpaceFsMoveInput, SpaceFsTreeResponse, SpaceUsageResponse, SpaceFsWriteFileInput, SpaceMember, SpaceRecord, SpaceRole, SpaceSessionsResponse } from "../types.js";
+import { type SessionPatchApplyResult } from "../session-patch-reducer.js";
+import type { CheckpointRecord, ContentBlock, SessionMessageResponse, SessionMessagesPaginatedResponse, SessionMessagesResponse, SessionRecord, SpaceAccessPolicy, SpaceBootstrapSource, SpaceChannelBindingInput, SpaceCheckpointDetailResponse, SpaceCreateResponse, SpaceEnvInput, SpaceFsFileResponse, SpaceFsMoveInput, SpaceFsTreeResponse, SpaceFsUploadResponse, SpaceUsageResponse, SpaceFsWriteFileInput, SpaceMember, SpaceRecord, SpaceRole, SpaceSessionsResponse } from "../types.js";
+import { SpaceInvitationsApi } from "./invitations.js";
 export type SessionSubscriptionHandlers = {
+    patch?: (event: WebsocketEventPayload) => void;
+    patchState?: (result: SessionPatchApplyResult) => void;
     progress?: (event: WebsocketEventPayload) => void;
     final?: (event: WebsocketEventPayload) => void;
     error?: (event: WebsocketEventPayload) => void;
     persisted?: (event: WebsocketEventPayload) => void;
     event?: (event: WebsocketEventPayload) => void;
 };
-export type SessionEventName = "turn.progress" | "turn.final" | "turn.error" | "message.persisted";
+export type SessionEventName = "turn.patch" | "turn.progress" | "turn.final" | "turn.error" | "message.persisted";
 export type SpaceEventName = SessionEventName | "event";
 type SessionSendMessageInput = {
     content: ContentBlock[];
@@ -58,6 +62,7 @@ export declare class SpaceFilesApi {
         fromPath: string;
         toPath: string;
     }>;
+    upload(files: File[], dir?: string): Promise<SpaceFsUploadResponse>;
 }
 declare class SessionMessagesClient {
     private readonly transport;
@@ -67,6 +72,9 @@ declare class SessionMessagesClient {
     private lastSentAt;
     constructor(transport: HttpTransport, sessionId: string);
     list(customFetch?: Fetch): Promise<SessionMessagesResponse>;
+    get(messageId: string, optionsOrFetch?: {
+        detail?: "summary" | "full";
+    } | Fetch, customFetch?: Fetch): Promise<SessionMessageResponse>;
     listPaginated(options?: {
         cursor?: number;
         limit?: number;
@@ -81,6 +89,7 @@ declare class SessionRealtimeClient {
     private readonly websocketClient;
     private readonly spaceId;
     private readonly sessionId;
+    private readonly patchReducer;
     constructor(websocketClient: WebsocketClient | null, spaceId: string, sessionId: string);
     subscribe(handlers: SessionSubscriptionHandlers): () => void;
     on(type: SessionEventName, handler: (event: WebsocketEventPayload) => void): () => void;
@@ -114,13 +123,19 @@ export declare class SpaceSessionsApi {
         ok: true;
         session: SessionRecord;
     }>;
-    list(customFetch?: Fetch): Promise<SpaceSessionsResponse>;
+    list(optionsOrFetch?: {
+        limit?: number;
+        cursor?: string | null;
+    } | Fetch, customFetch?: Fetch): Promise<SpaceSessionsResponse>;
     byId(sessionId: string): SessionClient;
 }
 export type WebSocketConnectionState = {
-    state: "open" | "closed" | "error";
+    state: "connecting" | "reconnecting" | "open" | "closed" | "error";
     willReconnect: boolean;
     connectionId?: string | null;
+    attempt?: number;
+    delayMs?: number;
+    recoverable?: boolean;
 };
 export declare class SpaceEventsApi {
     private readonly websocketClient;
@@ -157,6 +172,49 @@ export declare class SpaceUsageApi {
     constructor(transport: HttpTransport, spaceId: string);
     get(days?: number, customFetch?: Fetch): Promise<SpaceUsageResponse>;
 }
+export type SpaceChannelBindingRecord = {
+    id: string;
+    spaceId: string;
+    channelId: string;
+    config: Record<string, unknown> | null;
+    createdAt: string;
+    channel: {
+        id: string;
+        userUuid: string;
+        provider: string;
+        name: string;
+        status: string;
+        createdAt: string;
+        updatedAt: string;
+    } | null;
+};
+export declare class SpaceChannelsApi {
+    private readonly transport;
+    private readonly spaceId;
+    constructor(transport: HttpTransport, spaceId: string);
+    list(): Promise<SpaceChannelBindingRecord[]>;
+    bind(channelId: string, config?: Record<string, unknown> | null): Promise<SpaceChannelBindingRecord>;
+    unbind(channelId: string): Promise<{
+        ok: true;
+    }>;
+}
+export declare class SpaceEnvApi {
+    private readonly transport;
+    private readonly spaceId;
+    constructor(transport: HttpTransport, spaceId: string);
+    list(): Promise<{
+        env: SpaceEnvInput[];
+    }>;
+    create(input: SpaceEnvInput): Promise<{
+        env: SpaceEnvInput[];
+    }>;
+    update(name: string, value: string): Promise<{
+        env: SpaceEnvInput[];
+    }>;
+    remove(name: string): Promise<{
+        env: SpaceEnvInput[];
+    }>;
+}
 export declare class SpaceCheckpointsApi {
     private readonly transport;
     private readonly spaceId;
@@ -180,6 +238,9 @@ export declare class SpaceClient {
     readonly access: SpaceAccessApi;
     readonly checkpoints: SpaceCheckpointsApi;
     readonly usage: SpaceUsageApi;
+    readonly channels: SpaceChannelsApi;
+    readonly env: SpaceEnvApi;
+    readonly invitations: SpaceInvitationsApi;
     constructor(id: string, transport: HttpTransport, websocketClient: WebsocketClient | null);
     get(customFetch?: Fetch): Promise<SpaceRecord>;
     rename(name: string): Promise<{

package/dist/apis/spaces.js

@@ -1,11 +1,13 @@
 import { ensureRealtimeConnected } from "../realtime.js";
+import { SessionPatchReducer, } from "../session-patch-reducer.js";
+import { SpaceInvitationsApi } from "./invitations.js";
 const DEFAULT_DEDUP_WINDOW_MS = 2000;
 const toSessionEventName = (type) => {
     switch (type) {
+        case "session.turn.patch":
+            return "turn.patch";
         case "session.turn.progress":
             return "turn.progress";
-        case "session.turn.final":
-            return "turn.final";
         case "session.turn.error":
             return "turn.error";
         case "session.message.persisted":
@@ -14,6 +16,24 @@ const toSessionEventName = (type) => {
             return null;
     }
 };
+const isAssistantFinalPersistedEvent = (event) => {
+    if (event.type !== "session.message.persisted")
+        return false;
+    const message = event.payload.message;
+    if (!message || typeof message !== "object")
+        return false;
+    const record = message;
+    return record.role === "assistant" && record.meta?.messageKind === "assistant_final";
+};
+const getPersistedMessageTurnId = (event) => {
+    if (event.type !== "session.message.persisted")
+        return null;
+    const message = event.payload.message;
+    if (!message || typeof message !== "object")
+        return null;
+    const meta = message.meta;
+    return typeof meta?.turnId === "string" ? meta.turnId : null;
+};
 export class SpacesApi {
     transport;
     constructor(transport) {
@@ -90,6 +110,19 @@ export class SpaceFilesApi {
             body: JSON.stringify(input),
         });
     }
+    upload(files, dir = "") {
+        const params = new URLSearchParams();
+        if (dir)
+            params.set("dir", dir);
+        const query = params.toString();
+        const formData = new FormData();
+        for (const file of files)
+            formData.append("files", file);
+        return this.transport.request(`/api/spaces/${this.spaceId}/fs/upload${query ? `?${query}` : ""}`, {
+            method: "POST",
+            body: formData,
+        });
+    }
 }
 class SessionMessagesClient {
     transport;
@@ -106,6 +139,17 @@ class SessionMessagesClient {
             fetch: customFetch,
         });
     }
+    get(messageId, optionsOrFetch, customFetch) {
+        const options = typeof optionsOrFetch === "function" ? undefined : optionsOrFetch;
+        const fetch = typeof optionsOrFetch === "function" ? optionsOrFetch : customFetch;
+        const params = new URLSearchParams();
+        if (options?.detail)
+            params.set("detail", options.detail);
+        const query = params.toString();
+        return this.transport.request(`/api/sessions/${this.sessionId}/messages/${messageId}${query ? `?${query}` : ""}`, {
+            fetch,
+        });
+    }
     listPaginated(options, customFetch) {
         const params = new URLSearchParams();
         if (options?.cursor !== undefined)
@@ -148,6 +192,7 @@ class SessionRealtimeClient {
     websocketClient;
     spaceId;
     sessionId;
+    patchReducer = new SessionPatchReducer();
     constructor(websocketClient, spaceId, sessionId) {
         this.websocketClient = websocketClient;
         this.spaceId = spaceId;
@@ -163,20 +208,56 @@ class SessionRealtimeClient {
                 return;
             handlers.event?.(event);
             const eventName = toSessionEventName(event.type);
+            if (eventName === "turn.patch") {
+                handlers.patch?.(event);
+                if (event.type === "session.turn.patch") {
+                    const payload = event.payload;
+                    if (typeof payload.seq === "number" &&
+                        typeof payload.baseSeq === "number" &&
+                        Array.isArray(payload.ops)) {
+                        handlers.patchState?.(this.patchReducer.applyPatch({
+                            spaceId: this.spaceId,
+                            sessionId: this.sessionId,
+                            turnId: typeof payload.turnId === "string" ? payload.turnId : null,
+                            seq: payload.seq,
+                            baseSeq: payload.baseSeq,
+                            ops: payload.ops,
+                            anchorUserMessageId: typeof payload.anchorUserMessageId === "string"
+                                ? payload.anchorUserMessageId
+                                : null,
+                        }));
+                    }
+                }
+            }
             if (eventName === "turn.progress")
                 handlers.progress?.(event);
-            if (eventName === "turn.final")
-                handlers.final?.(event);
-            if (eventName === "turn.error")
+            if (eventName === "turn.error") {
+                this.patchReducer.fail({
+                    spaceId: this.spaceId,
+                    sessionId: this.sessionId,
+                });
                 handlers.error?.(event);
+            }
             if (eventName === "message.persisted")
                 handlers.persisted?.(event);
+            if (isAssistantFinalPersistedEvent(event)) {
+                this.patchReducer.complete({
+                    spaceId: this.spaceId,
+                    sessionId: this.sessionId,
+                    turnId: getPersistedMessageTurnId(event),
+                });
+                handlers.final?.(event);
+            }
         });
         return () => unsubscribe();
     }
     on(type, handler) {
         return this.subscribe({
             event: (event) => {
+                if (type === "turn.final" && isAssistantFinalPersistedEvent(event)) {
+                    handler(event);
+                    return;
+                }
                 if (toSessionEventName(event.type) === type)
                     handler(event);
             },
@@ -233,9 +314,17 @@ export class SpaceSessionsApi {
             body: JSON.stringify(input ?? {}),
         });
     }
-    list(customFetch) {
-        return this.transport.request(`/api/spaces/${this.spaceId}/sessions`, {
-            fetch: customFetch,
+    list(optionsOrFetch, customFetch) {
+        const options = typeof optionsOrFetch === "function" ? undefined : optionsOrFetch;
+        const fetch = typeof optionsOrFetch === "function" ? optionsOrFetch : customFetch;
+        const params = new URLSearchParams();
+        if (options?.limit !== undefined)
+            params.set("limit", String(options.limit));
+        if (options?.cursor)
+            params.set("cursor", options.cursor);
+        const query = params.toString();
+        return this.transport.request(`/api/spaces/${this.spaceId}/sessions${query ? `?${query}` : ""}`, {
+            fetch,
         });
     }
     byId(sessionId) {
@@ -266,6 +355,10 @@ export class SpaceEventsApi {
                 handler(event);
                 return;
             }
+            if (type === "turn.final" && isAssistantFinalPersistedEvent(event)) {
+                handler(event);
+                return;
+            }
             if (toSessionEventName(event.type) === type)
                 handler(event);
         });
@@ -326,6 +419,55 @@ export class SpaceUsageApi {
         return this.transport.request(`/api/spaces/${this.spaceId}/usage?${params.toString()}`, { fetch: customFetch });
     }
 }
+export class SpaceChannelsApi {
+    transport;
+    spaceId;
+    constructor(transport, spaceId) {
+        this.transport = transport;
+        this.spaceId = spaceId;
+    }
+    list() {
+        return this.transport.request(`/api/spaces/${this.spaceId}/channels`);
+    }
+    bind(channelId, config) {
+        return this.transport.request(`/api/spaces/${this.spaceId}/channels/${channelId}`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ config: config ?? null }),
+        });
+    }
+    unbind(channelId) {
+        return this.transport.request(`/api/spaces/${this.spaceId}/channels/${channelId}`, { method: "DELETE" });
+    }
+}
+export class SpaceEnvApi {
+    transport;
+    spaceId;
+    constructor(transport, spaceId) {
+        this.transport = transport;
+        this.spaceId = spaceId;
+    }
+    list() {
+        return this.transport.request(`/api/spaces/${this.spaceId}/env`);
+    }
+    create(input) {
+        return this.transport.request(`/api/spaces/${this.spaceId}/env`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(input),
+        });
+    }
+    update(name, value) {
+        return this.transport.request(`/api/spaces/${this.spaceId}/env/${encodeURIComponent(name)}`, {
+            method: "PUT",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ value }),
+        });
+    }
+    remove(name) {
+        return this.transport.request(`/api/spaces/${this.spaceId}/env/${encodeURIComponent(name)}`, { method: "DELETE" });
+    }
+}
 export class SpaceCheckpointsApi {
     transport;
     spaceId;
@@ -357,6 +499,9 @@ export class SpaceClient {
     access;
     checkpoints;
     usage;
+    channels;
+    env;
+    invitations;
     constructor(id, transport, websocketClient) {
         this.id = id;
         this.transport = transport;
@@ -367,6 +512,9 @@ export class SpaceClient {
         this.access = new SpaceAccessApi(transport, id);
         this.checkpoints = new SpaceCheckpointsApi(transport, id);
         this.usage = new SpaceUsageApi(transport, id);
+        this.channels = new SpaceChannelsApi(transport, id);
+        this.env = new SpaceEnvApi(transport, id);
+        this.invitations = new SpaceInvitationsApi(transport, id);
     }
     get(customFetch) {
         return this.transport.request(`/api/spaces/${this.id}`, {

package/dist/client.d.ts

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

package/dist/client.js

@@ -6,8 +6,10 @@ 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 } from "./transport.js";
 import { createWebsocketClient } from "./websocket.js";
+import { resolveApiBaseUrl, resolveWebsocketUrl } from "./environment.js";
 export class CohubClient {
     spaces;
     channels;
@@ -17,27 +19,49 @@ export class CohubClient {
     sessionAccess;
     tasks;
     cronJobs;
+    invite;
     transport;
     websocketClient;
     constructor(options = {}) {
+        const apiBaseUrl = resolveApiBaseUrl(options);
         this.transport = new HttpTransport(options);
         this.websocketClient = createWebsocketClient({
+            url: resolveWebsocketUrl({
+                env: options.websocket?.env ?? options.env,
+                url: options.websocket?.url,
+            }),
             ...options.websocket,
             getAccessToken: options.getAccessToken,
         });
         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, this.websocketClient);
     }
     onConnection(handler) {
+        const connectingCleanup = this.websocketClient.on("connecting", (payload) => {
+            handler({
+                state: payload.isReconnect ? "reconnecting" : "connecting",
+                willReconnect: payload.isReconnect,
+                attempt: payload.attempt,
+            });
+        });
+        const reconnectingCleanup = this.websocketClient.on("reconnecting", (payload) => {
+            handler({
+                state: "reconnecting",
+                willReconnect: true,
+                attempt: payload.attempt,
+                delayMs: payload.delayMs,
+            });
+        });
         const openCleanup = this.websocketClient.on("open", (payload) => {
             handler({
                 state: "open",
@@ -51,10 +75,16 @@ export class CohubClient {
                 willReconnect: payload.willReconnect,
             });
         });
-        const errorCleanup = this.websocketClient.on("error", () => {
-            handler({ state: "error", willReconnect: true });
+        const errorCleanup = this.websocketClient.on("error", (payload) => {
+            handler({
+                state: "error",
+                willReconnect: payload.recoverable,
+                recoverable: payload.recoverable,
+            });
         });
         return () => {
+            connectingCleanup();
+            reconnectingCleanup();
             openCleanup();
             closeCleanup();
             errorCleanup();