diff --git a/api/server/utils/import/importBatchBuilder.js b/api/server/utils/import/importBatchBuilder.js index 3ab878f298..0328d344d9 100644 --- a/api/server/utils/import/importBatchBuilder.js +++ b/api/server/utils/import/importBatchBuilder.js @@ -175,6 +175,7 @@ class ImportBatchBuilder { delete convo.lastResponseAt; delete convo.lastResponseMessageId; delete convo.lastResponseIsManual; + delete convo.isMarkedUnread; delete convo.lastSeenAt; this.conversations.push(convo); diff --git a/client/src/components/Conversations/__tests__/running.spec.ts b/client/src/components/Conversations/__tests__/running.spec.ts index 396bd642e5..3af52fa202 100644 --- a/client/src/components/Conversations/__tests__/running.spec.ts +++ b/client/src/components/Conversations/__tests__/running.spec.ts @@ -249,8 +249,11 @@ describe('groupConversationsByStatus finished chats', () => { ]); }); - it('leaves a chat marked unread by hand in its date group', () => { - const manual = replied('manual', 1, { lastResponseIsManual: true }); + it.each([ + { lastResponseIsManual: true }, + { isMarkedUnread: true, lastResponseMessageId: 'real-reply' }, + ])('leaves a chat marked unread by hand in its date group (%j)', (marker) => { + const manual = replied('manual', 1, marker); const dated = groupConversations([manual], newestFirst); expect(partitionGroups(dated, new Set(), newestFirst)).toBe(dated); diff --git a/client/src/components/Conversations/running.ts b/client/src/components/Conversations/running.ts index 563d7e9c5a..61e2d83fda 100644 --- a/client/src/components/Conversations/running.ts +++ b/client/src/components/Conversations/running.ts @@ -22,7 +22,11 @@ function showsStatusGroups(options: ConversationGroupOptions): boolean { /** A reply that landed while the user was elsewhere. "Mark as unread" sets the same * stamp as a reminder, not as a finished run, so that chat keeps its date. */ function isFinishedUnseen(conversation: TConversation): boolean { - return conversation.lastResponseIsManual !== true && isConversationUnseen(conversation); + return ( + conversation.isMarkedUnread !== true && + conversation.lastResponseIsManual !== true && + isConversationUnseen(conversation) + ); } function newestFirst(a: TConversation, b: TConversation): number { diff --git a/client/src/components/Conversations/utils.ts b/client/src/components/Conversations/utils.ts index 62c1ef2b0f..e9c2dd69a7 100644 --- a/client/src/components/Conversations/utils.ts +++ b/client/src/components/Conversations/utils.ts @@ -44,6 +44,7 @@ export function areConversationListItemFieldsEqual( holds, which means these have to be compared in their own right. */ prevConversation.lastResponseAt === nextConversation.lastResponseAt && prevConversation.lastResponseIsManual === nextConversation.lastResponseIsManual && + prevConversation.isMarkedUnread === nextConversation.isMarkedUnread && prevConversation.lastSeenAt === nextConversation.lastSeenAt ); } diff --git a/client/src/data-provider/__tests__/pinnedConversations.test.tsx b/client/src/data-provider/__tests__/pinnedConversations.test.tsx index 627d3d29d2..a25506df02 100644 --- a/client/src/data-provider/__tests__/pinnedConversations.test.tsx +++ b/client/src/data-provider/__tests__/pinnedConversations.test.tsx @@ -444,6 +444,7 @@ describe('pinned list cache synchronization', () => { isShared: true, lastResponseAt: '2026-08-16T10:00:00.000Z', lastResponseIsManual: true, + isMarkedUnread: true, lastSeenAt: '2026-08-16T10:01:00.000Z', } as TConversation); @@ -451,6 +452,7 @@ describe('pinned list cache synchronization', () => { expect('isShared' in stripped).toBe(false); expect('lastResponseAt' in stripped).toBe(false); expect('lastResponseIsManual' in stripped).toBe(false); + expect('isMarkedUnread' in stripped).toBe(false); expect('lastSeenAt' in stripped).toBe(false); expect(stripped.conversationId).toBe(pinnedConversationId); expect(stripped.title).toBe(pinnedConvo.title); diff --git a/client/src/data-provider/__tests__/useMarkConversationUnreadMutation.test.tsx b/client/src/data-provider/__tests__/useMarkConversationUnreadMutation.test.tsx index 4684f538e3..62e2d8e2d6 100644 --- a/client/src/data-provider/__tests__/useMarkConversationUnreadMutation.test.tsx +++ b/client/src/data-provider/__tests__/useMarkConversationUnreadMutation.test.tsx @@ -4,8 +4,12 @@ import { EModelEndpoint, QueryKeys } from 'librechat-data-provider'; import { QueryClient, QueryClientProvider } from '@tanstack/react-query'; import type { InfiniteData } from '@tanstack/react-query'; import type { ConversationCursorData } from '~/utils/convos'; +import { + groupConversationsByStatus, + FINISHED_CHATS_GROUP, +} from '~/components/Conversations/running'; import { useMarkConversationSeenMutation, useMarkConversationUnreadMutation } from '../mutations'; -import { isConversationUnseen, updateConvoInAllQueries } from '~/utils'; +import { applyServerReplyStamp, isConversationUnseen, updateConvoInAllQueries } from '~/utils'; const mockMarkUnread = jest.fn(); const mockMarkSeen = jest.fn(); @@ -73,6 +77,43 @@ describe('useMarkConversationUnreadMutation', () => { mockMarkSeen.mockReset(); }); + it('keeps a manually unread real reply out of Finished, then lifts a newer reply', async () => { + mockMarkUnread.mockResolvedValue({ + modified: true, + lastResponseAt: RESPONDED_AT, + isMarkedUnread: true, + }); + const { result, cached, queryClient } = setup(RESPONDED_AT, SEEN_AT); + const options = { field: 'updatedAt', direction: 'desc' } as const; + await act(async () => { + await result.current.mutateAsync({ conversationId: CONVO_ID }); + }); + expect(cached()?.isMarkedUnread).toBe(true); + expect(cached()?.lastResponseMessageId).toBe('original-reply'); + const dates = [['Today', [cached()!]]] as [string, NonNullable>[]][]; + expect(groupConversationsByStatus(dates, new Set(), options)).toBe(dates); + act(() => { + applyServerReplyStamp(queryClient, CONVO_ID, { + lastResponseAt: '2026-08-16T12:00:00.000Z', + lastResponseMessageId: 'new-reply', + }); + }); + expect(cached()?.isMarkedUnread).toBeUndefined(); + expect(groupConversationsByStatus([['Today', [cached()!]]], new Set(), options)[0][0]).toBe( + FINISHED_CHATS_GROUP, + ); + }); + + it('restores manual unread intent when the write fails', async () => { + mockMarkUnread.mockRejectedValue(new Error('Unavailable')); + const { result, cached } = setup(RESPONDED_AT, SEEN_AT); + await act(async () => { + await result.current.mutateAsync({ conversationId: CONVO_ID }).catch(() => undefined); + }); + expect(cached()?.isMarkedUnread).toBeUndefined(); + expect(cached()?.lastSeenAt).toBe(SEEN_AT); + }); + it('reasserts the unread state when a refetch lands on top of it', async () => { /* A list refetch already in flight can have read the old catch-up and commit after the optimistic clear, quietly taking the dot back off a conversation the server did flag. */ @@ -87,6 +128,7 @@ describe('useMarkConversationUnreadMutation', () => { await waitFor(() => expect(isConversationUnseen(cached())).toBe(true)); expect(cached()?.lastSeenAt).toBeUndefined(); + expect(cached()?.isMarkedUnread).toBe(true); }); it('preserves a later seen operation even when its stamp equals the original catch-up', async () => { diff --git a/client/src/data-provider/mutations.ts b/client/src/data-provider/mutations.ts index cdc3e18162..67609383e0 100644 --- a/client/src/data-provider/mutations.ts +++ b/client/src/data-provider/mutations.ts @@ -569,7 +569,11 @@ export const useMarkConversationSeenMutation = (): UseMutationResult< */ type UnreadWriteBaseline = Pick< t.TConversation, - 'lastResponseAt' | 'lastResponseMessageId' | 'lastResponseIsManual' | 'lastSeenAt' + | 'lastResponseAt' + | 'lastResponseMessageId' + | 'lastResponseIsManual' + | 'isMarkedUnread' + | 'lastSeenAt' >; const resolveReplyIdentity = ( @@ -671,6 +675,7 @@ const reassertAcceptedUnread = ( serverResponseAt == null ? convo.lastResponseMessageId : resolveReplyIdentity(convo, data), lastResponseIsManual: serverResponseAt == null ? convo.lastResponseIsManual : data.lastResponseIsManual, + isMarkedUnread: data.isMarkedUnread ?? true, lastSeenAt: undefined, })); }; @@ -702,6 +707,7 @@ export const useMarkConversationUnreadMutation = (): UseMutationResult< lastResponseAt: observed?.lastResponseAt, lastResponseMessageId: observed?.lastResponseMessageId, lastResponseIsManual: observed?.lastResponseIsManual, + isMarkedUnread: observed?.isMarkedUnread, lastSeenAt: observed?.lastSeenAt, }); const interrupted = await cancelConvoReadFetches(queryClient, vars.conversationId); @@ -710,6 +716,7 @@ export const useMarkConversationUnreadMutation = (): UseMutationResult< lastResponseAt: owner.chain.baseline.lastResponseAt, lastResponseMessageId: owner.chain.baseline.lastResponseMessageId, lastResponseIsManual: owner.chain.baseline.lastResponseIsManual, + isMarkedUnread: owner.chain.baseline.isMarkedUnread, lastSeenAt: owner.chain.baseline.lastSeenAt, token: owner.token, interrupted, @@ -734,6 +741,7 @@ export const useMarkConversationUnreadMutation = (): UseMutationResult< : convo.lastResponseMessageId, lastResponseIsManual: convo.lastResponseAt == null || convo.lastResponseIsManual === true ? true : undefined, + isMarkedUnread: true, lastSeenAt: undefined, })); return context; @@ -812,6 +820,7 @@ export const useMarkConversationUnreadMutation = (): UseMutationResult< const lastResponseIsManual = keepsCached ? cached?.lastResponseIsManual : data.lastResponseIsManual; + const isMarkedUnread = keepsCached ? cached?.isMarkedUnread : (data.isMarkedUnread ?? true); const lastResponseMessageId = keepsCached || serverResponseAt == null ? cached?.lastResponseMessageId @@ -820,6 +829,7 @@ export const useMarkConversationUnreadMutation = (): UseMutationResult< cached?.lastSeenAt === undefined && cachedResponseAt === lastResponseAt && cached?.lastResponseIsManual === lastResponseIsManual && + cached?.isMarkedUnread === isMarkedUnread && cached?.lastResponseMessageId === lastResponseMessageId ) { return; @@ -829,6 +839,7 @@ export const useMarkConversationUnreadMutation = (): UseMutationResult< lastResponseAt, lastResponseMessageId, lastResponseIsManual, + isMarkedUnread, lastSeenAt: undefined, })); }, @@ -865,6 +876,7 @@ export const useMarkConversationUnreadMutation = (): UseMutationResult< lastResponseAt: context?.lastResponseAt, lastResponseMessageId: resolveReplyIdentity(convo, context), lastResponseIsManual: context?.lastResponseIsManual, + isMarkedUnread: context?.isMarkedUnread, lastSeenAt: context?.lastSeenAt, })); }, diff --git a/client/src/hooks/Conversations/useReplyWatcher.ts b/client/src/hooks/Conversations/useReplyWatcher.ts index 0f54eee2f5..cf4f3c10fd 100644 --- a/client/src/hooks/Conversations/useReplyWatcher.ts +++ b/client/src/hooks/Conversations/useReplyWatcher.ts @@ -220,6 +220,7 @@ const mergeTimestamps = async ( lastResponseAt, lastResponseMessageId, lastResponseIsManual, + isMarkedUnread, lastSeenAt, updatedAt, } = convo; @@ -260,6 +261,7 @@ const mergeTimestamps = async ( cached && cached.lastResponseAt === lastResponseAt && cached.lastResponseIsManual === lastResponseIsManual && + cached.isMarkedUnread === isMarkedUnread && cached.lastSeenAt === (lastSeenAt ?? undefined) && (updatedAt === undefined || cached.updatedAt === updatedAt) && (incomingResponseMessageId === undefined || @@ -286,11 +288,13 @@ const mergeTimestamps = async ( lastResponseIsManual === true ? undefined : (incomingResponseMessageId ?? cached.lastResponseMessageId); + const nextIsMarkedUnread = stampDelivery ? cached.isMarkedUnread : isMarkedUnread; const nextLastSeenAt = stampDelivery ? cached.lastSeenAt : lastSeenAt; const nextUpdatedAt = stampDelivery ? cached.updatedAt : (updatedAt ?? cached.updatedAt); if ( cached.lastResponseMessageId !== nextLastResponseMessageId || cached.lastResponseIsManual !== lastResponseIsManual || + cached.isMarkedUnread !== nextIsMarkedUnread || cached.lastSeenAt !== nextLastSeenAt || cached.updatedAt !== nextUpdatedAt ) { @@ -298,6 +302,7 @@ const mergeTimestamps = async ( ...current, lastResponseMessageId: nextLastResponseMessageId, lastResponseIsManual, + isMarkedUnread: nextIsMarkedUnread, lastSeenAt: nextLastSeenAt, updatedAt: nextUpdatedAt, })); @@ -355,6 +360,7 @@ const mergeTimestamps = async ( fresh.lastResponseAt === lastResponseAt && fresh.lastResponseMessageId === (incomingResponseMessageId ?? fresh.lastResponseMessageId) && fresh.lastResponseIsManual === lastResponseIsManual && + fresh.isMarkedUnread === isMarkedUnread && fresh.lastSeenAt === (lastSeenAt ?? undefined) && (updatedAt === undefined || fresh.updatedAt === updatedAt) ) { @@ -369,6 +375,7 @@ const mergeTimestamps = async ( lastResponseAt, lastResponseMessageId: incomingResponseMessageId ?? current.lastResponseMessageId, lastResponseIsManual, + isMarkedUnread, lastSeenAt, updatedAt: updatedAt ?? current.updatedAt, }), diff --git a/client/src/utils/conversation.ts b/client/src/utils/conversation.ts index 1675d2cecf..1f578e3884 100644 --- a/client/src/utils/conversation.ts +++ b/client/src/utils/conversation.ts @@ -28,6 +28,7 @@ const sidebarFields = [ 'lastResponseAt', 'lastResponseMessageId', 'lastResponseIsManual', + 'isMarkedUnread', 'lastSeenAt', 'isTemporary', 'expiredAt', diff --git a/client/src/utils/convos.ts b/client/src/utils/convos.ts index f050dc30f3..63fa5bd674 100644 --- a/client/src/utils/convos.ts +++ b/client/src/utils/convos.ts @@ -1240,6 +1240,7 @@ export function applyServerReplyStamp( lastResponseAt, lastResponseMessageId: lastResponseMessageId ?? convo.lastResponseMessageId, lastResponseIsManual: undefined, + isMarkedUnread: advances ? undefined : convo.isMarkedUnread, lastSeenAt: advances ? undefined : convo.lastSeenAt, updatedAt: updatedAt ?? convo.updatedAt, }), @@ -1278,6 +1279,13 @@ const preserveReadState = (next: TConversation, found: TConversation): TConversa if (!('lastResponseIsManual' in next)) { merged.lastResponseIsManual = found.lastResponseIsManual; } + if (!('isMarkedUnread' in next)) { + merged.isMarkedUnread = + next.lastResponseAt != null && + (found.lastResponseAt == null || next.lastResponseAt > found.lastResponseAt) + ? undefined + : found.isMarkedUnread; + } if (!('lastSeenAt' in next)) { merged.lastSeenAt = found.lastSeenAt; } @@ -1296,6 +1304,7 @@ const chatOwnedStaleFields = [ 'lastResponseAt', 'lastResponseMessageId', 'lastResponseIsManual', + 'isMarkedUnread', 'lastSeenAt', ] as const; diff --git a/e2e/specs/mock/scenarios/unseen-replies.spec.ts b/e2e/specs/mock/scenarios/unseen-replies.spec.ts index eed4179a68..2f5c66a1c8 100644 --- a/e2e/specs/mock/scenarios/unseen-replies.spec.ts +++ b/e2e/specs/mock/scenarios/unseen-replies.spec.ts @@ -258,6 +258,24 @@ test.describe('unseen replies', () => { /* At least one more, not exactly one: the other projects share this user * and seed unseen conversations of their own while this one runs. */ await expect.poll(() => titleCount(page)).toBeGreaterThanOrEqual(baseline + 1); + await expect.poll(async () => (await readConversation(id))?.isMarkedUnread).toBe(true); + expect((await readConversation(id))?.lastResponseIsManual).not.toBe(true); + await page.reload(); + await openSidebar(page); + await expect(row.locator('span[aria-hidden="true"].bg-status-info')).toBeVisible(); + await expect + .poll(async () => + row.evaluate((node) => { + let previous = node.closest('[role="row"]')?.previousElementSibling; + while (previous) { + const heading = previous.querySelector('h2'); + if (heading) return heading.textContent; + previous = previous.previousElementSibling; + } + return null; + }), + ) + .toBe('Today'); const token = await getAccessToken(page); const neverReplied = conversationId(); diff --git a/packages/data-provider/src/config.ts b/packages/data-provider/src/config.ts index 44e6a247c7..560e5f3da2 100644 --- a/packages/data-provider/src/config.ts +++ b/packages/data-provider/src/config.ts @@ -158,6 +158,7 @@ export const excludedKeys = new Set([ 'lastResponseAt', 'lastResponseMessageId', 'lastResponseIsManual', + 'isMarkedUnread', 'lastSeenAt', ]); diff --git a/packages/data-provider/src/schemas.spec.ts b/packages/data-provider/src/schemas.spec.ts index 7ec806e2ff..d16ae2e124 100644 --- a/packages/data-provider/src/schemas.spec.ts +++ b/packages/data-provider/src/schemas.spec.ts @@ -798,12 +798,14 @@ describe('tPresetSchema', () => { lastResponseAt: '2026-08-16T10:00:00.000Z', lastResponseMessageId: 'reply-1', lastResponseIsManual: true, + isMarkedUnread: true, lastSeenAt: '2026-08-16T09:00:00.000Z', }); expect(parsed).not.toHaveProperty('lastResponseAt'); expect(parsed).not.toHaveProperty('lastResponseMessageId'); expect(parsed).not.toHaveProperty('lastResponseIsManual'); + expect(parsed).not.toHaveProperty('isMarkedUnread'); expect(parsed).not.toHaveProperty('lastSeenAt'); }); diff --git a/packages/data-provider/src/schemas.ts b/packages/data-provider/src/schemas.ts index 2f062b4d33..830fb997dd 100644 --- a/packages/data-provider/src/schemas.ts +++ b/packages/data-provider/src/schemas.ts @@ -1255,6 +1255,8 @@ export const tConversationSchema = z.object({ lastResponseMessageId: z.string().optional(), /** True only while `lastResponseAt` is the synthetic marker from "mark unread". */ lastResponseIsManual: z.boolean().optional(), + /** Manual reminder, cleared by reading or a new persisted reply. */ + isMarkedUnread: z.boolean().optional(), /** Set when the user has the newest message on screen; compared against `lastResponseAt`. */ lastSeenAt: z.string().optional(), /* Files */ @@ -1326,6 +1328,7 @@ export const tPresetSchema = tConversationSchema lastResponseAt: true, lastResponseMessageId: true, lastResponseIsManual: true, + isMarkedUnread: true, lastSeenAt: true, }) .merge( diff --git a/packages/data-provider/src/types.ts b/packages/data-provider/src/types.ts index 4f16626bd6..4aac843eee 100644 --- a/packages/data-provider/src/types.ts +++ b/packages/data-provider/src/types.ts @@ -513,6 +513,7 @@ export type TMarkConversationUnreadResponse = { lastResponseMessageId?: string; /** True only when the settled stamp is the synthetic mark-unread marker. */ lastResponseIsManual?: boolean; + isMarkedUnread?: boolean; }; export type TSharedMessagesResponse = Omit & { diff --git a/packages/data-provider/src/types/queries.ts b/packages/data-provider/src/types/queries.ts index 5328a8052d..4552b5fff5 100644 --- a/packages/data-provider/src/types/queries.ts +++ b/packages/data-provider/src/types/queries.ts @@ -54,6 +54,7 @@ export type MinimalConversation = Pick< | 'lastResponseAt' | 'lastResponseMessageId' | 'lastResponseIsManual' + | 'isMarkedUnread' | 'lastSeenAt' >; diff --git a/packages/data-schemas/src/methods/conversation.spec.ts b/packages/data-schemas/src/methods/conversation.spec.ts index eaa3eadecc..632364428c 100644 --- a/packages/data-schemas/src/methods/conversation.spec.ts +++ b/packages/data-schemas/src/methods/conversation.spec.ts @@ -3181,6 +3181,7 @@ describe('Conversation Operations', () => { const result = await markConvoUnread('user123', mockConversationData.conversationId); expect(result.modified).toBe(true); + expect(result.isMarkedUnread).toBe(true); const convo = await Conversation.findOne({ conversationId: mockConversationData.conversationId, @@ -3188,6 +3189,7 @@ describe('Conversation Operations', () => { expect(convo?.lastSeenAt).toBeUndefined(); expect(convo?.lastResponseAt?.toISOString()).toBe('2026-08-16T10:00:00.000Z'); expect(convo?.lastResponseIsManual).toBeUndefined(); + expect(convo?.isMarkedUnread).toBe(true); }); it('returns the stamp it settled on so the client never invents one', async () => { @@ -3293,6 +3295,65 @@ describe('Conversation Operations', () => { expect(convo?.lastSeenAt).toBeInstanceOf(Date); }); }); + + describe('manual unread reminders', () => { + it('survives reload and is cleared by a persisted real reply', async () => { + await Conversation.create({ + conversationId: mockConversationData.conversationId, + user: 'user123', + endpoint: EModelEndpoint.openAI, + lastResponseAt: new Date('2026-08-16T10:00:00.000Z'), + lastResponseMessageId: 'original-reply', + }); + await methods.markConvoUnread('user123', mockConversationData.conversationId); + const unread = await Conversation.findOne({ + conversationId: mockConversationData.conversationId, + }).lean(); + expect(unread?.isMarkedUnread).toBe(true); + expect(unread?.lastResponseMessageId).toBe('original-reply'); + await methods.stampConvoLastResponse( + 'user123', + mockConversationData.conversationId, + 'new-reply', + ); + const replied = await Conversation.findOne({ + conversationId: mockConversationData.conversationId, + }).lean(); + expect(replied?.isMarkedUnread).toBeUndefined(); + expect(replied?.lastResponseMessageId).toBe('new-reply'); + }); + + it('is cleared only by an acknowledgement of the current reply', async () => { + const responseAt = new Date('2026-08-16T10:00:00.000Z'); + await Conversation.create({ + conversationId: mockConversationData.conversationId, + user: 'user123', + endpoint: EModelEndpoint.openAI, + lastResponseAt: responseAt, + isMarkedUnread: true, + }); + await methods.markConvoSeen( + 'user123', + mockConversationData.conversationId, + new Date(responseAt.getTime() - 1), + ); + expect( + ( + await Conversation.findOne({ + conversationId: mockConversationData.conversationId, + }).lean() + )?.isMarkedUnread, + ).toBe(true); + await methods.markConvoSeen('user123', mockConversationData.conversationId, responseAt); + expect( + ( + await Conversation.findOne({ + conversationId: mockConversationData.conversationId, + }).lean() + )?.isMarkedUnread, + ).toBeUndefined(); + }); + }); describe('unseen-reply fields', () => { it('returns lastResponseAt, manual marker, and lastSeenAt from the cursor listing', async () => { const lastResponseAt = new Date('2026-08-16T10:00:00.000Z'); @@ -3304,6 +3365,7 @@ describe('Conversation Operations', () => { lastResponseAt, lastResponseMessageId: 'reply-listed', lastResponseIsManual: true, + isMarkedUnread: true, lastSeenAt, }); @@ -3312,6 +3374,7 @@ describe('Conversation Operations', () => { expect(conversations[0].lastResponseAt?.toISOString()).toBe(lastResponseAt.toISOString()); expect(conversations[0].lastResponseMessageId).toBe('reply-listed'); expect(conversations[0].lastResponseIsManual).toBe(true); + expect(conversations[0].isMarkedUnread).toBe(true); expect(conversations[0].lastSeenAt?.toISOString()).toBe(lastSeenAt.toISOString()); }); diff --git a/packages/data-schemas/src/methods/conversation.ts b/packages/data-schemas/src/methods/conversation.ts index 272f40a8f6..3cc503ace5 100644 --- a/packages/data-schemas/src/methods/conversation.ts +++ b/packages/data-schemas/src/methods/conversation.ts @@ -573,6 +573,7 @@ export interface ConversationMethods { lastResponseAt?: Date; lastResponseMessageId?: string; lastResponseIsManual?: boolean; + isMarkedUnread?: boolean; }>; stampConvoLastResponse( user: string, @@ -653,7 +654,7 @@ export function createConversationMethods( casFilter, { $set: { lastResponseAt: stamp, lastResponseMessageId: responseMessageId }, - $unset: { lastSeenAt: '', lastResponseIsManual: '' }, + $unset: { lastSeenAt: '', lastResponseIsManual: '', isMarkedUnread: '' }, $max: { updatedAt: stamp }, }, { new: true, projection, timestamps: false }, @@ -2413,6 +2414,7 @@ export function createConversationMethods( /* Read-state fields are server-owned. A stale marker must never be reintroduced by a * metadata save after a real reply cleared it. */ delete update.lastResponseIsManual; + delete update.isMarkedUnread; delete update.lastResponseAt; delete update.lastResponseMessageId; delete update.initial_agent_id; @@ -2436,6 +2438,7 @@ export function createConversationMethods( } const unsetFields: Record = { ...(metadata?.unsetFields ?? {}) }; delete unsetFields.lastResponseIsManual; + delete unsetFields.isMarkedUnread; delete unsetFields.lastResponseMessageId; delete unsetFields.lastResponseAt; delete unsetFields.initial_agent_id; @@ -2568,7 +2571,7 @@ export function createConversationMethods( const { lastResponseAt, ...withoutReplyStamp } = setFields; operation.$set = withoutReplyStamp; operation.$max = { lastResponseAt }; - operation.$unset = { lastResponseIsManual: '' }; + operation.$unset = { lastResponseIsManual: '', isMarkedUnread: '' }; } if (Object.keys(unsetFields).length > 0) { operation.$unset = { @@ -2736,6 +2739,7 @@ export function createConversationMethods( lastResponseAt: 1, lastResponseMessageId: 1, lastResponseIsManual: 1, + isMarkedUnread: 1, updatedAt: 1, }, ); @@ -2746,6 +2750,7 @@ export function createConversationMethods( conversation.lastResponseAt = stamped.stamp; conversation.lastResponseMessageId = stamped.conversation.lastResponseMessageId; conversation.lastResponseIsManual = stamped.conversation.lastResponseIsManual; + conversation.isMarkedUnread = stamped.conversation.isMarkedUnread; conversation.lastSeenAt = undefined; if (stamped.conversation.updatedAt) { conversation.updatedAt = stamped.conversation.updatedAt; @@ -3091,6 +3096,7 @@ export function createConversationMethods( delete sanitized.lastResponseAt; delete sanitized.lastResponseMessageId; delete sanitized.lastResponseIsManual; + delete sanitized.isMarkedUnread; delete sanitized.lastSeenAt; delete sanitized.codeApprovalMode; delete sanitized.initial_agent_id; @@ -3512,7 +3518,7 @@ export function createConversationMethods( the sidebar lists archived and unarchived chats in the same session, and the active list also carries the unarchived pins beside them. */ .select( - 'conversationId endpoint title createdAt updatedAt archivedAt isArchived user model agent_id assistant_id spec iconURL chatProjectId pinned lastResponseAt lastResponseMessageId lastResponseIsManual lastSeenAt', + 'conversationId endpoint title createdAt updatedAt archivedAt isArchived user model agent_id assistant_id spec iconURL chatProjectId pinned lastResponseAt lastResponseMessageId lastResponseIsManual isMarkedUnread lastSeenAt', ) .sort(sortObj) .limit(pageSize + 1) @@ -4003,7 +4009,7 @@ export function createConversationMethods( const lastSeenAt = observedResponseAt && observedResponseAt > now ? observedResponseAt : now; const result = await Conversation.updateOne( filter, - { $set: { lastSeenAt } }, + { $set: { lastSeenAt }, $unset: { isMarkedUnread: '' } }, { timestamps: false }, ); /* Matched, not modified: a retry of an acknowledgement that already landed writes the @@ -4032,7 +4038,12 @@ export function createConversationMethods( async function markConvoUnread(user: string, conversationId: string) { try { const Conversation = mongoose.models.Conversation as Model; - const projection = { lastResponseAt: 1, lastResponseMessageId: 1, lastResponseIsManual: 1 }; + const projection = { + lastResponseAt: 1, + lastResponseMessageId: 1, + lastResponseIsManual: 1, + isMarkedUnread: 1, + }; const stamped = await Conversation.findOneAndUpdate( { conversationId, @@ -4040,12 +4051,15 @@ export function createConversationMethods( $or: [{ lastResponseAt: null }, { lastResponseAt: { $exists: false } }], }, { - $set: { lastResponseAt: new Date(), lastResponseIsManual: true }, + $set: { lastResponseAt: new Date(), lastResponseIsManual: true, isMarkedUnread: true }, $unset: { lastSeenAt: '', lastResponseMessageId: '' }, }, { timestamps: false, new: true, projection }, ).lean< - Pick + Pick< + IConversation, + 'lastResponseAt' | 'lastResponseMessageId' | 'lastResponseIsManual' | 'isMarkedUnread' + > >(); if (stamped) { return { @@ -4053,15 +4067,19 @@ export function createConversationMethods( lastResponseAt: stamped.lastResponseAt, lastResponseMessageId: stamped.lastResponseMessageId, lastResponseIsManual: stamped.lastResponseIsManual === true, + isMarkedUnread: stamped.isMarkedUnread, }; } const cleared = await Conversation.findOneAndUpdate( { conversationId, user }, - { $unset: { lastSeenAt: '' } }, + { $set: { isMarkedUnread: true }, $unset: { lastSeenAt: '' } }, { timestamps: false, new: true, projection }, ).lean< - Pick + Pick< + IConversation, + 'lastResponseAt' | 'lastResponseMessageId' | 'lastResponseIsManual' | 'isMarkedUnread' + > >(); return cleared @@ -4070,6 +4088,7 @@ export function createConversationMethods( lastResponseAt: cleared.lastResponseAt, lastResponseMessageId: cleared.lastResponseMessageId, lastResponseIsManual: cleared.lastResponseIsManual === true, + isMarkedUnread: cleared.isMarkedUnread, } : { modified: false }; } catch (error) { diff --git a/packages/data-schemas/src/schema/convo.ts b/packages/data-schemas/src/schema/convo.ts index 61050a0034..44c1349e30 100644 --- a/packages/data-schemas/src/schema/convo.ts +++ b/packages/data-schemas/src/schema/convo.ts @@ -400,6 +400,9 @@ const convoSchema: Schema = new Schema( lastResponseIsManual: { type: Boolean, }, + isMarkedUnread: { + type: Boolean, + }, lastSeenAt: { type: Date, }, diff --git a/packages/data-schemas/src/types/convo.ts b/packages/data-schemas/src/types/convo.ts index 13c7d9d1df..0d2a20b1f1 100644 --- a/packages/data-schemas/src/types/convo.ts +++ b/packages/data-schemas/src/types/convo.ts @@ -346,6 +346,8 @@ export interface IConversation extends Document { lastResponseMessageId?: string; /** True only while `lastResponseAt` is the synthetic marker from "mark unread". */ lastResponseIsManual?: boolean; + /** Manual reminder, cleared by reading or a new persisted reply. */ + isMarkedUnread?: boolean; /** Set when the user has the newest message on screen; compared against `lastResponseAt`. */ lastSeenAt?: Date; }