@fluxy-chat/sdk 0.1.0

package/dist/index.js

@@ -0,0 +1,843 @@
+export { FluxyAuthError, FluxyConnectionError, FluxySendError, FluxyTimeoutError, FLUXY_WS_CLOSE_NORMAL, FLUXY_WS_CLOSE_POLICY, computeReconnectBackoffMs, mapWebSocketCloseToError, } from "./errors";
+export { FluxyChatRoomConnection, } from "./room-connection";
+export { FluxyMessageStream } from "./message-stream";
+import { FluxyChatRoomConnection } from "./room-connection";
+import { FluxyAuthError, FluxySendError } from "./errors";
+function inferAttachmentKind(contentType, fileName) {
+    const ct = (contentType || "").toLowerCase();
+    if (ct.startsWith("image/"))
+        return "image";
+    if (ct.startsWith("audio/"))
+        return "audio";
+    if (/\.(webm|m4a|mp3|wav|ogg)$/i.test(fileName))
+        return "audio";
+    return "file";
+}
+export class FluxyChatClient {
+    constructor(options) {
+        this.baseUrl = options.baseUrl.replace(/\/+$/, "");
+        this.userId = options.userId;
+        this.apiKey = options.apiKey;
+        this.token = options.token;
+    }
+    isAuthenticated() {
+        return !!this.token;
+    }
+    authHeaders() {
+        if (this.token) {
+            return {
+                Authorization: `Bearer ${this.token}`,
+            };
+        }
+        if (this.apiKey) {
+            return {
+                "X-Fluxy-Api-Key": this.apiKey,
+            };
+        }
+        return undefined;
+    }
+    connect(roomId) {
+        const wsBase = this.baseUrl.replace(/^http/, "ws");
+        const url = new URL(`/ws/room/${encodeURIComponent(roomId)}`, wsBase.endsWith("/") ? wsBase : `${wsBase}/`);
+        if (this.apiKey) {
+            url.searchParams.set("apiKey", this.apiKey);
+        }
+        if (this.token) {
+            url.searchParams.set("token", this.token);
+        }
+        url.searchParams.set("userId", this.userId);
+        const ws = new WebSocket(url.toString());
+        return ws;
+    }
+    /**
+     * Resilient room WebSocket with typed errors, exponential backoff reconnect,
+     * and optional REST history replay after reconnect.
+     */
+    connectRoom(roomId, options) {
+        return new FluxyChatRoomConnection(this, roomId, options);
+    }
+    connectSSE(roomId) {
+        if (!this.token)
+            return null;
+        const url = new URL(`/rooms/${encodeURIComponent(roomId)}/stream`, this.baseUrl);
+        url.searchParams.set("token", this.token);
+        url.searchParams.set("userId", this.userId);
+        return new EventSource(url.toString());
+    }
+    async fetchMessages(roomId, limit = 50) {
+        const trimmedRoomId = roomId.trim();
+        if (!trimmedRoomId)
+            return [];
+        const url = new URL("/api/messages", this.baseUrl);
+        url.searchParams.set("roomId", trimmedRoomId);
+        url.searchParams.set("limit", String(limit));
+        const res = await fetch(url.toString(), {
+            headers: this.authHeaders(),
+        });
+        if (!res.ok)
+            throw new Error(`Failed to fetch messages: ${res.status}`);
+        const body = await res.json();
+        return body.messages ?? [];
+    }
+    async listRooms(type) {
+        const url = new URL("/rooms", this.baseUrl);
+        if (type)
+            url.searchParams.set("type", type);
+        const res = await fetch(url.toString(), {
+            headers: this.authHeaders(),
+        });
+        if (!res.ok)
+            throw new Error(`Failed to load rooms: ${res.status}`);
+        const body = await res.json();
+        return body.rooms ?? [];
+    }
+    // --- Authenticated REST helpers (used opportunistically by hooks) ---
+    async createMessage(roomId, content, replyTo, attachments) {
+        if (!this.token)
+            return null;
+        const res = await fetch(new URL("/messages", this.baseUrl).toString(), {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                ...this.authHeaders(),
+            },
+            body: JSON.stringify({
+                roomId,
+                content,
+                replyTo: replyTo ?? null,
+                ...(attachments?.length ? { attachments } : {}),
+            }),
+        });
+        if (!res.ok) {
+            throw new Error(`Failed to create message: ${res.status}`);
+        }
+        const body = await res.json();
+        return body.message ?? null;
+    }
+    /**
+     * Upload to Worker `POST /upload` (requires JWT). Returns attachment fields for composing a message.
+     */
+    async uploadFile(roomId, file) {
+        if (!this.token) {
+            throw new Error("JWT is required for uploads");
+        }
+        const contentType = file.type || "application/octet-stream";
+        const url = new URL("/upload", this.baseUrl).toString();
+        const res = await fetch(url, {
+            method: "POST",
+            headers: {
+                "Content-Type": contentType,
+                Authorization: `Bearer ${this.token}`,
+                "X-File-Name": file.name.slice(0, 255),
+                "X-Room-Id": roomId,
+            },
+            body: file,
+        });
+        if (!res.ok) {
+            throw new Error(`Upload failed: ${res.status}`);
+        }
+        const json = (await res.json());
+        const f = json.file;
+        if (!f?.url)
+            throw new Error("Invalid upload response");
+        return {
+            kind: inferAttachmentKind(contentType, file.name || f.name || ""),
+            url: f.url,
+            name: (f.name || file.name || "upload").slice(0, 255),
+            sizeBytes: typeof f.size === "number" ? f.size : file.size,
+            contentType,
+        };
+    }
+    async editMessageRest(messageId, content) {
+        if (!this.token)
+            return;
+        const url = new URL(`/messages/${messageId}`, this.baseUrl);
+        const res = await fetch(url.toString(), {
+            method: "PATCH",
+            headers: {
+                "Content-Type": "application/json",
+                ...this.authHeaders(),
+            },
+            body: JSON.stringify({ content }),
+        });
+        if (!res.ok) {
+            throw new Error(`Failed to edit message: ${res.status}`);
+        }
+    }
+    async deleteMessageRest(messageId) {
+        if (!this.token)
+            return;
+        const url = new URL(`/messages/${messageId}`, this.baseUrl);
+        const res = await fetch(url.toString(), {
+            method: "DELETE",
+            headers: this.authHeaders(),
+        });
+        if (!res.ok) {
+            throw new Error(`Failed to delete message: ${res.status}`);
+        }
+    }
+    async sendReactionRest(messageId, emoji, op = "add") {
+        if (!this.token)
+            return;
+        const url = new URL(`/messages/${messageId}/reactions`, this.baseUrl);
+        const res = await fetch(url.toString(), {
+            method: op === "remove" ? "DELETE" : "POST",
+            headers: {
+                "Content-Type": "application/json",
+                ...this.authHeaders(),
+            },
+            body: JSON.stringify({ emoji }),
+        });
+        if (!res.ok) {
+            throw new Error(`Failed to update reaction: ${res.status}`);
+        }
+    }
+    async markReadRest(roomId, messageId) {
+        if (!this.token)
+            return;
+        const url = new URL(`/rooms/${encodeURIComponent(roomId)}/read`, this.baseUrl);
+        const res = await fetch(url.toString(), {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                ...this.authHeaders(),
+            },
+            body: JSON.stringify({ messageId }),
+        });
+        if (!res.ok) {
+            throw new Error(`Failed to mark read: ${res.status}`);
+        }
+    }
+    async listAgents() {
+        if (!this.token)
+            return [];
+        const res = await fetch(new URL("/agents", this.baseUrl).toString(), {
+            headers: this.authHeaders(),
+        });
+        if (!res.ok)
+            throw new Error(`Failed to list agents: ${res.status}`);
+        const body = await res.json();
+        return body.agents ?? [];
+    }
+    async invokeAgentRest(agentId, roomId, content, options) {
+        if (!this.token)
+            throw new Error("invokeAgent requires JWT token");
+        const url = new URL(`/agents/${encodeURIComponent(agentId)}/invoke`, this.baseUrl);
+        const res = await fetch(url.toString(), {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                ...this.authHeaders(),
+            },
+            body: JSON.stringify({
+                roomId,
+                content,
+                replyTo: options?.replyTo ?? null,
+                stream: options?.stream !== false,
+            }),
+        });
+        if (!res.ok)
+            throw new Error(`Failed to invoke agent: ${res.status}`);
+        return res.json();
+    }
+    async getAgentRuns(agentId, limit = 50) {
+        if (!this.token)
+            return [];
+        const url = new URL(`/agents/${encodeURIComponent(agentId)}/runs`, this.baseUrl);
+        url.searchParams.set("limit", String(limit));
+        const res = await fetch(url.toString(), {
+            headers: this.authHeaders(),
+        });
+        if (!res.ok)
+            throw new Error(`Failed to fetch agent runs: ${res.status}`);
+        const body = await res.json();
+        return body.runs ?? [];
+    }
+    async getAgent(agentId) {
+        if (!this.token)
+            return null;
+        const url = new URL(`/agents/${encodeURIComponent(agentId)}`, this.baseUrl);
+        const res = await fetch(url.toString(), { headers: this.authHeaders() });
+        if (res.status === 404)
+            return null;
+        if (!res.ok)
+            throw new Error(`Failed to get agent: ${res.status}`);
+        const body = await res.json();
+        return body.agent ?? null;
+    }
+    async createAgent(body) {
+        if (!this.token)
+            throw new Error("createAgent requires JWT token");
+        const res = await fetch(new URL("/agents", this.baseUrl).toString(), {
+            method: "POST",
+            headers: { "Content-Type": "application/json", ...this.authHeaders() },
+            body: JSON.stringify(body),
+        });
+        if (!res.ok)
+            throw new Error(`Failed to create agent: ${res.status}`);
+        const data = await res.json();
+        return data.agent;
+    }
+    async updateAgent(agentId, body) {
+        if (!this.token)
+            throw new Error("updateAgent requires JWT token");
+        const url = new URL(`/agents/${encodeURIComponent(agentId)}`, this.baseUrl);
+        const res = await fetch(url.toString(), {
+            method: "PATCH",
+            headers: { "Content-Type": "application/json", ...this.authHeaders() },
+            body: JSON.stringify(body),
+        });
+        if (!res.ok)
+            throw new Error(`Failed to update agent: ${res.status}`);
+        const data = await res.json();
+        return data.agent;
+    }
+    async deleteAgent(agentId) {
+        if (!this.token)
+            throw new Error("deleteAgent requires JWT token");
+        const url = new URL(`/agents/${encodeURIComponent(agentId)}`, this.baseUrl);
+        const res = await fetch(url.toString(), {
+            method: "DELETE",
+            headers: this.authHeaders(),
+        });
+        if (!res.ok)
+            throw new Error(`Failed to delete agent: ${res.status}`);
+    }
+    async createRoom(body) {
+        if (!this.token)
+            throw new Error("createRoom requires JWT token");
+        const res = await fetch(new URL("/rooms", this.baseUrl).toString(), {
+            method: "POST",
+            headers: { "Content-Type": "application/json", ...this.authHeaders() },
+            body: JSON.stringify(body),
+        });
+        if (!res.ok)
+            throw new Error(`Failed to create room: ${res.status}`);
+        const data = await res.json();
+        return data.room;
+    }
+    async updateRoom(roomId, body) {
+        if (!this.token)
+            throw new Error("updateRoom requires JWT token");
+        const url = new URL(`/rooms/${encodeURIComponent(roomId)}`, this.baseUrl);
+        const res = await fetch(url.toString(), {
+            method: "PATCH",
+            headers: { "Content-Type": "application/json", ...this.authHeaders() },
+            body: JSON.stringify(body),
+        });
+        if (!res.ok)
+            throw new Error(`Failed to update room: ${res.status}`);
+    }
+    async deleteRoom(roomId) {
+        if (!this.token)
+            throw new Error("deleteRoom requires JWT token");
+        const url = new URL(`/rooms/${encodeURIComponent(roomId)}`, this.baseUrl);
+        const res = await fetch(url.toString(), {
+            method: "DELETE",
+            headers: this.authHeaders(),
+        });
+        if (!res.ok)
+            throw new Error(`Failed to delete room: ${res.status}`);
+    }
+    async addRoomMember(roomId, userId, role = "member") {
+        if (!this.token)
+            throw new Error("addRoomMember requires JWT token");
+        const url = new URL(`/rooms/${encodeURIComponent(roomId)}/members`, this.baseUrl);
+        const res = await fetch(url.toString(), {
+            method: "POST",
+            headers: { "Content-Type": "application/json", ...this.authHeaders() },
+            body: JSON.stringify({ userId, role }),
+        });
+        if (!res.ok)
+            throw new Error(`Failed to add room member: ${res.status}`);
+    }
+    async removeRoomMember(roomId, userId) {
+        if (!this.token)
+            throw new Error("removeRoomMember requires JWT token");
+        const url = new URL(`/rooms/${encodeURIComponent(roomId)}/members/${encodeURIComponent(userId)}`, this.baseUrl);
+        const res = await fetch(url.toString(), {
+            method: "DELETE",
+            headers: this.authHeaders(),
+        });
+        if (!res.ok)
+            throw new Error(`Failed to remove room member: ${res.status}`);
+    }
+    async registerWebhook(body) {
+        if (!this.token)
+            throw new Error("registerWebhook requires JWT token");
+        const res = await fetch(new URL("/webhooks/register", this.baseUrl).toString(), {
+            method: "POST",
+            headers: { "Content-Type": "application/json", ...this.authHeaders() },
+            body: JSON.stringify(body),
+        });
+        if (!res.ok)
+            throw new Error(`Failed to register webhook: ${res.status}`);
+        const data = await res.json();
+        return data.webhook;
+    }
+    async updateWebhook(webhookId, body) {
+        if (!this.token)
+            throw new Error("updateWebhook requires JWT token");
+        const url = new URL(`/webhooks/${encodeURIComponent(webhookId)}`, this.baseUrl);
+        const res = await fetch(url.toString(), {
+            method: "PATCH",
+            headers: { "Content-Type": "application/json", ...this.authHeaders() },
+            body: JSON.stringify(body),
+        });
+        if (!res.ok)
+            throw new Error(`Failed to update webhook: ${res.status}`);
+    }
+    async deleteWebhook(webhookId) {
+        if (!this.token)
+            throw new Error("deleteWebhook requires JWT token");
+        const url = new URL(`/webhooks/${encodeURIComponent(webhookId)}`, this.baseUrl);
+        const res = await fetch(url.toString(), {
+            method: "DELETE",
+            headers: this.authHeaders(),
+        });
+        if (!res.ok)
+            throw new Error(`Failed to delete webhook: ${res.status}`);
+    }
+}
+// React hook convenience API
+import { useEffect, useRef, useState } from "react";
+export function useChat({ roomId, client, agentId }) {
+    const [messages, setMessages] = useState([]);
+    const [online, setOnline] = useState(0);
+    const [typingUsers, setTypingUsers] = useState({});
+    const [seenBy, setSeenBy] = useState({});
+    const [onlineUsers, setOnlineUsers] = useState([]);
+    const [connected, setConnected] = useState(false);
+    const [connectionStatus, setConnectionStatus] = useState("connecting");
+    const [reconnectAttempt, setReconnectAttempt] = useState(0);
+    const [connectionError, setConnectionError] = useState(null);
+    const [agentTyping, setAgentTyping] = useState(false);
+    const [wsTypingAgentId, setWsTypingAgentId] = useState(null);
+    const [invokeTypingAgentId, setInvokeTypingAgentId] = useState(null);
+    const [reactions, setReactions] = useState({});
+    const connectionRef = useRef(null);
+    const sseRef = useRef(null);
+    const pollTimerRef = useRef(null);
+    useEffect(() => {
+        let active = true;
+        const trimmedRoomId = roomId.trim();
+        const MAX_WS_RECONNECT_ATTEMPTS = 6;
+        const POLL_INTERVAL_MS = 4000;
+        const stopPollingFallback = () => {
+            if (pollTimerRef.current) {
+                clearInterval(pollTimerRef.current);
+                pollTimerRef.current = null;
+            }
+        };
+        const stopSSEFallback = () => {
+            if (sseRef.current) {
+                sseRef.current.close();
+                sseRef.current = null;
+            }
+        };
+        const startPollingFallback = () => {
+            stopPollingFallback();
+            stopSSEFallback();
+            const tick = async () => {
+                if (!active)
+                    return;
+                try {
+                    const next = await client.fetchMessages(trimmedRoomId);
+                    if (active)
+                        setMessages(next);
+                }
+                catch {
+                    /* ignore transient poll errors */
+                }
+            };
+            void tick();
+            pollTimerRef.current = setInterval(tick, POLL_INTERVAL_MS);
+        };
+        const startSSEFallback = () => {
+            stopPollingFallback();
+            stopSSEFallback();
+            const es = client.connectSSE(trimmedRoomId);
+            if (!es) {
+                startPollingFallback();
+                return;
+            }
+            sseRef.current = es;
+            setConnectionStatus("sse");
+            es.addEventListener("message", (event) => {
+                if (!active)
+                    return;
+                try {
+                    const data = JSON.parse(event.data);
+                    handleEvent(data);
+                }
+                catch {
+                    /* ignore malformed SSE events */
+                }
+            });
+            es.addEventListener("error", () => {
+                if (!active)
+                    return;
+                stopSSEFallback();
+                startPollingFallback();
+                setConnectionStatus("polling");
+            });
+        };
+        const handleEvent = (data) => {
+            if (data.type === "history") {
+                setMessages(data.messages);
+            }
+            else if (data.type === "message") {
+                setMessages((prev) => {
+                    const idx = prev.findIndex((m) => m.id === data.id);
+                    if (idx >= 0) {
+                        const next = [...prev];
+                        next[idx] = { ...next[idx], ...data };
+                        return next;
+                    }
+                    return [...prev, data];
+                });
+            }
+            else if (data.type === "presence") {
+                setOnline(data.online);
+                if (data.users)
+                    setOnlineUsers(data.users);
+            }
+            else if (data.type === "typing") {
+                setTypingUsers((prev) => ({
+                    ...prev,
+                    [data.userId]: data.isTyping,
+                }));
+            }
+            else if (data.type === "agentTyping") {
+                setAgentTyping(data.isTyping);
+                setWsTypingAgentId(data.isTyping ? data.agentId : null);
+            }
+            else if (data.type === "edit") {
+                setMessages((prev) => prev.map((m) => m.id === data.id
+                    ? {
+                        ...m,
+                        content: data.content,
+                        editedAt: data.editedAt,
+                        streaming: data.streaming ?? false,
+                    }
+                    : m));
+            }
+            else if (data.type === "reaction") {
+                setReactions((prev) => {
+                    const byMessage = { ...prev };
+                    const current = { ...(byMessage[data.messageId] || {}) };
+                    const existingCount = current[data.emoji] || 0;
+                    if (data.op === "remove") {
+                        const nextCount = Math.max(existingCount - 1, 0);
+                        if (nextCount === 0) {
+                            delete current[data.emoji];
+                        }
+                        else {
+                            current[data.emoji] = nextCount;
+                        }
+                    }
+                    else {
+                        current[data.emoji] = existingCount + 1;
+                    }
+                    if (Object.keys(current).length === 0) {
+                        delete byMessage[data.messageId];
+                    }
+                    else {
+                        byMessage[data.messageId] = current;
+                    }
+                    return byMessage;
+                });
+            }
+            else if (data.type === "read") {
+                setSeenBy((prev) => {
+                    const existing = prev[data.messageId] || [];
+                    if (existing.includes(data.userId))
+                        return prev;
+                    return {
+                        ...prev,
+                        [data.messageId]: [...existing, data.userId],
+                    };
+                });
+            }
+            else if (data.type === "delete") {
+                if (data.hard) {
+                    setMessages((prev) => prev.filter((m) => m.id !== data.id));
+                }
+                else {
+                    setMessages((prev) => prev.map((m) => m.id === data.id
+                        ? { ...m, content: "[deleted]", deletedAt: data.deletedAt }
+                        : m));
+                }
+            }
+        };
+        if (!trimmedRoomId || !client.isAuthenticated()) {
+            setMessages([]);
+            setConnected(false);
+            setConnectionStatus("disconnected");
+            return () => {
+                active = false;
+                stopPollingFallback();
+                stopSSEFallback();
+                connectionRef.current?.close();
+                connectionRef.current = null;
+            };
+        }
+        client.fetchMessages(trimmedRoomId).then((initial) => {
+            if (!active)
+                return;
+            setMessages(initial);
+        }).catch(() => {
+            /* history load is best-effort until member JWT + room are ready */
+        });
+        const connection = client.connectRoom(trimmedRoomId, {
+            maxReconnectAttempts: MAX_WS_RECONNECT_ATTEMPTS,
+            onStatusChange: (status) => {
+                if (!active)
+                    return;
+                if (status === "connected") {
+                    setConnected(true);
+                    setConnectionStatus("connected");
+                    setReconnectAttempt(0);
+                    setConnectionError(null);
+                    stopPollingFallback();
+                    stopSSEFallback();
+                }
+                else if (status === "connecting") {
+                    setConnectionStatus("connecting");
+                    setConnected(false);
+                }
+                else if (status === "reconnecting") {
+                    setConnectionStatus("reconnecting");
+                    setConnected(false);
+                    setReconnectAttempt(connection.reconnectAttempts);
+                }
+                else if (status === "disconnected") {
+                    setConnected(false);
+                    setConnectionStatus("disconnected");
+                }
+            },
+            onAuthError: (err) => {
+                if (!active)
+                    return;
+                setConnectionError(err);
+                setConnected(false);
+                setConnectionStatus("disconnected");
+            },
+            onConnectionError: (err) => {
+                if (!active)
+                    return;
+                if (!(err instanceof FluxyAuthError)) {
+                    setConnectionError(err);
+                }
+            },
+            onReconnectFailed: () => {
+                if (!active)
+                    return;
+                setReconnectAttempt(connection.reconnectAttempts);
+                if (client.isAuthenticated()) {
+                    startSSEFallback();
+                }
+                else {
+                    startPollingFallback();
+                }
+            },
+        });
+        connection.addEventListener("message", (data) => {
+            if (!active)
+                return;
+            handleEvent(data);
+        });
+        connectionRef.current = connection;
+        connection.connect();
+        return () => {
+            active = false;
+            stopPollingFallback();
+            stopSSEFallback();
+            connection.close();
+            connectionRef.current = null;
+            setConnected(false);
+            setConnectionStatus("disconnected");
+        };
+    }, [roomId, client]);
+    const sendMessage = (content, replyTo, attachments) => {
+        if (client.isAuthenticated()) {
+            void client
+                .createMessage(roomId, content, replyTo, attachments)
+                .catch((err) => 
+            // eslint-disable-next-line no-console
+            console.error("[fluxychat] REST sendMessage failed, falling back to WS:", err));
+            return;
+        }
+        try {
+            connectionRef.current?.sendJson({
+                type: "message",
+                userId: client.userId,
+                content,
+                parentId: replyTo ?? null,
+                attachments: attachments ?? [],
+            });
+        }
+        catch (err) {
+            if (err instanceof FluxySendError)
+                return;
+            throw err;
+        }
+    };
+    const setTyping = (isTyping) => {
+        try {
+            connectionRef.current?.sendJson({
+                type: "typing",
+                userId: client.userId,
+                isTyping,
+            });
+        }
+        catch {
+            /* socket not open */
+        }
+    };
+    const editMessage = (messageId, content) => {
+        const tryWsEdit = () => {
+            try {
+                connectionRef.current?.sendJson({
+                    type: "edit",
+                    userId: client.userId,
+                    messageId,
+                    content,
+                });
+            }
+            catch {
+                /* socket not open */
+            }
+        };
+        if (client.isAuthenticated()) {
+            void client.editMessageRest(messageId, content).catch((err) => {
+                // eslint-disable-next-line no-console
+                console.error("[fluxychat] REST editMessage failed, falling back to WS:", err);
+                tryWsEdit();
+            });
+            return;
+        }
+        tryWsEdit();
+    };
+    const sendReaction = (messageId, emoji, op = "add") => {
+        if (client.isAuthenticated()) {
+            void client
+                .sendReactionRest(messageId, emoji, op)
+                .catch((err) => 
+            // eslint-disable-next-line no-console
+            console.error("[fluxychat] REST sendReaction failed, falling back to WS:", err));
+            return;
+        }
+        try {
+            connectionRef.current?.sendJson({
+                type: "reaction",
+                userId: client.userId,
+                messageId,
+                emoji,
+                op,
+            });
+        }
+        catch {
+            /* socket not open */
+        }
+    };
+    const sendReadReceipt = (messageId) => {
+        if (client.isAuthenticated()) {
+            void client
+                .markReadRest(roomId, messageId)
+                .catch((err) => 
+            // eslint-disable-next-line no-console
+            console.error("[fluxychat] REST sendReadReceipt failed, falling back to WS:", err));
+            return;
+        }
+        try {
+            connectionRef.current?.sendJson({
+                type: "read",
+                userId: client.userId,
+                messageId,
+            });
+        }
+        catch {
+            /* socket not open */
+        }
+    };
+    const deleteMessage = (messageId) => {
+        const tryWsDelete = () => {
+            try {
+                connectionRef.current?.sendJson({ type: "delete", messageId });
+            }
+            catch {
+                /* socket not open */
+            }
+        };
+        if (client.isAuthenticated()) {
+            void client.deleteMessageRest(messageId).catch((err) => {
+                // eslint-disable-next-line no-console
+                console.error("[fluxychat] REST deleteMessage failed, falling back to WS:", err);
+                tryWsDelete();
+            });
+            return;
+        }
+        tryWsDelete();
+    };
+    const invokeAgent = async (content, options) => {
+        const targetAgentId = options?.agentId || agentId;
+        if (!targetAgentId) {
+            throw new Error("invokeAgent requires an agentId in hook options or call options");
+        }
+        setAgentTyping(true);
+        try {
+            const result = await client.invokeAgentRest(targetAgentId, roomId, content, {
+                replyTo: options?.replyTo,
+            });
+            return result;
+        }
+        finally {
+            setAgentTyping(false);
+        }
+    };
+    return {
+        messages,
+        online,
+        typingUsers,
+        seenBy,
+        onlineUsers,
+        connected,
+        connectionStatus,
+        reconnectAttempt,
+        connectionError,
+        agentTyping,
+        typingAgentId: wsTypingAgentId ?? invokeTypingAgentId,
+        reactions,
+        sendMessage,
+        setTyping,
+        editMessage,
+        sendReaction,
+        sendReadReceipt,
+        deleteMessage,
+        invokeAgent,
+    };
+}
+export function useRooms(client) {
+    const [rooms, setRooms] = useState([]);
+    const [loading, setLoading] = useState(false);
+    const [error, setError] = useState(null);
+    const load = async () => {
+        setLoading(true);
+        setError(null);
+        try {
+            const next = await client.listRooms();
+            setRooms(next);
+        }
+        catch (e) {
+            setError(e instanceof Error ? e.message : String(e));
+        }
+        finally {
+            setLoading(false);
+        }
+    };
+    useEffect(() => {
+        void load();
+    }, [client]);
+    return { rooms, loading, error, reload: load };
+}