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

5.3 KB
Raw Blame
import { logger } from '@librechat/data-schemas';
import {
  outboundTimeoutMessage,
  getOutboundTimeout,
  getOutboundTimeoutMs,
  toolRequestBudget,
  createSpeechBudget,
  serviceRequestBudget,
  SERVICE_REQUEST_TIMEOUT_MS,
  outboundRequestBudget,
  DEFAULT_OUTBOUND_TIMEOUTS_MS,
} from './timeouts';
import { isAbortError } from './errors';
import { logAxiosError } from './axios';

describe('outbound timeouts', () => {
  it('uses the default when the config omits the key', () => {
    expect(getOutboundTimeoutMs(undefined, 'ragMs')).toBe(DEFAULT_OUTBOUND_TIMEOUTS_MS.ragMs);
    expect(getOutboundTimeoutMs({ timeouts: { ocrMs: 1_000 } }, 'ragMs')).toBe(
      DEFAULT_OUTBOUND_TIMEOUTS_MS.ragMs,
    );
  });

  it('uses the configured value when present', () => {
    expect(getOutboundTimeoutMs({ timeouts: { moderationMs: 2_500 } }, 'moderationMs')).toBe(2_500);
  });
});

describe('outboundRequestBudget', () => {
  it('aborts at the wall-clock deadline and names the key to raise', async () => {
    const { timeout, timeoutErrorMessage, signal } = outboundRequestBudget(20, 'ragMs');

    expect(timeout).toBe(20);
    expect(timeoutErrorMessage).toBe(outboundTimeoutMessage('ragMs', 20));
    await new Promise((resolve) => signal.addEventListener('abort', resolve));
    expect(signal.reason).toMatchObject({ name: 'TimeoutError' });
  });

  it('also follows the caller signal', () => {
    const controller = new AbortController();
    const { signal } = outboundRequestBudget(60_000, 'actionsMs', controller.signal);

    controller.abort();

    expect(signal.aborted).toBe(true);
  });
});

describe('getOutboundTimeout', () => {
  const timeoutErrorMessage = outboundTimeoutMessage('actionsMs', 5);

  it('recognizes a request cancelled by its deadline', () => {
    const canceled = {
      code: 'ERR_CANCELED',
      message: 'canceled',
      config: {
        timeoutErrorMessage,
        signal: { reason: new DOMException('timed out', 'TimeoutError') },
      },
    };

    expect(getOutboundTimeout(canceled)?.message).toBe(timeoutErrorMessage);
    expect(isAbortError(canceled)).toBe(false);
  });

  it('recognizes an idle timeout carrying the budget message', () => {
    const idle = {
      code: 'ECONNABORTED',
      message: timeoutErrorMessage,
      config: { timeoutErrorMessage },
    };

    expect(getOutboundTimeout(idle)).toBe(idle);
  });

  it('leaves a user stop as an abort', () => {
    const stopped = {
      code: 'ERR_CANCELED',
      message: 'canceled',
      config: {
        timeoutErrorMessage,
        signal: { reason: new DOMException('stopped', 'AbortError') },
      },
    };

    expect(getOutboundTimeout(stopped)).toBeUndefined();
    expect(isAbortError(stopped)).toBe(true);
  });

  it('still reports a deadline wrapped in a cause as a failure', () => {
    const canceled = {
      code: 'ERR_CANCELED',
      message: 'canceled',
      config: {
        timeoutErrorMessage,
        signal: { reason: new DOMException('timed out', 'TimeoutError') },
      },
    };

    expect(isAbortError(new Error('tool failed', { cause: canceled }))).toBe(false);
  });

  it('does not read the message of an error without a budget', () => {
    const guarded = Object.defineProperty({}, 'message', {
      get() {
        throw new Error('message must not be read');
      },
    });

    expect(getOutboundTimeout(guarded)).toBeUndefined();
  });
});

describe('logAxiosError on a budget overrun', () => {
  it('warns with the key to raise instead of logging a generic failure', () => {
    const warn = jest.spyOn(logger, 'warn').mockImplementation(() => logger);
    const error = jest.spyOn(logger, 'error').mockImplementation(() => logger);
    const timeoutErrorMessage = outboundTimeoutMessage('ragMs', 30_000);
    const idle = {
      code: 'ECONNABORTED',
      message: timeoutErrorMessage,
      config: { timeoutErrorMessage },
    };

    const message = logAxiosError({ message: 'RAG query failed:', error: idle });

    expect(message).toContain('timeouts.ragMs (30000 ms)');
    expect(warn).toHaveBeenCalledWith(message);
    expect(error).not.toHaveBeenCalled();
    warn.mockRestore();
    error.mockRestore();
  });
});

describe('toolRequestBudget', () => {
  it('defaults to the tools budget and honors the configured one', () => {
    expect(toolRequestBudget().timeout).toBe(DEFAULT_OUTBOUND_TIMEOUTS_MS.toolsMs);
    const budget = toolRequestBudget({ toolsMs: 2_000 });
    expect(budget.timeout).toBe(2_000);
    expect(budget.timeoutErrorMessage).toBe(outboundTimeoutMessage('toolsMs', 2_000));
  });
});

describe('createSpeechBudget', () => {
  it('starts a fresh deadline per request and shares the disconnect signal', () => {
    const close = new AbortController();
    const next = createSpeechBudget({ timeouts: { speechMs: 2_000 } }, close.signal);
    const first = next();
    const second = next();
    expect(first.timeout).toBe(2_000);
    expect(first.signal).not.toBe(second.signal);
    close.abort();
    expect(first.signal.aborted).toBe(true);
    expect(second.signal.aborted).toBe(true);
    expect(next().signal.aborted).toBe(true);
  });
});

describe('serviceRequestBudget', () => {
  it('bounds a request by the fixed service timeout with a fresh deadline', () => {
    const first = serviceRequestBudget();
    expect(first.timeout).toBe(SERVICE_REQUEST_TIMEOUT_MS);
    expect(first.signal).not.toBe(serviceRequestBudget().signal);
  });
});