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: 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.tsxindex 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.tsindex 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.tsindex 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.tsnew file mode 100644index 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.tsindex 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);