Just as wrong.
Way cheaper.

Mock openai with one line. Your app keeps calling new OpenAI(). Read the guide →

jest.mock('openai', () => require('llmao/openai'));

import * as llmao from 'llmao/testing';
import { classify } from './support'; // uses new OpenAI() inside

beforeEach(() => llmao.reset());

test('classifies shipping tickets', async () => {
  llmao.configure({ script: [{ when: /never arrived/i, text: 'shipping' }] });

  expect(await classify('My order never arrived')).toBe('shipping');
  expect(llmao.lastCall().prompt).toBe('My order never arrived');
});

Same idea with vi.mock. Test mode creates no timers, so fake timers work too. Read the guide →

import * as llmao from 'llmao/testing';
import { classify } from './support';

vi.mock('openai', () => import('llmao/openai'));

test('sends the right system prompt', async () => {
  llmao.configure({ script: [{ text: 'billing' }] });
  await classify('I was charged twice');

  expect(llmao.lastCall()).toMatchObject({
    model: 'gpt-4o',
    system: 'Classify the ticket as billing, shipping or other.',
  });
});

Script tool use: the first answer calls your tool, the second one reads its result. Read the guide →

jest.mock('@anthropic-ai/sdk', () => require('llmao/anthropic'));

import * as llmao from 'llmao/testing';
import { askAboutStocks } from './agent';

test('uses the stock tool', async () => {
  llmao.configure({
    script: [
      { when: 'stock', toolCalls: [{ name: 'get_stock_price', args: { ticker: 'NVDA' } }] },
      { when: 'stock', afterToolResults: true, text: 'NVDA is trading at $1,337.' },
    ],
  });

  expect(await askAboutStocks('What is the stock price of NVDA?')).toBe('NVDA is trading at $1,337.');
});

Mock @ai-sdk/openai or @ai-sdk/anthropic. generateObject gets objects that match your schema. Read the guide →

import { generateObject } from 'ai';
import { openai } from '@ai-sdk/openai'; // this is llmao now
import { z } from 'zod';

vi.mock('@ai-sdk/openai', () => import('llmao/ai-sdk'));

test('extracts a user', async () => {
  const { object } = await generateObject({
    model: openai('gpt-4o'),
    schema: z.object({ name: z.string(), email: z.string().email() }),
    prompt: 'Extract the user from this email…',
  });

  expect(object.email).toContain('@');
});

The SDKs' own error classes, with retry-after headers. Every retry is recorded. Read the guide →

test('gives up after the SDK retries', async () => {
  llmao.configure({ failures: { rateLimit: 1 } });

  await expect(classify('hi')).rejects.toBeInstanceOf(OpenAI.RateLimitError);
  expect(llmao.calls).toHaveLength(3); // the first attempt plus 2 retries
});

test('recovers when the retry works', async () => {
  llmao.configure({ script: [{ error: 'rate_limit', once: true }, { text: 'billing' }] });

  expect(await classify('charged twice')).toBe('billing');
});

No module mocking: run the fake API in the test process and point the SDKs at it. Read the guide →

import { serve } from 'llmao/server';
import * as llmao from 'llmao/testing';

const server = await serve({ port: 0 });
process.env.OPENAI_BASE_URL = `${server.url}/v1`;
process.env.ANTHROPIC_BASE_URL = server.url;

test('classifies tickets', async () => {
  const { classify } = await import('./support.js');
  llmao.configure({ script: [{ text: 'shipping' }] });

  assert.equal(await classify('My order never arrived'), 'shipping');
});