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: Unblock Conversation Deletion After Queued Turns (#16174)

lia-by-librechat[bot]bddfc5ce50c9
diff --git a/client/src/data-provider/__tests__/pinnedConversations.test.tsx b/client/src/data-provider/__tests__/pinnedConversations.test.tsx
index 95ca4a5bb4..aa44a16756 100644
--- a/client/src/data-provider/__tests__/pinnedConversations.test.tsx
+++ b/client/src/data-provider/__tests__/pinnedConversations.test.tsx
@@ -522,6 +522,57 @@ describe('pinned list cache synchronization', () => {
});
});
+describe('delete mutation failure recovery', () => {
+ it('reports a failed delete without removing cached chats and allows a successful retry', async () => {
+ const error = new Error('Request failed with status code 500');
+ deleteConversation.mockRejectedValueOnce(error).mockResolvedValueOnce({
+ acknowledged: true,
+ deletedCount: 1,
+ messages: { acknowledged: true, deletedCount: 0 },
+ });
+ const queryClient = createQueryClient();
+ const conversationKey = [QueryKeys.conversation, pinnedConversationId];
+ const pinnedKey = [QueryKeys.pinnedConversations];
+ const listKeys = [QueryKeys.allConversations, QueryKeys.archivedConversations];
+ queryClient.setQueryData(conversationKey, pinnedConvo);
+ queryClient.setQueryData(pinnedKey, listResponse([pinnedConvo]));
+ for (const key of listKeys) {
+ queryClient.setQueryData([key], {
+ pages: [listResponse([pinnedConvo])],
+ pageParams: [undefined],
+ });
+ }
+ const onError = jest.fn();
+ const onSuccess = jest.fn();
+ const payload = { conversationId: pinnedConversationId };
+ const { result } = renderHook(() => useDeleteConversationMutation({ onError, onSuccess }), {
+ wrapper: createWrapper(queryClient),
+ });
+
+ act(() => result.current.mutate(payload));
+ await waitFor(() => expect(result.current.isError).toBe(true));
+
+ expect(onError).toHaveBeenCalledTimes(1);
+ expect(onError).toHaveBeenCalledWith(error, payload, undefined);
+ expect(onSuccess).not.toHaveBeenCalled();
+ expect(queryClient.getQueryData(conversationKey)).toEqual(pinnedConvo);
+ expect(queryClient.getQueryData(pinnedKey)).toEqual(listResponse([pinnedConvo]));
+ for (const key of listKeys) {
+ expect(queryClient.getQueryData([key])).toMatchObject({
+ pages: [listResponse([pinnedConvo])],
+ });
+ }
+
+ act(() => result.current.mutate(payload));
+ await waitFor(() => expect(result.current.isSuccess).toBe(true));
+
+ expect(onSuccess).toHaveBeenCalledTimes(1);
+ expect(onError).toHaveBeenCalledTimes(1);
+ expect(queryClient.getQueryData(conversationKey)).toBeUndefined();
+ expect(queryClient.getQueryData(pinnedKey)).toEqual(listResponse([]));
+ });
+});
+
describe('delete mutation project lookup', () => {
const projectId = 'project-pinned';
diff --git a/client/src/data-provider/mutations.ts b/client/src/data-provider/mutations.ts
index 5c914b5e7a..97193a4137 100644
--- a/client/src/data-provider/mutations.ts
+++ b/client/src/data-provider/mutations.ts
@@ -701,9 +701,7 @@ export const useDeleteConversationMutation = (
await queryClient.cancelQueries([QueryKeys.pinnedConversations]);
// could store old state if needed for rollback
},
- onError: () => {
- // TODO: CHECK THIS, no-op; restore if needed
- },
+ onError: options?.onError,
onSuccess: (data, vars, context) => {
const deletedConversation = vars.conversationId
? queryClient.getQueryData<t.TConversation>([QueryKeys.conversation, vars.conversationId])
diff --git a/packages/data-schemas/src/methods/index.ts b/packages/data-schemas/src/methods/index.ts
index 3ddf1be4b4..316bdd081d 100644
--- a/packages/data-schemas/src/methods/index.ts
+++ b/packages/data-schemas/src/methods/index.ts
@@ -350,6 +350,9 @@ export function createMethods(
sourceId: 'agent-queued-turn',
reason: 'queued_turn_conversation_deleted',
settledAt,
+ /** The source lane is fenced and admission has settled. Queued-turn
+ * deliveries need not receive a later terminal handling receipt. */
+ allowSucceeded: true,
};
let retired = await agentTriggerDeliveryMethods.retireAgentTriggerDelivery(retirement);
if (!retired) {
diff --git a/packages/data-schemas/src/methods/queuedTurn.deletion.spec.ts b/packages/data-schemas/src/methods/queuedTurn.deletion.spec.ts
new file mode 100644
index 0000000000..5260a4062d
--- /dev/null
+++ b/packages/data-schemas/src/methods/queuedTurn.deletion.spec.ts
@@ -0,0 +1,223 @@
+import mongoose from 'mongoose';
+import { createHash } from 'node:crypto';
+import { MongoMemoryServer } from 'mongodb-memory-server';
+import { createModels } from '~/models';
+import { createMethods } from './index';
+
+jest.mock('~/models/plugins/mongoMeili', () => jest.fn());
+jest.mock('~/config/winston', () => ({
+ error: jest.fn(),
+ warn: jest.fn(),
+ info: jest.fn(),
+ debug: jest.fn(),
+}));
+
+const models = createModels(mongoose);
+const methods = createMethods(mongoose);
+let mongoServer: MongoMemoryServer;
+
+beforeAll(async () => {
+ mongoServer = await MongoMemoryServer.create();
+ await mongoose.connect(mongoServer.getUri());
+ await Promise.all(Object.values(models).map((model) => model.init()));
+}, 60_000);
+
+beforeEach(async () => {
+ await Promise.all([
+ models.Conversation.deleteMany({}),
+ models.Message.deleteMany({}),
+ models.AgentQueuedTurn.deleteMany({}),
+ models.AgentQueuedTurnSequence.deleteMany({}),
+ models.AgentTriggerDelivery.deleteMany({}),
+ models.AgentTriggerLaneSequence.deleteMany({}),
+ ]);
+});
+
+afterAll(async () => {
+ await mongoose.disconnect();
+ await mongoServer?.stop();
+});
+
+async function admitQueuedTurn(awaitTerminalHandling?: true) {
+ const user = new mongoose.Types.ObjectId();
+ const now = new Date();
+ const scope = { user, conversationId: 'queued-conversation', tenantId: 'tenant-1' };
+ await models.Conversation.create({ ...scope, user: user.toString(), endpoint: 'agents' });
+ const queued = await methods.enqueueAgentQueuedTurn({
+ ...scope,
+ agentId: 'agent-1',
+ parentMessageId: 'parent-1',
+ clientRequestId: 'request-1',
+ text: 'follow up',
+ availableAt: now,
+ });
+ const deliveryKey = `queued-${queued.turn.queuedTurnId}`;
+ const turnScope = { ...scope, queuedTurnId: queued.turn.queuedTurnId, deliveryKey };
+ await methods.reserveAgentQueuedTurnDelivery(turnScope);
+ await methods.enqueueAgentTriggerDelivery({
+ ...scope,
+ deliveryKey,
+ fingerprint: deliveryKey,
+ orderingKey: deliveryKey,
+ availableAt: now,
+ awaitTerminalHandling,
+ envelope: {
+ mode: 'continue',
+ event: { source: { type: 'internal', id: 'agent-queued-turn' } },
+ target: { conversationId: scope.conversationId, bindingId: 'queued-binding' },
+ },
+ });
+ await methods.markQueuedTurnScheduled({ ...turnScope, scheduledAt: now });
+ const claim = {
+ ...turnScope,
+ claimId: 'turn-claim',
+ claimBy: 'turn-worker',
+ now,
+ leaseUntil: new Date(now.getTime() + 60_000),
+ };
+ await methods.claimNextAgentQueuedTurn(claim);
+ await methods.beginAgentQueuedTurnAdmission({
+ ...claim,
+ admissionId: deliveryKey,
+ startedAt: now,
+ });
+ await expect(
+ methods.markAgentQueuedTurnAdmitted({
+ ...claim,
+ admissionId: deliveryKey,
+ admissionMode: 'ordinary',
+ lineagePredecessorId: `root:${createHash('sha256').update('parent-1').digest('base64url')}`,
+ generationId: 'generation-1',
+ generationCreatedAt: now.getTime(),
+ settledAt: now,
+ }),
+ ).resolves.toMatchObject({ outcome: 'admitted' });
+ const deliveryClaim = await methods.claimNextAgentTriggerDelivery({
+ workerId: 'delivery-worker',
+ claimToken: 'delivery-claim',
+ now,
+ leaseUntil: claim.leaseUntil,
+ });
+ if (deliveryClaim == null) {
+ throw new Error('Expected a delivery claim');
+ }
+ const fence = {
+ id: deliveryClaim.id,
+ workerId: 'delivery-worker',
+ claimToken: 'delivery-claim',
+ };
+ const attempt = await methods.beginAgentTriggerDeliveryAttempt({ ...fence, now });
+ if (attempt == null) {
+ throw new Error('Expected a delivery attempt');
+ }
+ await expect(
+ methods.completeAgentTriggerDelivery({
+ ...fence,
+ attempt,
+ awaitTerminalHandling,
+ settledAt: now,
+ result: { status: 'started', conversationId: scope.conversationId },
+ handling: {
+ status: 'started',
+ conversationId: scope.conversationId,
+ streamId: 'generation-1',
+ generationCreatedAt: now.getTime(),
+ startedAt: now,
+ },
+ }),
+ ).resolves.toBe(true);
+ return { ...turnScope, now };
+}
+
+describe('queued-turn conversation deletion through createMethods', () => {
+ it('requires explicit opt-in and the matching internal source for transport-only success', async () => {
+ const turn = await admitQueuedTurn();
+ const retirement = {
+ deliveryKey: turn.deliveryKey,
+ sourceId: 'agent-queued-turn',
+ settledAt: new Date(),
+ reason: 'queued_turn_conversation_deleted',
+ };
+
+ await expect(methods.retireAgentTriggerDelivery(retirement)).resolves.toBe(false);
+ await expect(
+ methods.retireAgentTriggerDelivery({
+ ...retirement,
+ sourceId: 'background-tool-completion',
+ allowSucceeded: true,
+ }),
+ ).resolves.toBe(false);
+ await expect(
+ methods.retireAgentTriggerDelivery({ ...retirement, allowSucceeded: true }),
+ ).resolves.toBe(true);
+ await expect(
+ methods.retireAgentTriggerDelivery({ ...retirement, allowSucceeded: true }),
+ ).resolves.toBe(true);
+ });
+
+ it.each(['published', 'retiring', undefined] as const)(
+ 'deletes an admitted turn with a successful delivery and deliveryState %s',
+ async (deliveryState) => {
+ const turn = await admitQueuedTurn();
+ await models.AgentQueuedTurn.updateOne(
+ { _id: turn.queuedTurnId },
+ deliveryState == null ? { $unset: { deliveryState: 1 } } : { $set: { deliveryState } },
+ );
+ const before = await models.AgentTriggerDelivery.findOne({
+ deliveryKey: turn.deliveryKey,
+ }).lean();
+ const unrelated = await models.Conversation.create({
+ user: turn.user.toString(),
+ conversationId: 'unrelated-conversation',
+ endpoint: 'agents',
+ });
+
+ await expect(
+ methods.deleteConvos(turn.user.toString(), { conversationId: turn.conversationId }),
+ ).resolves.toMatchObject({ deletedCount: 1, conversationIds: [turn.conversationId] });
+
+ expect(await models.AgentQueuedTurn.countDocuments({ _id: turn.queuedTurnId })).toBe(0);
+ expect(await models.Conversation.findById(unrelated._id)).not.toBeNull();
+ expect(await models.Conversation.findOne({ conversationId: turn.conversationId })).toBeNull();
+ await expect(
+ models.AgentTriggerDelivery.findOne({ deliveryKey: turn.deliveryKey }).lean(),
+ ).resolves.toMatchObject({
+ status: 'succeeded',
+ result: before?.result,
+ handling: before?.handling,
+ settledAt: before?.settledAt,
+ expiresAt: before?.expiresAt,
+ });
+ },
+ );
+
+ it('keeps explicit terminal-handling fences and recovers a failed retirement on retry', async () => {
+ const turn = await admitQueuedTurn(true);
+ const remove = () =>
+ methods.deleteConvos(turn.user.toString(), { conversationId: turn.conversationId });
+
+ await expect(remove()).rejects.toThrow('deliveries must retire');
+ await expect(models.AgentQueuedTurn.findById(turn.queuedTurnId).lean()).resolves.toMatchObject({
+ deliveryState: 'retiring',
+ });
+ expect(
+ await models.Conversation.findOne({ conversationId: turn.conversationId }),
+ ).not.toBeNull();
+
+ await models.AgentTriggerDelivery.updateOne(
+ { deliveryKey: turn.deliveryKey },
+ { $set: { 'handling.status': 'applied', 'handling.settledAt': new Date() } },
+ );
+ await expect(remove()).resolves.toMatchObject({ deletedCount: 1 });
+ });
+
+ it('recovers a retiring source after its successful delivery receipt expires', async () => {
+ const turn = await admitQueuedTurn();
+ await methods.beginAgentQueuedTurnMissingDeliveryRetirement({ deliveryKey: turn.deliveryKey });
+ await models.AgentTriggerDelivery.deleteOne({ deliveryKey: turn.deliveryKey });
+
+ await expect(
+ methods.deleteConvos(turn.user.toString(), { conversationId: turn.conversationId }),
+ ).resolves.toMatchObject({ deletedCount: 1 });
+ });
+});
diff --git a/packages/data-schemas/src/methods/triggerDelivery.ts b/packages/data-schemas/src/methods/triggerDelivery.ts
index f2d12193b0..0137a6dd43 100644
--- a/packages/data-schemas/src/methods/triggerDelivery.ts
+++ b/packages/data-schemas/src/methods/triggerDelivery.ts
@@ -289,6 +289,9 @@ export interface AgentTriggerDeliveryMethods {
reason: string;
onlyIfUnclaimed?: boolean;
onlyIfDead?: boolean;
+ /** Accept transport success without a terminal handling receipt, unless the
+ * delivery explicitly keeps its lane open for terminal handling. */
+ allowSucceeded?: boolean;
}) => Promise<boolean>;
renewAgentTriggerDeliveryProducerLease: (input: {
deliveryKey: string;
@@ -2068,6 +2071,9 @@ export function createAgentTriggerDeliveryMethods(
reason: string;
onlyIfUnclaimed?: boolean;
onlyIfDead?: boolean;
+ /** Accept transport success without a terminal handling receipt, unless the
+ * delivery explicitly keeps its lane open for terminal handling. */
+ allowSucceeded?: boolean;
}): Promise<boolean> {
if (
input.deliveryKey.length === 0 ||
@@ -2161,6 +2167,7 @@ export function createAgentTriggerDeliveryMethods(
$or: [
{ handling: { $exists: false } },
{ 'handling.status': { $in: ['applied', 'completed_no_action', 'failed', 'cancelled'] } },
+ ...(input.allowSucceeded === true ? [{ awaitTerminalHandling: { $ne: true } }] : []),
],
})) != null
);