@neta-art/cohub 1.9.0 → 1.10.1

package/dist/websocket.js

@@ -1,628 +1,2 @@
-import { getSessionTurnPatchStreamKey, 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(),
-    event: new Set(),
-    ready: new Set(),
-    auth: new Set(),
-    messageAccepted: new Set(),
-    serverError: new Set(),
-    pong: new Set(),
-});
-const toWebSocketUrl = (input, env) => resolveWebsocketUrl({ url: input, env });
-const normalizeOptions = (options = {}) => ({
-    url: toWebSocketUrl(options.url, options.env),
-    autoReconnect: options.autoReconnect !== false,
-    reconnectBaseDelayMs: options.reconnectBaseDelayMs ?? 1000,
-    reconnectMaxDelayMs: options.reconnectMaxDelayMs ?? 15000,
-    pingIntervalMs: options.pingIntervalMs ?? 20000,
-    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 PATCH_STREAM_BUFFER_MAX_PENDING = 128;
-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);
-        this.name = "WebsocketAuthError";
-    }
-}
-export class WebsocketClient {
-    url;
-    autoReconnect;
-    reconnectBaseDelayMs;
-    reconnectMaxDelayMs;
-    pingIntervalMs;
-    pongTimeoutMs;
-    debug;
-    getAccessToken;
-    WebSocketImpl;
-    ws = null;
-    pingTimer = null;
-    reconnectTimer = null;
-    reconnectTimerResolver = null;
-    reconnectAttempt = 0;
-    manuallyClosed = false;
-    connectPromise = null;
-    authWaiter = null;
-    awaitingPong = false;
-    lastPingRequestId = null;
-    pongDeadlineAt = 0;
-    compactStreamContexts = new Map();
-    patchStreamBuffers = new Map();
-    state = "idle";
-    connectionId = null;
-    listeners = createEventMap();
-    constructor(options = {}) {
-        const normalized = normalizeOptions(options);
-        this.url = normalized.url;
-        this.autoReconnect = normalized.autoReconnect;
-        this.reconnectBaseDelayMs = normalized.reconnectBaseDelayMs;
-        this.reconnectMaxDelayMs = normalized.reconnectMaxDelayMs;
-        this.pingIntervalMs = normalized.pingIntervalMs;
-        this.pongTimeoutMs = normalized.pongTimeoutMs;
-        this.debug = normalized.debug;
-        this.getAccessToken = options.getAccessToken;
-        this.WebSocketImpl = options.WebSocketImpl ?? WebSocket;
-    }
-    on(type, handler) {
-        this.listeners[type].add(handler);
-        return () => this.off(type, handler);
-    }
-    off(type, handler) {
-        this.listeners[type].delete(handler);
-    }
-    emit(type, payload) {
-        for (const handler of this.listeners[type]) {
-            handler(payload);
-        }
-    }
-    log(...args) {
-        if (this.debug)
-            console.log("[WebsocketClient]", ...args);
-    }
-    async connect() {
-        if (this.connectPromise)
-            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.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;
-            let settled = false;
-            const rejectOnce = (error) => {
-                if (settled)
-                    return;
-                settled = true;
-                this.connectPromise = null;
-                reject(error);
-            };
-            const resolveOnce = () => {
-                if (settled)
-                    return;
-                settled = true;
-                this.connectPromise = null;
-                resolve();
-            };
-            ws.onopen = async () => {
-                try {
-                    this.log("connected", { url: this.url, isReconnect, attempt: this.reconnectAttempt });
-                    this.startPingLoop();
-                    await this.authenticate();
-                    this.state = "open";
-                    this.reconnectAttempt = 0;
-                    this.emit("open", { connectionId: this.connectionId });
-                    resolveOnce();
-                }
-                catch (error) {
-                    const authError = error instanceof Error ? error : new Error("authentication failed");
-                    this.emit("error", { error: authError, recoverable: false });
-                    rejectOnce(authError);
-                    ws.close(4003, AUTH_CLOSE_REASON);
-                }
-            };
-            ws.onmessage = (event) => {
-                this.handleMessage(event.data);
-            };
-            ws.onerror = (error) => {
-                this.emit("error", { error, recoverable: !this.manuallyClosed });
-            };
-            ws.onclose = (event) => {
-                this.stopPingLoop();
-                const wasConnecting = this.state === "connecting" || this.state === "reconnecting";
-                this.state = "closed";
-                this.ws = null;
-                this.compactStreamContexts.clear();
-                this.patchStreamBuffers.clear();
-                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(closeError);
-                }
-                if (willReconnect) {
-                    void this.scheduleReconnect(event.code, event.reason);
-                }
-            };
-        });
-        return this.connectPromise;
-    }
-    async disconnect(code = 1000, reason = "manual") {
-        this.manuallyClosed = true;
-        this.clearReconnectTimer();
-        this.stopPingLoop();
-        this.state = "closed";
-        this.rejectAuthWaiter(new Error("disconnected"));
-        this.ws?.close(code, reason);
-        this.ws = null;
-        this.connectPromise = null;
-        this.compactStreamContexts.clear();
-        this.patchStreamBuffers.clear();
-    }
-    async sendMessage(input) {
-        await this.ensureOpen();
-        this.send({
-            type: "session.message.create",
-            requestId: input.requestId,
-            payload: {
-                spaceId: input.spaceId,
-                sessionId: input.sessionId,
-                content: input.content,
-                clientMessageId: input.clientMessageId,
-                model: input.model,
-                provider: input.provider,
-            },
-        });
-    }
-    ack(eventId, requestId) {
-        this.send({
-            type: "ack",
-            requestId,
-            payload: eventId ? { eventId } : undefined,
-        });
-    }
-    ping(requestId) {
-        const effectiveRequestId = requestId ?? `ping-${Date.now()}`;
-        this.awaitingPong = true;
-        this.lastPingRequestId = effectiveRequestId;
-        this.pongDeadlineAt = Date.now() + this.pongTimeoutMs;
-        this.send({ type: "ping", requestId: effectiveRequestId, payload: {} });
-    }
-    async ensureOpen() {
-        if (this.state === "open" && this.ws?.readyState === WebSocket.OPEN)
-            return;
-        await this.connect();
-    }
-    send(event) {
-        const ws = this.ws;
-        if (!ws || ws.readyState !== WebSocket.OPEN) {
-            throw new Error("websocket is not open");
-        }
-        ws.send(JSON.stringify(event));
-    }
-    async authenticate() {
-        const token = this.getAccessToken ? await this.getAccessToken() : null;
-        if (!token)
-            throw new WebsocketAuthError("missing access token");
-        const waiter = this.createAuthWaiter();
-        this.send({
-            type: "auth",
-            payload: { token, capabilities: [WS_COMPACT_STREAM_CAPABILITY] },
-        });
-        await waiter.promise;
-    }
-    createAuthWaiter() {
-        this.rejectAuthWaiter(new Error("superseded auth waiter"));
-        let resolve;
-        let reject;
-        const promise = new Promise((res, rej) => {
-            resolve = res;
-            reject = rej;
-        });
-        this.authWaiter = { promise, resolve, reject };
-        return this.authWaiter;
-    }
-    resolveAuthWaiter() {
-        if (!this.authWaiter)
-            return;
-        this.authWaiter.resolve();
-        this.authWaiter = null;
-    }
-    rejectAuthWaiter(error) {
-        if (!this.authWaiter)
-            return;
-        this.authWaiter.reject(error);
-        this.authWaiter = null;
-    }
-    handleMessage(raw) {
-        let parsed;
-        try {
-            parsed = typeof raw === "string" ? JSON.parse(raw) : JSON.parse(String(raw));
-        }
-        catch {
-            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"), recoverable: true });
-            return;
-        }
-        const envelope = result.data;
-        this.rememberCompactStreamContext(envelope);
-        if (envelope.type === "session.turn.patch") {
-            this.handlePatchEnvelope(envelope);
-            return;
-        }
-        switch (envelope.type) {
-            case "system.ready": {
-                const connectionId = typeof envelope.payload.connectionId === "string"
-                    ? envelope.payload.connectionId
-                    : null;
-                if (connectionId) {
-                    this.connectionId = connectionId;
-                    this.emit("ready", { connectionId });
-                }
-                this.emit("event", envelope);
-                return;
-            }
-            case "system.auth.ok": {
-                const connectionId = typeof envelope.payload.connectionId === "string"
-                    ? envelope.payload.connectionId
-                    : this.connectionId;
-                const user = envelope.payload.user && typeof envelope.payload.user === "object"
-                    ? envelope.payload.user
-                    : {};
-                if (connectionId) {
-                    this.connectionId = connectionId;
-                    this.emit("auth", { connectionId, user });
-                }
-                this.resolveAuthWaiter();
-                this.emit("event", envelope);
-                return;
-            }
-            case "system.request.error": {
-                const message = typeof envelope.payload.message === "string"
-                    ? envelope.payload.message
-                    : "request failed";
-                const code = typeof envelope.payload.code === "string"
-                    ? envelope.payload.code
-                    : undefined;
-                const error = new WebsocketAuthError(message);
-                this.rejectAuthWaiter(error);
-                this.emit("serverError", {
-                    code,
-                    message,
-                    requestId: envelope.requestId ?? null,
-                    sessionId: envelope.sessionId ?? null,
-                    spaceId: envelope.spaceId ?? null,
-                });
-                this.emit("event", envelope);
-                return;
-            }
-            case "session.request.accepted": {
-                const payload = envelope.payload;
-                this.emit("messageAccepted", {
-                    requestId: envelope.requestId ?? null,
-                    sessionId: envelope.sessionId ?? null,
-                    spaceId: envelope.spaceId ?? null,
-                    clientMessageId: typeof payload.clientMessageId === "string" ? payload.clientMessageId : null,
-                });
-                this.emit("event", envelope);
-                return;
-            }
-            case "session.request.error": {
-                const payload = envelope.payload;
-                this.emit("serverError", {
-                    code: typeof payload.code === "string" ? payload.code : undefined,
-                    message: typeof payload.message === "string" ? payload.message : undefined,
-                    requestId: envelope.requestId ?? null,
-                    sessionId: envelope.sessionId ?? null,
-                    spaceId: envelope.spaceId ?? null,
-                    clientMessageId: typeof payload.clientMessageId === "string" ? payload.clientMessageId : null,
-                });
-                this.emit("event", envelope);
-                return;
-            }
-            case "system.pong": {
-                const requestId = envelope.requestId ?? null;
-                if (!requestId || requestId === this.lastPingRequestId) {
-                    this.awaitingPong = false;
-                    this.lastPingRequestId = null;
-                    this.pongDeadlineAt = 0;
-                }
-                this.emit("pong", { requestId });
-                return;
-            }
-            case "system.ack.ok": {
-                return;
-            }
-            default: {
-                this.emit("event", envelope);
-                return;
-            }
-        }
-    }
-    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,
-                messageOrdinal: typeof payload.messageOrdinal === "number"
-                    ? payload.messageOrdinal
-                    : null,
-                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);
-                this.patchStreamBuffers.delete(sid);
-            }
-        }
-    }
-    getPatchStreamBufferKey(envelope) {
-        if (envelope.type !== "session.turn.patch")
-            return null;
-        const payload = envelope.payload;
-        const realtimeMeta = payload._rt && typeof payload._rt === "object"
-            ? payload._rt
-            : null;
-        if (typeof realtimeMeta?.sid === "string" && realtimeMeta.sid.trim()) {
-            return realtimeMeta.sid;
-        }
-        return getSessionTurnPatchStreamKey(payload, { includeSessionFallback: true });
-    }
-    handlePatchEnvelope(envelope) {
-        const payload = envelope.payload;
-        if (typeof payload.seq !== "number" ||
-            typeof payload.baseSeq !== "number" ||
-            !Number.isInteger(payload.seq) ||
-            !Number.isInteger(payload.baseSeq) ||
-            payload.seq < 0 ||
-            payload.baseSeq < 0) {
-            this.emit("event", envelope);
-            return;
-        }
-        const key = this.getPatchStreamBufferKey(envelope);
-        if (!key) {
-            this.emit("event", envelope);
-            return;
-        }
-        if (payload.baseSeq === 0) {
-            const buffer = { nextSeq: payload.seq + 1, pending: new Map() };
-            this.patchStreamBuffers.set(key, buffer);
-            this.emit("event", envelope);
-            this.flushPatchStreamBuffer(buffer);
-            return;
-        }
-        const buffer = this.patchStreamBuffers.get(key);
-        if (!buffer) {
-            const newBuffer = {
-                nextSeq: payload.baseSeq + 1,
-                pending: new Map([[payload.seq, envelope]]),
-            };
-            this.patchStreamBuffers.set(key, newBuffer);
-            this.flushPatchStreamBuffer(newBuffer);
-            return;
-        }
-        if (payload.seq < buffer.nextSeq)
-            return;
-        buffer.pending.set(payload.seq, envelope);
-        if (!this.enforcePatchStreamBufferLimit(key, buffer))
-            return;
-        this.flushPatchStreamBuffer(buffer);
-    }
-    enforcePatchStreamBufferLimit(key, buffer) {
-        if (buffer.pending.size <= PATCH_STREAM_BUFFER_MAX_PENDING)
-            return true;
-        this.patchStreamBuffers.delete(key);
-        this.emit("error", {
-            error: new Error(`patch stream buffer overflow: ${key}`),
-            recoverable: true,
-        });
-        return false;
-    }
-    flushPatchStreamBuffer(buffer) {
-        while (true) {
-            const envelope = buffer.pending.get(buffer.nextSeq);
-            if (!envelope)
-                return;
-            const seq = envelope.payload.seq;
-            if (typeof seq !== "number" || !Number.isInteger(seq))
-                return;
-            buffer.pending.delete(buffer.nextSeq);
-            buffer.nextSeq = seq + 1;
-            this.emit("event", envelope);
-        }
-    }
-    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,
-                messageOrdinal: context.messageOrdinal,
-                sourceMessageId: context.messageId,
-                anchorUserMessageId: context.anchorUserMessageId,
-                seq: frame.s,
-                baseSeq: frame.b,
-                ops: [op],
-                _rt: { sid: frame.sid },
-            },
-        };
-        this.handlePatchEnvelope(envelope);
-    }
-    startPingLoop() {
-        this.stopPingLoop();
-        this.pingTimer = setInterval(() => {
-            if (this.ws?.readyState !== WebSocket.OPEN)
-                return;
-            if (this.awaitingPong &&
-                this.pongDeadlineAt > 0 &&
-                Date.now() > this.pongDeadlineAt) {
-                this.emit("error", { error: new Error("websocket pong timeout"), recoverable: true });
-                this.ws.close(4002, "pong timeout");
-                return;
-            }
-            this.ping();
-        }, this.pingIntervalMs);
-    }
-    stopPingLoop() {
-        if (this.pingTimer) {
-            clearInterval(this.pingTimer);
-            this.pingTimer = null;
-        }
-        this.awaitingPong = false;
-        this.lastPingRequestId = null;
-        this.pongDeadlineAt = 0;
-    }
-    clearReconnectTimer() {
-        if (this.reconnectTimer) {
-            clearTimeout(this.reconnectTimer);
-            this.reconnectTimer = null;
-        }
-        if (this.reconnectTimerResolver) {
-            const resolve = this.reconnectTimerResolver;
-            this.reconnectTimerResolver = null;
-            resolve();
-        }
-    }
-    async scheduleReconnect(code, reason) {
-        this.clearReconnectTimer();
-        const attempt = this.reconnectAttempt + 1;
-        const delay = Math.min(this.reconnectBaseDelayMs * 2 ** this.reconnectAttempt, this.reconnectMaxDelayMs);
-        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.reconnectTimerResolver = resolve;
-            this.reconnectTimer = setTimeout(() => {
-                this.reconnectTimer = null;
-                this.reconnectTimerResolver = null;
-                resolve();
-            }, delay);
-        });
-        if (this.manuallyClosed)
-            return;
-        if (typeof navigator !== "undefined" && navigator.onLine === false) {
-            await new Promise((resolve) => {
-                const fallbackTimer = setTimeout(resolve, this.reconnectMaxDelayMs);
-                const handleOnline = () => {
-                    clearTimeout(fallbackTimer);
-                    globalThis.removeEventListener?.("online", handleOnline);
-                    resolve();
-                };
-                globalThis.addEventListener?.("online", handleOnline, { once: true });
-            });
-            if (this.manuallyClosed)
-                return;
-        }
-        await this.connect().catch((error) => {
-            this.emit("error", { error, recoverable: true });
-        });
-    }
-}
-export const createWebsocketClient = (options) => new WebsocketClient(options);
+import { n as createWebsocketClient, t as WebsocketClient } from "./chunks/websocket.js";
+export { WebsocketClient, createWebsocketClient };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neta-art/cohub",
-  "version": "1.9.0",
+  "version": "1.10.1",
   "description": "Cohub SDK for spaces, sessions, checkpoints, and realtime agent collaboration.",
   "license": "UNLICENSED",
   "private": false,
@@ -36,6 +36,10 @@
     "./websocket": {
       "types": "./dist/websocket.d.ts",
       "import": "./dist/websocket.js"
+    },
+    "./debugger": {
+      "types": "./dist/debugger.d.ts",
+      "import": "./dist/debugger.js"
     }
   },
   "types": "./dist/index.d.ts",
@@ -43,14 +47,14 @@
     "dist",
     "README.md"
   ],
-  "dependencies": {
-    "@neta-art/cohub-protocol": "2.0.0"
-  },
+  "dependencies": {},
   "devDependencies": {
-    "typescript": "^6.0.3"
+    "tsdown": "^0.22.0",
+    "typescript": "^6.0.3",
+    "@cohub/protocol": "2.0.0"
   },
   "scripts": {
-    "build": "tsc -p tsconfig.build.json",
-    "typecheck": "tsc -p tsconfig.json --noEmit"
+    "build": "tsdown",
+    "typecheck": "tsgo -p tsconfig.json --noEmit"
   }
 }

package/dist/apis/channels.d.ts

@@ -1,13 +0,0 @@
-import type { HttpTransport, Fetch } from "../transport.js";
-import type { Channel } from "../types.js";
-export declare class ChannelsApi {
-    private readonly transport;
-    constructor(transport: HttpTransport);
-    list(customFetch?: Fetch): Promise<Channel[]>;
-    create(data: {
-        provider: string;
-        name: string;
-        credentials: Record<string, unknown>;
-    }): Promise<unknown>;
-    delete(id: string): Promise<unknown>;
-}