@fluxy-chat/sdk 0.1.0 → 0.2.0

package/dist/realtime-provider.js

@@ -0,0 +1,130 @@
+"use client";
+import { jsx as _jsx } from "react/jsx-runtime";
+import React from "react";
+import { FluxyChatClient } from "./index";
+import { decodeFluxyJwtPayload, jwtRefreshDelayMs } from "./jwt-utils";
+import { FluxyRealtimeContext } from "./use-fluxy-chat";
+async function resolveAuthToken(provider) {
+    if (typeof provider === "string") {
+        return { token: provider };
+    }
+    const result = await provider();
+    if (typeof result === "string") {
+        return { token: result };
+    }
+    return result;
+}
+async function fetchConnectSession(connectUrl, init) {
+    const res = await fetch(connectUrl, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...(init?.headers ?? {}) },
+        body: JSON.stringify({}),
+        ...init,
+    });
+    const data = (await res.json().catch(() => ({})));
+    if (!res.ok) {
+        throw new Error(data.error ?? `Connect failed (${res.status})`);
+    }
+    if (!data.memberJwt?.trim()) {
+        throw new Error("Connect response did not include memberJwt");
+    }
+    return {
+        token: data.memberJwt,
+        userId: data.memberUserId,
+    };
+}
+export function FluxyRealtimeProvider({ children, workerUrl, authTokenProvider, connectUrl, connectRequestInit, userId: userIdProp, refreshBufferMs = 5 * 60 * 1000, onSessionError, }) {
+    const [token, setToken] = React.useState(null);
+    const [userId, setUserId] = React.useState(userIdProp ?? "");
+    const [refreshKey, setRefreshKey] = React.useState(0);
+    const isRefreshingRef = React.useRef(false);
+    const providerRef = React.useRef(authTokenProvider);
+    const connectUrlRef = React.useRef(connectUrl);
+    const connectInitRef = React.useRef(connectRequestInit);
+    React.useEffect(() => {
+        providerRef.current = authTokenProvider;
+    });
+    React.useEffect(() => {
+        connectUrlRef.current = connectUrl;
+    });
+    React.useEffect(() => {
+        connectInitRef.current = connectRequestInit;
+    });
+    React.useEffect(() => {
+        if (userIdProp)
+            setUserId(userIdProp);
+    }, [userIdProp]);
+    const refreshSession = React.useCallback(() => {
+        if (isRefreshingRef.current)
+            return;
+        setRefreshKey((k) => k + 1);
+    }, []);
+    React.useEffect(() => {
+        if (!authTokenProvider && !connectUrlRef.current)
+            return;
+        let cancelled = false;
+        let timer = null;
+        const run = async () => {
+            isRefreshingRef.current = true;
+            try {
+                let session;
+                if (connectUrlRef.current) {
+                    session = await fetchConnectSession(connectUrlRef.current, connectInitRef.current);
+                }
+                else if (providerRef.current) {
+                    session = await resolveAuthToken(providerRef.current);
+                }
+                else {
+                    return;
+                }
+                if (cancelled)
+                    return;
+                setToken(session.token);
+                const claims = decodeFluxyJwtPayload(session.token);
+                const resolvedUserId = session.userId ?? claims.sub ?? userIdProp ?? "";
+                if (resolvedUserId)
+                    setUserId(resolvedUserId);
+                if (claims.exp && typeof providerRef.current !== "string") {
+                    const delay = jwtRefreshDelayMs(claims.exp, refreshBufferMs);
+                    timer = setTimeout(() => {
+                        if (!cancelled)
+                            run();
+                    }, delay);
+                }
+            }
+            catch (err) {
+                const error = err instanceof Error ? err : new Error(String(err));
+                onSessionError?.(error);
+            }
+            finally {
+                if (!cancelled)
+                    isRefreshingRef.current = false;
+            }
+        };
+        void run();
+        return () => {
+            cancelled = true;
+            isRefreshingRef.current = false;
+            if (timer)
+                clearTimeout(timer);
+        };
+    }, [authTokenProvider, connectUrl, connectRequestInit, refreshBufferMs, refreshKey, userIdProp, onSessionError]);
+    const client = React.useMemo(() => {
+        if (!token?.trim() || !userId.trim())
+            return null;
+        return new FluxyChatClient({
+            baseUrl: workerUrl.replace(/\/+$/, ""),
+            userId,
+            token,
+        });
+    }, [workerUrl, userId, token]);
+    const value = React.useMemo(() => ({
+        client,
+        userId,
+        token,
+        workerUrl,
+        ready: Boolean(client),
+        refreshSession,
+    }), [client, userId, token, workerUrl, refreshSession]);
+    return _jsx(FluxyRealtimeContext.Provider, { value: value, children: children });
+}

package/dist/room-rest.d.ts

@@ -0,0 +1,4 @@
+import type { FluxyRoomMember } from "./index";
+export declare const FLUXY_MAX_MESSAGE_LENGTH = 4000;
+export declare function normalizeRoomMember(raw: Record<string, unknown>): FluxyRoomMember | null;
+export declare function normalizeRoomMembers(rows: unknown[]): FluxyRoomMember[];

package/dist/room-rest.js

@@ -0,0 +1,24 @@
+export const FLUXY_MAX_MESSAGE_LENGTH = 4000;
+export function normalizeRoomMember(raw) {
+    const userId = String(raw.userId ?? raw.user_id ?? "").trim();
+    if (!userId)
+        return null;
+    const role = String(raw.role ?? "member").trim() || "member";
+    const joined_at = typeof raw.joined_at === "string"
+        ? raw.joined_at
+        : typeof raw.joinedAt === "string"
+            ? raw.joinedAt
+            : undefined;
+    return { userId, role, joined_at };
+}
+export function normalizeRoomMembers(rows) {
+    const out = [];
+    for (const row of rows) {
+        if (!row || typeof row !== "object")
+            continue;
+        const member = normalizeRoomMember(row);
+        if (member)
+            out.push(member);
+    }
+    return out;
+}

package/dist/use-chat.d.ts

@@ -0,0 +1,49 @@
+import type { FluxyChatAttachment, FluxyChatClient, FluxyChatMessage } from "./index";
+export interface UseChatOptions {
+    roomId: string;
+    /** Omit when wrapped in `FluxyRealtimeProvider`. */
+    client?: FluxyChatClient;
+    agentId?: string;
+    /** Initial REST page size (default 50). */
+    historyLimit?: number;
+}
+export declare function useChat({ roomId, client: clientProp, agentId, historyLimit }: UseChatOptions): {
+    messages: FluxyChatMessage[];
+    hasMore: boolean;
+    isLoadingMore: boolean;
+    loadMore: () => Promise<void>;
+    online: number;
+    typingUsers: Record<string, boolean>;
+    seenBy: Record<number, string[]>;
+    onlineUsers: string[];
+    connected: boolean;
+    connectionStatus: "connecting" | "connected" | "reconnecting" | "disconnected" | "polling" | "sse";
+    reconnectAttempt: number;
+    connectionError: Error | null;
+    agentTyping: boolean;
+    typingAgentId: string | null;
+    reactions: Record<number, Record<string, number>>;
+    sendMessage: (content: string, replyTo?: number | null, attachments?: FluxyChatAttachment[]) => void;
+    setTyping: (isTyping: boolean) => void;
+    editMessage: (messageId: number, content: string) => void;
+    sendReaction: (messageId: number, emoji: string, op?: "add" | "remove") => void;
+    sendReadReceipt: (messageId: number) => void;
+    deleteMessage: (messageId: number) => void;
+    invokeAgent: (content: string, options?: {
+        agentId?: string;
+        replyTo?: number | null;
+    }) => Promise<{
+        run: {
+            id: string;
+            status: string;
+            latencyMs?: number;
+            inputTokens?: number;
+            outputTokens?: number;
+            estimatedCost?: number;
+            iterations?: number;
+            toolCalls?: import("./index").FluxyChatToolCall[];
+            createdAt: string;
+        };
+        message: FluxyChatMessage;
+    }>;
+};

package/dist/use-chat.js

@@ -0,0 +1,482 @@
+"use client";
+import React from "react";
+import { FluxyAuthError, FluxySendError } from "./errors";
+import { mergeMessagesChronological, sortMessagesChronological, } from "./message-history";
+import { useFluxyChatOptional } from "./use-fluxy-chat";
+export function useChat({ roomId, client: clientProp, agentId, historyLimit = 50 }) {
+    const realtime = useFluxyChatOptional();
+    const client = clientProp ?? realtime?.client ?? null;
+    const [messages, setMessages] = React.useState([]);
+    const [hasMore, setHasMore] = React.useState(false);
+    const [isLoadingMore, setIsLoadingMore] = React.useState(false);
+    const [online, setOnline] = React.useState(0);
+    const [typingUsers, setTypingUsers] = React.useState({});
+    const [seenBy, setSeenBy] = React.useState({});
+    const [onlineUsers, setOnlineUsers] = React.useState([]);
+    const [connected, setConnected] = React.useState(false);
+    const [connectionStatus, setConnectionStatus] = React.useState("connecting");
+    const [reconnectAttempt, setReconnectAttempt] = React.useState(0);
+    const [connectionError, setConnectionError] = React.useState(null);
+    const [agentTyping, setAgentTyping] = React.useState(false);
+    const [wsTypingAgentId, setWsTypingAgentId] = React.useState(null);
+    const [invokeTypingAgentId, setInvokeTypingAgentId] = React.useState(null);
+    const [reactions, setReactions] = React.useState({});
+    const connectionRef = React.useRef(null);
+    const sseRef = React.useRef(null);
+    const pollTimerRef = React.useRef(null);
+    const loadMore = React.useCallback(async () => {
+        if (!client || isLoadingMore || !hasMore)
+            return;
+        const trimmedRoomId = roomId.trim();
+        if (!trimmedRoomId)
+            return;
+        const chronological = sortMessagesChronological(messages);
+        const oldest = chronological[0];
+        if (!oldest?.createdAt)
+            return;
+        setIsLoadingMore(true);
+        try {
+            const older = await client.fetchMessages(trimmedRoomId, {
+                limit: historyLimit,
+                before: oldest.createdAt,
+            });
+            setMessages((prev) => mergeMessagesChronological(prev, older));
+            setHasMore(older.length >= historyLimit);
+        }
+        catch {
+            /* keep existing list */
+        }
+        finally {
+            setIsLoadingMore(false);
+        }
+    }, [client, hasMore, historyLimit, isLoadingMore, messages, roomId]);
+    React.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 = () => {
+            if (!client)
+                return;
+            stopPollingFallback();
+            stopSSEFallback();
+            const tick = async () => {
+                if (!active || !client)
+                    return;
+                try {
+                    const next = await client.fetchMessages(trimmedRoomId, { limit: historyLimit });
+                    if (active) {
+                        setMessages(next);
+                        setHasMore(next.length >= historyLimit);
+                    }
+                }
+                catch {
+                    /* ignore transient poll errors */
+                }
+            };
+            void tick();
+            pollTimerRef.current = setInterval(tick, POLL_INTERVAL_MS);
+        };
+        const startSSEFallback = () => {
+            if (!client)
+                return;
+            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((prev) => mergeMessagesChronological(prev, sortMessagesChronological(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 sortMessagesChronological(next);
+                    }
+                    return sortMessagesChronological([...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 (!client || !trimmedRoomId || !client.isAuthenticated()) {
+            setMessages([]);
+            setHasMore(false);
+            setConnected(false);
+            setConnectionStatus("disconnected");
+            return () => {
+                active = false;
+                stopPollingFallback();
+                stopSSEFallback();
+                connectionRef.current?.close();
+                connectionRef.current = null;
+            };
+        }
+        client
+            .fetchMessages(trimmedRoomId, { limit: historyLimit })
+            .then((initial) => {
+            if (!active)
+                return;
+            setMessages(initial);
+            setHasMore(initial.length >= historyLimit);
+        })
+            .catch(() => {
+            /* history load is best-effort until member JWT + room are ready */
+        });
+        const connection = client.connectRoom(trimmedRoomId, {
+            maxReconnectAttempts: MAX_WS_RECONNECT_ATTEMPTS,
+            historyLimit,
+            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");
+                realtime?.refreshSession();
+            },
+            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, historyLimit, realtime?.refreshSession]);
+    const sendMessage = (content, replyTo, attachments) => {
+        if (!client)
+            return;
+        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) => {
+        if (!client)
+            return;
+        try {
+            connectionRef.current?.sendJson({
+                type: "typing",
+                userId: client.userId,
+                isTyping,
+            });
+        }
+        catch {
+            /* socket not open */
+        }
+    };
+    const editMessage = (messageId, content) => {
+        if (!client)
+            return;
+        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)
+            return;
+        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)
+            return;
+        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) => {
+        if (!client)
+            return;
+        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) => {
+        if (!client) {
+            throw new Error("useChat requires a FluxyChatClient or FluxyRealtimeProvider");
+        }
+        const targetAgentId = options?.agentId || agentId;
+        if (!targetAgentId) {
+            throw new Error("invokeAgent requires an agentId in hook options or call options");
+        }
+        setAgentTyping(true);
+        try {
+            return await client.invokeAgentRest(targetAgentId, roomId, content, {
+                replyTo: options?.replyTo,
+            });
+        }
+        finally {
+            setAgentTyping(false);
+        }
+    };
+    return {
+        messages,
+        hasMore,
+        isLoadingMore,
+        loadMore,
+        online,
+        typingUsers,
+        seenBy,
+        onlineUsers,
+        connected,
+        connectionStatus,
+        reconnectAttempt,
+        connectionError,
+        agentTyping,
+        typingAgentId: wsTypingAgentId ?? invokeTypingAgentId,
+        reactions,
+        sendMessage,
+        setTyping,
+        editMessage,
+        sendReaction,
+        sendReadReceipt,
+        deleteMessage,
+        invokeAgent,
+    };
+}