@fluxy-chat/sdk 0.1.0 → 0.2.1

package/dist/realtime-provider.js

@@ -0,0 +1,131 @@
+"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 { trimTrailingSlashes } from "./url-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: trimTrailingSlashes(workerUrl),
+            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/url-utils.d.ts

@@ -0,0 +1,2 @@
+/** Strip trailing slashes without regex (avoids ReDoS on hostile URLs). */
+export declare function trimTrailingSlashes(url: string): string;

package/dist/url-utils.js

@@ -0,0 +1,7 @@
+/** Strip trailing slashes without regex (avoids ReDoS on hostile URLs). */
+export function trimTrailingSlashes(url) {
+    let out = url;
+    while (out.endsWith("/"))
+        out = out.slice(0, -1);
+    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;
+    }>;
+};