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: Keep Manual Unread Reminders in Date Groups

Liac41413ad21d5
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<ReturnType<typeof cached>>[]][];
+ 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<TSharedLink, 'messages'> & {
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<IConversation>();
+ 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<IConversation>();
+ 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<IConversation>()
+ )?.isMarkedUnread,
+ ).toBe(true);
+ await methods.markConvoSeen('user123', mockConversationData.conversationId, responseAt);
+ expect(
+ (
+ await Conversation.findOne({
+ conversationId: mockConversationData.conversationId,
+ }).lean<IConversation>()
+ )?.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<string, number> = { ...(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<IConversation>;
- 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<IConversation, 'lastResponseAt' | 'lastResponseMessageId' | 'lastResponseIsManual'>
+ 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<IConversation, 'lastResponseAt' | 'lastResponseMessageId' | 'lastResponseIsManual'>
+ 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<IConversation> = 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;
}