@zenify-omni/chat-ui-react-js 0.1.0

package/utils/chat_socket.js

@@ -0,0 +1,1225 @@
+import i18n from "@zenify-omni/chat-js/lib/i18n/index.js";
+import { createChatSocket } from "@zenify-omni/chat-js/socket/index.js";
+import { registerChatTransport } from "@zenify-omni/chat-js/transport-registry.js";
+import { PRE_LOGOUT_EVENT } from "@zenify-omni/chat-js/constants/events.js";
+import { v4 as uuidv4 } from "uuid";
+import { getUser, isAdmin, isRoleTeamLeader, isSupervisor } from "@zenify-omni/chat-js/utils/auth.js";
+import {
+  buildChatMessage,
+  ChatFilterAssignStatus,
+  ChatMessageKey,
+  ChatSource,
+  ContentfulMessageTypes,
+  InviteStatus,
+  MessageType,
+  PinMessageTypes,
+  ReminderMessageTypes,
+  AgentReplyMessageTypes
+} from "@zenify-omni/chat-js/constants/chat-message.js";
+import useChatStore from "../store/chat-store.js";
+import useLumiLearnFromChatStore from "../store/lumi-learn-from-chat-store.js";
+import useEntityExtractStore from "../store/entity-extract-store.js";
+import useKnowledgeCrawlStore from "../store/knowledge-crawl-store.js";
+import {
+  LUMI_LEARN_FROM_CHAT_SOCKET_EVENT,
+  ENTITY_EXTRACT_SOCKET_EVENT,
+  KNOWLEDGE_CRAWL_SOCKET_EVENT
+} from "@zenify-omni/chat-js/constants/chatbot.js";
+import { queryClient } from "../config/runtime.js";
+import { isChatVisible, navigate } from "../config/navigation.js";
+import { pushNotification } from "./notification.js";
+import QUERY_KEY from "@zenify-omni/chat-js/constants/use-query-key.js";
+import {
+  getChatListV2,
+  leaveChat as leaveChatApi
+} from "@zenify-omni/chat-js/api/chat.js";
+import { SeniorStaffRoles, UserRole } from "@zenify-omni/chat-js/constants/user.js";
+import { isInArray } from "@zenify-omni/chat-js/utils/data.js";
+import { throwException } from "../exceptions/throw-exception.js";
+import { buildQueryParams } from "../components/chat-route/chat-list/util.js";
+import { getAllAgent } from "@zenify-omni/chat-js/api/report.js";
+import {
+  isFacebook,
+  isZaloGroup
+} from "../components/chat-route/util.js";
+import { CHATTER_TYPES } from "../components/chat-route/chat-box/constants.js";
+import { receiveInvite, getChatMessageList } from "@zenify-omni/chat-js/api/chatroom.js";
+import { debouncedInvalidate } from "@zenify-omni/chat-js/utils/debounced-invalidate.js";
+import { env } from "../config/env.js";
+import { onModuleDispose } from "../config/hmr.js";
+import {
+  getTabStatusFromChat,
+  getClosedSessionPayload,
+  getReceivedSessionPayload,
+  isClosedChatBySession
+} from "../store/chat-store-helpers.js";
+import {
+  applyEndedChat,
+  applyJoinedChat,
+  applyReceivedChat,
+  applyReopenedChat,
+  isJoinHandled,
+  isReceiveHandled,
+  isChatListSearching,
+  queueRoomForChatList,
+  limitedGetChatRoomDetail,
+  addUnhiddenChats
+} from "./chat-actions.js";
+let socket = null;
+let clientId = null;
+let reconnectDebounceTimer = null;
+let reconnectResyncCursor = null;
+const onSocketConnect = () => {
+  console.log("Connected to chat server");
+  useChatStore.getState().setIsSocketConnected(true);
+};
+const onSocketReconnect = (attempt) => {
+  useChatStore.getState().setIsSocketConnected(true);
+  if (reconnectDebounceTimer) clearTimeout(reconnectDebounceTimer);
+  reconnectDebounceTimer = setTimeout(() => {
+    reconnectDebounceTimer = null;
+    handleReconnect(attempt);
+  }, 500);
+};
+const handleReconnect = async (attempt) => {
+  console.log(`Reconnected to chat server (attempt ${attempt})`);
+  const onChatScreen = isChatVisible();
+  const store = useChatStore.getState();
+  if (onChatScreen) {
+    store.setIsSilentRefreshChatList(true);
+    store.resetLastRefreshTimeTicketPage();
+  }
+  const { currentChatId, setTicketChatMessages } = useChatStore.getState();
+  if (onChatScreen && currentChatId) {
+  }
+  if (!currentChatId) {
+    reconnectResyncCursor = null;
+    return;
+  }
+  const cursor = reconnectResyncCursor;
+  reconnectResyncCursor = null;
+  if (!cursor || cursor.roomId !== currentChatId || !cursor.lastMessageId)
+    return;
+  const roomIdAtStart = currentChatId;
+  const params = {
+    limit: 1e3,
+    sort: "-created_at -_id",
+    type: "cursor",
+    ignore_state: true,
+    until_id: cursor.lastMessageId
+  };
+  try {
+    const { data } = await getChatMessageList(currentChatId, { params });
+    if (useChatStore.getState().currentChatId !== roomIdAtStart) {
+      useChatStore.getState().markRoomUnloaded(roomIdAtStart);
+      return;
+    }
+    const items = data?.items || [];
+    if (!items.length) return;
+    const current = useChatStore.getState().ticketChatMessages[currentChatId] || [];
+    setTicketChatMessages(currentChatId, [...current, ...items]);
+  } catch (error) {
+    console.error("Error fetching messages after reconnecting:", error);
+  }
+};
+const onLumiLearnFromChat = (payload) => {
+  if (!payload?.type || !payload?.bot_id) return;
+  if (String(payload.user_id) !== String(getUser()?._id)) return;
+  useLumiLearnFromChatStore.getState().ingestEvent(payload);
+};
+const onEntityExtract = (payload) => {
+  if (!payload?.type || !payload?.bot_id) return;
+  if (!payload?.data?.source_link) return;
+  if (String(payload.user_id) !== String(getUser()?._id)) return;
+  useEntityExtractStore.getState().ingestEvent(payload);
+};
+const onKnowledgeCrawl = (payload) => {
+  if (!payload?.type || !payload?.data?.knowledge_id) return;
+  if (payload.user_id && String(payload.user_id) !== String(getUser()?._id)) {
+    return;
+  }
+  useKnowledgeCrawlStore.getState().ingestEvent(payload);
+};
+const onConnectError = (error) => {
+  useChatStore.getState().setIsSocketConnected(false);
+  console.error("Chat server connection error", error);
+};
+const onDisconnectError = (reason) => {
+  useChatStore.getState().setIsSocketConnected(false);
+  const onChatScreen = isChatVisible();
+  const { currentChatId, ticketChatMessages } = useChatStore.getState();
+  if (onChatScreen && currentChatId && !reconnectResyncCursor) {
+    const lastMessageId = (ticketChatMessages[currentChatId] || []).findLast(
+      (message) => message?._id && message.status === "success"
+    )?._id;
+    if (lastMessageId) {
+      reconnectResyncCursor = {
+        roomId: currentChatId,
+        lastMessageId
+      };
+    }
+  }
+  useChatStore.getState().resetLoadedRooms();
+  console.error("Chat server disconnect error", reason);
+  if (onChatScreen && currentChatId) {
+  }
+};
+const addContentfulMessage = async (chat) => {
+  const room_id = chat.room_id;
+  if (!room_id) return;
+  if (!chat._id) return;
+  const chatStore = useChatStore.getState();
+  let oldTab = null;
+  let chatItem = chatStore.chatList.find((x) => x._id === room_id);
+  const existedInList = !!chatItem;
+  if (chatItem) {
+    oldTab = getTabStatusFromChat(chatItem);
+  }
+  if (!chatItem) {
+    const isLoaded = chatStore.currentChatId === room_id || !!chatStore.loadedRooms[room_id];
+    if (isLoaded) {
+      chatStore.addNewMessage(room_id, {
+        ...chat,
+        _id: chat._id,
+        chatter_id: chat.chatter_id,
+        chatter_name: chat?.chatter_name,
+        chatter_type: chat.chatter_type,
+        content: chat.content,
+        status: chat.status,
+        type: chat.type,
+        created_at: chat.created_at,
+        updated_at: chat.updated_at,
+        source: chat.source
+      });
+      return;
+    }
+    if (!isChatVisible()) return;
+    if (isChatListSearching()) return;
+    queueRoomForChatList(room_id);
+    return;
+  }
+  if (chatItem) {
+    const liveStore = useChatStore.getState();
+    const currentChatId = liveStore.currentChatId;
+    const isCommentFb = chat?.content?.type === MessageType.ACTION_COMMENT_FB;
+    const msgContentType = chat?.content?.type;
+    const isAgentOrBot = [CHATTER_TYPES.AGENT, CHATTER_TYPES.BOT].includes(
+      chat?.chatter_type
+    );
+    const isCustomerChatter = [
+      CHATTER_TYPES.CUSTOMER,
+      CHATTER_TYPES.CONTACT
+    ].includes(chat?.chatter_type);
+    const isUndoMessage = chat.extra_data && chat.extra_data.is_undo === true && !!chat.extra_data.undo_original;
+    const isDeleteMessage = chat.extra_data && chat.extra_data.is_deleted === true && !!chat.extra_data.deleted_original;
+    const isMessageReadByContact = !!chat.read_receipt;
+    const isReaction = (
+      // Tin nhắn có extra_data chứa reactions array nhưng content type không phải reaction (chatting fallback khi nhận về trước khi pzalo trẳ về)
+      chat.content && chat.content.type !== MessageType.REACTION && chat.extra_data && Array.isArray(chat.extra_data.reactions)
+    );
+    const roomMessages = liveStore.ticketChatMessages[room_id] || [];
+    const lastRoomMessage = roomMessages[roomMessages.length - 1];
+    const isReactionUndoOrDelete = isReaction || isUndoMessage || isDeleteMessage;
+    const isLastRoomMessage = !!lastRoomMessage && lastRoomMessage._id === chat._id;
+    const shouldKeepLastMsg = isReactionUndoOrDelete && !isLastRoomMessage;
+    const shouldSkipUpdateTime = isReactionUndoOrDelete && isLastRoomMessage;
+    const isAgentReplySuccess = isAgentOrBot && AgentReplyMessageTypes.includes(msgContentType) && !isUndoMessage && !isDeleteMessage && !isReaction && chat.status === "success";
+    const shouldStopSla = isAgentReplySuccess && chat?.chatter_type === CHATTER_TYPES.AGENT;
+    const isUnanswered = isAgentReplySuccess ? false : isCustomerChatter ? true : chatItem.is_unanswered;
+    const isReopeningFromClosed = isClosedChatBySession(chatItem?.session) && !isClosedChatBySession(chat?.session);
+    const newChatItem = {
+      ...chatItem,
+      last_msg: isCommentFb || shouldKeepLastMsg || isMessageReadByContact ? chatItem.last_msg : {
+        ...chatItem.last_msg || {},
+        ...chat?.content || {},
+        ...shouldSkipUpdateTime ? {} : { time: chat.updated_at },
+        chatter_name: chat?.chatter_name,
+        chatter_type: chat?.chatter_type
+      },
+      // Tin chưa trả lời (tin khách) -> tăng unread; ngược lại (agent/bot đã
+      // reply) -> reset về 0. Nếu agent đang mở room này thì không tăng unread.
+      // isUnanswered=true + agent/bot (vd: status chưa 'success' do server không
+      // gửi field này): vẫn reset về 0 vì agent đang reply, badge phải biến mất.
+      unread: isUnanswered && room_id !== currentChatId ? isCustomerChatter ? isReopeningFromClosed ? 1 : (chatItem.unread || 0) + 1 : isAgentOrBot ? 0 : chatItem.unread : 0,
+      is_unanswered: isUnanswered,
+      // Agent đã trả lời -> gỡ badge sla_status (WARNING/BREACHED) trên chat
+      // item. Clear ngay tại đây vì newChatItem là bản append cuối cùng vào
+      // list, patch chỗ khác sẽ bị nó đè lại.
+      ...shouldStopSla ? { sla_status: "" } : {},
+      ...isClosedChatBySession(chat?.session) ? getClosedSessionPayload() : getReceivedSessionPayload(chat?.session?.is_received || false),
+      ...oldTab === ChatFilterAssignStatus.Closed ? { assigned: null } : {}
+    };
+    if (shouldStopSla) {
+    }
+    const isGroupZalo = isZaloGroup(chatItem);
+    const chatter_name = isGroupZalo && chat.status === "pending" ? chatItem.source_name + ` (${chat?.chatter_name})` : chat?.chatter_name;
+    const message = {
+      ...chat,
+      _id: chat._id,
+      chatter_id: chat.chatter_id,
+      chatter_name,
+      chatter_type: chat.chatter_type,
+      content: chat.content,
+      status: chat.status,
+      type: chat.type,
+      created_at: chat.created_at,
+      updated_at: chat.updated_at,
+      source: chat.source
+    };
+    const isLoaded = currentChatId === room_id || !!liveStore.loadedRooms[room_id];
+    if (isLoaded) {
+      chatStore.addNewMessage(room_id, message);
+      if (isReaction) {
+        chatStore.confirmPendingReaction(room_id, chat._id);
+      }
+    }
+    if (isLoaded && chat.read_receipt) {
+      useChatStore.getState().applyReadReceipt(room_id, chat.read_receipt);
+    }
+    if (isLoaded && message.seq != null && message.status === "success") {
+      const roomReads = useChatStore.getState().roomReadUpdates[room_id] ?? {};
+      const toApply = Object.entries(roomReads).filter(
+        ([, data]) => data.lastReadSeq != null && data.lastReadSeq >= message.seq
+      );
+      if (toApply.length > 0) {
+        useChatStore.setState((state) => ({
+          ticketChatMessages: {
+            ...state.ticketChatMessages,
+            [room_id]: (state.ticketChatMessages[room_id] ?? []).map((m) => {
+              if (m._id !== message._id) return m;
+              const existing = new Set((m.agent_reads ?? []).map((r) => r._id));
+              const newReads = toApply.filter(([uid]) => !existing.has(uid)).map(([uid, data]) => ({
+                _id: uid,
+                name: data.name,
+                avatar: data.avatar,
+                readed_at: data.readAt
+              }));
+              if (newReads.length === 0) return m;
+              return {
+                ...m,
+                agent_reads: [...m.agent_reads ?? [], ...newReads]
+              };
+            })
+          }
+        }));
+      }
+    }
+    const unansweredFilter = liveStore.filterState?.is_unanswered;
+    const noLongerMatchesUnansweredFilter = unansweredFilter === "true" && !isUnanswered || unansweredFilter === "false" && isUnanswered;
+    if (noLongerMatchesUnansweredFilter && existedInList) {
+      chatStore.removeChatFromList(room_id);
+      return;
+    }
+    const newTab = getTabStatusFromChat(newChatItem);
+    if (existedInList && oldTab !== newTab) {
+      chatStore.transitionChatTab(oldTab, newTab, newChatItem);
+      chatStore.resetLastRefreshTimeTicketPage();
+    }
+    chatStore.appendChats({
+      tab: newTab,
+      chats: [newChatItem]
+    });
+  }
+};
+const onAddMessage = async (data) => {
+  const resetLastRefreshTimeTicketPage = useChatStore.getState().resetLastRefreshTimeTicketPage;
+  const msgType = data.content.type;
+  if (!msgType) return;
+  if (ContentfulMessageTypes.includes(msgType) || ReminderMessageTypes.includes(msgType) || PinMessageTypes.includes(msgType)) {
+    if (PinMessageTypes.includes(msgType)) {
+      debouncedInvalidate(
+        queryClient,
+        [QUERY_KEY.GET_PINNED_MESSAGES, data.room_id],
+        { delay: 500 }
+      );
+    }
+    if (data.client_id === clientId) {
+      return;
+    }
+    await addContentfulMessage(data);
+    return;
+  }
+  const roomId = data.room_id;
+  if (!roomId) return;
+  switch (msgType) {
+    case MessageType.ACTION_END: {
+      applyEndedChat(data);
+      debouncedInvalidate(queryClient, [
+        QUERY_KEY.GET_DISTRIBUTION_LOGS,
+        roomId
+      ]);
+      return;
+    }
+    case MessageType.ACTION_RECEIVE: {
+      if (isReceiveHandled(roomId, data.chatter_id)) return;
+      await applyReceivedChat(data);
+      debouncedInvalidate(queryClient, [
+        QUERY_KEY.GET_DISTRIBUTION_LOGS,
+        roomId
+      ]);
+      return;
+    }
+    case MessageType.ACTION_REOPEN: {
+      await applyReopenedChat(data);
+      debouncedInvalidate(queryClient, [
+        QUERY_KEY.GET_DISTRIBUTION_LOGS,
+        roomId
+      ]);
+      return;
+    }
+    case MessageType.ACTION_LEAVE: {
+      const store = useChatStore.getState();
+      const isLoaded = roomId === store.currentChatId || !!store.loadedRooms[roomId];
+      if (!isLoaded) return;
+      store.addNewMessage(
+        roomId,
+        buildChatMessage({
+          id: data._id,
+          roomId,
+          tenantId: data.tenant_id,
+          source: data.source,
+          chatterId: data.chatter_id,
+          chatterName: data.chatter_name,
+          chatterType: data.chatter_type,
+          type: MessageType.ACTION_LEAVE,
+          status: data.status,
+          createdAt: data.created_at,
+          updatedAt: data.updated_at,
+          content: data.content
+        })
+      );
+      store.updateChatDetail(roomId, {
+        last_msg: {
+          _id: data._id,
+          msg_id: data._id,
+          text: data.content?.text,
+          type: data.content?.type,
+          time: data.created_at,
+          chatter_type: data.chatter_type,
+          chatter_name: data.chatter_name,
+          chatter_id: data.chatter_id,
+          // Socket gửi removed_by_* trong content, còn preview (chat-item.jsx)
+          // đọc chúng ở cấp cao nhất của last_msg vì API gắn sẵn ở đó. Không
+          // nâng lên thì last_msg mới (updateChatDetail ghi đè cả object) mất
+          // hai trường này ⇒ danh sách chat báo "tự rời" thay vì "bị X xóa",
+          // chỉ đúng lại sau khi reload.
+          removed_by_id: data.content?.removed_by_id,
+          removed_by_name: data.content?.removed_by_name,
+          ...data.session_id ? { session_id: data.session_id } : {}
+        }
+      });
+      return;
+    }
+    case MessageType.ACTION_TIKTOK_END_SESSION: {
+      const store = useChatStore.getState();
+      const isLoaded = roomId === store.currentChatId || !!store.loadedRooms[roomId];
+      if (!isLoaded) return;
+      const message = buildChatMessage({
+        id: data._id,
+        roomId,
+        tenantId: data.tenant_id,
+        source: data.source,
+        chatterId: data.chatter_id,
+        chatterName: data.chatter_name,
+        chatterType: data.chatter_type,
+        type: MessageType.ACTION_TIKTOK_END_SESSION,
+        status: data.status,
+        createdAt: data.created_at,
+        updatedAt: data.updated_at,
+        content: data.content
+      });
+      store.addNewMessage(roomId, message);
+      return;
+    }
+    case MessageType.ZALO_ACCEPT_FRIEND: {
+      await addContentfulMessage(data);
+      const timeoutId = setTimeout(() => {
+        resetLastRefreshTimeTicketPage();
+        clearTimeout(timeoutId);
+      }, 3e3);
+      return;
+    }
+    case MessageType.ZALO_CREATE_GROUP:
+    case MessageType.ZALO_CALL: {
+      await addContentfulMessage(data);
+      return;
+    }
+    default:
+      return;
+  }
+};
+const getTicketInfoWithFilter = async (ticketId) => {
+  try {
+    const filterState = {
+      ...useChatStore.getState().filterState,
+      ticket_ids: [ticketId],
+      assign_status: null
+    };
+    const params = buildQueryParams(filterState);
+    const { data } = await getChatListV2({ params });
+    if (data && data.list && data.list.length > 0) {
+      return data.list[0];
+    } else {
+      return null;
+    }
+  } catch (error) {
+    console.error("Error fetching ticket detail:", error);
+    return null;
+  }
+};
+const getTicketChatDetail = async (ticketId) => getTicketInfoWithFilter(ticketId);
+const onRequestContactChat = async (data) => {
+  const ticketId = data._id;
+  if (!ticketId) return;
+  const chatStore = useChatStore.getState();
+  const chatList = chatStore.chatList || [];
+  if (chatList.some((item) => item._id === ticketId)) return;
+  const currentUser = getUser();
+  if (!currentUser) return;
+  try {
+    let updatedTicket = await getTicketChatDetail(ticketId);
+    if (!updatedTicket) return;
+    let chatItem = null;
+    let agentInGroups = [];
+    if (isRoleTeamLeader()) {
+      try {
+        const { data: data2, error } = await getAllAgent(
+          JSON.stringify([currentUser.group_id])
+        );
+        if (!error && data2 && data2?.list?.length) {
+          agentInGroups = data2?.list?.map((agent) => agent._id);
+        }
+      } catch (e) {
+        console.error("Error fetching agents in groups:", e);
+      }
+    }
+    const isTeamLeaderOfGroup = isRoleTeamLeader() && (data?.group_id && data.group_ids?.includes(currentUser.group_id) || Number(currentUser.group_id) === Number(updatedTicket?.group_id) || agentInGroups?.includes(updatedTicket?.assign_agent_id) || agentInGroups?.some((id) => !!isInArray(id, updatedTicket?.in_room)));
+    const isAssignedAgent = updatedTicket.assign_agent_id === currentUser._id || updatedTicket.agent_uid === currentUser._id;
+    const isInRoom = isInArray(currentUser._id, updatedTicket?.in_room);
+    if (isAdmin() || isSupervisor() || isTeamLeaderOfGroup || isAssignedAgent || isInRoom) {
+      chatItem = {
+        ...updatedTicket,
+        receiver_id: updatedTicket?.receiver_id || null
+        // Ensure receiver_id is set
+      };
+    }
+    if (!chatItem) {
+      console.log("No permission to access this chat");
+      return;
+    }
+    joinChat(chatItem._id);
+    const tabChat = chatItem?.receiver_id ? ChatFilterAssignStatus.Received : ChatFilterAssignStatus.NotReceived;
+    useChatStore.getState().appendChats({
+      source: ChatSource.Socket,
+      tab: tabChat,
+      chats: [chatItem]
+    });
+    if (useChatStore.getState().currentChatId === chatItem._id) {
+      useChatStore.getState().resetLastRefreshTimeTicketPage();
+    }
+  } catch (error) {
+    console.error("Error in onRequestContactChat:", error);
+  }
+};
+const onInviteChat = async (data) => {
+  const user = getUser();
+  if (!user) return;
+  switch (data.status) {
+    case InviteStatus.INVITE: {
+      if (!Array.isArray(data.userIds) || !data.userIds.includes(user._id))
+        return;
+      const payload = {
+        chat_room_id: data.chat_room_id,
+        chat_session_id: data.chat_session_id
+      };
+      pushNotification(
+        i18n.t("common:nav.notification", { defaultValue: "Th\xF4ng b\xE1o" }),
+        {
+          // description: `${fromUserName} vừa mời bạn vào cuộc hội thoại!`,
+          description: data.message,
+          duration: Infinity,
+          notificationKey: `invite-${data.chat_room_id}`,
+          action: {
+            label: i18n.t("common:action.agree", { defaultValue: "\u0110\u1ED3ng \xFD" }),
+            onClick: () => acceptInviteChat(payload)
+          },
+          cancel: {
+            label: i18n.t("common:action.reject", { defaultValue: "T\u1EEB ch\u1ED1i" }),
+            onClick: () => rejectInviteChat(payload)
+          }
+        }
+      );
+      return;
+    }
+    case InviteStatus.ACCEPT: {
+      const lastMessage = data?.data || null;
+      if (!lastMessage) return;
+      const roomId = lastMessage.room_id;
+      if (!isJoinHandled(roomId, lastMessage.chatter_id)) {
+        await applyJoinedChat(lastMessage);
+      }
+      if (data.message && Array.isArray(data.notifyUserIds) && data.notifyUserIds.length > 0 && data.notifyUserIds.includes(user?._id)) {
+        pushNotification(
+          i18n.t("common:nav.notification", { defaultValue: "Th\xF4ng b\xE1o" }),
+          {
+            description: data.message
+          }
+        );
+      }
+      return;
+    }
+    case InviteStatus.REJECT:
+      return;
+    default:
+      return;
+  }
+};
+async function onDistributeChat(data) {
+  const chatStore = useChatStore.getState();
+  const {
+    chatRoomId,
+    userIds,
+    notify_user_ids: notifyUserIds,
+    redistribution_force: redistributionForce,
+    redistribution_message: redistributionMessage
+  } = data;
+  const user = getUser();
+  if (!user) return;
+  const params = buildQueryParams(chatStore.filterState || {});
+  const chat = chatStore.chatList.find((x) => x._id === chatRoomId);
+  if (Array.isArray(userIds) && userIds.includes(user._id) || isAdmin() || isSupervisor()) {
+    const isAssigned = Array.isArray(userIds) && userIds.includes(user._id);
+    if (isChatVisible() && (chat || isAssigned)) {
+      const { data: newChat } = await limitedGetChatRoomDetail(
+        chatRoomId,
+        params
+      );
+      if (newChat) {
+        if (!chat) {
+          const tab = getTabStatusFromChat(newChat);
+          chatStore.appendChats({
+            tab,
+            chats: [newChat]
+          });
+        } else {
+          const oldTab = getTabStatusFromChat(chat);
+          const newTab = getTabStatusFromChat(newChat);
+          chatStore.transitionChatTab(oldTab, newTab, newChat);
+          chatStore.moveChat({
+            roomId: chatRoomId,
+            payload: {
+              ...getReceivedSessionPayload(
+                newChat?.session?.is_received || false
+              )
+            }
+          });
+          const nextAssignedId = newChat?.session?.assigned_id;
+          if (nextAssignedId) {
+            const inRoom = newChat?.users_in_room?.find(
+              (x) => x._id === nextAssignedId
+            );
+            chatStore.updateChatDetail(chatRoomId, {
+              assigned: {
+                _id: nextAssignedId,
+                name: inRoom?.name
+              }
+            });
+          } else {
+            chatStore.updateChatDetail(chatRoomId, { assigned: null });
+          }
+        }
+      }
+    }
+    if (Array.isArray(notifyUserIds) && notifyUserIds.includes(user._id)) {
+      pushNotification(
+        i18n.t("common:nav.notification", { defaultValue: "Th\xF4ng b\xE1o" }),
+        {
+          // Phân bổ lại (redistribution_force): dùng text do BE build sẵn
+          // (vd "Hệ thống đã phân bổ lại hội thoại cho ...") thay cho text mặc định.
+          description: redistributionForce && redistributionMessage ? redistributionMessage : i18n.t("common:toast.assignedNewConversation", {
+            defaultValue: "B\u1EA1n \u0111\xE3 \u0111\u01B0\u1EE3c g\xE1n v\xE0o cu\u1ED9c h\u1ED9i tho\u1EA1i m\u1EDBi"
+          }),
+          duration: 5e3
+        }
+      );
+    }
+  }
+  if (chatStore.currentChatId === chatRoomId) {
+    chatStore.resetLastRefreshTimeTicketPage();
+  }
+  debouncedInvalidate(queryClient, [
+    QUERY_KEY.GET_DISTRIBUTION_LOGS,
+    chatRoomId
+  ]);
+}
+function keepsRoomVisibilityByRole(user) {
+  const { roles = [], role } = user || {};
+  return [...roles, role].filter(Boolean).some((r) => SeniorStaffRoles.includes(r));
+}
+function onRemoveUserFromChat(data) {
+  const chatStore = useChatStore.getState();
+  const { chatRoomId, userIds, actionBy, source } = data || {};
+  const user = getUser();
+  if (!user || !chatRoomId || !Array.isArray(userIds)) return;
+  const refreshRoomDetail = () => {
+    if (chatStore.currentChatId === chatRoomId) {
+      chatStore.resetLastRefreshTimeTicketPage();
+      return;
+    }
+    queryClient.removeQueries({
+      predicate: (query) => query.queryKey?.[0] === QUERY_KEY.GET_CHAT_ROOM_DETAIL && query.queryKey?.[1]?.chatRoomId === chatRoomId
+    });
+  };
+  if (!userIds.includes(user._id)) {
+    refreshRoomDetail();
+    return;
+  }
+  const keepsVisibility = source === "remove_members" && keepsRoomVisibilityByRole(user);
+  const isSelfLeave = String(actionBy?._id ?? "") === String(user._id);
+  if (actionBy?.name && !isSelfLeave) {
+    pushNotification(i18n.t("common:nav.notification"), {
+      description: keepsVisibility ? i18n.t("chat:message.youWereRemovedButCanStillView", {
+        actor: actionBy.name,
+        defaultValue: "B\u1EA1n \u0111\xE3 b\u1ECB {actor} x\xF3a kh\u1ECFi \u0111o\u1EA1n chat, kh\xF4ng g\u1EEDi \u0111\u01B0\u1EE3c tin nh\u1EAFn n\u1EEFa"
+      }) : i18n.t("chat:message.youWereRemovedFromChat", {
+        actor: actionBy.name,
+        defaultValue: "B\u1EA1n \u0111\xE3 b\u1ECB {actor} x\xF3a kh\u1ECFi \u0111o\u1EA1n chat"
+      })
+    });
+  }
+  if (keepsVisibility) {
+    refreshRoomDetail();
+    return;
+  }
+  chatStore.removeChat(chatRoomId);
+  if (chatStore.currentChatId === chatRoomId) {
+    navigate({ to: "/chat" });
+  }
+}
+function onHideChatRoom(data) {
+  const { room_ids: roomIds } = data;
+  if (!roomIds?.length) return;
+  const chatStore = useChatStore.getState();
+  const currentChatId = chatStore.currentChatId;
+  const shouldNavigateAway = roomIds.includes(currentChatId) && isChatVisible();
+  roomIds.forEach((roomId) => chatStore.removeChat(roomId));
+  if (shouldNavigateAway) {
+    navigate({ to: "/chat" });
+  }
+}
+function onUnhideChatRoom(data) {
+  const { room_ids: roomIds } = data;
+  if (!roomIds?.length) return;
+  addUnhiddenChats(roomIds);
+}
+async function onUnhandledChanged(data) {
+  const { chatRoomId, is_unhandled: isUnhandled } = data || {};
+  if (!chatRoomId) return;
+  const chatStore = useChatStore.getState();
+  const chat = chatStore.chatList.find((c) => c._id === chatRoomId);
+  if (chat) {
+    const filterValue = chatStore.filterState?.is_unhandled;
+    const noLongerMatchesFilter = filterValue === "true" && !isUnhandled || filterValue === "false" && !!isUnhandled;
+    if (noLongerMatchesFilter) {
+      chatStore.removeChat(chatRoomId);
+    } else {
+      chatStore.updateChatDetail(chatRoomId, { is_unhandled: !!isUnhandled });
+    }
+    return;
+  }
+  if (isChatListSearching()) return;
+  queueRoomForChatList(chatRoomId, { is_unhandled: !!isUnhandled });
+}
+const onChangePersonalZaloType = (data) => {
+  const { pzalo_type, page_id, page_name, name, email, user_ids } = data;
+  const user = getUser();
+  if (!user) return;
+  useChatStore.getState().setFilterState({});
+  const currentChatId = useChatStore.getState().currentChatId;
+  const msg = pzalo_type === "personal" ? i18n.t("common:toast.zaloTransferredToUser", {
+    page_name,
+    name,
+    email,
+    defaultValue: "Zalo c\xE1 nh\xE2n {page_name} \u0111\xE3 \u0111\u01B0\u1EE3c chuy\u1EC3n sang cho: {name}, email: {email}!"
+  }) : i18n.t("common:toast.zaloTransferredToSharedPersonal", {
+    page_name,
+    defaultValue: "Zalo {page_name} \u0111\xE3 \u0111\u01B0\u1EE3c chuy\u1EC3n sang Zalo c\xE1 nh\xE2n d\xF9ng chung!"
+  });
+  let notifiedUserId = "";
+  if (isChatVisible()) {
+    if (currentChatId) {
+      const chatList = useChatStore.getState().chatList;
+      const zaloChatting = chatList.find(
+        (chat) => chat._id === currentChatId && chat.is_personal_zalo === true && chat.page_id === page_id
+      );
+      if (zaloChatting) {
+        useChatStore.getState().resetLastRefreshTimeTicketPage();
+        pushNotification(
+          i18n.t("common:nav.notification", { defaultValue: "Th\xF4ng b\xE1o" }),
+          {
+            description: msg,
+            duration: 1e4
+          }
+        );
+        notifiedUserId = user._id;
+      }
+    }
+  }
+  if (user_ids.includes(user._id) && notifiedUserId !== user._id) {
+    pushNotification(
+      i18n.t("common:nav.notification", { defaultValue: "Th\xF4ng b\xE1o" }),
+      {
+        description: msg,
+        duration: 1e4
+      }
+    );
+  }
+};
+const onZaloFriendEvent = (data) => {
+  const { message, room_id, tenant_id } = data;
+  const currentUser = getUser();
+  if (!currentUser || tenant_id !== currentUser.tenant_id) return;
+  const currentChatId = useChatStore.getState().currentChatId;
+  if (currentChatId !== room_id) return;
+  const chatStore = useChatStore.getState();
+  const currentMessages = chatStore.ticketChatMessages[room_id] || [];
+  const messageIndex = currentMessages.findIndex(
+    (msg) => msg._id === message._id
+  );
+  if (messageIndex !== -1) {
+    const updatedMessages = [...currentMessages];
+    const existingMessage = updatedMessages[messageIndex];
+    updatedMessages[messageIndex] = {
+      ...existingMessage,
+      ...message,
+      // content_obj: newContentObj,
+      // extra_data: newExtraData,
+      content: message.content !== void 0 ? message.content : existingMessage.content,
+      // Giữ nguyên các field đã normalize
+      dateLabel: existingMessage.dateLabel,
+      showUserName: existingMessage.showUserName,
+      normalized: existingMessage.normalized
+    };
+    useChatStore.setState((state) => ({
+      ticketChatMessages: {
+        ...state.ticketChatMessages,
+        [room_id]: updatedMessages
+      }
+    }));
+  }
+};
+const onMessageRead = ({ roomId, userId, messageIds, readAt }) => {
+  const messageIdSet = new Set(messageIds);
+  const messages = useChatStore.getState().ticketChatMessages[roomId] ?? [];
+  const needsUpdate = messages.some(
+    (msg) => messageIdSet.has(msg._id) && !(msg.agent_reads ?? []).some((r) => r._id === userId)
+  );
+  if (!needsUpdate) return;
+  useChatStore.setState((state) => ({
+    ticketChatMessages: {
+      ...state.ticketChatMessages,
+      [roomId]: (state.ticketChatMessages[roomId] ?? []).map((msg) => {
+        if (!messageIdSet.has(msg._id)) return msg;
+        if ((msg.agent_reads ?? []).some((r) => r._id === userId)) return msg;
+        return {
+          ...msg,
+          agent_reads: [
+            ...msg.agent_reads ?? [],
+            { _id: userId, readed_at: readAt }
+          ]
+        };
+      })
+    }
+  }));
+};
+const onRoomReadUpdated = ({
+  roomId,
+  userId,
+  lastReadSeq,
+  readAt,
+  name,
+  avatar
+}) => {
+  useChatStore.getState().updateRoomReadUpdate(roomId, userId, { name, avatar, lastReadSeq, readAt });
+  useChatStore.getState().updateChatUnread(roomId, { unread: 0 });
+  const messages = useChatStore.getState().ticketChatMessages[roomId] ?? [];
+  const needsUpdate = messages.some(
+    (msg) => msg.seq != null && msg.seq <= lastReadSeq && !(msg.agent_reads ?? []).some((r) => r._id === userId)
+  );
+  if (needsUpdate) {
+    useChatStore.setState((state) => ({
+      ticketChatMessages: {
+        ...state.ticketChatMessages,
+        [roomId]: (state.ticketChatMessages[roomId] ?? []).map((msg) => {
+          if (msg.seq == null || msg.seq > lastReadSeq) return msg;
+          if ((msg.agent_reads ?? []).some((r) => r._id === userId)) return msg;
+          return {
+            ...msg,
+            agent_reads: [
+              ...msg.agent_reads ?? [],
+              { _id: userId, readed_at: readAt }
+            ]
+          };
+        })
+      }
+    }));
+  }
+};
+const connectSocket = () => {
+  const user = getUser();
+  if (!user) return;
+  if (socket) return;
+  socket = createChatSocket(env.CHAT_URL, user);
+  socket.on("connect", onSocketConnect);
+  socket.on("connect_error", onConnectError);
+  socket.on("reconnect", onSocketReconnect);
+  socket.on("disconnect", onDisconnectError);
+  socket.on(ChatMessageKey.ADD_MESSAGE, onAddMessage);
+  socket.on(ChatMessageKey.REQUEST_CONTACT_CHAT, onRequestContactChat);
+  socket.on(ChatMessageKey.INVITE, onInviteChat);
+  socket.on(ChatMessageKey.CHANGE_PERSONAL_ZALO_TYPE, onChangePersonalZaloType);
+  socket.on(ChatMessageKey.ZALO_FRIEND_EVENT, onZaloFriendEvent);
+  socket.on(ChatMessageKey.DISTRIBUTE_CHAT, onDistributeChat);
+  socket.on(ChatMessageKey.REMOVE_USER_FROM_CHAT, onRemoveUserFromChat);
+  socket.on(ChatMessageKey.HIDE_CHAT_ROOM, onHideChatRoom);
+  socket.on(ChatMessageKey.UNHIDE_CHAT_ROOM, onUnhideChatRoom);
+  socket.on(ChatMessageKey.UNHANDLED_CHANGED, onUnhandledChanged);
+  socket.on(ChatMessageKey.ROOM_READ_UPDATED, onRoomReadUpdated);
+  socket.on(ChatMessageKey.MESSAGE_READ, onMessageRead);
+  socket.on(LUMI_LEARN_FROM_CHAT_SOCKET_EVENT, onLumiLearnFromChat);
+  socket.on(ENTITY_EXTRACT_SOCKET_EVENT, onEntityExtract);
+  socket.on(KNOWLEDGE_CRAWL_SOCKET_EVENT, onKnowledgeCrawl);
+  clientId = uuidv4();
+};
+const disconnectSocket = () => {
+  if (!socket) return;
+  if (reconnectDebounceTimer) {
+    clearTimeout(reconnectDebounceTimer);
+    reconnectDebounceTimer = null;
+  }
+  reconnectResyncCursor = null;
+  socket.off("connect", onSocketConnect);
+  socket.off("connect_error", onConnectError);
+  socket.off("reconnect", onSocketReconnect);
+  socket.off("disconnect", onDisconnectError);
+  socket.off(ChatMessageKey.ADD_MESSAGE, onAddMessage);
+  socket.off(ChatMessageKey.REQUEST_CONTACT_CHAT, onRequestContactChat);
+  socket.off(ChatMessageKey.INVITE, onInviteChat);
+  socket.off(ChatMessageKey.CHANGE_PERSONAL_ZALO_TYPE, onChangePersonalZaloType);
+  socket.off(ChatMessageKey.ZALO_FRIEND_EVENT, onZaloFriendEvent);
+  socket.off(ChatMessageKey.DISTRIBUTE_CHAT, onDistributeChat);
+  socket.off(ChatMessageKey.REMOVE_USER_FROM_CHAT, onRemoveUserFromChat);
+  socket.off(ChatMessageKey.HIDE_CHAT_ROOM, onHideChatRoom);
+  socket.off(ChatMessageKey.UNHIDE_CHAT_ROOM, onUnhideChatRoom);
+  socket.off(ChatMessageKey.UNHANDLED_CHANGED, onUnhandledChanged);
+  socket.off(ChatMessageKey.ROOM_READ_UPDATED, onRoomReadUpdated);
+  socket.off(ChatMessageKey.MESSAGE_READ, onMessageRead);
+  socket.off(LUMI_LEARN_FROM_CHAT_SOCKET_EVENT, onLumiLearnFromChat);
+  socket.off(ENTITY_EXTRACT_SOCKET_EVENT, onEntityExtract);
+  socket.off(KNOWLEDGE_CRAWL_SOCKET_EVENT, onKnowledgeCrawl);
+  useChatStore.getState().setIsSocketConnected(false);
+  socket.disconnect();
+  socket = null;
+};
+let __preLogoutBound = false;
+if (!__preLogoutBound) {
+  document.addEventListener(PRE_LOGOUT_EVENT, disconnectSocket);
+  __preLogoutBound = true;
+}
+onModuleDispose(
+  () => document.removeEventListener(PRE_LOGOUT_EVENT, disconnectSocket)
+);
+const sendMessage = (chatItem, contentTxt, type = MessageType.TEXT, options = {}, fileName, contentOption) => {
+  const { replySelected } = useChatStore.getState();
+  let contentSocket = contentTxt;
+  let mention_infos = {};
+  let extra_data = {};
+  let styles;
+  const user = getUser();
+  if (!user) return;
+  if (replySelected) {
+    options.reply_msg_id = isFacebook(chatItem) ? replySelected.extra_data?.msg_id : replySelected._id;
+  }
+  if (options._mentionData) {
+    const { textOriginal, mentions, mentionsDisplay } = options._mentionData;
+    if (mentions?.length > 0) {
+      options.mentions = mentions;
+      mention_infos = {
+        mention_to: mentionsDisplay,
+        txt: textOriginal
+      };
+    }
+    delete options._mentionData;
+  }
+  if (options.styles) {
+    styles = options.styles;
+  }
+  const {
+    _id: room_id,
+    source,
+    source_id,
+    source_room_id
+    // source_name,
+  } = chatItem;
+  if (!socket || !room_id) return;
+  if ((ContentfulMessageTypes.includes(type) || type === MessageType.ACTION_JOIN) && !ReminderMessageTypes.includes(type)) {
+    if (replySelected) {
+      extra_data.reply_msg_info = replySelected;
+    }
+    if (mention_infos) {
+      extra_data.mention_infos = mention_infos;
+    }
+    if (styles) {
+      extra_data.styles = styles;
+    }
+  }
+  const content = {
+    type,
+    text: contentSocket,
+    file_name: fileName,
+    ...type === "image" || type === "file" || type === "video" ? { src: contentSocket } : {},
+    ...type == MessageType.REACTION ? contentOption.reaction : {},
+    ...type == "pin_message" ? contentOption.pin : {},
+    ...type == "unpin_message" ? contentOption.unpin : {},
+    ...options.tag ? { tag: options.tag } : {}
+  };
+  delete options.tag;
+  socket.emit(ChatMessageKey.NEW_MESSAGE, room_id, {
+    room_id,
+    chatter_id: user._id,
+    chatter_name: user.name,
+    chatter_avatar: user.avatar,
+    chatter_type: "agent",
+    date: Date.now(),
+    content,
+    source,
+    source_id,
+    source_room_id,
+    client_id: clientId,
+    extra_data,
+    ...options
+  });
+};
+const acceptInviteChat = async (data) => {
+  if (!socket) return;
+  const sessionId = data.chat_session_id;
+  if (!sessionId) return;
+  try {
+    await receiveInvite({ sessionId });
+  } catch (e) {
+    throwException(e);
+  }
+};
+const rejectInviteChat = () => {
+  if (!socket) return;
+};
+const assignChat = (data) => {
+  if (!socket) return;
+  socket.emit(
+    ChatMessageKey.ASSIGN,
+    data.agentId,
+    data.fromUserId,
+    data.fromUser,
+    data.tenantId,
+    data.ticketId
+  );
+};
+const leaveChat = async (roomId) => {
+  if (!socket) return;
+  const { error } = await leaveChatApi(roomId);
+  if (error) return;
+  socket.emit(ChatMessageKey.LEAVE, {
+    room_id: roomId
+  });
+  sendMessage({ _id: roomId }, "", MessageType.ACTION_LEAVE);
+  const chatList = useChatStore.getState().chatList || [];
+  const newChatList = chatList.filter((chat) => chat?._id !== roomId);
+  useChatStore.getState().setChatList(newChatList);
+  useChatStore.getState().removeTicketChatMessage(roomId);
+  navigate({ to: "/chat" });
+};
+const onForwardChat = (data) => {
+  const user = getUser();
+  if (!user) return;
+  if (data?.agent_id === user._id) {
+    const description = data?.from_user;
+    if (data?.status === "reject") {
+      pushNotification(
+        i18n.t("common:nav.notification", { defaultValue: "Th\xF4ng b\xE1o" }),
+        {
+          description: i18n.t("common:toast.agentRejectedConversation", {
+            description,
+            defaultValue: "{description} \u0111\xE3 t\u1EEB ch\u1ED1i ti\u1EBFp nh\u1EADn cu\u1ED9c h\u1ED9i tho\u1EA1i!"
+          })
+        }
+      );
+    } else if (data?.status === "accept") {
+      pushNotification(
+        i18n.t("common:nav.notification", { defaultValue: "Th\xF4ng b\xE1o" }),
+        {
+          description: i18n.t("common:toast.agentAcceptedConversation", {
+            description,
+            defaultValue: "{description} \u0111\xE3 \u0111\u1ED3ng \xFD ti\u1EBFp nh\u1EADn cu\u1ED9c h\u1ED9i tho\u1EA1i!"
+          })
+        }
+      );
+      const chatList = useChatStore.getState().chatList;
+      const newChatList = chatList.map((chat) => {
+        if (chat?._id === data?.ticket_id) {
+          const currentReceiverId = chat?.receiver_id;
+          chat.receiver_id = data?.from_user_id;
+          chat.in_room = (chat?.in_room || [])?.filter((ir) => ir !== currentReceiverId).push(data?.from_user_id);
+          if (user?.role === UserRole.AGENT && currentReceiverId === user._id) {
+            return null;
+          }
+        }
+        return chat;
+      });
+      useChatStore.getState().setChatList(newChatList.filter((r) => r));
+    } else if (data?.status === "invite") {
+      const payload = {
+        agentId: data?.from_user_id,
+        fromUserId: user._id,
+        fromUser: user.name,
+        tenantId: user.tenant_id,
+        ticketId: data?.ticket_id
+      };
+      pushNotification(
+        i18n.t("common:nav.notification", { defaultValue: "Th\xF4ng b\xE1o" }),
+        {
+          description: i18n.t("common:toast.conversationForwardRequest", {
+            description,
+            defaultValue: "{description} v\u1EEBa y\xEAu c\u1EA7u chuy\u1EC3n ti\u1EBFp cu\u1ED9c h\u1ED9i tho\u1EA1i cho b\u1EA1n!"
+          }),
+          duration: Infinity,
+          action: {
+            label: i18n.t("common:action.agree", { defaultValue: "\u0110\u1ED3ng \xFD" }),
+            onClick: () => forwardChat({ ...payload, status: "accept" })
+          },
+          cancel: {
+            label: i18n.t("common:action.reject", { defaultValue: "T\u1EEB ch\u1ED1i" }),
+            onClick: () => forwardChat({ ...payload, status: "reject" })
+          }
+        }
+      );
+    }
+  }
+};
+const onRefreshStatus = (data) => {
+  const chatList = useChatStore.getState().chatList || [];
+  const currentChat = useChatStore.getState().currentChat || [];
+  const currentChatId = useChatStore.getState().currentChatId || null;
+  if (data?.type === "contact") {
+    const updatedChatList = chatList.map((d) => {
+      if (d?._id === data?.ticket_id && d.requester) {
+        d.requester.is_online = data?.status || 0;
+      }
+      return d;
+    });
+    useChatStore.getState().setChatList(updatedChatList);
+  }
+  if (currentChatId && currentChat?.length) {
+    const updateCurrentChat = currentChat.map((d) => {
+      if (d?.chatter_id === data?.user_id) {
+        d.is_online = data?.status || 0;
+      }
+      return d;
+    });
+    useChatStore.setState({ currentChat: updateCurrentChat });
+  }
+};
+const monitor = (data) => {
+  if (!socket) return;
+  socket.emit(ChatMessageKey.MONITOR, data);
+};
+const joinFbWebhook = (data) => {
+  if (!socket) return;
+  socket.emit(ChatMessageKey.JOIN_FB_WEBHOOK, data);
+};
+const sendUtilityMessage = (chatItem, content, extraData = {}) => {
+  const user = getUser();
+  if (!user) return;
+  const { _id: room_id, source, source_id, source_room_id } = chatItem;
+  if (!socket || !room_id) return;
+  socket.emit(ChatMessageKey.NEW_MESSAGE, room_id, {
+    room_id,
+    chatter_id: user._id,
+    chatter_name: user.name,
+    chatter_avatar: user.avatar,
+    chatter_type: "agent",
+    date: Date.now(),
+    content,
+    source,
+    source_id,
+    source_room_id,
+    client_id: clientId,
+    extra_data: extraData
+  });
+};
+const joinChat = (ticketId) => {
+  socket?.emit(ChatMessageKey.JOIN, ticketId);
+};
+const forwardChat = (data) => {
+  if (!socket) return;
+  socket.emit(ChatMessageKey.FORWARD, {
+    agent_id: data.agentId,
+    from_user_id: data.fromUserId,
+    from_user: data.fromUser,
+    tenant_id: data.tenantId,
+    ticket_id: data.ticketId,
+    status: data.status
+  });
+};
+const sendInternalMessage = (roomId, message) => {
+  if (!socket || !roomId || !message) return;
+  socket.emit(ChatMessageKey.NEW_INTERNAL_MESSAGE, {
+    room_id: roomId,
+    message
+  });
+};
+const joinInternalChat = (data) => {
+  if (!socket) return;
+  socket.emit(ChatMessageKey.JOIN_INTERNAL, {
+    room_id: data?.roomId,
+    agent_id: data?.agentId
+  });
+};
+registerChatTransport({
+  name: "chat",
+  connect: connectSocket,
+  disconnect: disconnectSocket,
+  methods: {
+    connectSocket,
+    disconnectSocket,
+    sendMessage,
+    sendUtilityMessage,
+    assignChat,
+    joinChat,
+    leaveChat,
+    forwardChat,
+    monitor,
+    sendInternalMessage,
+    joinInternalChat,
+    joinFbWebhook,
+    onMessageRead,
+    onRoomReadUpdated,
+    addContentfulMessage
+  }
+});
+export {
+  addContentfulMessage,
+  assignChat,
+  connectSocket,
+  disconnectSocket,
+  forwardChat,
+  joinChat,
+  joinFbWebhook,
+  joinInternalChat,
+  leaveChat,
+  monitor,
+  onMessageRead,
+  onRoomReadUpdated,
+  sendInternalMessage,
+  sendMessage,
+  sendUtilityMessage
+};