@meshagent/meshagent-react 0.38.2 → 0.38.4

package/dist/cjs/livekit-client.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LivekitClient = exports.LivekitConnectionInfo = void 0;
+const meshagent_1 = require("@meshagent/meshagent");
+class LivekitConnectionInfo {
+    constructor({ url, token }) {
+        Object.defineProperty(this, "url", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "token", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.url = url;
+        this.token = token;
+    }
+}
+exports.LivekitConnectionInfo = LivekitConnectionInfo;
+class LivekitClient {
+    constructor({ room }) {
+        Object.defineProperty(this, "room", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.room = room;
+    }
+    async getConnectionInfo({ breakoutRoom, } = {}) {
+        const response = await this.room.invoke({
+            toolkit: 'livekit',
+            tool: 'connect',
+            input: { breakout_room: breakoutRoom ?? null },
+        });
+        if (!(response instanceof meshagent_1.JsonContent)) {
+            throw new meshagent_1.RoomServerException('unexpected return type from livekit.connect');
+        }
+        const responseJson = response.json;
+        if (typeof responseJson !== 'object'
+            || responseJson == null
+            || Array.isArray(responseJson)) {
+            throw new meshagent_1.RoomServerException('unexpected return type from livekit.connect');
+        }
+        const token = responseJson.token;
+        const url = responseJson.url;
+        if (typeof token !== 'string' || typeof url !== 'string') {
+            throw new meshagent_1.RoomServerException('unexpected return type from livekit.connect');
+        }
+        return new LivekitConnectionInfo({ token, url });
+    }
+}
+exports.LivekitClient = LivekitClient;
+if (!Object.getOwnPropertyDescriptor(meshagent_1.RoomClient.prototype, 'livekit')) {
+    Object.defineProperty(meshagent_1.RoomClient.prototype, 'livekit', {
+        configurable: true,
+        enumerable: false,
+        get() {
+            return new LivekitClient({ room: this });
+        },
+    });
+}

package/dist/cjs/livekit-protocol.d.ts

@@ -0,0 +1,21 @@
+import type { ProtocolChannel } from '@meshagent/meshagent';
+import * as livekit from 'livekit-client';
+export declare class LivekitProtocolChannel implements ProtocolChannel {
+    private readonly room;
+    private readonly remote;
+    private readonly topic;
+    private onDataReceived?;
+    private readonly handleDataReceivedBound;
+    constructor({ room, remote, topic, }: {
+        room: livekit.Room;
+        remote: livekit.RemoteParticipant;
+        topic: string;
+    });
+    start(onDataReceived: (data: Uint8Array) => void, _params: {
+        onDone?: () => void;
+        onError?: (error: unknown) => void;
+    }): void;
+    sendData(data: Uint8Array): Promise<void>;
+    dispose(): void;
+    private handleDataReceived;
+}

package/dist/cjs/livekit-protocol.js

@@ -0,0 +1,97 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LivekitProtocolChannel = void 0;
+const livekit = __importStar(require("livekit-client"));
+class LivekitProtocolChannel {
+    constructor({ room, remote, topic, }) {
+        Object.defineProperty(this, "room", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "remote", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "topic", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "onDataReceived", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "handleDataReceivedBound", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.room = room;
+        this.remote = remote;
+        this.topic = topic;
+        this.handleDataReceivedBound = this.handleDataReceived.bind(this);
+    }
+    start(onDataReceived, _params) {
+        this.onDataReceived = onDataReceived;
+        this.room.on(livekit.RoomEvent.DataReceived, this.handleDataReceivedBound);
+    }
+    async sendData(data) {
+        await this.room.localParticipant.publishData(data, {
+            reliable: true,
+            topic: this.topic,
+            destinationIdentities: [this.remote.identity],
+        });
+    }
+    dispose() {
+        this.room.off(livekit.RoomEvent.DataReceived, this.handleDataReceivedBound);
+        this.onDataReceived = undefined;
+    }
+    handleDataReceived(payload, participant, _kind, topic, _encryptionType) {
+        const identityMatches = participant?.identity === this.remote.identity;
+        if (identityMatches && topic === this.topic) {
+            this.onDataReceived?.(payload);
+        }
+    }
+}
+exports.LivekitProtocolChannel = LivekitProtocolChannel;

package/dist/cjs/room-connection-scope.d.ts

@@ -1,8 +1,5 @@
-import { RoomClient } from '@meshagent/meshagent';
-export interface RoomConnectionInfo {
-    url: string;
-    jwt: string;
-}
+import { type OAuthTokenRequest, RoomClient, type SecretRequest } from '@meshagent/meshagent';
+import type { RoomConnectionInfo } from '@meshagent/meshagent';
 export declare const developmentAuthorization: ({ url, projectId, apiKeyId, participantName, roomName, secret, }: {
     url: string;
     projectId: string;
@@ -11,27 +8,30 @@ export declare const developmentAuthorization: ({ url, projectId, apiKeyId, part
     roomName: string;
     secret: string;
 }) => (() => Promise<RoomConnectionInfo>);
+export declare const staticAuthorization: ({ projectId, roomName, url, jwt, }: {
+    projectId: string;
+    roomName: string;
+    url: string;
+    jwt: string;
+}) => (() => Promise<RoomConnectionInfo>);
 export interface UseRoomConnectionOptions {
-    /** Async function that returns `{ url, jwt }` for the room. */
-    authorization: () => Promise<{
-        url: string;
-        jwt: string;
-    }>;
-    /** Enable the optional messaging layer (default = `true`). */
+    reconnectKey?: string;
+    authorization: () => Promise<RoomConnectionInfo>;
     enableMessaging?: boolean;
+    onReady?: (room: RoomClient) => void;
+    oauthTokenRequestHandler?: (room: RoomClient, request: OAuthTokenRequest) => Promise<void> | void;
+    secretRequestHandler?: (room: RoomClient, request: SecretRequest) => Promise<void> | void;
+    roomClientFactory?: (connectionInfo: RoomConnectionInfo) => RoomClient;
 }
-/**
- * Shape of the object returned by the hook.
- */
 export interface UseRoomConnectionResult {
     client: RoomClient | null;
-    state: 'authorizing' | 'connecting' | 'ready' | 'done';
+    state: 'authorizing' | 'connecting' | 'retrying' | 'ready' | 'done';
     ready: boolean;
     done: boolean;
     error: unknown;
     dispose: () => void;
 }
-export declare function useRoomConnection(props: UseRoomConnectionOptions): UseRoomConnectionResult;
+export declare function useRoomConnection({ reconnectKey, authorization, enableMessaging, onReady, oauthTokenRequestHandler, secretRequestHandler, roomClientFactory, }: UseRoomConnectionOptions): UseRoomConnectionResult;
 export interface UseRoomIndicatorsResult {
     typing: boolean;
     thinking: boolean;

package/dist/cjs/room-connection-scope.js

@@ -1,17 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.developmentAuthorization = void 0;
+exports.staticAuthorization = exports.developmentAuthorization = void 0;
 exports.useRoomConnection = useRoomConnection;
 exports.useRoomIndicators = useRoomIndicators;
 const react_1 = require("react");
-const subscribe_async_gen_1 = require("./subscribe-async-gen");
 const meshagent_1 = require("@meshagent/meshagent");
-const meshagent_2 = require("@meshagent/meshagent");
+const subscribe_async_gen_1 = require("./subscribe-async-gen");
+const retryBaseDelayMs = 500;
+const retryMaxDelayMs = 30000;
+function getRetryDelayMs(retryCount) {
+    return Math.min(retryMaxDelayMs, retryBaseDelayMs * 2 ** retryCount);
+}
+function isRetryableConnectionError(error) {
+    return error instanceof meshagent_1.RoomServerException && error.retryable;
+}
 /* -------------------------------------------------
  * Authorization helpers
  * ------------------------------------------------- */
 const developmentAuthorization = ({ url, projectId, apiKeyId, participantName, roomName, secret, }) => async () => {
-    const token = new meshagent_2.ParticipantToken({
+    const token = new meshagent_1.ParticipantToken({
         name: participantName,
         projectId,
         apiKeyId,
@@ -19,72 +26,171 @@ const developmentAuthorization = ({ url, projectId, apiKeyId, participantName, r
     token.addRoomGrant(roomName);
     token.addRoleGrant('user');
     const jwt = await token.toJwt({ token: secret });
-    return { url, jwt };
+    return {
+        jwt,
+        projectId,
+        roomName,
+        roomUrl: url,
+    };
 };
 exports.developmentAuthorization = developmentAuthorization;
-function useRoomConnection(props) {
-    const { authorization, enableMessaging = true } = props;
+const staticAuthorization = ({ projectId, roomName, url, jwt, }) => async () => ({
+    jwt,
+    projectId,
+    roomName,
+    roomUrl: url,
+});
+exports.staticAuthorization = staticAuthorization;
+function useRoomConnection({ reconnectKey, authorization, enableMessaging = true, onReady, oauthTokenRequestHandler, secretRequestHandler, roomClientFactory, }) {
     const [client, setClient] = (0, react_1.useState)(null);
     const [ready, setReady] = (0, react_1.useState)(false);
     const [state, setState] = (0, react_1.useState)('authorizing');
     const [error, setError] = (0, react_1.useState)(null);
-    // Keep the latest client in a ref so we can call `dispose` in cleanup.
     const clientRef = (0, react_1.useRef)(null);
-    clientRef.current = client;
-    // Instance method exposed to consumers (rarely needed).
-    const dispose = () => {
-        clientRef.current?.dispose();
-        setState('done');
-    };
+    const cancelConnectionRef = (0, react_1.useRef)(() => { });
     (0, react_1.useEffect)(() => {
         let cancelled = false;
-        const connect = async () => {
-            try {
-                // 1️⃣  Get connection credentials
-                const { url, jwt } = await authorization();
-                if (cancelled)
+        let retryTimeout = null;
+        const clearRetryTimeout = () => {
+            if (retryTimeout != null) {
+                clearTimeout(retryTimeout);
+                retryTimeout = null;
+            }
+        };
+        const disposeClient = (room) => {
+            if (room == null) {
+                return;
+            }
+            if (clientRef.current === room) {
+                clientRef.current = null;
+            }
+            room.dispose();
+        };
+        const waitForRetry = (delayMs) => new Promise((resolve) => {
+            retryTimeout = setTimeout(() => {
+                retryTimeout = null;
+                resolve();
+            }, delayMs);
+        });
+        setClient(null);
+        setReady(false);
+        const cancelConnection = ({ updateState }) => {
+            if (cancelled) {
+                return;
+            }
+            cancelled = true;
+            clearRetryTimeout();
+            const currentClient = clientRef.current;
+            clientRef.current = null;
+            disposeClient(currentClient);
+            if (updateState) {
+                setClient(null);
+                setReady(false);
+            }
+        };
+        cancelConnectionRef.current = () => cancelConnection({ updateState: true });
+        void (async () => {
+            let retryCount = 0;
+            while (!cancelled) {
+                let connectionInfo;
+                try {
+                    setState('authorizing');
+                    setError(null);
+                    connectionInfo = await authorization();
+                }
+                catch (nextError) {
+                    if (cancelled) {
+                        return;
+                    }
+                    setError(nextError);
+                    setState('done');
+                    setReady(false);
                     return;
-                const room = new meshagent_2.RoomClient({
-                    protocolFactory: meshagent_2.WebSocketClientProtocol.createFactory({ url, token: jwt }),
-                });
-                setClient(room);
-                setState('connecting');
-                await room.start({
-                    onDone: () => {
-                        if (cancelled)
-                            return;
-                        setState('done');
-                    },
-                    onError: (e) => {
-                        if (cancelled)
-                            return;
-                        setError(e);
-                        setState('done');
-                    },
-                });
-                if (enableMessaging) {
-                    room.messaging.enable();
                 }
-                if (cancelled)
+                if (cancelled) {
                     return;
-                setState('ready');
-                setReady(true);
-            }
-            catch (e) {
-                if (cancelled)
+                }
+                let nextClient;
+                if (roomClientFactory != null) {
+                    nextClient = roomClientFactory(connectionInfo);
+                }
+                else {
+                    nextClient = new meshagent_1.RoomClient({
+                        protocolFactory: meshagent_1.WebSocketClientProtocol.createFactory({
+                            url: connectionInfo.roomUrl,
+                            token: connectionInfo.jwt,
+                        }),
+                        oauthTokenRequestHandler: oauthTokenRequestHandler == null
+                            ? undefined
+                            : (request) => oauthTokenRequestHandler(nextClient, request),
+                        secretRequestHandler: secretRequestHandler == null
+                            ? undefined
+                            : (request) => secretRequestHandler(nextClient, request),
+                    });
+                }
+                clientRef.current = nextClient;
+                setClient(nextClient);
+                setReady(false);
+                setState('connecting');
+                try {
+                    await nextClient.start({
+                        onDone: () => {
+                            if (cancelled || clientRef.current !== nextClient) {
+                                return;
+                            }
+                            setReady(false);
+                            setState('done');
+                        },
+                        onError: (nextError) => {
+                            if (cancelled || clientRef.current !== nextClient) {
+                                return;
+                            }
+                            setError(nextError);
+                            setReady(false);
+                            setState('done');
+                        },
+                    });
+                    if (enableMessaging) {
+                        nextClient.messaging.enable();
+                    }
+                    if (cancelled || clientRef.current !== nextClient) {
+                        disposeClient(nextClient);
+                        return;
+                    }
+                    retryCount = 0;
+                    setError(null);
+                    setReady(true);
+                    setState('ready');
+                    onReady?.(nextClient);
                     return;
-                setError(e);
-                setState('done');
+                }
+                catch (nextError) {
+                    disposeClient(nextClient);
+                    if (cancelled) {
+                        return;
+                    }
+                    setClient((currentClient) => currentClient === nextClient ? null : currentClient);
+                    setReady(false);
+                    setError(nextError);
+                    if (!isRetryableConnectionError(nextError)) {
+                        setState('done');
+                        return;
+                    }
+                    setState('retrying');
+                    await waitForRetry(getRetryDelayMs(retryCount));
+                    retryCount += 1;
+                }
             }
-        };
-        connect();
+        })();
         return () => {
-            // React unmount or deps change → cancel & dispose
-            cancelled = true;
-            dispose();
+            cancelConnection({ updateState: false });
+            cancelConnectionRef.current = () => { };
         };
-        // eslint‑disable‑next‑line react-hooks/exhaustive-deps
-    }, []); // run once, just like componentDidMount
+    }, [reconnectKey, enableMessaging, roomClientFactory]);
+    const dispose = () => {
+        cancelConnectionRef.current();
+        setState('done');
+    };
     return {
         client,
         state,
@@ -100,48 +206,59 @@ function useRoomIndicators({ room, path }) {
     const [typing, setTyping] = (0, react_1.useState)(false);
     const [thinking, setThinking] = (0, react_1.useState)(false);
     (0, react_1.useEffect)(() => {
-        if (!room)
+        if (!room) {
             return;
-        const s = (0, subscribe_async_gen_1.subscribe)(room.listen(), {
+        }
+        setTyping(false);
+        setThinking(false);
+        const subscription = (0, subscribe_async_gen_1.subscribe)(room.listen(), {
             next: (event) => {
-                if (event instanceof meshagent_1.RoomMessageEvent) {
-                    const { message } = event;
-                    // Ignore messages from ourselves
-                    if (message.fromParticipantId === room.localParticipant?.id) {
-                        return;
-                    }
-                    // Ignore messages not for this path
-                    if (message.message.path !== path) {
-                        return;
-                    }
-                    if (message.type === "typing") {
-                        // Clear any existing timer for this participant
-                        clearTimeout(typingMap.current[message.fromParticipantId]);
-                        // Set a new timer to remove typing after 1 second
-                        typingMap.current[message.fromParticipantId] = setTimeout(() => {
-                            delete typingMap.current[message.fromParticipantId];
-                            setTyping(Object.keys(typingMap.current).length > 0);
-                        }, 1000);
-                        // Update typing state
+                if (!(event instanceof meshagent_1.RoomMessageEvent)) {
+                    return;
+                }
+                const { message } = event;
+                if (message.fromParticipantId === room.localParticipant?.id) {
+                    return;
+                }
+                if (message.message.path !== path) {
+                    return;
+                }
+                if (message.type === 'typing') {
+                    clearTimeout(typingMap.current[message.fromParticipantId]);
+                    typingMap.current[message.fromParticipantId] = setTimeout(() => {
+                        delete typingMap.current[message.fromParticipantId];
                         setTyping(Object.keys(typingMap.current).length > 0);
-                    }
-                    else if (message.type === "thinking") {
-                        clearTimeout(thinkingMap.current[message.fromParticipantId]);
-                        if (message.message.thinking) {
-                            thinkingMap.current[message.fromParticipantId] = setTimeout(() => {
-                                delete thinkingMap.current[message.fromParticipantId];
-                                setThinking(Object.keys(thinkingMap.current).length > 0);
-                            }, 5000);
-                        }
-                        else {
-                            delete thinkingMap.current[message.fromParticipantId];
-                        }
+                    }, 1000);
+                    setTyping(Object.keys(typingMap.current).length > 0);
+                    return;
+                }
+                if (message.type !== 'thinking') {
+                    return;
+                }
+                clearTimeout(thinkingMap.current[message.fromParticipantId]);
+                if (message.message.thinking) {
+                    thinkingMap.current[message.fromParticipantId] = setTimeout(() => {
+                        delete thinkingMap.current[message.fromParticipantId];
                         setThinking(Object.keys(thinkingMap.current).length > 0);
-                    }
+                    }, 5000);
+                }
+                else {
+                    delete thinkingMap.current[message.fromParticipantId];
                 }
+                setThinking(Object.keys(thinkingMap.current).length > 0);
             },
         });
-        return () => s.unsubscribe();
-    }, [room, path]);
+        return () => {
+            subscription.unsubscribe();
+            for (const timeout of Object.values(typingMap.current)) {
+                clearTimeout(timeout);
+            }
+            for (const timeout of Object.values(thinkingMap.current)) {
+                clearTimeout(timeout);
+            }
+            typingMap.current = {};
+            thinkingMap.current = {};
+        };
+    }, [path, room]);
     return { typing, thinking };
 }

package/dist/cjs/room-participants.d.ts

@@ -0,0 +1,2 @@
+import { RoomClient, RemoteParticipant } from '@meshagent/meshagent';
+export declare function useRoomParticipants(room: RoomClient | null): RemoteParticipant[];

package/dist/cjs/room-participants.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useRoomParticipants = useRoomParticipants;
+const react_1 = require("react");
+function sameParticipantIds(currentParticipants, nextParticipants) {
+    if (currentParticipants.length !== nextParticipants.length) {
+        return false;
+    }
+    const currentParticipantIds = new Set(currentParticipants.map((participant) => participant.id));
+    for (const participant of nextParticipants) {
+        if (!currentParticipantIds.has(participant.id)) {
+            return false;
+        }
+    }
+    return true;
+}
+function useRoomParticipants(room) {
+    const [participants, setParticipants] = (0, react_1.useState)([]);
+    (0, react_1.useEffect)(() => {
+        if (room == null) {
+            setParticipants([]);
+            return;
+        }
+        const updateParticipants = () => {
+            const nextParticipants = room.messaging.remoteParticipants;
+            setParticipants((currentParticipants) => {
+                if (sameParticipantIds(currentParticipants, nextParticipants)) {
+                    return currentParticipants;
+                }
+                return [...nextParticipants];
+            });
+        };
+        room.messaging.on('participant_added', updateParticipants);
+        room.messaging.on('participant_removed', updateParticipants);
+        room.messaging.on('messaging_enabled', updateParticipants);
+        room.on('disconnected', updateParticipants);
+        updateParticipants();
+        return () => {
+            room.messaging.off('participant_added', updateParticipants);
+            room.messaging.off('participant_removed', updateParticipants);
+            room.messaging.off('messaging_enabled', updateParticipants);
+            room.off('disconnected', updateParticipants);
+        };
+    }, [room]);
+    return participants;
+}

package/dist/esm/client-toolkits.d.ts

@@ -1,8 +1,8 @@
-import { RoomClient, Toolkit } from '@meshagent/meshagent';
+import { RoomClient, Toolkit } from "@meshagent/meshagent";
 interface ClientToolkitsProps {
     room: RoomClient;
     toolkits: Toolkit[];
     public?: boolean;
 }
-export declare const useClientToolkits: ({ room, toolkits, public: isPublic }: ClientToolkitsProps) => void;
+export declare const useClientToolkits: ({ room, toolkits, public: isPublic, }: ClientToolkitsProps) => void;
 export {};