Skip to content

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

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.ts
index 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.ts
index 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.tsx
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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;