@veroai/chat 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,86 @@
+import { C as ChatEvents, a as CallAction, b as CallType } from './client-C63XKtNw.js';
+export { A as AgentConfig, c as ApiError, d as ApiResponse, e as CallEvent, f as ChatApi, g as ChatClient, h as ChatClientConfig, i as Conversation, j as ConversationType, k as CreateConversationParams, G as GetMessagesParams, M as Message, l as MessageType, N as NewMessageEvent, P as PaginatedMessages, m as Participant, n as PresenceEvent, o as PresenceStatus, R as ReadReceipt, p as ReadReceiptEvent, q as RoomInfo, S as SendMessageParams, T as TypingEvent, U as User, r as UserPresence, W as WebSocketEventType, s as WebSocketMessage } from './client-C63XKtNw.js';
+import EventEmitter from 'eventemitter3';
+
+/**
+ * VeroAI Chat WebSocket Manager
+ *
+ * Handles WebSocket connection, reconnection, and message handling
+ */
+
+interface WebSocketConfig {
+    url: string;
+    getToken: () => string | null | Promise<string | null>;
+    autoReconnect?: boolean;
+    reconnectInterval?: number;
+    maxReconnectAttempts?: number;
+    heartbeatInterval?: number;
+}
+type ConnectionState = 'disconnected' | 'connecting' | 'connected' | 'reconnecting';
+/**
+ * WebSocket connection manager with auto-reconnect
+ */
+declare class WebSocketManager extends EventEmitter<ChatEvents> {
+    private config;
+    private ws;
+    private state;
+    private reconnectAttempts;
+    private reconnectTimer;
+    private heartbeatTimer;
+    private pendingMessages;
+    constructor(config: WebSocketConfig);
+    /**
+     * Get current connection state
+     */
+    getState(): ConnectionState;
+    /**
+     * Check if connected
+     */
+    isConnected(): boolean;
+    /**
+     * Connect to the WebSocket server
+     */
+    connect(): Promise<void>;
+    /**
+     * Disconnect from the WebSocket server
+     */
+    disconnect(): void;
+    /**
+     * Send a message through the WebSocket
+     */
+    send(type: string, payload: unknown): void;
+    /**
+     * Send typing indicator
+     */
+    sendTypingStart(conversationId: string): void;
+    /**
+     * Stop typing indicator
+     */
+    sendTypingStop(conversationId: string): void;
+    /**
+     * Subscribe to a conversation for real-time updates
+     */
+    subscribeToConversation(conversationId: string): void;
+    /**
+     * Unsubscribe from a conversation
+     */
+    unsubscribeFromConversation(conversationId: string): void;
+    /**
+     * Update presence status
+     */
+    updatePresence(status: string, statusMessage?: string): void;
+    /**
+     * Send call notification (ring, accept, reject, end)
+     * Note: Actual WebRTC signaling is handled by LiveKit
+     */
+    sendCallNotification(conversationId: string, action: CallAction, callType?: CallType, roomName?: string): void;
+    private handleClose;
+    private scheduleReconnect;
+    private handleMessage;
+    private flushPendingMessages;
+    private startHeartbeat;
+    private stopHeartbeat;
+    private clearTimers;
+}
+
+export { CallAction, CallType, ChatEvents, WebSocketManager };

package/dist/index.js

@@ -0,0 +1,3 @@
+export { ChatApi, ChatClient, WebSocketManager } from './chunk-JI6KXOLF.js';
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.js"}

package/dist/react/index.d.ts

@@ -0,0 +1,187 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import React from 'react';
+import { g as ChatClient, U as User, i as Conversation, o as PresenceStatus, h as ChatClientConfig, M as Message, S as SendMessageParams } from '../client-C63XKtNw.js';
+import 'eventemitter3';
+
+interface ChatContextValue {
+    /** The ChatClient instance */
+    client: ChatClient | null;
+    /** Whether the WebSocket is connected */
+    isConnected: boolean;
+    /** Current user profile */
+    currentUser: User | null;
+    /** List of conversations */
+    conversations: Conversation[];
+    /** Loading state for conversations */
+    isLoadingConversations: boolean;
+    /** Refresh conversations from server */
+    refreshConversations: () => Promise<void>;
+    /** Connect to WebSocket */
+    connect: () => Promise<void>;
+    /** Disconnect from WebSocket */
+    disconnect: () => void;
+    /** Update current user's status */
+    updateStatus: (status: PresenceStatus, statusMessage?: string) => Promise<void>;
+}
+interface ChatProviderProps {
+    children: React.ReactNode;
+    /** ChatClient configuration */
+    config: ChatClientConfig;
+    /** Auto-fetch conversations on mount */
+    autoFetchConversations?: boolean;
+    /** Auto-fetch current user on mount */
+    autoFetchCurrentUser?: boolean;
+}
+/**
+ * ChatProvider - Provides chat functionality to React components
+ *
+ * @example
+ * ```tsx
+ * function App() {
+ *   return (
+ *     <ChatProvider
+ *       config={{
+ *         apiUrl: 'https://api.veroai.dev',
+ *         wsUrl: 'wss://ws.veroai.dev',
+ *         token: authToken,
+ *       }}
+ *     >
+ *       <ChatApp />
+ *     </ChatProvider>
+ *   );
+ * }
+ * ```
+ */
+declare function ChatProvider({ children, config, autoFetchConversations, autoFetchCurrentUser, }: ChatProviderProps): react_jsx_runtime.JSX.Element;
+/**
+ * useChat - Access chat context
+ *
+ * @example
+ * ```tsx
+ * function ChatList() {
+ *   const { conversations, isConnected } = useChat();
+ *   return <div>{conversations.map(c => <div key={c.id}>{c.name}</div>)}</div>;
+ * }
+ * ```
+ */
+declare function useChat(): ChatContextValue;
+/**
+ * useChatClient - Access the ChatClient instance directly
+ */
+declare function useChatClient(): ChatClient | null;
+
+/**
+ * useConversation Hook
+ *
+ * Manage a single conversation with real-time updates
+ */
+
+interface UseConversationOptions {
+    /** Auto-fetch messages on mount */
+    autoFetchMessages?: boolean;
+    /** Number of messages to fetch initially */
+    initialMessageLimit?: number;
+    /** Auto-subscribe to real-time updates */
+    autoSubscribe?: boolean;
+}
+interface UseConversationReturn {
+    /** The conversation object */
+    conversation: Conversation | null;
+    /** Messages in the conversation */
+    messages: Message[];
+    /** Whether messages are loading */
+    isLoading: boolean;
+    /** Whether more messages are available */
+    hasMore: boolean;
+    /** Users currently typing */
+    typingUsers: string[];
+    /** Send a message */
+    sendMessage: (params: SendMessageParams) => Promise<Message>;
+    /** Send a text message (convenience) */
+    send: (content: string) => Promise<Message>;
+    /** Load more (older) messages */
+    loadMore: () => Promise<void>;
+    /** Refresh messages from server */
+    refresh: () => Promise<void>;
+    /** Mark conversation as read */
+    markAsRead: () => Promise<void>;
+    /** Start typing indicator */
+    startTyping: () => void;
+    /** Stop typing indicator */
+    stopTyping: () => void;
+    /** Error if any */
+    error: Error | null;
+}
+/**
+ * useConversation - Manage a single conversation
+ *
+ * @example
+ * ```tsx
+ * function ChatRoom({ conversationId }) {
+ *   const {
+ *     messages,
+ *     send,
+ *     isLoading,
+ *     typingUsers,
+ *   } = useConversation(conversationId);
+ *
+ *   return (
+ *     <div>
+ *       {messages.map(m => <Message key={m.id} message={m} />)}
+ *       {typingUsers.length > 0 && <div>Someone is typing...</div>}
+ *       <input onKeyDown={(e) => e.key === 'Enter' && send(e.target.value)} />
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useConversation(conversationId: string | undefined, options?: UseConversationOptions): UseConversationReturn;
+
+/**
+ * usePresence Hook
+ *
+ * Track and manage user presence/online status
+ */
+
+interface UsePresenceReturn {
+    /** Online users */
+    onlineUsers: User[];
+    /** Whether loading online users */
+    isLoading: boolean;
+    /** Get presence status for a specific user */
+    getUserStatus: (userId: string) => PresenceStatus;
+    /** Refresh online users list */
+    refresh: () => Promise<void>;
+    /** Error if any */
+    error: Error | null;
+}
+/**
+ * usePresence - Track online users and presence
+ *
+ * @example
+ * ```tsx
+ * function OnlineUsers() {
+ *   const { onlineUsers, getUserStatus } = usePresence();
+ *
+ *   return (
+ *     <div>
+ *       {onlineUsers.map(user => (
+ *         <div key={user.id}>
+ *           {user.firstName} - {getUserStatus(user.id)}
+ *         </div>
+ *       ))}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function usePresence(): UsePresenceReturn;
+/**
+ * useUserPresence - Track presence for a specific user
+ */
+declare function useUserPresence(userId: string | undefined): {
+    status: PresenceStatus;
+    isOnline: boolean;
+};
+
+export { type ChatContextValue, ChatProvider, type ChatProviderProps, type UseConversationOptions, type UseConversationReturn, type UsePresenceReturn, useChat, useChatClient, useConversation, usePresence, useUserPresence };

package/dist/react/index.js

@@ -0,0 +1,371 @@
+import { ChatClient } from '../chunk-JI6KXOLF.js';
+import { createContext, useState, useRef, useEffect, useCallback, useContext } from 'react';
+import { jsx } from 'react/jsx-runtime';
+
+var ChatContext = createContext(null);
+function ChatProvider({
+  children,
+  config,
+  autoFetchConversations = true,
+  autoFetchCurrentUser = true
+}) {
+  const [client, setClient] = useState(null);
+  const [isConnected, setIsConnected] = useState(false);
+  const [currentUser, setCurrentUser] = useState(null);
+  const [conversations, setConversations] = useState([]);
+  const [isLoadingConversations, setIsLoadingConversations] = useState(false);
+  const clientRef = useRef(null);
+  useEffect(() => {
+    const chatClient = new ChatClient({
+      ...config,
+      autoConnect: false
+      // We'll connect manually to handle state
+    });
+    clientRef.current = chatClient;
+    setClient(chatClient);
+    chatClient.on("connected", () => setIsConnected(true));
+    chatClient.on("disconnected", () => setIsConnected(false));
+    chatClient.on("conversation:created", (conv) => {
+      setConversations((prev) => [conv, ...prev]);
+    });
+    chatClient.on("conversation:updated", (conv) => {
+      setConversations(
+        (prev) => prev.map((c) => c.id === conv.id ? conv : c)
+      );
+    });
+    chatClient.on("message:new", ({ conversationId }) => {
+      setConversations(
+        (prev) => prev.map(
+          (c) => c.id === conversationId ? { ...c, lastMessageAt: (/* @__PURE__ */ new Date()).toISOString() } : c
+        )
+      );
+    });
+    if (config.wsUrl && config.autoConnect !== false) {
+      chatClient.connect().catch(console.error);
+    }
+    return () => {
+      chatClient.disconnect();
+      chatClient.removeAllListeners();
+    };
+  }, [config.apiUrl, config.wsUrl, config.token]);
+  useEffect(() => {
+    if (!client || !autoFetchCurrentUser) return;
+    client.getCurrentUser().then(setCurrentUser).catch(console.error);
+  }, [client, autoFetchCurrentUser]);
+  const refreshConversations = useCallback(async () => {
+    if (!client) return;
+    setIsLoadingConversations(true);
+    try {
+      const convs = await client.listConversations();
+      setConversations(convs);
+    } catch (error) {
+      console.error("[ChatProvider] Failed to fetch conversations:", error);
+    } finally {
+      setIsLoadingConversations(false);
+    }
+  }, [client]);
+  useEffect(() => {
+    if (autoFetchConversations && client) {
+      refreshConversations();
+    }
+  }, [autoFetchConversations, client, refreshConversations]);
+  const connect = useCallback(async () => {
+    if (client) {
+      await client.connect();
+    }
+  }, [client]);
+  const disconnect = useCallback(() => {
+    client?.disconnect();
+  }, [client]);
+  const updateStatus = useCallback(
+    async (status, statusMessage) => {
+      if (client) {
+        await client.updateStatus(status, statusMessage);
+        setCurrentUser(
+          (prev) => prev ? { ...prev, status, statusMessage } : prev
+        );
+      }
+    },
+    [client]
+  );
+  const value = {
+    client,
+    isConnected,
+    currentUser,
+    conversations,
+    isLoadingConversations,
+    refreshConversations,
+    connect,
+    disconnect,
+    updateStatus
+  };
+  return /* @__PURE__ */ jsx(ChatContext.Provider, { value, children });
+}
+function useChat() {
+  const context = useContext(ChatContext);
+  if (!context) {
+    throw new Error("useChat must be used within a ChatProvider");
+  }
+  return context;
+}
+function useChatClient() {
+  const { client } = useChat();
+  return client;
+}
+function useConversation(conversationId, options = {}) {
+  const {
+    autoFetchMessages = true,
+    initialMessageLimit = 50,
+    autoSubscribe = true
+  } = options;
+  const { client, conversations } = useChat();
+  const [conversation, setConversation] = useState(null);
+  const [messages, setMessages] = useState([]);
+  const [isLoading, setIsLoading] = useState(false);
+  const [hasMore, setHasMore] = useState(true);
+  const [typingUsers, setTypingUsers] = useState([]);
+  const [error, setError] = useState(null);
+  useEffect(() => {
+    if (!conversationId) {
+      setConversation(null);
+      setMessages([]);
+      return;
+    }
+    const existing = conversations.find((c) => c.id === conversationId);
+    if (existing) {
+      setConversation(existing);
+    } else if (client) {
+      client.getConversation(conversationId).then(setConversation).catch((err) => {
+        setError(err);
+        console.error("[useConversation] Failed to fetch conversation:", err);
+      });
+    }
+  }, [conversationId, conversations, client]);
+  const fetchMessages = useCallback(async (before) => {
+    if (!client || !conversationId) return;
+    setIsLoading(true);
+    setError(null);
+    try {
+      const result = await client.getMessages(conversationId, {
+        limit: initialMessageLimit,
+        before
+      });
+      if (before) {
+        setMessages((prev) => [...prev, ...result.messages]);
+      } else {
+        setMessages(result.messages);
+      }
+      setHasMore(result.hasMore);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error(String(err)));
+      console.error("[useConversation] Failed to fetch messages:", err);
+    } finally {
+      setIsLoading(false);
+    }
+  }, [client, conversationId, initialMessageLimit]);
+  useEffect(() => {
+    if (autoFetchMessages && conversationId && client) {
+      fetchMessages();
+    }
+  }, [autoFetchMessages, conversationId, client, fetchMessages]);
+  useEffect(() => {
+    if (!client || !conversationId || !autoSubscribe) return;
+    client.subscribeToConversation(conversationId);
+    const handleNewMessage = ({ message, conversationId: convId }) => {
+      if (convId === conversationId) {
+        setMessages((prev) => [message, ...prev]);
+      }
+    };
+    const handleMessageUpdated = (message) => {
+      if (message.conversationId === conversationId) {
+        setMessages(
+          (prev) => prev.map((m) => m.id === message.id ? message : m)
+        );
+      }
+    };
+    const handleMessageDeleted = (messageId, convId) => {
+      if (convId === conversationId) {
+        setMessages((prev) => prev.filter((m) => m.id !== messageId));
+      }
+    };
+    const handleTypingStart = ({ conversationId: convId, userId }) => {
+      if (convId === conversationId) {
+        setTypingUsers(
+          (prev) => prev.includes(userId) ? prev : [...prev, userId]
+        );
+      }
+    };
+    const handleTypingStop = ({ conversationId: convId, userId }) => {
+      if (convId === conversationId) {
+        setTypingUsers((prev) => prev.filter((id) => id !== userId));
+      }
+    };
+    client.on("message:new", handleNewMessage);
+    client.on("message:updated", handleMessageUpdated);
+    client.on("message:deleted", handleMessageDeleted);
+    client.on("typing:start", handleTypingStart);
+    client.on("typing:stop", handleTypingStop);
+    return () => {
+      client.unsubscribeFromConversation(conversationId);
+      client.off("message:new", handleNewMessage);
+      client.off("message:updated", handleMessageUpdated);
+      client.off("message:deleted", handleMessageDeleted);
+      client.off("typing:start", handleTypingStart);
+      client.off("typing:stop", handleTypingStop);
+    };
+  }, [client, conversationId, autoSubscribe]);
+  const sendMessage = useCallback(
+    async (params) => {
+      if (!client || !conversationId) {
+        throw new Error("No conversation selected");
+      }
+      return client.sendMessage(conversationId, params);
+    },
+    [client, conversationId]
+  );
+  const send = useCallback(
+    async (content) => {
+      return sendMessage({ content });
+    },
+    [sendMessage]
+  );
+  const loadMore = useCallback(async () => {
+    if (!hasMore || isLoading || messages.length === 0) return;
+    const oldestMessage = messages[messages.length - 1];
+    await fetchMessages(oldestMessage.createdAt);
+  }, [hasMore, isLoading, messages, fetchMessages]);
+  const refresh = useCallback(async () => {
+    setMessages([]);
+    setHasMore(true);
+    await fetchMessages();
+  }, [fetchMessages]);
+  const markAsRead = useCallback(async () => {
+    if (!client || !conversationId) return;
+    await client.markConversationRead(conversationId);
+  }, [client, conversationId]);
+  const startTyping = useCallback(() => {
+    if (conversationId) {
+      client?.sendTypingStart(conversationId);
+    }
+  }, [client, conversationId]);
+  const stopTyping = useCallback(() => {
+    if (conversationId) {
+      client?.sendTypingStop(conversationId);
+    }
+  }, [client, conversationId]);
+  return {
+    conversation,
+    messages,
+    isLoading,
+    hasMore,
+    typingUsers,
+    sendMessage,
+    send,
+    loadMore,
+    refresh,
+    markAsRead,
+    startTyping,
+    stopTyping,
+    error
+  };
+}
+function usePresence() {
+  const { client } = useChat();
+  const [onlineUsers, setOnlineUsers] = useState([]);
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const [presenceMap, setPresenceMap] = useState(/* @__PURE__ */ new Map());
+  const refresh = useCallback(async () => {
+    if (!client) return;
+    setIsLoading(true);
+    setError(null);
+    try {
+      const users = await client.getOnlineUsers();
+      setOnlineUsers(users);
+      const newMap = /* @__PURE__ */ new Map();
+      users.forEach((user) => {
+        if (user.status) {
+          newMap.set(user.id, user.status);
+        }
+      });
+      setPresenceMap(newMap);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error(String(err)));
+      console.error("[usePresence] Failed to fetch online users:", err);
+    } finally {
+      setIsLoading(false);
+    }
+  }, [client]);
+  useEffect(() => {
+    if (client) {
+      refresh();
+    }
+  }, [client, refresh]);
+  useEffect(() => {
+    if (!client) return;
+    const handlePresenceUpdate = ({ userId, status }) => {
+      setPresenceMap((prev) => {
+        const newMap = new Map(prev);
+        newMap.set(userId, status);
+        return newMap;
+      });
+      if (status === "offline") {
+        setOnlineUsers((prev) => prev.filter((u) => u.id !== userId));
+      } else {
+        setOnlineUsers((prev) => {
+          const exists = prev.some((u) => u.id === userId);
+          if (!exists) {
+            refresh();
+          }
+          return prev.map(
+            (u) => u.id === userId ? { ...u, status } : u
+          );
+        });
+      }
+    };
+    client.on("presence:updated", handlePresenceUpdate);
+    return () => {
+      client.off("presence:updated", handlePresenceUpdate);
+    };
+  }, [client, refresh]);
+  const getUserStatus = useCallback(
+    (userId) => {
+      return presenceMap.get(userId) || "offline";
+    },
+    [presenceMap]
+  );
+  return {
+    onlineUsers,
+    isLoading,
+    getUserStatus,
+    refresh,
+    error
+  };
+}
+function useUserPresence(userId) {
+  const { client } = useChat();
+  const [status, setStatus] = useState("offline");
+  useEffect(() => {
+    if (!client || !userId) return;
+    client.getUser(userId).then((user) => {
+      setStatus(user.status || "offline");
+    }).catch(console.error);
+    const handlePresenceUpdate = ({ userId: eventUserId, status: newStatus }) => {
+      if (eventUserId === userId) {
+        setStatus(newStatus);
+      }
+    };
+    client.on("presence:updated", handlePresenceUpdate);
+    return () => {
+      client.off("presence:updated", handlePresenceUpdate);
+    };
+  }, [client, userId]);
+  return {
+    status,
+    isOnline: status !== "offline"
+  };
+}
+
+export { ChatProvider, useChat, useChatClient, useConversation, usePresence, useUserPresence };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map