@neta-art/cohub 1.1.0 → 1.2.1

package/dist/websocket.js

@@ -1,5 +1,8 @@
-import { realtimeEnvelopeSchema, } from "@neta-art/cohub-protocol/realtime";
+import { realtimeCompactFrameSchema, realtimeEnvelopeSchema, WS_COMPACT_STREAM_CAPABILITY, } from "@neta-art/cohub-protocol/realtime";
+import { resolveWebsocketUrl } from "./environment.js";
 const createEventMap = () => ({
+    connecting: new Set(),
+    reconnecting: new Set(),
     open: new Set(),
     close: new Set(),
     error: new Set(),
@@ -10,24 +13,9 @@ const createEventMap = () => ({
     serverError: new Set(),
     pong: new Set(),
 });
-const toWebSocketUrl = (input) => {
-    const base = (input?.trim() || "").replace(/\/$/, "");
-    if (base) {
-        if (base.startsWith("ws://") || base.startsWith("wss://"))
-            return `${base}/ws`;
-        if (base.startsWith("http://"))
-            return `${base.replace(/^http:/, "ws:")}/ws`;
-        if (base.startsWith("https://"))
-            return `${base.replace(/^https:/, "wss:")}/ws`;
-    }
-    if (typeof window !== "undefined") {
-        const protocol = window.location.protocol === "https:" ? "wss:" : "ws:";
-        return `${protocol}//${window.location.host}/ws`;
-    }
-    return "ws://localhost:8788/ws";
-};
+const toWebSocketUrl = (input, env) => resolveWebsocketUrl({ url: input, env });
 const normalizeOptions = (options = {}) => ({
-    url: toWebSocketUrl(options.url),
+    url: toWebSocketUrl(options.url, options.env),
     autoReconnect: options.autoReconnect !== false,
     reconnectBaseDelayMs: options.reconnectBaseDelayMs ?? 1000,
     reconnectMaxDelayMs: options.reconnectMaxDelayMs ?? 15000,
@@ -35,6 +23,37 @@ const normalizeOptions = (options = {}) => ({
     pongTimeoutMs: options.pongTimeoutMs ?? 15000,
     debug: options.debug === true,
 });
+const formatCloseMessage = (code, reason) => `WebSocket closed: ${code ?? 0} ${reason || ""}`.trim();
+const isRetryableCloseCode = (code) => {
+    if (code === 1000)
+        return false;
+    if (code === 4003)
+        return false;
+    return true;
+};
+const AUTH_CLOSE_REASON = "authentication failed";
+const isRecord = (value) => Boolean(value && typeof value === "object" && !Array.isArray(value));
+const compactFrameToPatchOperation = (frame) => {
+    if (frame.t === "d")
+        return { v: frame.v };
+    if (frame.o === "remove")
+        return { o: "remove", p: frame.p };
+    if (frame.o === "merge") {
+        return isRecord(frame.v) ? { o: "merge", p: frame.p, v: frame.v } : null;
+    }
+    if (!("v" in frame))
+        return null;
+    switch (frame.o) {
+        case "append":
+            return { o: "append", p: frame.p, v: frame.v };
+        case "replace":
+            return { o: "replace", p: frame.p, v: frame.v };
+        case "add":
+            return { o: "add", p: frame.p, v: frame.v };
+        default:
+            return null;
+    }
+};
 class WebsocketAuthError extends Error {
     constructor(message) {
         super(message);
@@ -54,6 +73,7 @@ export class WebsocketClient {
     ws = null;
     pingTimer = null;
     reconnectTimer = null;
+    reconnectTimerResolver = null;
     reconnectAttempt = 0;
     manuallyClosed = false;
     connectPromise = null;
@@ -61,6 +81,7 @@ export class WebsocketClient {
     awaitingPong = false;
     lastPingRequestId = null;
     pongDeadlineAt = 0;
+    compactStreamContexts = new Map();
     state = "idle";
     connectionId = null;
     listeners = createEventMap();
@@ -97,8 +118,11 @@ export class WebsocketClient {
             return this.connectPromise;
         if (this.state === "open" && this.ws?.readyState === WebSocket.OPEN)
             return;
+        const isReconnect = this.reconnectAttempt > 0 || this.state === "reconnecting";
         this.manuallyClosed = false;
-        this.state = "connecting";
+        this.clearReconnectTimer();
+        this.state = isReconnect ? "reconnecting" : "connecting";
+        this.emit("connecting", { isReconnect, attempt: this.reconnectAttempt });
         this.connectPromise = new Promise((resolve, reject) => {
             const ws = new this.WebSocketImpl(this.url);
             this.ws = ws;
@@ -119,7 +143,7 @@ export class WebsocketClient {
             };
             ws.onopen = async () => {
                 try {
-                    this.log("connected", this.url);
+                    this.log("connected", { url: this.url, isReconnect, attempt: this.reconnectAttempt });
                     this.startPingLoop();
                     await this.authenticate();
                     this.state = "open";
@@ -129,37 +153,36 @@ export class WebsocketClient {
                 }
                 catch (error) {
                     const authError = error instanceof Error ? error : new Error("authentication failed");
+                    this.emit("error", { error: authError, recoverable: false });
                     rejectOnce(authError);
-                    ws.close(4003, authError.message);
+                    ws.close(4003, AUTH_CLOSE_REASON);
                 }
             };
             ws.onmessage = (event) => {
                 this.handleMessage(event.data);
             };
             ws.onerror = (error) => {
-                this.emit("error", { error });
+                this.emit("error", { error, recoverable: !this.manuallyClosed });
             };
             ws.onclose = (event) => {
                 this.stopPingLoop();
-                const wasConnecting = this.state === "connecting";
+                const wasConnecting = this.state === "connecting" || this.state === "reconnecting";
                 this.state = "closed";
                 this.ws = null;
-                this.rejectAuthWaiter(new Error(`WebSocket closed: ${event.code} ${event.reason || ""}`.trim()));
-                const willReconnect = !this.manuallyClosed && this.autoReconnect;
+                const closeError = new Error(formatCloseMessage(event.code, event.reason));
+                this.rejectAuthWaiter(closeError);
+                const willReconnect = !this.manuallyClosed && this.autoReconnect && isRetryableCloseCode(event.code);
+                this.log("closed", { code: event.code, reason: event.reason, willReconnect, wasConnecting });
                 this.emit("close", {
                     code: event.code,
                     reason: event.reason,
                     willReconnect,
                 });
                 if (wasConnecting) {
-                    rejectOnce(new Error(`WebSocket closed: ${event.code} ${event.reason || ""}`.trim()));
-                    if (event.code === 4001 && willReconnect) {
-                        void this.scheduleReconnect();
-                    }
-                    return;
+                    rejectOnce(closeError);
                 }
                 if (willReconnect) {
-                    void this.scheduleReconnect();
+                    void this.scheduleReconnect(event.code, event.reason);
                 }
             };
         });
@@ -221,7 +244,10 @@ export class WebsocketClient {
         if (!token)
             throw new WebsocketAuthError("missing access token");
         const waiter = this.createAuthWaiter();
-        this.send({ type: "auth", payload: { token } });
+        this.send({
+            type: "auth",
+            payload: { token, capabilities: [WS_COMPACT_STREAM_CAPABILITY] },
+        });
         await waiter.promise;
     }
     createAuthWaiter() {
@@ -253,15 +279,21 @@ export class WebsocketClient {
             parsed = typeof raw === "string" ? JSON.parse(raw) : JSON.parse(String(raw));
         }
         catch {
-            this.emit("error", { error: new Error("invalid websocket payload") });
+            this.emit("error", { error: new Error("invalid websocket payload"), recoverable: true });
+            return;
+        }
+        const compactResult = realtimeCompactFrameSchema.safeParse(parsed);
+        if (compactResult.success) {
+            this.handleCompactFrame(compactResult.data);
             return;
         }
         const result = realtimeEnvelopeSchema.safeParse(parsed);
         if (!result.success) {
-            this.emit("error", { error: new Error("invalid realtime envelope") });
+            this.emit("error", { error: new Error("invalid realtime envelope"), recoverable: true });
             return;
         }
         const envelope = result.data;
+        this.rememberCompactStreamContext(envelope);
         switch (envelope.type) {
             case "system.ready": {
                 const connectionId = typeof envelope.payload.connectionId === "string"
@@ -351,6 +383,79 @@ export class WebsocketClient {
             }
         }
     }
+    rememberCompactStreamContext(envelope) {
+        if (envelope.type === "session.turn.patch") {
+            const payload = envelope.payload;
+            const turnId = typeof payload.turnId === "string" ? payload.turnId : null;
+            const messageId = typeof payload.messageId === "string" ? payload.messageId : null;
+            const realtimeMeta = payload._rt && typeof payload._rt === "object"
+                ? payload._rt
+                : null;
+            const sid = typeof realtimeMeta?.sid === "string" && realtimeMeta.sid.trim()
+                ? realtimeMeta.sid
+                : turnId ?? messageId;
+            if (!sid)
+                return;
+            this.compactStreamContexts.set(sid, {
+                spaceId: envelope.spaceId ?? null,
+                sessionId: envelope.sessionId ?? null,
+                turnId,
+                messageId,
+                anchorUserMessageId: typeof payload.anchorUserMessageId === "string"
+                    ? payload.anchorUserMessageId
+                    : null,
+            });
+            return;
+        }
+        if (envelope.type !== "session.message.persisted")
+            return;
+        const message = envelope.payload.message;
+        if (!message || typeof message !== "object")
+            return;
+        const meta = message.meta;
+        const turnId = typeof meta?.turnId === "string" ? meta.turnId : null;
+        if (!turnId)
+            return;
+        for (const [sid, context] of this.compactStreamContexts.entries()) {
+            if (context.turnId === turnId)
+                this.compactStreamContexts.delete(sid);
+        }
+    }
+    handleCompactFrame(frame) {
+        const context = this.compactStreamContexts.get(frame.sid);
+        if (!context?.sessionId) {
+            this.emit("error", {
+                error: new Error(`unknown compact stream: ${frame.sid}`),
+                recoverable: true,
+            });
+            return;
+        }
+        const op = compactFrameToPatchOperation(frame);
+        if (!op) {
+            this.emit("error", {
+                error: new Error(`invalid compact stream frame: ${frame.sid}`),
+                recoverable: true,
+            });
+            return;
+        }
+        const envelope = {
+            id: `compact:${frame.sid}:${frame.s}`,
+            timestamp: Date.now(),
+            domain: "session",
+            type: "session.turn.patch",
+            spaceId: context.spaceId,
+            sessionId: context.sessionId,
+            payload: {
+                turnId: context.turnId,
+                messageId: context.messageId,
+                anchorUserMessageId: context.anchorUserMessageId,
+                seq: frame.s,
+                baseSeq: frame.b,
+                ops: [op],
+            },
+        };
+        this.emit("event", envelope);
+    }
     startPingLoop() {
         this.stopPingLoop();
         this.pingTimer = setInterval(() => {
@@ -359,7 +464,7 @@ export class WebsocketClient {
             if (this.awaitingPong &&
                 this.pongDeadlineAt > 0 &&
                 Date.now() > this.pongDeadlineAt) {
-                this.emit("error", { error: new Error("websocket pong timeout") });
+                this.emit("error", { error: new Error("websocket pong timeout"), recoverable: true });
                 this.ws.close(4002, "pong timeout");
                 return;
             }
@@ -376,22 +481,41 @@ export class WebsocketClient {
         this.pongDeadlineAt = 0;
     }
     clearReconnectTimer() {
-        if (!this.reconnectTimer)
-            return;
-        clearTimeout(this.reconnectTimer);
-        this.reconnectTimer = null;
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+        if (this.reconnectTimerResolver) {
+            const resolve = this.reconnectTimerResolver;
+            this.reconnectTimerResolver = null;
+            resolve();
+        }
     }
-    async scheduleReconnect() {
+    async scheduleReconnect(code, reason) {
         this.clearReconnectTimer();
+        const attempt = this.reconnectAttempt + 1;
         const delay = Math.min(this.reconnectBaseDelayMs * 2 ** this.reconnectAttempt, this.reconnectMaxDelayMs);
-        this.reconnectAttempt += 1;
+        this.reconnectAttempt = attempt;
+        this.state = "reconnecting";
+        this.log("schedule reconnect", { attempt, delay, code, reason });
+        this.emit("reconnecting", {
+            attempt,
+            delayMs: delay,
+            code,
+            reason,
+        });
         await new Promise((resolve) => {
-            this.reconnectTimer = setTimeout(() => resolve(), delay);
+            this.reconnectTimerResolver = resolve;
+            this.reconnectTimer = setTimeout(() => {
+                this.reconnectTimer = null;
+                this.reconnectTimerResolver = null;
+                resolve();
+            }, delay);
         });
         if (this.manuallyClosed)
             return;
         await this.connect().catch((error) => {
-            this.emit("error", { error });
+            this.emit("error", { error, recoverable: true });
         });
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neta-art/cohub",
-  "version": "1.1.0",
+  "version": "1.2.1",
   "description": "Cohub SDK for spaces, sessions, checkpoints, and realtime agent collaboration.",
   "license": "UNLICENSED",
   "private": false,
@@ -43,14 +43,14 @@
     "dist",
     "README.md"
   ],
-  "scripts": {
-    "build": "tsc -p tsconfig.build.json",
-    "typecheck": "tsc -p tsconfig.json --noEmit"
-  },
   "dependencies": {
-    "@neta-art/cohub-protocol": "^1.0.0"
+    "@neta-art/cohub-protocol": "1.2.1"
   },
   "devDependencies": {
     "typescript": "^6.0.3"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit"
   }
-}
+}