@@ -0,0 +1,153 @@
+const express = require('express');
+const request = require('supertest');
+
+const mockHasGenerationClaim = jest.fn();
+const mockIpLimiter = jest.fn((_req, res) => res.status(429).json({ limited: 'ip' }));
+const mockUserLimiter = jest.fn((_req, res) => res.status(429).json({ limited: 'user' }));
+const mockRetryLimiter = jest.fn((_req, _res, next) => next());
+const mockRetryProbeLimiter = jest.fn((_req, _res, next) => next());
+const mockExemptAgentTrigger = jest.fn(() => false);
+const mockExemptSchedule = jest.fn(() => false);
+
+jest.mock('@librechat/data-schemas', () => ({
+  logger: {
+    debug: jest.fn(),
+    warn: jest.fn(),
+    error: jest.fn(),
+    info: jest.fn(),
+  },
+}));
+
+jest.mock('@librechat/api', () => ({
+  isEnabled: jest.fn(() => true),
+  detectGenerationRetry: async (req, _res, next) => {
+    req._isConfirmedGenerationRetry = await mockHasGenerationClaim(
+      req.user?.id,
+      req.body?.clientRequestId,
+    );
+    next();
+  },
+  isConfirmedGenerationRetry: (req) => req._isConfirmedGenerationRetry === true,
+  generationRetryProbeLimiter: (...args) => mockRetryProbeLimiter(...args),
+  generationRetryLimiter: (...args) => mockRetryLimiter(...args),
+  isAgentTriggerRequest: jest.fn(() => false),
+  captureScheduleFireContext: jest.fn(),
+  exemptAgentTriggerFromIpLimiter: (...args) => mockExemptAgentTrigger(...args),
+  exemptFromUserLimiter: (...args) => mockExemptSchedule(...args),
+  createMessageFilterPii: jest.fn(() => (_req, _res, next) => next()),
+}));
+
+jest.mock('~/server/middleware', () => ({
+  uaParser: (_req, _res, next) => next(),
+  checkBan: (_req, _res, next) => next(),
+  requireJwtAuth: (req, _res, next) => {
+    req.user = { id: 'user-1' };
+    next();
+  },
+  moderateText: (_req, _res, next) => next(),
+  messageIpLimiter: (...args) => mockIpLimiter(...args),
+  configMiddleware: (_req, _res, next) => next(),
+  messageUserLimiter: (...args) => mockUserLimiter(...args),
+}));
+
+jest.mock('~/server/routes/agents/chat', () => {
+  const router = require('express').Router();
+  router.post('/', (_req, res) => res.status(201).json({ admitted: true }));
+  return router;
+});
+jest.mock('~/server/routes/agents/v1', () => ({
+  v1: require('express').Router(),
+}));
+jest.mock('~/server/routes/agents/openai', () => require('express').Router());
+jest.mock('~/server/routes/agents/responses', () => require('express').Router());
+jest.mock('~/server/controllers/agents/steer', () => {
+  const controller = (_req, _res, next) => next();
+  controller.SteerDeliveryController = (_req, _res, next) => next();
+  controller.SteerCancelController = (_req, _res, next) => next();
+  controller.SteerArmController = (_req, _res, next) => next();
+  return controller;
+});
+jest.mock('~/models', () => ({}));
+jest.mock('~/server/services/Schedules', () => ({}));
+
+const agentsRouter = require('../index');
+const app = express();
+app.use(express.json());
+app.use('/agents', agentsRouter);
+
+describe('start-generation idempotency before message limiters', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    mockExemptAgentTrigger.mockReturnValue(false);
+    mockExemptSchedule.mockReturnValue(false);
+  });
+
+  it('lets a confirmed retry reach the controller without consuming either limiter', async () => {
+    mockHasGenerationClaim.mockResolvedValue(true);
+
+    const response = await request(app).post('/agents/chat').send({ clientRequestId: 'request-1' });
+
+    expect(response.status).toBe(201);
+    expect(mockRetryProbeLimiter).toHaveBeenCalledTimes(1);
+    expect(mockRetryLimiter).toHaveBeenCalledTimes(1);
+    expect(mockIpLimiter).not.toHaveBeenCalled();
+    expect(mockUserLimiter).not.toHaveBeenCalled();
+  });
+
+  it('keeps a new submission behind the configured message limiters', async () => {
+    mockHasGenerationClaim.mockResolvedValue(false);
+
+    const response = await request(app).post('/agents/chat').send({ clientRequestId: 'request-2' });
+
+    expect(response.status).toBe(429);
+    expect(response.body).toEqual({ limited: 'ip' });
+    expect(mockRetryProbeLimiter).toHaveBeenCalledTimes(1);
+    expect(mockRetryLimiter).toHaveBeenCalledTimes(1);
+    expect(mockIpLimiter).toHaveBeenCalledTimes(1);
+    expect(mockUserLimiter).not.toHaveBeenCalled();
+  });
+
+  it('defers an excessive confirmed retry before the chat pipeline', async () => {
+    mockHasGenerationClaim.mockResolvedValue(true);
+    mockRetryLimiter.mockImplementationOnce((_req, res) =>
+      res.status(503).json({ code: 'SERVER_NOT_READY' }),
+    );
+
+    const response = await request(app).post('/agents/chat').send({ clientRequestId: 'request-3' });
+
+    expect(response.status).toBe(503);
+    expect(response.body.code).toBe('SERVER_NOT_READY');
+    expect(mockIpLimiter).not.toHaveBeenCalled();
+    expect(mockUserLimiter).not.toHaveBeenCalled();
+  });
+
+  it('bounds candidate probes before durable storage inspection', async () => {
+    mockRetryProbeLimiter.mockImplementationOnce((_req, res) =>
+      res.status(503).json({ code: 'SERVER_NOT_READY' }),
+    );
+
+    const response = await request(app).post('/agents/chat').send({ clientRequestId: 'request-5' });
+
+    expect(response.status).toBe(503);
+    expect(mockHasGenerationClaim).not.toHaveBeenCalled();
+    expect(mockRetryLimiter).not.toHaveBeenCalled();
+    expect(mockIpLimiter).not.toHaveBeenCalled();
+    expect(mockUserLimiter).not.toHaveBeenCalled();
+  });
+
+  it.each([
+    ['an agent-trigger delivery', mockExemptAgentTrigger],
+    ['a scheduled delivery', mockExemptSchedule],
+  ])('keeps %s outside the human retry bucket', async (_label, exemption) => {
+    mockHasGenerationClaim.mockResolvedValue(true);
+    exemption.mockReturnValue(true);
+
+    const response = await request(app).post('/agents/chat').send({ clientRequestId: 'request-4' });
+
+    expect(response.status).toBe(201);
+    expect(mockRetryProbeLimiter).not.toHaveBeenCalled();
+    expect(mockRetryLimiter).not.toHaveBeenCalled();
+    expect(mockIpLimiter).not.toHaveBeenCalled();
+    expect(mockUserLimiter).not.toHaveBeenCalled();
+  });
+});
@@ -18,6 +18,10 @@ const {
   exemptAgentTriggerFromIpLimiter,
   captureScheduleFireContext,
   exemptFromUserLimiter: exemptScheduleFromUserLimiter,
+  detectGenerationRetry,
+  isConfirmedGenerationRetry,
+  generationRetryProbeLimiter,
+  generationRetryLimiter,
 } = require('@librechat/api');
 const { createSseStreamTelemetry } = require('@librechat/api/telemetry');
 const { logger } = require('@librechat/data-schemas');
@@ -1075,14 +1079,41 @@ router.post(
 router.use('/', v1);
 
 const chatRouter = express.Router();
+const useMessageIpLimiter = isEnabled(LIMIT_MESSAGE_IP);
+const useMessageUserLimiter = isEnabled(LIMIT_MESSAGE_USER);
 chatRouter.use(configMiddleware);
+if (useMessageIpLimiter || useMessageUserLimiter) {
+  chatRouter.use(
+    unless(
+      (req) => exemptAgentTriggerFromIpLimiter(req) || exemptScheduleFromUserLimiter(req),
+      generationRetryProbeLimiter,
+    ),
+  );
+  chatRouter.use(detectGenerationRetry);
+  chatRouter.use(
+    unless(
+      (req) => exemptAgentTriggerFromIpLimiter(req) || exemptScheduleFromUserLimiter(req),
+      generationRetryLimiter,
+    ),
+  );
+}
 
-if (isEnabled(LIMIT_MESSAGE_IP)) {
-  chatRouter.use(unless(exemptAgentTriggerFromIpLimiter, messageIpLimiter));
+if (useMessageIpLimiter) {
+  chatRouter.use(
+    unless(
+      (req) => exemptAgentTriggerFromIpLimiter(req) || isConfirmedGenerationRetry(req),
+      messageIpLimiter,
+    ),
+  );
 }
 
-if (isEnabled(LIMIT_MESSAGE_USER)) {
-  chatRouter.use(unless(exemptScheduleFromUserLimiter, messageUserLimiter));
+if (useMessageUserLimiter) {
+  chatRouter.use(
+    unless(
+      (req) => exemptScheduleFromUserLimiter(req) || isConfirmedGenerationRetry(req),
+      messageUserLimiter,
+    ),
+  );
 }
 
 chatRouter.use('/', chat);
 
@@ -171,6 +171,7 @@
     "@langchain/langgraph-checkpoint-mongodb": "^1.4.0",
     "cluster-key-slot": "^1.1.2",
     "croner": "^10.0.1",
+    "express-rate-limit": "^8.5.1",
     "helmet": "^8.3.0",
     "proxy-from-env": "^2.1.0",
     "re2js": "^2.8.6"
 
@@ -0,0 +1,144 @@
+import express from 'express';
+import request from 'supertest';
+import { logger } from '@librechat/data-schemas';
+import type { NextFunction, Request, Response } from 'express';
+import {
+  detectGenerationRetry,
+  generationRetryLimiter,
+  generationRetryProbeLimiter,
+  GENERATION_RETRY_MAX,
+  GENERATION_RETRY_PROBE_MAX,
+  isConfirmedGenerationRetry,
+} from './generationRetry';
+import { GenerationJobManager } from '~/stream/GenerationJobManager';
+
+function generationRequest(overrides: Partial<Request> = {}): Request {
+  return {
+    method: 'POST',
+    path: '/',
+    body: { clientRequestId: 'request-1' },
+    user: { id: 'user-1' },
+    ...overrides,
+  } as Request;
+}
+
+describe('generation retry admission', () => {
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  it('marks only a submission with an existing durable claim as a retry', async () => {
+    const hasClaim = jest.spyOn(GenerationJobManager, 'hasGenerationClaim').mockResolvedValue(true);
+    const req = generationRequest();
+    const next = jest.fn() as NextFunction;
+
+    await detectGenerationRetry(req, {} as Response, next);
+
+    expect(hasClaim).toHaveBeenCalledWith('user-1', 'request-1');
+    expect(isConfirmedGenerationRetry(req)).toBe(true);
+    expect(next).toHaveBeenCalledTimes(1);
+  });
+
+  it('leaves a new submission subject to the ordinary message limiters', async () => {
+    jest.spyOn(GenerationJobManager, 'hasGenerationClaim').mockResolvedValue(false);
+    const req = generationRequest();
+
+    await detectGenerationRetry(req, {} as Response, jest.fn());
+
+    expect(isConfirmedGenerationRetry(req)).toBe(false);
+  });
+
+  it.each([
+    ['a resume', { path: '/resume' }],
+    ['a resume with a trailing slash', { path: '/resume/' }],
+    ['a case-insensitive resume route', { path: '/Resume' }],
+    ['a request without an authenticated user', { user: undefined }],
+    ['an invalid idempotency key', { body: { clientRequestId: 'invalid key' } }],
+  ])('does not probe %s', async (_label, overrides) => {
+    const hasClaim = jest.spyOn(GenerationJobManager, 'hasGenerationClaim');
+    const req = generationRequest(overrides as Partial<Request>);
+    const next = jest.fn() as NextFunction;
+
+    await detectGenerationRetry(req, {} as Response, next);
+
+    expect(hasClaim).not.toHaveBeenCalled();
+    expect(isConfirmedGenerationRetry(req)).toBe(false);
+    expect(next).toHaveBeenCalledTimes(1);
+  });
+
+  it('fails closed to the ordinary limiters when the claim probe is unavailable', async () => {
+    jest
+      .spyOn(GenerationJobManager, 'hasGenerationClaim')
+      .mockRejectedValue(new Error('store unavailable'));
+    const warn = jest.spyOn(logger, 'warn').mockImplementation(() => logger);
+    const req = generationRequest();
+    const next = jest.fn() as NextFunction;
+
+    await detectGenerationRetry(req, {} as Response, next);
+
+    expect(isConfirmedGenerationRetry(req)).toBe(false);
+    expect(warn).toHaveBeenCalledWith(
+      '[GenerationIdempotency] Failed to inspect start-generation claim',
+      expect.objectContaining({ userId: 'user-1', clientRequestId: 'request-1' }),
+    );
+    expect(next).toHaveBeenCalledTimes(1);
+  });
+
+  it('bounds fresh claim probes before accessing the shared store', async () => {
+    const hasClaim = jest
+      .spyOn(GenerationJobManager, 'hasGenerationClaim')
+      .mockResolvedValue(false);
+    const downstream = jest.fn((_req, res) => res.sendStatus(204));
+    const app = express();
+    app.use(express.json());
+    app.use((req, _res, next) => {
+      req.user = { id: 'bounded-probe-user' };
+      next();
+    });
+    app.use(generationRetryProbeLimiter);
+    app.use(detectGenerationRetry);
+    app.post('/', downstream);
+
+    for (let attempt = 0; attempt < GENERATION_RETRY_PROBE_MAX; attempt += 1) {
+      await request(app)
+        .post('/')
+        .send({ clientRequestId: `probe-${attempt}` })
+        .expect(204);
+    }
+    const rejected = await request(app)
+      .post('/')
+      .send({ clientRequestId: 'probe-rejected' })
+      .expect(503);
+
+    expect(rejected.headers['retry-after']).toBeDefined();
+    expect(rejected.body.code).toBe('SERVER_NOT_READY');
+    expect(hasClaim).toHaveBeenCalledTimes(GENERATION_RETRY_PROBE_MAX);
+    expect(downstream).toHaveBeenCalledTimes(GENERATION_RETRY_PROBE_MAX);
+  });
+
+  it('makes a bounded confirmed retry delay participate in readiness recovery', async () => {
+    jest.spyOn(GenerationJobManager, 'hasGenerationClaim').mockResolvedValue(true);
+    const downstream = jest.fn((_req, res) => res.sendStatus(204));
+    const app = express();
+    app.use(express.json());
+    app.use((req, _res, next) => {
+      req.user = { id: 'bounded-retry-user' };
+      next();
+    });
+    app.use(detectGenerationRetry);
+    app.use(generationRetryLimiter);
+    app.post('/', downstream);
+
+    for (let attempt = 0; attempt < GENERATION_RETRY_MAX; attempt += 1) {
+      await request(app).post('/').send({ clientRequestId: 'bounded-request' }).expect(204);
+    }
+    const rejected = await request(app)
+      .post('/')
+      .send({ clientRequestId: 'bounded-request' })
+      .expect(503);
+
+    expect(rejected.headers['retry-after']).toBeDefined();
+    expect(rejected.body.code).toBe('SERVER_NOT_READY');
+    expect(downstream).toHaveBeenCalledTimes(GENERATION_RETRY_MAX);
+  });
+});