@solveo-ai/react-native 0.1.0 → 0.1.1

package/dist/index.mjs

@@ -0,0 +1,822 @@
+import React, { createContext, useMemo, useState, useEffect, useContext, useCallback } from 'react';
+import { SolveoSDK, createCustomerSocket, CustomerSocketManager, createAgentSocket, AgentSocketManager, createStreamingSocket } from '@solveo-ai/sdk-core';
+import AsyncStorage from '@react-native-async-storage/async-storage';
+import { Platform } from 'react-native';
+
+// src/SolveoProvider.tsx
+var SolveoContext = createContext(null);
+function SolveoProvider({ children, config }) {
+  const sdk = useMemo(
+    () => new SolveoSDK({
+      ...config,
+      platform: "react-native"
+    }),
+    [config.apiUrl, config.apiKey, config.token, config.widgetId]
+  );
+  const [customerSocket, setCustomerSocket] = useState(null);
+  const [customerSocketManager, setCustomerSocketManager] = useState(null);
+  const [agentSocket, setAgentSocket] = useState(null);
+  const [agentSocketManager, setAgentSocketManager] = useState(null);
+  const [streamingSocket, setStreamingSocket] = useState(null);
+  const connectCustomerSocket = (conversationId) => {
+    if (customerSocket) {
+      customerSocket.disconnect();
+    }
+    const socket = createCustomerSocket(config.apiUrl, conversationId);
+    const manager = new CustomerSocketManager(socket);
+    setCustomerSocket(socket);
+    setCustomerSocketManager(manager);
+    socket.connect();
+  };
+  const disconnectCustomerSocket = () => {
+    if (customerSocket) {
+      customerSocket.disconnect();
+      setCustomerSocket(null);
+      setCustomerSocketManager(null);
+    }
+  };
+  const connectAgentSocket = (token) => {
+    if (agentSocket) {
+      agentSocket.disconnect();
+    }
+    const socket = createAgentSocket(config.apiUrl, token);
+    const manager = new AgentSocketManager(socket);
+    setAgentSocket(socket);
+    setAgentSocketManager(manager);
+    socket.connect();
+  };
+  const disconnectAgentSocket = () => {
+    if (agentSocket) {
+      agentSocket.disconnect();
+      setAgentSocket(null);
+      setAgentSocketManager(null);
+    }
+  };
+  const connectStreamingSocket = (conversationId) => {
+    if (streamingSocket) {
+      streamingSocket.disconnect();
+    }
+    const socket = createStreamingSocket(config.apiUrl, conversationId);
+    setStreamingSocket(socket);
+    socket.connect();
+  };
+  const disconnectStreamingSocket = () => {
+    if (streamingSocket) {
+      streamingSocket.disconnect();
+      setStreamingSocket(null);
+    }
+  };
+  useEffect(() => {
+    if (config.autoConnectCustomer && config.conversationId) {
+      connectCustomerSocket(config.conversationId);
+    }
+    if (config.autoConnectAgent && config.token) {
+      connectAgentSocket(config.token);
+    }
+    return () => {
+      disconnectCustomerSocket();
+      disconnectAgentSocket();
+      disconnectStreamingSocket();
+    };
+  }, [config.autoConnectCustomer, config.autoConnectAgent, config.conversationId, config.token]);
+  const value = {
+    sdk,
+    config,
+    customerSocket,
+    customerSocketManager,
+    agentSocket,
+    agentSocketManager,
+    streamingSocket,
+    connectCustomerSocket,
+    disconnectCustomerSocket,
+    connectAgentSocket,
+    disconnectAgentSocket,
+    connectStreamingSocket,
+    disconnectStreamingSocket
+  };
+  return /* @__PURE__ */ React.createElement(SolveoContext.Provider, { value }, children);
+}
+function useSolveo() {
+  const context = useContext(SolveoContext);
+  if (!context) {
+    throw new Error("useSolveo must be used within a SolveoProvider");
+  }
+  return context;
+}
+var STORAGE_KEYS = {
+  CONVERSATION_ID: "@solveo/conversation_id",
+  MESSAGES: "@solveo/messages",
+  USER_IDENTITY: "@solveo/user_identity",
+  WIDGET_CONFIG: "@solveo/widget_config"
+};
+var storage = {
+  async getConversationId() {
+    return AsyncStorage.getItem(STORAGE_KEYS.CONVERSATION_ID);
+  },
+  async setConversationId(id) {
+    await AsyncStorage.setItem(STORAGE_KEYS.CONVERSATION_ID, id);
+  },
+  async clearConversationId() {
+    await AsyncStorage.removeItem(STORAGE_KEYS.CONVERSATION_ID);
+  },
+  async getMessages(conversationId) {
+    const data = await AsyncStorage.getItem(`${STORAGE_KEYS.MESSAGES}_${conversationId}`);
+    return data ? JSON.parse(data) : [];
+  },
+  async setMessages(conversationId, messages) {
+    await AsyncStorage.setItem(`${STORAGE_KEYS.MESSAGES}_${conversationId}`, JSON.stringify(messages));
+  },
+  async getUserIdentity() {
+    const data = await AsyncStorage.getItem(STORAGE_KEYS.USER_IDENTITY);
+    return data ? JSON.parse(data) : null;
+  },
+  async setUserIdentity(identity) {
+    await AsyncStorage.setItem(STORAGE_KEYS.USER_IDENTITY, JSON.stringify(identity));
+  },
+  async getWidgetConfig(widgetId) {
+    const data = await AsyncStorage.getItem(`${STORAGE_KEYS.WIDGET_CONFIG}_${widgetId}`);
+    return data ? JSON.parse(data) : null;
+  },
+  async setWidgetConfig(widgetId, config) {
+    await AsyncStorage.setItem(`${STORAGE_KEYS.WIDGET_CONFIG}_${widgetId}`, JSON.stringify(config));
+  }
+};
+
+// src/hooks/useChat.ts
+function useChat(options = {}) {
+  const { sdk, config, streamingSocket, connectStreamingSocket } = useSolveo();
+  const [conversation, setConversation] = useState(null);
+  const [messages, setMessages] = useState([]);
+  const [isLoading, setIsLoading] = useState(false);
+  const [isStreaming, setIsStreaming] = useState(false);
+  const [streamingContent, setStreamingContent] = useState("");
+  const [error, setError] = useState(null);
+  useEffect(() => {
+    if (options.persistConversation) {
+      loadPersistedConversation();
+    }
+  }, [options.persistConversation]);
+  useEffect(() => {
+    if (!streamingSocket || !conversation) return;
+    const handleMessage = (msg) => {
+      if (msg.type === "agent_typing") {
+        setIsStreaming(true);
+        setStreamingContent("");
+      } else if (msg.type === "agent_message_chunk") {
+        setStreamingContent((prev) => prev + (msg.content || ""));
+      } else if (msg.type === "agent_message_complete") {
+        setIsStreaming(false);
+        if (msg.message_id) {
+          loadMessages(conversation.id);
+        }
+      }
+    };
+    const handleError = (err) => {
+      setError(new Error(err.message || "Streaming error"));
+      setIsStreaming(false);
+    };
+    streamingSocket.on("message", handleMessage);
+    streamingSocket.on("error", handleError);
+    return () => {
+      streamingSocket.off("message", handleMessage);
+      streamingSocket.off("error", handleError);
+    };
+  }, [streamingSocket, conversation]);
+  const loadPersistedConversation = async () => {
+    try {
+      const convId = await storage.getConversationId();
+      if (convId) {
+        const conv = await sdk.widgetConversations.get(convId);
+        setConversation(conv);
+        await loadMessages(convId);
+      }
+    } catch (err) {
+      console.error("Failed to load persisted conversation:", err);
+    }
+  };
+  const createConversation = useCallback(async () => {
+    setIsLoading(true);
+    setError(null);
+    try {
+      const identity = await storage.getUserIdentity();
+      const conv = await sdk.widgetConversations.create({
+        widget_id: options.widgetId || config.widgetId,
+        agent_id: options.agentId,
+        customer_email: identity?.email || config.user?.email,
+        customer_name: identity?.name || config.user?.name
+      });
+      setConversation(conv);
+      if (options.persistConversation) {
+        await storage.setConversationId(conv.id);
+      }
+      connectStreamingSocket(conv.id);
+      return conv;
+    } catch (err) {
+      setError(err);
+      throw err;
+    } finally {
+      setIsLoading(false);
+    }
+  }, [sdk, options, config]);
+  const loadMessages = useCallback(async (conversationId) => {
+    try {
+      const msgs = await sdk.widgetMessages.list(conversationId);
+      setMessages(msgs);
+      if (options.persistConversation) {
+        await storage.setMessages(conversationId, msgs);
+      }
+    } catch (err) {
+      setError(err);
+    }
+  }, [sdk, options]);
+  const sendMessage = useCallback(async (content) => {
+    if (!conversation) {
+      throw new Error("No active conversation");
+    }
+    setIsLoading(true);
+    setError(null);
+    try {
+      if (streamingSocket?.isConnected()) {
+        streamingSocket.sendMessage(content);
+      } else {
+        const response = await sdk.widgetMessages.send(conversation.id, { content });
+        setMessages((prev) => [...prev, response.message, response.ai_response].filter(Boolean));
+      }
+    } catch (err) {
+      setError(err);
+      throw err;
+    } finally {
+      setIsLoading(false);
+    }
+  }, [conversation, streamingSocket, sdk]);
+  const submitFeedback = useCallback(async (messageId, rating) => {
+    if (!conversation) return;
+    try {
+      await sdk.widgetMessages.submitFeedback(conversation.id, messageId, rating);
+    } catch (err) {
+      setError(err);
+    }
+  }, [conversation, sdk]);
+  return {
+    conversation,
+    messages,
+    isLoading,
+    isStreaming,
+    streamingContent,
+    error,
+    createConversation,
+    sendMessage,
+    loadMessages,
+    submitFeedback
+  };
+}
+function useRealtime() {
+  const { customerSocketManager } = useSolveo();
+  const [isConnected, setIsConnected] = useState(false);
+  const [agentTyping, setAgentTyping] = useState(false);
+  const [queuePosition, setQueuePosition] = useState(null);
+  const [estimatedWait, setEstimatedWait] = useState(null);
+  useEffect(() => {
+    if (!customerSocketManager) return;
+    const socket = customerSocketManager.getSocket();
+    socket.on("connect", () => setIsConnected(true));
+    socket.on("disconnect", () => setIsConnected(false));
+    customerSocketManager.onAgentTyping(() => {
+      setAgentTyping(true);
+      setTimeout(() => setAgentTyping(false), 3e3);
+    });
+    customerSocketManager.onQueueUpdate((data) => {
+      setQueuePosition(data.queue_position);
+      setEstimatedWait(data.estimated_wait);
+    });
+    return () => {
+      socket.off("connect");
+      socket.off("disconnect");
+    };
+  }, [customerSocketManager]);
+  return {
+    isConnected,
+    agentTyping,
+    queuePosition,
+    estimatedWait
+  };
+}
+function useEscalation() {
+  const { customerSocketManager, connectCustomerSocket, disconnectCustomerSocket } = useSolveo();
+  const [escalationId, setEscalationId] = useState(null);
+  const [assignedAgent, setAssignedAgent] = useState(null);
+  const [status, setStatus] = useState("idle");
+  useEffect(() => {
+    if (!customerSocketManager) return;
+    customerSocketManager.onAgentConnected((data) => {
+      setEscalationId(data.escalation_id);
+      setAssignedAgent({
+        name: data.agent_name,
+        avatar_url: data.agent_avatar
+      });
+      setStatus("active");
+    });
+    customerSocketManager.onQueueUpdate((data) => {
+      setStatus("queued");
+    });
+    customerSocketManager.onEscalationResolved(() => {
+      setStatus("resolved");
+    });
+    customerSocketManager.onHandedBack(() => {
+      setStatus("idle");
+      setEscalationId(null);
+      setAssignedAgent(null);
+    });
+  }, [customerSocketManager]);
+  const requestHuman = useCallback((conversationId) => {
+    connectCustomerSocket(conversationId);
+    if (customerSocketManager) {
+      customerSocketManager.requestHuman();
+      setStatus("requesting");
+    }
+  }, [customerSocketManager, connectCustomerSocket]);
+  const endChat = useCallback(() => {
+    if (escalationId && customerSocketManager) {
+      customerSocketManager.endChat(escalationId);
+      disconnectCustomerSocket();
+      setStatus("idle");
+      setEscalationId(null);
+      setAssignedAgent(null);
+    }
+  }, [escalationId, customerSocketManager, disconnectCustomerSocket]);
+  const submitCSAT = useCallback((rating) => {
+    if (escalationId && customerSocketManager) {
+      customerSocketManager.submitCSAT(escalationId, rating);
+    }
+  }, [escalationId, customerSocketManager]);
+  return {
+    escalationId,
+    assignedAgent,
+    status,
+    requestHuman,
+    endChat,
+    submitCSAT
+  };
+}
+function useWidgetConfig(widgetId) {
+  const { sdk, config } = useSolveo();
+  const effectiveWidgetId = widgetId || config.widgetId;
+  const [widget, setWidget] = useState(null);
+  const [widgetConfig, setWidgetConfig] = useState(null);
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState(null);
+  useEffect(() => {
+    if (effectiveWidgetId) {
+      loadConfig();
+    }
+  }, [effectiveWidgetId]);
+  const loadConfig = async () => {
+    if (!effectiveWidgetId) return;
+    setIsLoading(true);
+    setError(null);
+    try {
+      const cached = await storage.getWidgetConfig(effectiveWidgetId);
+      if (cached) {
+        setWidget(cached);
+        setWidgetConfig(cached.config);
+      }
+      const w = await sdk.widgetConfig.getConfig(effectiveWidgetId);
+      setWidget(w);
+      setWidgetConfig(w.config);
+      await storage.setWidgetConfig(effectiveWidgetId, w);
+    } catch (err) {
+      setError(err);
+    } finally {
+      setIsLoading(false);
+    }
+  };
+  return {
+    widget,
+    widgetConfig,
+    isLoading,
+    error,
+    reload: loadConfig
+  };
+}
+function usePushNotifications(options = {}) {
+  const { sdk } = useSolveo();
+  const {
+    mode = "widget",
+    conversationId,
+    autoRegister = false,
+    handlers
+  } = options;
+  const [state, setState] = useState({
+    device: null,
+    isRegistered: false,
+    isInitialized: false,
+    permissionStatus: "undetermined"
+  });
+  const requestPermission = useCallback(async () => {
+    try {
+      const messaging = await import('@react-native-firebase/messaging').then((m) => m.default);
+      const authStatus = await messaging().requestPermission();
+      const enabled = authStatus === messaging.AuthorizationStatus.AUTHORIZED || authStatus === messaging.AuthorizationStatus.PROVISIONAL;
+      setState((prev) => ({
+        ...prev,
+        permissionStatus: enabled ? "granted" : "denied"
+      }));
+      return enabled;
+    } catch (error) {
+      console.error("Failed to request permission (Firebase Messaging not installed?):", error);
+      try {
+        const Notifications = await import('expo-notifications');
+        const { status } = await Notifications.requestPermissionsAsync();
+        const granted = status === "granted";
+        setState((prev) => ({
+          ...prev,
+          permissionStatus: granted ? "granted" : "denied"
+        }));
+        return granted;
+      } catch (expoError) {
+        console.error("Failed to request permission (Expo Notifications not installed?):", expoError);
+        setState((prev) => ({ ...prev, permissionStatus: "denied" }));
+        return false;
+      }
+    }
+  }, []);
+  const getToken = useCallback(async () => {
+    try {
+      const messaging = await import('@react-native-firebase/messaging').then((m) => m.default);
+      const token = await messaging().getToken();
+      return token;
+    } catch (error) {
+      console.error("Failed to get FCM token:", error);
+      try {
+        const Notifications = await import('expo-notifications');
+        const token = await Notifications.getExpoPushTokenAsync();
+        return token.data;
+      } catch (expoError) {
+        console.error("Failed to get Expo push token:", expoError);
+        return null;
+      }
+    }
+  }, []);
+  const registerDevice = useCallback(
+    async (convId, pushToken, bundleId) => {
+      if (mode !== "widget") {
+        console.warn("registerDevice is only for widget mode. Use registerAgentDevice for agent mode.");
+        return null;
+      }
+      const targetConversationId = convId || conversationId;
+      if (!targetConversationId) {
+        console.error("conversationId is required for widget mode registration");
+        return null;
+      }
+      try {
+        const token = pushToken || await getToken();
+        if (!token) {
+          throw new Error("Failed to get push token");
+        }
+        const platform = Platform.OS === "ios" ? "IOS" : "ANDROID";
+        const device = await sdk.widgetDevices.register({
+          conversation_id: targetConversationId,
+          platform,
+          push_token: token,
+          bundle_id: bundleId
+        });
+        setState((prev) => ({ ...prev, device, isRegistered: true }));
+        return device;
+      } catch (error) {
+        console.error("Failed to register device:", error);
+        throw error;
+      }
+    },
+    [sdk, conversationId, mode, getToken]
+  );
+  const registerAgentDevice = useCallback(
+    async (pushToken, deviceName) => {
+      if (mode !== "agent") {
+        console.warn("registerAgentDevice is only for agent mode. Use registerDevice for widget mode.");
+        return null;
+      }
+      try {
+        const token = pushToken || await getToken();
+        if (!token) {
+          throw new Error("Failed to get push token");
+        }
+        const platform = Platform.OS === "ios" ? "IOS" : "ANDROID";
+        const response = await sdk.client.post("/user-devices", {
+          platform,
+          push_token: token,
+          device_name: deviceName || `${Platform.OS} Device`
+        });
+        setState((prev) => ({
+          ...prev,
+          device: response.data,
+          isRegistered: true
+        }));
+        return response.data;
+      } catch (error) {
+        console.error("Failed to register agent device:", error);
+        throw error;
+      }
+    },
+    [sdk, mode, getToken]
+  );
+  const unregisterDevice = useCallback(async () => {
+    if (!state.device) {
+      return;
+    }
+    try {
+      if (mode === "widget") {
+        await sdk.widgetDevices.unregister(state.device.id);
+      } else {
+        await sdk.client.delete(`/user-devices/${state.device.id}`);
+      }
+      setState((prev) => ({
+        ...prev,
+        device: null,
+        isRegistered: false
+      }));
+    } catch (error) {
+      console.error("Failed to unregister device:", error);
+      throw error;
+    }
+  }, [sdk, state.device, mode]);
+  useEffect(() => {
+    if (!handlers?.onNotificationReceived) {
+      return;
+    }
+    let unsubscribe;
+    const setupForegroundHandler = async () => {
+      try {
+        const messaging = await import('@react-native-firebase/messaging').then((m) => m.default);
+        unsubscribe = messaging().onMessage(async (remoteMessage) => {
+          console.log("Foreground notification received:", remoteMessage);
+          handlers.onNotificationReceived?.(remoteMessage);
+        });
+      } catch (error) {
+        try {
+          const Notifications = await import('expo-notifications');
+          const subscription = Notifications.addNotificationReceivedListener((notification) => {
+            console.log("Foreground notification received (Expo):", notification);
+            handlers.onNotificationReceived?.(notification);
+          });
+          unsubscribe = () => subscription.remove();
+        } catch (expoError) {
+          console.error("Failed to setup foreground handler:", expoError);
+        }
+      }
+    };
+    setupForegroundHandler();
+    return () => {
+      unsubscribe?.();
+    };
+  }, [handlers?.onNotificationReceived]);
+  useEffect(() => {
+    if (!handlers?.onNotificationTapped) {
+      return;
+    }
+    let unsubscribe;
+    const setupTapHandler = async () => {
+      try {
+        const messaging = await import('@react-native-firebase/messaging').then((m) => m.default);
+        messaging().getInitialNotification().then((remoteMessage) => {
+          if (remoteMessage) {
+            console.log("Notification opened app from quit state:", remoteMessage);
+            handlers.onNotificationTapped?.(remoteMessage);
+          }
+        });
+        unsubscribe = messaging().onNotificationOpenedApp((remoteMessage) => {
+          console.log("Notification opened app from background:", remoteMessage);
+          handlers.onNotificationTapped?.(remoteMessage);
+        });
+      } catch (error) {
+        try {
+          const Notifications = await import('expo-notifications');
+          const subscription = Notifications.addNotificationResponseReceivedListener((response) => {
+            console.log("Notification tapped (Expo):", response);
+            handlers.onNotificationTapped?.(response.notification);
+          });
+          unsubscribe = () => subscription.remove();
+        } catch (expoError) {
+          console.error("Failed to setup tap handler:", expoError);
+        }
+      }
+    };
+    setupTapHandler();
+    return () => {
+      unsubscribe?.();
+    };
+  }, [handlers?.onNotificationTapped]);
+  useEffect(() => {
+    let unsubscribe;
+    const setupTokenRefreshHandler = async () => {
+      try {
+        const messaging = await import('@react-native-firebase/messaging').then((m) => m.default);
+        unsubscribe = messaging().onTokenRefresh(async (newToken) => {
+          console.log("FCM token refreshed:", newToken);
+          if (state.isRegistered) {
+            if (mode === "widget" && conversationId) {
+              await registerDevice(conversationId, newToken);
+            } else if (mode === "agent") {
+              await registerAgentDevice(newToken);
+            }
+          }
+        });
+      } catch (error) {
+        console.error("Failed to setup token refresh handler:", error);
+      }
+    };
+    setupTokenRefreshHandler();
+    return () => {
+      unsubscribe?.();
+    };
+  }, [state.isRegistered, mode, conversationId, registerDevice, registerAgentDevice]);
+  useEffect(() => {
+    const checkPermission = async () => {
+      try {
+        const messaging = await import('@react-native-firebase/messaging').then((m) => m.default);
+        const authStatus = await messaging().hasPermission();
+        const granted = authStatus === messaging.AuthorizationStatus.AUTHORIZED || authStatus === messaging.AuthorizationStatus.PROVISIONAL;
+        setState((prev) => ({
+          ...prev,
+          permissionStatus: granted ? "granted" : authStatus === messaging.AuthorizationStatus.NOT_DETERMINED ? "undetermined" : "denied",
+          isInitialized: true
+        }));
+        if (granted && autoRegister && !state.isRegistered) {
+          if (mode === "widget" && conversationId) {
+            await registerDevice();
+          } else if (mode === "agent") {
+            await registerAgentDevice();
+          }
+        }
+      } catch (error) {
+        console.error("Failed to check permission:", error);
+        setState((prev) => ({ ...prev, isInitialized: true }));
+      }
+    };
+    checkPermission();
+  }, [autoRegister, mode, conversationId, registerDevice, registerAgentDevice]);
+  return {
+    ...state,
+    requestPermission,
+    registerDevice,
+    registerAgentDevice,
+    unregisterDevice
+  };
+}
+function useAttachments(conversationId) {
+  const { sdk } = useSolveo();
+  const [uploading, setUploading] = useState(false);
+  const [uploadProgress, setUploadProgress] = useState(0);
+  const uploadAttachment = useCallback(async (file, attachmentType) => {
+    if (!conversationId) {
+      throw new Error("No conversation ID provided");
+    }
+    setUploading(true);
+    setUploadProgress(0);
+    try {
+      const response = await fetch(file.uri);
+      const blob = await response.blob();
+      const attachment = await sdk.widgetAttachments.upload(conversationId, blob, attachmentType);
+      setUploadProgress(100);
+      return attachment;
+    } catch (error) {
+      console.error("Failed to upload attachment:", error);
+      throw error;
+    } finally {
+      setUploading(false);
+      setUploadProgress(0);
+    }
+  }, [sdk, conversationId]);
+  return {
+    uploading,
+    uploadProgress,
+    uploadAttachment
+  };
+}
+function useAgents(accountId) {
+  const { sdk } = useSolveo();
+  const [agents, setAgents] = useState([]);
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const loadAgents = useCallback(async () => {
+    if (!accountId) return;
+    setIsLoading(true);
+    try {
+      const data = await sdk.agents.list(accountId);
+      setAgents(data);
+    } catch (err) {
+      setError(err);
+    } finally {
+      setIsLoading(false);
+    }
+  }, [sdk, accountId]);
+  useEffect(() => {
+    if (accountId) {
+      loadAgents();
+    }
+  }, [accountId]);
+  const createAgent = useCallback(async (data) => {
+    if (!accountId) throw new Error("No account ID");
+    const agent = await sdk.agents.create(accountId, data);
+    setAgents((prev) => [...prev, agent]);
+    return agent;
+  }, [sdk, accountId]);
+  const updateAgent = useCallback(async (id, data) => {
+    const agent = await sdk.agents.update(id, data);
+    setAgents((prev) => prev.map((a) => a.id === id ? agent : a));
+    return agent;
+  }, [sdk]);
+  const deleteAgent = useCallback(async (id) => {
+    await sdk.agents.delete(id);
+    setAgents((prev) => prev.filter((a) => a.id !== id));
+  }, [sdk]);
+  return {
+    agents,
+    isLoading,
+    error,
+    createAgent,
+    updateAgent,
+    deleteAgent,
+    reload: loadAgents
+  };
+}
+function useConversations(accountId) {
+  const { sdk } = useSolveo();
+  const [conversations, setConversations] = useState([]);
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const loadConversations = useCallback(async () => {
+    if (!accountId) return;
+    setIsLoading(true);
+    try {
+      const data = await sdk.conversations.list(accountId);
+      setConversations(data);
+    } catch (err) {
+      setError(err);
+    } finally {
+      setIsLoading(false);
+    }
+  }, [sdk, accountId]);
+  useEffect(() => {
+    if (accountId) {
+      loadConversations();
+    }
+  }, [accountId]);
+  const resolveConversation = useCallback(async (id) => {
+    await sdk.conversations.resolve(id);
+    setConversations((prev) => prev.map((c) => c.id === id ? { ...c, status: "RESOLVED" } : c));
+  }, [sdk]);
+  return {
+    conversations,
+    isLoading,
+    error,
+    resolveConversation,
+    reload: loadConversations
+  };
+}
+function useAnalytics(accountId, days = 30) {
+  const { sdk } = useSolveo();
+  const [metrics, setMetrics] = useState(null);
+  const [sentiment, setSentiment] = useState(null);
+  const [feedback, setFeedback] = useState(null);
+  const [tokenUsage, setTokenUsage] = useState(null);
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const loadAnalytics = useCallback(async () => {
+    if (!accountId) return;
+    setIsLoading(true);
+    try {
+      const [m, s, f, t] = await Promise.all([
+        sdk.analytics.getMetrics(accountId, days),
+        sdk.analytics.getSentiment(accountId, days),
+        sdk.analytics.getFeedback(accountId, days),
+        sdk.analytics.getTokenUsage(accountId, days)
+      ]);
+      setMetrics(m);
+      setSentiment(s);
+      setFeedback(f);
+      setTokenUsage(t);
+    } catch (err) {
+      setError(err);
+    } finally {
+      setIsLoading(false);
+    }
+  }, [sdk, accountId, days]);
+  useEffect(() => {
+    if (accountId) {
+      loadAnalytics();
+    }
+  }, [accountId, days]);
+  return {
+    metrics,
+    sentiment,
+    feedback,
+    tokenUsage,
+    isLoading,
+    error,
+    reload: loadAnalytics
+  };
+}
+
+export { SolveoProvider, storage, useAgents, useAnalytics, useAttachments, useChat, useConversations, useEscalation, usePushNotifications, useRealtime, useSolveo, useWidgetConfig };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map