n CometChat React Native UI Kit, the Conversations and Chat components re-render/reinitialize every time the screen regains focus, causing UI lag and brief freezes. A built-in offline caching mechanism is needed to persist conversations and messages locally, so the UI can reuse existing data instead of rebuilding on each navigation. This would ensure smoother transitions, reduce unnecessary re-renders, and enable incremental updates instead of full reloads.

Currently, all default modals provided by the UI Kit can only be closed through explicit button actions (e.g., close or cancel buttons). In our application, we follow a UX pattern where modals can also be dismissed by clicking on the overlay (outside the modal content). This behavior is already implemented in our custom modals, and we would like to have the same capability in the UI Kit modals for consistency.

We need support for 24-hour time format and proper date localization in the Angular v4 UI Kit. Currently, the UI Kit does not provide a way to configure or customize the time format or adapt date/time display based on locale. This limits the ability to align the UI with regional preferences and user expectations.

Currently, CometChat provides sentAt and updatedAt fields as Unix timestamps in seconds (10-digit format). This limitation can lead to inconsistent or non-deterministic ordering when multiple messages are sent within the same second, especially in high-frequency messaging scenarios. While using the auto-incrementing id field as a secondary sort key serves as a workaround, it introduces additional client-side logic and does not fully replace the need for precise timestamping.

Currently, in CometChat Calls (including the Flutter UI Kit), participants have the ability to mute other users through the participant actions menu. This behavior is not ideal for many applications, as it allows users to control other participants’ audio without restriction, resulting in a poor user experience and reduced sense of personal control. To address this, we propose introducing granular permission controls for participant audio actions. This would include the ability to restrict mute functionality so that users can only mute or unmute themselves by default, along with an option to disable the “muteParticipant” capability through roles or permissions. Additionally, the UI Kit should support conditionally hiding or disabling mute controls for other participants based on these permissions, while still allowing flexibility for privileged roles such as moderators or admins to retain this capability if required. The expected outcome is that each participant can manage only their own microphone unless explicitly granted additional permissions. Muting others would be restricted by default, and the UI Kit would dynamically reflect these permission settings. Implementing this feature would significantly improve user experience, prevent misuse, align CometChat with standard practices in modern communication platforms, and reduce the need for extensive UI-level customizations.

When a user sends a message and begins typing a new one before the previous send operation completes, the message composer may unexpectedly clear the newly typed text. This occurs due to the internal composerRestore mechanism, which is intended to restore user input after the SDK clears the composer on send completion. Currently, the restoration process triggers a component remount with the correct initialComposerText. However, it is immediately followed by a reset of composerRestore, causing a second remount without the restored text—resulting in text loss.

We need the ability to ensure that only one tab on the same device can participate in a call at any given time, while still allowing users to explicitly switch between devices (e.g., mobile app ↔ web browser). Additional Considerations / Questions: Is there any session arbitration or device takeover API available? Can we query the number of active connections for a given UID? What is the recommended approach or architecture to enforce single-session calling in a multi-tab web application?

We need a provision to add new/custom toolbar options to the existing toolbar menu in the React Native UI Kit. This would allow developers to extend the toolbar with additional actions based on their use case.

We need a retry button for failed messages in the main message list so users can easily resend them.

When we copy a mention from the chat, paste it into the composer, and then send it, it is sent as plain text instead of a clickable mention.

Requesting support for Picture-in-Picture (PiP) mode and a “Tap to return to call” experience similar to Google Meet. This would allow the call to remain active when the app is minimized or runs in the background, with a floating PiP window for quick access and the ability to instantly return to the full call screen.

Provide an option in group management APIs to set the actor name for action messages independently of permission checks. Currently, using onBehalfOf enforces user permissions, while omitting it defaults the actor to “System.” A flag or parameter to control only the display name (without tying it to permissions) would help support server-side operations while maintaining accurate user attribution in UI messages.

We request enhancements to the CometChat calling infrastructure to support robust backend-driven control and visibility over call sessions. While the current React Native SDK enables basic calling functionality, there are several limitations from a backend perspective that restrict advanced use cases such as monitoring, compliance, and centralized session management. We propose the following enhancements: A. Server-Side Call Lifecycle APIs APIs to fetch detailed call session data (status, participants, timestamps, termination reasons) Ability to monitor and manage active calls in real-time B. Force Call Termination API Backend API to terminate active calls programmatically Support for use cases like moderation, time limits, and system-triggered disconnects C. Server-Side Recording Management APIs to start/stop recordings from backend Support for configurable formats (audio/video), resolution, and layouts Synchronous or callback-based recording access D. Enhanced Webhook Events Detailed call termination reasons Network-related events and failure diagnostics User-level disconnect causes E. Custom Metadata Support Ability to attach custom metadata to call sessions Metadata accessible via webhooks and APIs for backend-driven workflows Expected Impact: These enhancements would enable: Better observability and debugging of call sessions Stronger compliance and governance controls Advanced backend-driven workflows and automation Improved overall flexibility for enterprise-grade applications We believe these capabilities are essential for building scalable, compliant, and fully managed calling solutions using CometChat.

Currently, message search uses fuzzy matching and returns results for partial or related keywords when searching for a phrase (e.g., searching “add member” returns results for “add” and “member” separately). We request the ability to perform exact phrase searches so that only messages containing the complete phrase are returned. This will help improve search precision and user experience.

is it posible to intergrate with MS-Teams calling? The use-case is that when a customer calls (through a regular phone) the phonecall is picked up by CometChat and an AI voice gives a response to the customer.

We would like to request support for message pinning and unpinning through REST APIs in CometChat. Currently, message pinning is only available via the Pin Message Extension and is not accessible through REST API endpoints. This limits use cases that rely on backend-driven workflows and server-side control. We propose adding endpoints to pin and unpin messages (e.g., POST /v3/messages/{messageId}/pin and DELETE /v3/messages/{messageId}/pin) so developers can manage pinned messages programmatically.

Add support for displaying unread indicators on message bubbles that contain threads (e.g., “12 replies”). The indicator can either show the unread count or a simple unread marker.

Request to add an export option in the CometChat dashboard to download active and inactive user lists directly. This would improve ease of access and reduce reliance on API calls for basic data retrieval.

Opening a conversation in the CometChat React Native UI Kit currently triggers a full reload of messages from the server each time, resulting in slower load times and a less responsive user experience. In a real-time chat application, users expect conversations to open instantly with previously viewed messages readily available. The lack of a local caching mechanism leads to repeated network calls and unnecessary data fetching, even for recently accessed chats. Introducing a local caching mechanism to store recent conversations and messages on the device would allow chats to load instantly while syncing with the server in the background. This would significantly improve performance, reduce latency, and provide a smoother and more seamless user experience, especially in low or unstable network conditions.

Currently, when a media or image upload fails due to poor or unstable network connectivity, there is no option for the user to retry or re-upload the file directly. We propose adding a retry or re-upload option for failed media uploads, allowing users to easily attempt the upload again without restarting the entire process. This enhancement would improve usability and provide a smoother experience in cases where uploads fail due to temporary network issues.