Enhanced ChatGPT Clone: Features Agents, MCP, Skills, DeepSeek, Anthropic, AWS, OpenAI, Responses API, Azure, Groq, o1, GPT-5, Mistral, OpenRouter, Vertex AI, Gemini, Artifacts, AI model switching, message search, Code Interpreter, langchain, DALL-E-3, OpenAPI Actions, Functions, Secure Multi-User Auth, Presets, open-source for self-hosting. Active
TypeScript aianthropicartifactsawsazurechatgptchatgpt-cloneclaudeclonedeepseekgeminigooglegpt-5librechatmcpo1openairesponses-apivisionwebui
fix: Preserve Legacy Unread Reminder Placement
Liad621cd8b69a8
diff --git a/client/src/components/Conversations/__tests__/running.spec.ts b/client/src/components/Conversations/__tests__/running.spec.tsindex 3af52fa202..b226a5a018 100644--- a/client/src/components/Conversations/__tests__/running.spec.ts+++ b/client/src/components/Conversations/__tests__/running.spec.ts@@ -207,6 +207,7 @@ describe('groupConversationsByStatus finished chats', () => {({...convo(conversationId, daysAgo),lastResponseAt: new Date(Date.now() - daysAgo * 86_400_000).toISOString(),+ isMarkedUnread: false,...read,}) as TConversation;@@ -259,6 +260,30 @@ describe('groupConversationsByStatus finished chats', () => {expect(partitionGroups(dated, new Set(), newestFirst)).toBe(dated);});+ it.each([undefined, false])(+ 'keeps unknown legacy intent in date groups (synthetic flag: %s)',+ (synthetic) => {+ const legacy = replied('legacy', 1, {+ isMarkedUnread: undefined,+ lastResponseIsManual: synthetic,+ lastResponseMessageId: 'existing-reply',+ lastSeenAt: undefined,+ });+ const restored = JSON.parse(JSON.stringify(legacy)) as TConversation;+ const dated = groupConversations([restored], newestFirst);+ expect(partitionGroups(dated, new Set(), newestFirst)).toBe(dated);+ },+ );++ it('shows a new confirmed reply after an unknown legacy reminder', () => {+ const legacy = replied('legacy', 1, { isMarkedUnread: undefined });+ const confirmed = replied('confirmed', 0);+ const dated = groupConversations([confirmed, legacy], newestFirst);+ const groups = partitionGroups(dated, new Set(), newestFirst);+ expect(groups[0]).toEqual([FINISHED_CHATS_GROUP, [confirmed]]);+ expect(groups.slice(1)).toEqual(groupConversations([legacy], newestFirst));+ });+it.each([{ field: 'updatedAt' as const, direction: 'asc' as const },{ field: 'title' as const, direction: 'asc' as const },diff --git a/client/src/components/Conversations/running.ts b/client/src/components/Conversations/running.tsindex 61e2d83fda..f047a0fc44 100644--- a/client/src/components/Conversations/running.ts+++ b/client/src/components/Conversations/running.ts@@ -19,11 +19,10 @@ function showsStatusGroups(options: ConversationGroupOptions): boolean {return !options.includePinned && options.field === 'updatedAt' && options.direction === 'desc';}-/** 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. */+/** Missing intent is legacy/unknown, not evidence of a newly finished reply. */function isFinishedUnseen(conversation: TConversation): boolean {return (- conversation.isMarkedUnread !== true &&+ conversation.isMarkedUnread === false &&conversation.lastResponseIsManual !== true &&isConversationUnseen(conversation));diff --git a/client/src/data-provider/__tests__/useMarkConversationUnreadMutation.test.tsx b/client/src/data-provider/__tests__/useMarkConversationUnreadMutation.test.tsxindex 62e2d8e2d6..0227f6afba 100644--- a/client/src/data-provider/__tests__/useMarkConversationUnreadMutation.test.tsx+++ b/client/src/data-provider/__tests__/useMarkConversationUnreadMutation.test.tsx@@ -98,12 +98,25 @@ describe('useMarkConversationUnreadMutation', () => {lastResponseMessageId: 'new-reply',});});- expect(cached()?.isMarkedUnread).toBeUndefined();+ expect(cached()?.isMarkedUnread).toBe(false);expect(groupConversationsByStatus([['Today', [cached()!]]], new Set(), options)[0][0]).toBe(FINISHED_CHATS_GROUP,);});+ it("keeps an older backend's successful unread response in the date group", async () => {+ mockMarkUnread.mockResolvedValue({ modified: true, lastResponseAt: RESPONDED_AT });+ const { result, cached } = setup(RESPONDED_AT, SEEN_AT);+ await act(async () => {+ await result.current.mutateAsync({ conversationId: CONVO_ID });+ });+ expect(cached()?.isMarkedUnread).toBe(true);+ const dates = [['Today', [cached()!]]] as [string, NonNullable<ReturnType<typeof cached>>[]][];+ expect(+ groupConversationsByStatus(dates, new Set(), { field: 'updatedAt', direction: 'desc' }),+ ).toBe(dates);+ });+it('restores manual unread intent when the write fails', async () => {mockMarkUnread.mockRejectedValue(new Error('Unavailable'));const { result, cached } = setup(RESPONDED_AT, SEEN_AT);diff --git a/client/src/utils/convos.spec.ts b/client/src/utils/convos.spec.tsindex 235f6c8113..c0565d59b1 100644--- a/client/src/utils/convos.spec.ts+++ b/client/src/utils/convos.spec.ts@@ -1201,6 +1201,43 @@ describe('Conversation Utilities', () => {expect(data!.pages[0].conversations[0].lastResponseMessageId).toBe('reply-a');});+ it('does not invent reply eligibility for an unclassified backend snapshot', () => {+ updateConvoInAllQueries(queryClient, 'a', (c) => ({+ ...c,+ lastResponseAt: '2026-08-16T10:00:00.000Z',+ isMarkedUnread: true,+ }));+ updateConvoInAllQueries(+ queryClient,+ 'a',+ () =>+ ({+ conversationId: 'a',+ lastResponseAt: '2026-08-16T11:00:00.000Z',+ }) as TConversation,+ );+ expect(findConvoInAllQueries(queryClient, 'a')?.isMarkedUnread).toBeUndefined();+ });++ it('marks only an advancing live reply as confirmed, preserving reminders on duplicate delivery', () => {+ const original = '2026-08-16T10:00:00.000Z';+ updateConvoInAllQueries(queryClient, 'a', (c) => ({+ ...c,+ lastResponseAt: original,+ isMarkedUnread: true,+ }));+ applyServerReplyStamp(queryClient, 'a', {+ lastResponseAt: original,+ lastResponseMessageId: 'existing',+ });+ expect(findConvoInAllQueries(queryClient, 'a')?.isMarkedUnread).toBe(true);+ applyServerReplyStamp(queryClient, 'a', {+ lastResponseAt: '2026-08-16T11:00:00.000Z',+ lastResponseMessageId: 'new',+ });+ expect(findConvoInAllQueries(queryClient, 'a')?.isMarkedUnread).toBe(false);+ });+it('updateConvoInAllQueries lets an explicit lastSeenAt win over the cached one', () => {updateConvoInAllQueries(queryClient, 'a', (c) => ({...c,diff --git a/client/src/utils/convos.ts b/client/src/utils/convos.tsindex 63fa5bd674..c18306a093 100644--- a/client/src/utils/convos.ts+++ b/client/src/utils/convos.ts@@ -1240,7 +1240,7 @@ export function applyServerReplyStamp(lastResponseAt,lastResponseMessageId: lastResponseMessageId ?? convo.lastResponseMessageId,lastResponseIsManual: undefined,- isMarkedUnread: advances ? undefined : convo.isMarkedUnread,+ isMarkedUnread: advances ? false : convo.isMarkedUnread,lastSeenAt: advances ? undefined : convo.lastSeenAt,updatedAt: updatedAt ?? convo.updatedAt,}),diff --git a/e2e/specs/mock/bookmarks.spec.ts b/e2e/specs/mock/bookmarks.spec.tsindex fb0ae727f7..eef6cb1192 100644--- a/e2e/specs/mock/bookmarks.spec.ts+++ b/e2e/specs/mock/bookmarks.spec.ts@@ -122,7 +122,11 @@ test.describe('bookmark counts', () => {await db.collection('conversations').updateOne({ conversationId: unreadId },{- $set: { lastResponseAt: previous, lastSeenAt: new Date(previous.getTime() - 1000) },+ $set: {+ lastResponseAt: previous,+ lastSeenAt: new Date(previous.getTime() - 1000),+ isMarkedUnread: false,+ },},);});diff --git a/e2e/specs/mock/scenarios/unseen-replies.spec.ts b/e2e/specs/mock/scenarios/unseen-replies.spec.tsindex 2f5c66a1c8..366d676686 100644--- a/e2e/specs/mock/scenarios/unseen-replies.spec.ts+++ b/e2e/specs/mock/scenarios/unseen-replies.spec.ts@@ -235,6 +235,46 @@ test.describe('unseen replies', () => {}});+ test('a pre-upgrade manual reminder keeps its date group after reload @scenario:legacy-manual-unread-keeps-date', async ({+ page,+ }) => {+ const id = conversationId();+ const title = `Legacy reminder ${id.slice(0, 8)}`;+ try {+ await seedConversation(id, title, { lastResponseAt: new Date(Date.now() - 2000) });+ await seedReplyMessage(id, title);+ await page.goto(NEW_CHAT_PATH);+ await openSidebar(page);+ const row = page.getByTestId('convo-item').filter({ hasText: title });+ for (let pass = 0; pass < 2; pass++) {+ if (pass > 0) {+ 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 stored = await readConversation(id);+ expect(stored?.isMarkedUnread).toBeUndefined();+ expect(stored?.lastResponseIsManual).toBeUndefined();+ expect(stored?.lastSeenAt).toBeUndefined();+ } finally {+ await cleanup(id);+ }+ });+test('marking a read conversation unread restores its dot and title count @scenario:mark-as-unread-restores-dot', async ({page,}) => {diff --git a/packages/data-provider/src/schemas.ts b/packages/data-provider/src/schemas.tsindex 830fb997dd..1830da048b 100644--- a/packages/data-provider/src/schemas.ts+++ b/packages/data-provider/src/schemas.ts@@ -1255,7 +1255,7 @@ 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. */+ /** True: manual reminder; false: real reply; absent: legacy/unknown intent. */isMarkedUnread: z.boolean().optional(),/** Set when the user has the newest message on screen; compared against `lastResponseAt`. */lastSeenAt: z.string().optional(),diff --git a/packages/data-provider/src/types.ts b/packages/data-provider/src/types.tsindex 4aac843eee..dc33077a1c 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;+ /** True: manual reminder; false: real reply; absent: legacy/unknown intent. */isMarkedUnread?: boolean;};diff --git a/packages/data-schemas/src/methods/conversation.spec.ts b/packages/data-schemas/src/methods/conversation.spec.tsindex 632364428c..711e152df7 100644--- a/packages/data-schemas/src/methods/conversation.spec.ts+++ b/packages/data-schemas/src/methods/conversation.spec.ts@@ -3319,10 +3319,36 @@ describe('Conversation Operations', () => {const replied = await Conversation.findOne({conversationId: mockConversationData.conversationId,}).lean<IConversation>();- expect(replied?.isMarkedUnread).toBeUndefined();+ expect(replied?.isMarkedUnread).toBe(false);expect(replied?.lastResponseMessageId).toBe('new-reply');});+ it('leaves legacy intent unknown through listing and metadata saves, until a real reply', async () => {+ await Conversation.create({+ conversationId: mockConversationData.conversationId,+ user: 'user123',+ endpoint: EModelEndpoint.openAI,+ lastResponseAt: new Date('2026-08-16T10:00:00.000Z'),+ lastResponseMessageId: 'legacy-reply',+ });+ await saveConvo(mockCtx, {+ conversationId: mockConversationData.conversationId,+ title: 'Reminder',+ });+ const { conversations } = await getConvosByCursor('user123');+ expect(conversations[0].isMarkedUnread).toBeUndefined();+ expect(conversations[0].lastResponseMessageId).toBe('legacy-reply');+ expect(conversations[0].lastSeenAt).toBeUndefined();+ await methods.stampConvoLastResponse(+ 'user123',+ mockConversationData.conversationId,+ 'confirmed-reply',+ );+ const reloaded = await getConvo('user123', mockConversationData.conversationId);+ expect(reloaded?.isMarkedUnread).toBe(false);+ expect(reloaded?.lastResponseMessageId).toBe('confirmed-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({diff --git a/packages/data-schemas/src/methods/conversation.ts b/packages/data-schemas/src/methods/conversation.tsindex 3cc503ace5..f58ea63f50 100644--- a/packages/data-schemas/src/methods/conversation.ts+++ b/packages/data-schemas/src/methods/conversation.ts@@ -653,8 +653,12 @@ export function createConversationMethods(const stamped = await Conversation.findOneAndUpdate(casFilter,{- $set: { lastResponseAt: stamp, lastResponseMessageId: responseMessageId },- $unset: { lastSeenAt: '', lastResponseIsManual: '', isMarkedUnread: '' },+ $set: {+ lastResponseAt: stamp,+ lastResponseMessageId: responseMessageId,+ isMarkedUnread: false,+ },+ $unset: { lastSeenAt: '', lastResponseIsManual: '' },$max: { updatedAt: stamp },},{ new: true, projection, timestamps: false },@@ -2569,9 +2573,9 @@ export function createConversationMethods(* DocumentDB targets rule out. */if (setFields.lastResponseAt instanceof Date) {const { lastResponseAt, ...withoutReplyStamp } = setFields;- operation.$set = withoutReplyStamp;+ operation.$set = { ...withoutReplyStamp, isMarkedUnread: false };operation.$max = { lastResponseAt };- operation.$unset = { lastResponseIsManual: '', isMarkedUnread: '' };+ operation.$unset = { lastResponseIsManual: '' };}if (Object.keys(unsetFields).length > 0) {operation.$unset = {diff --git a/packages/data-schemas/src/types/convo.ts b/packages/data-schemas/src/types/convo.tsindex 0d2a20b1f1..98d1d5b6df 100644--- a/packages/data-schemas/src/types/convo.ts+++ b/packages/data-schemas/src/types/convo.ts@@ -346,7 +346,7 @@ 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. */+ /** True: manual reminder; false: real reply; absent: legacy/unknown intent. */isMarkedUnread?: boolean;/** Set when the user has the newest message on screen; compared against `lastResponseAt`. */lastSeenAt?: Date;