@thrillee/aegischat 0.1.5 → 0.1.6

package/dist/index.js

@@ -285,15 +285,28 @@ var MAX_RECONNECT_ATTEMPTS = 5;
 var MAX_RECONNECT_DELAY = 3e4;
 var PING_INTERVAL = 3e4;
 var SESSION_STORAGE_KEY = "@aegischat/activeChannel";
-function useChat(options) {
-  const { config, role, clientId, initialSession, autoConnect = true, onMessage, onTyping, onConnectionChange } = options;
-  const [session, setSession] = (0, import_react.useState)(initialSession ?? null);
+function useChat(options = {}) {
+  const {
+    config,
+    role,
+    clientId,
+    initialSession,
+    autoConnect = true,
+    onMessage,
+    onTyping,
+    onConnectionChange
+  } = options;
+  const [session, setSession] = (0, import_react.useState)(null);
   const [isConnected, setIsConnected] = (0, import_react.useState)(false);
   const [isConnecting, setIsConnecting] = (0, import_react.useState)(false);
-  const [activeChannelId, setActiveChannelIdState] = (0, import_react.useState)(null);
+  const [activeChannelId, setActiveChannelIdState] = (0, import_react.useState)(
+    null
+  );
   const [channels, setChannels] = (0, import_react.useState)([]);
   const [messages, setMessages] = (0, import_react.useState)([]);
-  const [typingUsers, setTypingUsers] = (0, import_react.useState)({});
+  const [typingUsers, setTypingUsers] = (0, import_react.useState)(
+    {}
+  );
   const [isLoadingChannels, setIsLoadingChannels] = (0, import_react.useState)(false);
   const [isLoadingMessages, setIsLoadingMessages] = (0, import_react.useState)(false);
   const [hasMoreMessages, setHasMoreMessages] = (0, import_react.useState)(true);
@@ -306,23 +319,19 @@ function useChat(options) {
   const isManualDisconnect = (0, import_react.useRef)(false);
   const oldestMessageId = (0, import_react.useRef)(null);
   const activeChannelIdRef = (0, import_react.useRef)(null);
-  const configRef = (0, import_react.useRef)(config);
-  const sessionRef = (0, import_react.useRef)(initialSession ?? null);
-  if (initialSession && !config) {
-    configureApiClient({
-      baseUrl: initialSession.api_url,
-      getAccessToken: async () => sessionRef.current?.access_token || ""
-    });
-  }
-  (0, import_react.useEffect)(() => {
-    configRef.current = config;
-  }, [config]);
+  const sessionRef = (0, import_react.useRef)(null);
+  const roleRef = (0, import_react.useRef)(void 0);
+  const clientIdRef = (0, import_react.useRef)(void 0);
+  const autoConnectRef = (0, import_react.useRef)(true);
+  const onMessageRef = (0, import_react.useRef)(void 0);
+  const onTypingRef = (0, import_react.useRef)(void 0);
+  const onConnectionChangeRef = (0, import_react.useRef)(void 0);
   (0, import_react.useEffect)(() => {
     activeChannelIdRef.current = activeChannelId;
   }, [activeChannelId]);
   (0, import_react.useEffect)(() => {
-    sessionRef.current = initialSession ?? null;
-  }, [initialSession]);
+    activeChannelIdRef.current = activeChannelId;
+  }, [activeChannelId]);
   const getActiveChannelId = (0, import_react.useCallback)(() => {
     if (typeof window === "undefined") return null;
     return sessionStorage.getItem(SESSION_STORAGE_KEY);
@@ -337,26 +346,29 @@ function useChat(options) {
       }
     }
   }, []);
-  const fetchFromComms = (0, import_react.useCallback)(async (path, fetchOptions = {}) => {
-    const currentSession = sessionRef.current;
-    if (!currentSession) {
-      throw new Error("Chat session not initialized");
-    }
-    const response = await fetch(`${currentSession.api_url}${path}`, {
-      ...fetchOptions,
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${currentSession.access_token}`,
-        ...fetchOptions.headers
+  const fetchFromComms = (0, import_react.useCallback)(
+    async (path, fetchOptions = {}) => {
+      const currentSession = sessionRef.current;
+      if (!currentSession) {
+        throw new Error("Chat session not initialized");
       }
-    });
-    if (!response.ok) {
-      const error = await response.json().catch(() => ({}));
-      throw new Error(error.message || `HTTP ${response.status}`);
-    }
-    const data = await response.json();
-    return data.data || data;
-  }, []);
+      const response = await fetch(`${currentSession.api_url}${path}`, {
+        ...fetchOptions,
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${currentSession.access_token}`,
+          ...fetchOptions.headers
+        }
+      });
+      if (!response.ok) {
+        const error = await response.json().catch(() => ({}));
+        throw new Error(error.message || `HTTP ${response.status}`);
+      }
+      const data = await response.json();
+      return data.data || data;
+    },
+    []
+  );
   const clearTimers = (0, import_react.useCallback)(() => {
     if (reconnectTimeout.current) {
       clearTimeout(reconnectTimeout.current);
@@ -367,111 +379,141 @@ function useChat(options) {
       pingInterval.current = null;
     }
   }, []);
-  const handleWebSocketMessage = (0, import_react.useCallback)((data) => {
-    const currentActiveChannelId = activeChannelIdRef.current;
-    console.log("[AegisChat] WebSocket message received:", data.type, data);
-    switch (data.type) {
-      case "message.new": {
-        const newMessage = data.payload;
-        if (newMessage.channel_id === currentActiveChannelId) {
-          setMessages((prev) => {
-            const existingIndex = prev.findIndex(
-              (m) => m.tempId && m.content === newMessage.content && m.status === "sending"
+  const handleWebSocketMessage = (0, import_react.useCallback)(
+    (data) => {
+      const currentActiveChannelId = activeChannelIdRef.current;
+      console.log("[AegisChat] WebSocket message received:", data.type, data);
+      switch (data.type) {
+        case "message.new": {
+          const newMessage = data.payload;
+          if (newMessage.channel_id === currentActiveChannelId) {
+            setMessages((prev) => {
+              const existingIndex = prev.findIndex(
+                (m) => m.tempId && m.content === newMessage.content && m.status === "sending"
+              );
+              if (existingIndex !== -1) {
+                const updated = [...prev];
+                updated[existingIndex] = { ...newMessage, status: "sent" };
+                return updated;
+              }
+              if (prev.some((m) => m.id === newMessage.id)) return prev;
+              return [...prev, { ...newMessage, status: "delivered" }];
+            });
+            onMessageRef.current?.(newMessage);
+          }
+          setChannels((prev) => {
+            const updated = prev.map(
+              (ch) => ch.id === newMessage.channel_id ? {
+                ...ch,
+                last_message: {
+                  id: newMessage.id,
+                  content: newMessage.content,
+                  created_at: newMessage.created_at,
+                  sender: {
+                    id: newMessage.sender_id,
+                    display_name: "Unknown",
+                    status: "online"
+                  }
+                },
+                unread_count: ch.id === currentActiveChannelId ? 0 : ch.unread_count + 1
+              } : ch
             );
-            if (existingIndex !== -1) {
-              const updated = [...prev];
-              updated[existingIndex] = { ...newMessage, status: "sent" };
-              return updated;
-            }
-            if (prev.some((m) => m.id === newMessage.id)) return prev;
-            return [...prev, { ...newMessage, status: "delivered" }];
+            return updated.sort((a, b) => {
+              const timeA = a.last_message?.created_at || "";
+              const timeB = b.last_message?.created_at || "";
+              return timeB.localeCompare(timeA);
+            });
           });
-          onMessage?.(newMessage);
+          break;
         }
-        setChannels((prev) => {
-          const updated = prev.map(
-            (ch) => ch.id === newMessage.channel_id ? {
-              ...ch,
-              last_message: {
-                id: newMessage.id,
-                content: newMessage.content,
-                created_at: newMessage.created_at,
-                sender: { id: newMessage.sender_id, display_name: "Unknown", status: "online" }
-              },
-              unread_count: ch.id === currentActiveChannelId ? 0 : ch.unread_count + 1
-            } : ch
-          );
-          return updated.sort((a, b) => {
-            const timeA = a.last_message?.created_at || "";
-            const timeB = b.last_message?.created_at || "";
-            return timeB.localeCompare(timeA);
-          });
-        });
-        break;
-      }
-      case "message.updated": {
-        const updatedMessage = data.payload;
-        setMessages((prev) => prev.map((m) => m.id === updatedMessage.id ? updatedMessage : m));
-        break;
-      }
-      case "message.deleted": {
-        const { message_id } = data.payload;
-        setMessages((prev) => prev.map((m) => m.id === message_id ? { ...m, deleted: true } : m));
-        break;
-      }
-      case "message.delivered":
-      case "message.read": {
-        const { message_id, channel_id, status } = data.payload;
-        if (channel_id === currentActiveChannelId) {
+        case "message.updated": {
+          const updatedMessage = data.payload;
           setMessages(
-            (prev) => prev.map((m) => m.id === message_id ? { ...m, status: status || "delivered" } : m)
+            (prev) => prev.map((m) => m.id === updatedMessage.id ? updatedMessage : m)
           );
+          break;
         }
-        break;
-      }
-      case "message.delivered.batch":
-      case "message.read.batch": {
-        const { channel_id } = data.payload;
-        if (channel_id === currentActiveChannelId) {
+        case "message.deleted": {
+          const { message_id } = data.payload;
           setMessages(
-            (prev) => prev.map((m) => m.status === "sent" || m.status === "delivered" ? { ...m, status: data.type === "message.delivered.batch" ? "delivered" : "read" } : m)
+            (prev) => prev.map(
+              (m) => m.id === message_id ? { ...m, deleted: true } : m
+            )
           );
+          break;
         }
-        break;
-      }
-      case "typing.start": {
-        const { channel_id, user } = data.payload;
-        const typingUser = {
-          id: user.id,
-          displayName: user.display_name,
-          avatarUrl: user.avatar_url,
-          startedAt: Date.now()
-        };
-        setTypingUsers((prev) => ({
-          ...prev,
-          [channel_id]: [...(prev[channel_id] || []).filter((u) => u.id !== user.id), typingUser]
-        }));
-        onTyping?.(channel_id, typingUser);
-        break;
-      }
-      case "typing.stop": {
-        const { channel_id, user_id } = data.payload;
-        setTypingUsers((prev) => ({
-          ...prev,
-          [channel_id]: (prev[channel_id] || []).filter((u) => u.id !== user_id)
-        }));
-        break;
+        case "message.delivered":
+        case "message.read": {
+          const { message_id, channel_id, status } = data.payload;
+          if (channel_id === currentActiveChannelId) {
+            setMessages(
+              (prev) => prev.map(
+                (m) => m.id === message_id ? {
+                  ...m,
+                  status: status || "delivered"
+                } : m
+              )
+            );
+          }
+          break;
+        }
+        case "message.delivered.batch":
+        case "message.read.batch": {
+          const { channel_id } = data.payload;
+          if (channel_id === currentActiveChannelId) {
+            setMessages(
+              (prev) => prev.map(
+                (m) => m.status === "sent" || m.status === "delivered" ? {
+                  ...m,
+                  status: data.type === "message.delivered.batch" ? "delivered" : "read"
+                } : m
+              )
+            );
+          }
+          break;
+        }
+        case "typing.start": {
+          const { channel_id, user } = data.payload;
+          const typingUser = {
+            id: user.id,
+            displayName: user.display_name,
+            avatarUrl: user.avatar_url,
+            startedAt: Date.now()
+          };
+          setTypingUsers((prev) => ({
+            ...prev,
+            [channel_id]: [
+              ...(prev[channel_id] || []).filter((u) => u.id !== user.id),
+              typingUser
+            ]
+          }));
+          onTypingRef.current?.(channel_id, typingUser);
+          break;
+        }
+        case "typing.stop": {
+          const { channel_id, user_id } = data.payload;
+          setTypingUsers((prev) => ({
+            ...prev,
+            [channel_id]: (prev[channel_id] || []).filter(
+              (u) => u.id !== user_id
+            )
+          }));
+          break;
+        }
+        case "pong":
+          break;
+        default:
+          console.log("[AegisChat] Unhandled message type:", data.type);
       }
-      case "pong":
-        break;
-      default:
-        console.log("[AegisChat] Unhandled message type:", data.type);
-    }
-  }, [onMessage, onTyping]);
+    },
+    []
+  );
   const connectWebSocket = (0, import_react.useCallback)(() => {
     const currentSession = sessionRef.current;
     if (!currentSession?.websocket_url || !currentSession?.access_token) {
-      console.warn("[AegisChat] Cannot connect WebSocket - missing session or token");
+      console.warn(
+        "[AegisChat] Cannot connect WebSocket - missing session or token"
+      );
       return;
     }
     if (wsRef.current?.readyState === WebSocket.OPEN) {
@@ -488,14 +530,19 @@ function useChat(options) {
       setIsConnected(true);
       setIsConnecting(false);
       reconnectAttempts.current = 0;
-      onConnectionChange?.(true);
+      onConnectionChangeRef.current?.(true);
       pingInterval.current = setInterval(() => {
         if (ws.readyState === WebSocket.OPEN) {
           ws.send(JSON.stringify({ type: "ping" }));
         }
       }, PING_INTERVAL);
       if (activeChannelIdRef.current) {
-        ws.send(JSON.stringify({ type: "channel.join", payload: { channel_id: activeChannelIdRef.current } }));
+        ws.send(
+          JSON.stringify({
+            type: "channel.join",
+            payload: { channel_id: activeChannelIdRef.current }
+          })
+        );
       }
     };
     ws.onmessage = (event) => {
@@ -511,9 +558,12 @@ function useChat(options) {
       setIsConnected(false);
       setIsConnecting(false);
       clearTimers();
-      onConnectionChange?.(false);
+      onConnectionChangeRef.current?.(false);
       if (!isManualDisconnect.current && reconnectAttempts.current < MAX_RECONNECT_ATTEMPTS) {
-        const delay = Math.min(RECONNECT_INTERVAL * Math.pow(2, reconnectAttempts.current), MAX_RECONNECT_DELAY);
+        const delay = Math.min(
+          RECONNECT_INTERVAL * Math.pow(2, reconnectAttempts.current),
+          MAX_RECONNECT_DELAY
+        );
         console.log(`[AegisChat] Reconnecting in ${delay}ms...`);
         reconnectTimeout.current = setTimeout(() => {
           reconnectAttempts.current++;
@@ -525,14 +575,18 @@ function useChat(options) {
       console.error("[AegisChat] WebSocket error:", error);
     };
     wsRef.current = ws;
-  }, [clearTimers, handleWebSocketMessage, onConnectionChange]);
+  }, [clearTimers, handleWebSocketMessage]);
   const connect = (0, import_react.useCallback)(async () => {
     console.log("[AegisChat] connect() called");
-    const targetSession = sessionRef.current ?? initialSession;
+    const targetSession = sessionRef.current;
     if (!targetSession) {
       console.log("[AegisChat] No session available, skipping connect");
       return;
     }
+    if (!autoConnectRef.current) {
+      console.log("[AegisChat] autoConnect is false, skipping connect");
+      return;
+    }
     connectWebSocket();
   }, [connectWebSocket]);
   const disconnect = (0, import_react.useCallback)(() => {
@@ -560,48 +614,72 @@ function useChat(options) {
       setIsLoadingChannels(false);
     }
   }, []);
-  const selectChannel = (0, import_react.useCallback)(async (channelId) => {
-    const currentActiveChannelId = activeChannelIdRef.current;
-    setActiveChannelId(channelId);
-    setMessages([]);
-    setHasMoreMessages(true);
-    oldestMessageId.current = null;
-    if (wsRef.current?.readyState === WebSocket.OPEN) {
-      if (currentActiveChannelId) {
-        wsRef.current.send(JSON.stringify({ type: "channel.leave", payload: { channel_id: currentActiveChannelId } }));
+  const selectChannel = (0, import_react.useCallback)(
+    async (channelId) => {
+      const currentActiveChannelId = activeChannelIdRef.current;
+      setActiveChannelId(channelId);
+      setMessages([]);
+      setHasMoreMessages(true);
+      oldestMessageId.current = null;
+      if (wsRef.current?.readyState === WebSocket.OPEN) {
+        if (currentActiveChannelId) {
+          wsRef.current.send(
+            JSON.stringify({
+              type: "channel.leave",
+              payload: { channel_id: currentActiveChannelId }
+            })
+          );
+        }
+        wsRef.current.send(
+          JSON.stringify({
+            type: "channel.join",
+            payload: { channel_id: channelId }
+          })
+        );
       }
-      wsRef.current.send(JSON.stringify({ type: "channel.join", payload: { channel_id: channelId } }));
-    }
-    setIsLoadingMessages(true);
-    try {
-      const response = await fetchFromComms(`/channels/${channelId}/messages?limit=50`);
-      setMessages(response.messages || []);
-      setHasMoreMessages(response.has_more);
-      if (response.oldest_id) {
-        oldestMessageId.current = response.oldest_id;
+      setIsLoadingMessages(true);
+      try {
+        const response = await fetchFromComms(
+          `/channels/${channelId}/messages?limit=50`
+        );
+        setMessages(response.messages || []);
+        setHasMoreMessages(response.has_more);
+        if (response.oldest_id) {
+          oldestMessageId.current = response.oldest_id;
+        }
+        await markAsRead(channelId);
+        setChannels(
+          (prev) => prev.map(
+            (ch) => ch.id === channelId ? { ...ch, unread_count: 0 } : ch
+          )
+        );
+      } catch (error) {
+        console.error("[AegisChat] Failed to load messages:", error);
+        setMessages([]);
+      } finally {
+        setIsLoadingMessages(false);
       }
-      await markAsRead(channelId);
-      setChannels((prev) => prev.map((ch) => ch.id === channelId ? { ...ch, unread_count: 0 } : ch));
-    } catch (error) {
-      console.error("[AegisChat] Failed to load messages:", error);
-      setMessages([]);
-    } finally {
-      setIsLoadingMessages(false);
-    }
-  }, [setActiveChannelId, fetchFromComms]);
-  const markAsRead = (0, import_react.useCallback)(async (channelId) => {
-    try {
-      await fetchFromComms(`/channels/${channelId}/read`, { method: "POST" });
-    } catch (error) {
-      console.error("[AegisChat] Failed to mark as read:", error);
-    }
-  }, [fetchFromComms]);
+    },
+    [setActiveChannelId, fetchFromComms]
+  );
+  const markAsRead = (0, import_react.useCallback)(
+    async (channelId) => {
+      try {
+        await fetchFromComms(`/channels/${channelId}/read`, { method: "POST" });
+      } catch (error) {
+        console.error("[AegisChat] Failed to mark as read:", error);
+      }
+    },
+    [fetchFromComms]
+  );
   const loadMoreMessages = (0, import_react.useCallback)(async () => {
     if (!activeChannelId || !hasMoreMessages || isLoadingMessages) return;
     setIsLoadingMessages(true);
     try {
       const params = oldestMessageId.current ? `?before=${oldestMessageId.current}&limit=50` : "?limit=50";
-      const response = await fetchFromComms(`/channels/${activeChannelId}/messages${params}`);
+      const response = await fetchFromComms(
+        `/channels/${activeChannelId}/messages${params}`
+      );
       setMessages((prev) => [...response.messages || [], ...prev]);
       setHasMoreMessages(response.has_more);
       if (response.oldest_id) {
@@ -613,138 +691,234 @@ function useChat(options) {
       setIsLoadingMessages(false);
     }
   }, [activeChannelId, hasMoreMessages, isLoadingMessages, fetchFromComms]);
-  const sendMessage = (0, import_react.useCallback)(async (content, msgOptions = {}) => {
-    const currentActiveChannelId = activeChannelIdRef.current;
-    const currentSession = sessionRef.current;
-    if (!currentActiveChannelId || !content.trim() || !currentSession) return;
-    const tempId = `temp-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
-    const trimmedContent = content.trim();
-    const optimisticMessage = {
-      id: tempId,
-      tempId,
-      channel_id: currentActiveChannelId,
-      sender_id: currentSession.comms_user_id,
-      content: trimmedContent,
-      type: msgOptions.type || "text",
-      created_at: (/* @__PURE__ */ new Date()).toISOString(),
-      updated_at: (/* @__PURE__ */ new Date()).toISOString(),
-      status: "sending",
-      metadata: msgOptions.metadata || {}
-    };
-    setMessages((prev) => [...prev, optimisticMessage]);
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    setChannels((prev) => {
-      const updated = prev.map(
-        (ch) => ch.id === currentActiveChannelId ? {
-          ...ch,
-          last_message: {
-            id: tempId,
-            content: trimmedContent,
-            created_at: now,
-            sender: { id: currentSession.comms_user_id, display_name: "You", status: "online" }
-          }
-        } : ch
-      );
-      return updated.sort((a, b) => {
-        const timeA = a.last_message?.created_at || "";
-        const timeB = b.last_message?.created_at || "";
-        return timeB.localeCompare(timeA);
-      });
-    });
-    try {
-      await fetchFromComms(`/channels/${currentActiveChannelId}/messages`, {
-        method: "POST",
-        body: JSON.stringify({ content: trimmedContent, type: msgOptions.type || "text", parent_id: msgOptions.parent_id, metadata: msgOptions.metadata })
-      });
-    } catch (error) {
-      console.error("[AegisChat] Failed to send message:", error);
-      setMessages(
-        (prev) => prev.map(
-          (m) => m.tempId === tempId ? { ...m, status: "failed", errorMessage: error instanceof Error ? error.message : "Failed to send" } : m
-        )
-      );
-      throw error;
-    }
-  }, [fetchFromComms]);
-  const uploadFile = (0, import_react.useCallback)(async (file) => {
-    const currentSession = sessionRef.current;
-    if (!currentSession) return null;
-    const fileId = `temp-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
-    setUploadProgress((prev) => [...prev, { fileId, fileName: file.name, progress: 0, status: "pending" }]);
-    try {
-      setUploadProgress((prev) => prev.map((p) => p.fileId === fileId ? { ...p, status: "uploading", progress: 10 } : p));
-      const uploadUrlResponse = await fetchFromComms("/files/upload-url", {
-        method: "POST",
-        body: JSON.stringify({ file_name: file.name, file_type: file.type || "application/octet-stream", file_size: file.size })
-      });
-      setUploadProgress((prev) => prev.map((p) => p.fileId === fileId ? { ...p, fileId: uploadUrlResponse.file_id, progress: 30 } : p));
-      const uploadResponse = await fetch(uploadUrlResponse.upload_url, {
-        method: "PUT",
-        body: file,
-        headers: { "Content-Type": file.type || "application/octet-stream" }
-      });
-      if (!uploadResponse.ok) throw new Error(`Upload failed: ${uploadResponse.statusText}`);
-      setUploadProgress((prev) => prev.map((p) => p.fileId === uploadUrlResponse.file_id ? { ...p, status: "confirming", progress: 70 } : p));
-      const confirmResponse = await fetchFromComms("/files", {
-        method: "POST",
-        body: JSON.stringify({ file_id: uploadUrlResponse.file_id })
+  const sendMessage = (0, import_react.useCallback)(
+    async (content, msgOptions = {}) => {
+      const currentActiveChannelId = activeChannelIdRef.current;
+      const currentSession = sessionRef.current;
+      if (!currentActiveChannelId || !content.trim() || !currentSession) return;
+      const tempId = `temp-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+      const trimmedContent = content.trim();
+      const optimisticMessage = {
+        id: tempId,
+        tempId,
+        channel_id: currentActiveChannelId,
+        sender_id: currentSession.comms_user_id,
+        content: trimmedContent,
+        type: msgOptions.type || "text",
+        created_at: (/* @__PURE__ */ new Date()).toISOString(),
+        updated_at: (/* @__PURE__ */ new Date()).toISOString(),
+        status: "sending",
+        metadata: msgOptions.metadata || {}
+      };
+      setMessages((prev) => [...prev, optimisticMessage]);
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      setChannels((prev) => {
+        const updated = prev.map(
+          (ch) => ch.id === currentActiveChannelId ? {
+            ...ch,
+            last_message: {
+              id: tempId,
+              content: trimmedContent,
+              created_at: now,
+              sender: {
+                id: currentSession.comms_user_id,
+                display_name: "You",
+                status: "online"
+              }
+            }
+          } : ch
+        );
+        return updated.sort((a, b) => {
+          const timeA = a.last_message?.created_at || "";
+          const timeB = b.last_message?.created_at || "";
+          return timeB.localeCompare(timeA);
+        });
       });
-      setUploadProgress((prev) => prev.map((p) => p.fileId === uploadUrlResponse.file_id ? { ...p, status: "complete", progress: 100 } : p));
-      setTimeout(() => setUploadProgress((prev) => prev.filter((p) => p.fileId !== uploadUrlResponse.file_id)), 2e3);
-      return confirmResponse.file;
-    } catch (error) {
-      console.error("[AegisChat] Failed to upload file:", error);
-      setUploadProgress((prev) => prev.map((p) => p.fileId === fileId ? { ...p, status: "error", error: error instanceof Error ? error.message : "Upload failed" } : p));
-      setTimeout(() => setUploadProgress((prev) => prev.filter((p) => p.fileId !== fileId)), 5e3);
-      return null;
-    }
-  }, [fetchFromComms]);
-  const sendMessageWithFiles = (0, import_react.useCallback)(async (content, files, msgOptions = {}) => {
-    const currentActiveChannelId = activeChannelIdRef.current;
-    const currentSession = sessionRef.current;
-    if (!currentActiveChannelId || !content.trim() && files.length === 0 || !currentSession) return;
-    const tempId = `temp-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
-    const trimmedContent = content.trim();
-    const optimisticMessage = {
-      id: tempId,
-      tempId,
-      channel_id: currentActiveChannelId,
-      sender_id: currentSession.comms_user_id,
-      content: trimmedContent || `Uploading ${files.length} file(s)...`,
-      type: "file",
-      created_at: (/* @__PURE__ */ new Date()).toISOString(),
-      updated_at: (/* @__PURE__ */ new Date()).toISOString(),
-      status: "sending",
-      metadata: { ...msgOptions.metadata, files: files.map((f) => ({ id: `temp-${f.name}`, filename: f.name, mime_type: f.type, size: f.size, url: "" })) }
-    };
-    setMessages((prev) => [...prev, optimisticMessage]);
-    try {
-      const uploadedFiles = [];
-      for (const file of files) {
-        const attachment = await uploadFile(file);
-        if (attachment) uploadedFiles.push(attachment);
+      try {
+        await fetchFromComms(
+          `/channels/${currentActiveChannelId}/messages`,
+          {
+            method: "POST",
+            body: JSON.stringify({
+              content: trimmedContent,
+              type: msgOptions.type || "text",
+              parent_id: msgOptions.parent_id,
+              metadata: msgOptions.metadata
+            })
+          }
+        );
+      } catch (error) {
+        console.error("[AegisChat] Failed to send message:", error);
+        setMessages(
+          (prev) => prev.map(
+            (m) => m.tempId === tempId ? {
+              ...m,
+              status: "failed",
+              errorMessage: error instanceof Error ? error.message : "Failed to send"
+            } : m
+          )
+        );
+        throw error;
       }
-      const messageType = uploadedFiles.length > 0 && !trimmedContent ? "file" : "text";
-      await fetchFromComms(`/channels/${currentActiveChannelId}/messages`, {
-        method: "POST",
-        body: JSON.stringify({
-          content: trimmedContent || (uploadedFiles.length > 0 ? `Shared ${uploadedFiles.length} file(s)` : ""),
-          type: msgOptions.type || messageType,
-          parent_id: msgOptions.parent_id,
-          metadata: { ...msgOptions.metadata, files: uploadedFiles },
-          file_ids: uploadedFiles.map((f) => f.id)
-        })
-      });
-    } catch (error) {
-      console.error("[AegisChat] Failed to send message with files:", error);
-      setMessages((prev) => prev.map((m) => m.tempId === tempId ? { ...m, status: "failed", errorMessage: error instanceof Error ? error.message : "Failed to send" } : m));
-      throw error;
-    }
-  }, [fetchFromComms, uploadFile]);
+    },
+    [fetchFromComms]
+  );
+  const uploadFile = (0, import_react.useCallback)(
+    async (file) => {
+      const currentSession = sessionRef.current;
+      if (!currentSession) return null;
+      const fileId = `temp-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+      setUploadProgress((prev) => [
+        ...prev,
+        { fileId, fileName: file.name, progress: 0, status: "pending" }
+      ]);
+      try {
+        setUploadProgress(
+          (prev) => prev.map(
+            (p) => p.fileId === fileId ? { ...p, status: "uploading", progress: 10 } : p
+          )
+        );
+        const uploadUrlResponse = await fetchFromComms("/files/upload-url", {
+          method: "POST",
+          body: JSON.stringify({
+            file_name: file.name,
+            file_type: file.type || "application/octet-stream",
+            file_size: file.size
+          })
+        });
+        setUploadProgress(
+          (prev) => prev.map(
+            (p) => p.fileId === fileId ? { ...p, fileId: uploadUrlResponse.file_id, progress: 30 } : p
+          )
+        );
+        const uploadResponse = await fetch(uploadUrlResponse.upload_url, {
+          method: "PUT",
+          body: file,
+          headers: { "Content-Type": file.type || "application/octet-stream" }
+        });
+        if (!uploadResponse.ok)
+          throw new Error(`Upload failed: ${uploadResponse.statusText}`);
+        setUploadProgress(
+          (prev) => prev.map(
+            (p) => p.fileId === uploadUrlResponse.file_id ? { ...p, status: "confirming", progress: 70 } : p
+          )
+        );
+        const confirmResponse = await fetchFromComms(
+          "/files",
+          {
+            method: "POST",
+            body: JSON.stringify({ file_id: uploadUrlResponse.file_id })
+          }
+        );
+        setUploadProgress(
+          (prev) => prev.map(
+            (p) => p.fileId === uploadUrlResponse.file_id ? { ...p, status: "complete", progress: 100 } : p
+          )
+        );
+        setTimeout(
+          () => setUploadProgress(
+            (prev) => prev.filter((p) => p.fileId !== uploadUrlResponse.file_id)
+          ),
+          2e3
+        );
+        return confirmResponse.file;
+      } catch (error) {
+        console.error("[AegisChat] Failed to upload file:", error);
+        setUploadProgress(
+          (prev) => prev.map(
+            (p) => p.fileId === fileId ? {
+              ...p,
+              status: "error",
+              error: error instanceof Error ? error.message : "Upload failed"
+            } : p
+          )
+        );
+        setTimeout(
+          () => setUploadProgress(
+            (prev) => prev.filter((p) => p.fileId !== fileId)
+          ),
+          5e3
+        );
+        return null;
+      }
+    },
+    [fetchFromComms]
+  );
+  const sendMessageWithFiles = (0, import_react.useCallback)(
+    async (content, files, msgOptions = {}) => {
+      const currentActiveChannelId = activeChannelIdRef.current;
+      const currentSession = sessionRef.current;
+      if (!currentActiveChannelId || !content.trim() && files.length === 0 || !currentSession)
+        return;
+      const tempId = `temp-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+      const trimmedContent = content.trim();
+      const optimisticMessage = {
+        id: tempId,
+        tempId,
+        channel_id: currentActiveChannelId,
+        sender_id: currentSession.comms_user_id,
+        content: trimmedContent || `Uploading ${files.length} file(s)...`,
+        type: "file",
+        created_at: (/* @__PURE__ */ new Date()).toISOString(),
+        updated_at: (/* @__PURE__ */ new Date()).toISOString(),
+        status: "sending",
+        metadata: {
+          ...msgOptions.metadata,
+          files: files.map((f) => ({
+            id: `temp-${f.name}`,
+            filename: f.name,
+            mime_type: f.type,
+            size: f.size,
+            url: ""
+          }))
+        }
+      };
+      setMessages((prev) => [...prev, optimisticMessage]);
+      try {
+        const uploadedFiles = [];
+        for (const file of files) {
+          const attachment = await uploadFile(file);
+          if (attachment) uploadedFiles.push(attachment);
+        }
+        const messageType = uploadedFiles.length > 0 && !trimmedContent ? "file" : "text";
+        await fetchFromComms(
+          `/channels/${currentActiveChannelId}/messages`,
+          {
+            method: "POST",
+            body: JSON.stringify({
+              content: trimmedContent || (uploadedFiles.length > 0 ? `Shared ${uploadedFiles.length} file(s)` : ""),
+              type: msgOptions.type || messageType,
+              parent_id: msgOptions.parent_id,
+              metadata: { ...msgOptions.metadata, files: uploadedFiles },
+              file_ids: uploadedFiles.map((f) => f.id)
+            })
+          }
+        );
+      } catch (error) {
+        console.error("[AegisChat] Failed to send message with files:", error);
+        setMessages(
+          (prev) => prev.map(
+            (m) => m.tempId === tempId ? {
+              ...m,
+              status: "failed",
+              errorMessage: error instanceof Error ? error.message : "Failed to send"
+            } : m
+          )
+        );
+        throw error;
+      }
+    },
+    [fetchFromComms, uploadFile]
+  );
   const stopTyping = (0, import_react.useCallback)(() => {
     const currentActiveChannelId = activeChannelIdRef.current;
     if (!currentActiveChannelId || !wsRef.current) return;
-    wsRef.current.send(JSON.stringify({ type: "typing.stop", payload: { channel_id: currentActiveChannelId } }));
+    wsRef.current.send(
+      JSON.stringify({
+        type: "typing.stop",
+        payload: { channel_id: currentActiveChannelId }
+      })
+    );
     if (typingTimeout.current) {
       clearTimeout(typingTimeout.current);
       typingTimeout.current = null;
@@ -753,46 +927,106 @@ function useChat(options) {
   const startTyping = (0, import_react.useCallback)(() => {
     const currentActiveChannelId = activeChannelIdRef.current;
     if (!currentActiveChannelId || !wsRef.current) return;
-    wsRef.current.send(JSON.stringify({ type: "typing.start", payload: { channel_id: currentActiveChannelId } }));
+    wsRef.current.send(
+      JSON.stringify({
+        type: "typing.start",
+        payload: { channel_id: currentActiveChannelId }
+      })
+    );
     if (typingTimeout.current) clearTimeout(typingTimeout.current);
     typingTimeout.current = setTimeout(stopTyping, TYPING_TIMEOUT);
   }, [stopTyping]);
-  const createDMWithUser = (0, import_react.useCallback)(async (userId) => {
-    try {
-      const channel = await fetchFromComms("/channels/dm", {
-        method: "POST",
-        body: JSON.stringify({ user_id: userId })
-      });
-      await refreshChannels();
-      return channel.id;
-    } catch (error) {
-      console.error("[AegisChat] Failed to create DM:", error);
-      return null;
-    }
-  }, [fetchFromComms, refreshChannels]);
-  const retryMessage = (0, import_react.useCallback)(async (tempId) => {
-    const failedMessage = messages.find((m) => m.tempId === tempId && m.status === "failed");
-    const currentActiveChannelId = activeChannelIdRef.current;
-    if (!failedMessage || !currentActiveChannelId) return;
-    setMessages((prev) => prev.map((m) => m.tempId === tempId ? { ...m, status: "sending", errorMessage: void 0 } : m));
-    try {
-      await fetchFromComms(`/channels/${currentActiveChannelId}/messages`, {
-        method: "POST",
-        body: JSON.stringify({ content: failedMessage.content, type: failedMessage.type, metadata: failedMessage.metadata })
-      });
-    } catch (error) {
-      console.error("[AegisChat] Failed to retry message:", error);
-      setMessages((prev) => prev.map((m) => m.tempId === tempId ? { ...m, status: "failed", errorMessage: error instanceof Error ? error.message : "Failed to send" } : m));
-    }
-  }, [messages, fetchFromComms]);
+  const createDMWithUser = (0, import_react.useCallback)(
+    async (userId) => {
+      try {
+        const channel = await fetchFromComms("/channels/dm", {
+          method: "POST",
+          body: JSON.stringify({ user_id: userId })
+        });
+        await refreshChannels();
+        return channel.id;
+      } catch (error) {
+        console.error("[AegisChat] Failed to create DM:", error);
+        return null;
+      }
+    },
+    [fetchFromComms, refreshChannels]
+  );
+  const retryMessage = (0, import_react.useCallback)(
+    async (tempId) => {
+      const failedMessage = messages.find(
+        (m) => m.tempId === tempId && m.status === "failed"
+      );
+      const currentActiveChannelId = activeChannelIdRef.current;
+      if (!failedMessage || !currentActiveChannelId) return;
+      setMessages(
+        (prev) => prev.map(
+          (m) => m.tempId === tempId ? { ...m, status: "sending", errorMessage: void 0 } : m
+        )
+      );
+      try {
+        await fetchFromComms(
+          `/channels/${currentActiveChannelId}/messages`,
+          {
+            method: "POST",
+            body: JSON.stringify({
+              content: failedMessage.content,
+              type: failedMessage.type,
+              metadata: failedMessage.metadata
+            })
+          }
+        );
+      } catch (error) {
+        console.error("[AegisChat] Failed to retry message:", error);
+        setMessages(
+          (prev) => prev.map(
+            (m) => m.tempId === tempId ? {
+              ...m,
+              status: "failed",
+              errorMessage: error instanceof Error ? error.message : "Failed to send"
+            } : m
+          )
+        );
+      }
+    },
+    [messages, fetchFromComms]
+  );
   const deleteFailedMessage = (0, import_react.useCallback)((tempId) => {
     setMessages((prev) => prev.filter((m) => m.tempId !== tempId));
   }, []);
+  const setup = (0, import_react.useCallback)((options2) => {
+    const {
+      config: config2,
+      role: role2,
+      clientId: clientId2,
+      initialSession: initialSession2,
+      autoConnect: autoConnect2 = true,
+      onMessage: onMessage2,
+      onTyping: onTyping2,
+      onConnectionChange: onConnectionChange2
+    } = options2;
+    roleRef.current = role2;
+    clientIdRef.current = clientId2;
+    autoConnectRef.current = autoConnect2;
+    onMessageRef.current = onMessage2;
+    onTypingRef.current = onTyping2;
+    onConnectionChangeRef.current = onConnectionChange2;
+    if (initialSession2) {
+      sessionRef.current = initialSession2;
+      if (!config2) {
+        configureApiClient({
+          baseUrl: initialSession2.api_url,
+          getAccessToken: async () => sessionRef.current?.access_token || ""
+        });
+      }
+      setSession(initialSession2);
+    }
+  }, []);
   (0, import_react.useEffect)(() => {
-    if (initialSession && !isConnected && !isConnecting && autoConnect) {
+    if (session && !isConnected && !isConnecting && autoConnectRef.current) {
       connectWebSocket();
     }
-  }, [initialSession, session, isConnected, isConnecting, autoConnect, connectWebSocket]);
+  }, [session, isConnected, isConnecting, connectWebSocket]);
   (0, import_react.useEffect)(() => {
     if (wsRef.current && wsRef.current.readyState === WebSocket.OPEN) {
       wsRef.current.onmessage = (event) => {
@@ -800,7 +1034,10 @@ function useChat(options) {
           const data = JSON.parse(event.data);
           handleWebSocketMessage(data);
         } catch (error) {
-          console.error("[AegisChat] Failed to parse WebSocket message:", error);
+          console.error(
+            "[AegisChat] Failed to parse WebSocket message:",
+            error
+          );
         }
       };
     }
@@ -852,7 +1089,8 @@ function useChat(options) {
     createDMWithUser,
     retryMessage,
     deleteFailedMessage,
-    markAsRead
+    markAsRead,
+    setup
   };
 }