@ai-sdk/openai 3.0.13 → 3.0.15

package/src/image/openai-image-model.ts

@@ -0,0 +1,305 @@
+import {
+  ImageModelV3,
+  ImageModelV3File,
+  SharedV3Warning,
+} from '@ai-sdk/provider';
+import {
+  combineHeaders,
+  convertBase64ToUint8Array,
+  convertToFormData,
+  createJsonResponseHandler,
+  downloadBlob,
+  postFormDataToApi,
+  postJsonToApi,
+} from '@ai-sdk/provider-utils';
+import { OpenAIConfig } from '../openai-config';
+import { openaiFailedResponseHandler } from '../openai-error';
+import { openaiImageResponseSchema } from './openai-image-api';
+import {
+  OpenAIImageModelId,
+  hasDefaultResponseFormat,
+  modelMaxImagesPerCall,
+} from './openai-image-options';
+
+interface OpenAIImageModelConfig extends OpenAIConfig {
+  _internal?: {
+    currentDate?: () => Date;
+  };
+}
+
+export class OpenAIImageModel implements ImageModelV3 {
+  readonly specificationVersion = 'v3';
+
+  get maxImagesPerCall(): number {
+    return modelMaxImagesPerCall[this.modelId] ?? 1;
+  }
+
+  get provider(): string {
+    return this.config.provider;
+  }
+
+  constructor(
+    readonly modelId: OpenAIImageModelId,
+    private readonly config: OpenAIImageModelConfig,
+  ) {}
+
+  async doGenerate({
+    prompt,
+    files,
+    mask,
+    n,
+    size,
+    aspectRatio,
+    seed,
+    providerOptions,
+    headers,
+    abortSignal,
+  }: Parameters<ImageModelV3['doGenerate']>[0]): Promise<
+    Awaited<ReturnType<ImageModelV3['doGenerate']>>
+  > {
+    const warnings: Array<SharedV3Warning> = [];
+
+    if (aspectRatio != null) {
+      warnings.push({
+        type: 'unsupported',
+        feature: 'aspectRatio',
+        details:
+          'This model does not support aspect ratio. Use `size` instead.',
+      });
+    }
+
+    if (seed != null) {
+      warnings.push({ type: 'unsupported', feature: 'seed' });
+    }
+
+    const currentDate = this.config._internal?.currentDate?.() ?? new Date();
+
+    if (files != null) {
+      const { value: response, responseHeaders } = await postFormDataToApi({
+        url: this.config.url({
+          path: '/images/edits',
+          modelId: this.modelId,
+        }),
+        headers: combineHeaders(this.config.headers(), headers),
+        formData: convertToFormData<OpenAIImageEditInput>({
+          model: this.modelId,
+          prompt,
+          image: await Promise.all(
+            files.map(file =>
+              file.type === 'file'
+                ? new Blob(
+                    [
+                      file.data instanceof Uint8Array
+                        ? new Blob([file.data as BlobPart], {
+                            type: file.mediaType,
+                          })
+                        : new Blob([convertBase64ToUint8Array(file.data)], {
+                            type: file.mediaType,
+                          }),
+                    ],
+                    { type: file.mediaType },
+                  )
+                : downloadBlob(file.url),
+            ),
+          ),
+          mask: mask != null ? await fileToBlob(mask) : undefined,
+          n,
+          size,
+          ...(providerOptions.openai ?? {}),
+        }),
+        failedResponseHandler: openaiFailedResponseHandler,
+        successfulResponseHandler: createJsonResponseHandler(
+          openaiImageResponseSchema,
+        ),
+        abortSignal,
+        fetch: this.config.fetch,
+      });
+
+      return {
+        images: response.data.map(item => item.b64_json),
+        warnings,
+        usage:
+          response.usage != null
+            ? {
+                inputTokens: response.usage.input_tokens ?? undefined,
+                outputTokens: response.usage.output_tokens ?? undefined,
+                totalTokens: response.usage.total_tokens ?? undefined,
+              }
+            : undefined,
+        response: {
+          timestamp: currentDate,
+          modelId: this.modelId,
+          headers: responseHeaders,
+        },
+        providerMetadata: {
+          openai: {
+            images: response.data.map(item => ({
+              ...(item.revised_prompt
+                ? { revisedPrompt: item.revised_prompt }
+                : {}),
+              created: response.created ?? undefined,
+              size: response.size ?? undefined,
+              quality: response.quality ?? undefined,
+              background: response.background ?? undefined,
+              outputFormat: response.output_format ?? undefined,
+            })),
+          },
+        },
+      };
+    }
+
+    const { value: response, responseHeaders } = await postJsonToApi({
+      url: this.config.url({
+        path: '/images/generations',
+        modelId: this.modelId,
+      }),
+      headers: combineHeaders(this.config.headers(), headers),
+      body: {
+        model: this.modelId,
+        prompt,
+        n,
+        size,
+        ...(providerOptions.openai ?? {}),
+        ...(!hasDefaultResponseFormat(this.modelId)
+          ? { response_format: 'b64_json' }
+          : {}),
+      },
+      failedResponseHandler: openaiFailedResponseHandler,
+      successfulResponseHandler: createJsonResponseHandler(
+        openaiImageResponseSchema,
+      ),
+      abortSignal,
+      fetch: this.config.fetch,
+    });
+
+    return {
+      images: response.data.map(item => item.b64_json),
+      warnings,
+      usage:
+        response.usage != null
+          ? {
+              inputTokens: response.usage.input_tokens ?? undefined,
+              outputTokens: response.usage.output_tokens ?? undefined,
+              totalTokens: response.usage.total_tokens ?? undefined,
+            }
+          : undefined,
+      response: {
+        timestamp: currentDate,
+        modelId: this.modelId,
+        headers: responseHeaders,
+      },
+      providerMetadata: {
+        openai: {
+          images: response.data.map(item => ({
+            ...(item.revised_prompt
+              ? { revisedPrompt: item.revised_prompt }
+              : {}),
+            created: response.created ?? undefined,
+            size: response.size ?? undefined,
+            quality: response.quality ?? undefined,
+            background: response.background ?? undefined,
+            outputFormat: response.output_format ?? undefined,
+          })),
+        },
+      },
+    };
+  }
+}
+
+type OpenAIImageEditInput = {
+  /**
+   * Allows to set transparency for the background of the generated image(s).
+   * This parameter is only supported for `gpt-image-1`. Must be one of
+   * `transparent`, `opaque` or `auto` (default value). When `auto` is used, the
+   * model will automatically determine the best background for the image.
+   *
+   * If `transparent`, the output format needs to support transparency, so it
+   * should be set to either `png` (default value) or `webp`.
+   *
+   */
+  background?: 'transparent' | 'opaque' | 'auto';
+  /**
+   * The image(s) to edit. Must be a supported image file or an array of images.
+   *
+   * For `gpt-image-1`, each image should be a `png`, `webp`, or `jpg` file less
+   * than 50MB. You can provide up to 16 images.
+   *
+   * For `dall-e-2`, you can only provide one image, and it should be a square
+   * `png` file less than 4MB.
+   *
+   */
+  image: Blob | Blob[];
+  input_fidelity?: ('high' | 'low') | null;
+  /**
+   * An additional image whose fully transparent areas (e.g. where alpha is zero) indicate where `image` should be edited. If there are multiple images provided, the mask will be applied on the first image. Must be a valid PNG file, less than 4MB, and have the same dimensions as `image`.
+   */
+  mask?: Blob;
+  /**
+   * The model to use for image generation. Only `dall-e-2` and `gpt-image-1` are supported. Defaults to `dall-e-2` unless a parameter specific to `gpt-image-1` is used.
+   */
+  model?: 'dall-e-2' | 'gpt-image-1' | 'gpt-image-1-mini' | (string & {});
+  /**
+   * The number of images to generate. Must be between 1 and 10.
+   */
+  n?: number;
+  /**
+   * The compression level (0-100%) for the generated images. This parameter
+   * is only supported for `gpt-image-1` with the `webp` or `jpeg` output
+   * formats, and defaults to 100.
+   *
+   */
+  output_compression?: number;
+  /**
+   * The format in which the generated images are returned. This parameter is
+   * only supported for `gpt-image-1`. Must be one of `png`, `jpeg`, or `webp`.
+   * The default value is `png`.
+   *
+   */
+  output_format?: 'png' | 'jpeg' | 'webp';
+  partial_images?: number | null;
+  /**
+   * A text description of the desired image(s). The maximum length is 1000 characters for `dall-e-2`, and 32000 characters for `gpt-image-1`.
+   */
+  prompt?: string;
+  /**
+   * The quality of the image that will be generated. `high`, `medium` and `low` are only supported for `gpt-image-1`. `dall-e-2` only supports `standard` quality. Defaults to `auto`.
+   *
+   */
+  quality?: 'standard' | 'low' | 'medium' | 'high' | 'auto';
+  /**
+   * The format in which the generated images are returned. Must be one of `url` or `b64_json`. URLs are only valid for 60 minutes after the image has been generated. This parameter is only supported for `dall-e-2`, as `gpt-image-1` will always return base64-encoded images.
+   */
+  response_format?: 'url' | 'b64_json';
+  /**
+   * The size of the generated images. Must be one of `1024x1024`, `1536x1024` (landscape), `1024x1536` (portrait), or `auto` (default value) for `gpt-image-1`, and one of `256x256`, `512x512`, or `1024x1024` for `dall-e-2`.
+   */
+  size?: `${number}x${number}`;
+  /**
+   * Edit the image in streaming mode. Defaults to `false`. See the
+   * [Image generation guide](https://platform.openai.com/docs/guides/image-generation) for more information.
+   *
+   */
+  stream?: boolean;
+  /**
+   * A unique identifier representing your end-user, which can help OpenAI to monitor and detect abuse. [Learn more](https://platform.openai.com/docs/guides/safety-best-practices#end-user-ids).
+   *
+   */
+  user?: string;
+};
+
+async function fileToBlob(
+  file: ImageModelV3File | undefined,
+): Promise<Blob | undefined> {
+  if (!file) return undefined;
+
+  if (file.type === 'url') {
+    return downloadBlob(file.url);
+  }
+
+  const data =
+    file.data instanceof Uint8Array
+      ? file.data
+      : convertBase64ToUint8Array(file.data);
+
+  return new Blob([data as BlobPart], { type: file.mediaType });
+}

package/src/image/openai-image-options.ts

@@ -0,0 +1,28 @@
+export type OpenAIImageModelId =
+  | 'dall-e-3'
+  | 'dall-e-2'
+  | 'gpt-image-1'
+  | 'gpt-image-1-mini'
+  | 'gpt-image-1.5'
+  | (string & {});
+
+// https://platform.openai.com/docs/guides/images
+export const modelMaxImagesPerCall: Record<OpenAIImageModelId, number> = {
+  'dall-e-3': 1,
+  'dall-e-2': 10,
+  'gpt-image-1': 10,
+  'gpt-image-1-mini': 10,
+  'gpt-image-1.5': 10,
+};
+
+const defaultResponseFormatPrefixes = [
+  'gpt-image-1-mini',
+  'gpt-image-1.5',
+  'gpt-image-1',
+];
+
+export function hasDefaultResponseFormat(modelId: string): boolean {
+  return defaultResponseFormatPrefixes.some(prefix =>
+    modelId.startsWith(prefix),
+  );
+}

package/src/index.ts

@@ -0,0 +1,9 @@
+export { createOpenAI, openai } from './openai-provider';
+export type { OpenAIProvider, OpenAIProviderSettings } from './openai-provider';
+export type { OpenAIResponsesProviderOptions } from './responses/openai-responses-options';
+export type { OpenAIChatLanguageModelOptions } from './chat/openai-chat-options';
+export type {
+  OpenaiResponsesTextProviderMetadata,
+  OpenaiResponsesSourceDocumentProviderMetadata,
+} from './responses/openai-responses-provider-metadata';
+export { VERSION } from './version';

package/src/internal/index.ts

@@ -0,0 +1,19 @@
+export * from '../chat/openai-chat-language-model';
+export * from '../chat/openai-chat-options';
+export * from '../completion/openai-completion-language-model';
+export * from '../completion/openai-completion-options';
+export * from '../embedding/openai-embedding-model';
+export * from '../embedding/openai-embedding-options';
+export * from '../image/openai-image-model';
+export * from '../image/openai-image-options';
+export * from '../transcription/openai-transcription-model';
+export * from '../transcription/openai-transcription-options';
+export * from '../speech/openai-speech-model';
+export * from '../speech/openai-speech-options';
+export * from '../responses/openai-responses-language-model';
+export * from '../responses/openai-responses-provider-metadata';
+export * from '../tool/apply-patch';
+export * from '../tool/code-interpreter';
+export * from '../tool/file-search';
+export * from '../tool/image-generation';
+export * from '../tool/web-search-preview';

package/src/openai-config.ts

@@ -0,0 +1,18 @@
+import { FetchFunction } from '@ai-sdk/provider-utils';
+
+export type OpenAIConfig = {
+  provider: string;
+  url: (options: { modelId: string; path: string }) => string;
+  headers: () => Record<string, string | undefined>;
+  fetch?: FetchFunction;
+  generateId?: () => string;
+  /**
+   * File ID prefixes used to identify file IDs in Responses API.
+   * When undefined, all file data is treated as base64 content.
+   *
+   * Examples:
+   * - OpenAI: ['file-'] for IDs like 'file-abc123'
+   * - Azure OpenAI: ['assistant-'] for IDs like 'assistant-abc123'
+   */
+  fileIdPrefixes?: readonly string[];
+};

package/src/openai-error.test.ts

@@ -0,0 +1,34 @@
+import { safeParseJSON } from '@ai-sdk/provider-utils';
+import { openaiErrorDataSchema } from './openai-error';
+import { describe, it, expect } from 'vitest';
+
+describe('openaiErrorDataSchema', () => {
+  it('should parse OpenRouter resource exhausted error', async () => {
+    const error = `
+{"error":{"message":"{\\n  \\"error\\": {\\n    \\"code\\": 429,\\n    \\"message\\": \\"Resource has been exhausted (e.g. check quota).\\",\\n    \\"status\\": \\"RESOURCE_EXHAUSTED\\"\\n  }\\n}\\n","code":429}}
+`;
+
+    const result = await safeParseJSON({
+      text: error,
+      schema: openaiErrorDataSchema,
+    });
+
+    expect(result).toStrictEqual({
+      success: true,
+      value: {
+        error: {
+          message:
+            '{\n  "error": {\n    "code": 429,\n    "message": "Resource has been exhausted (e.g. check quota).",\n    "status": "RESOURCE_EXHAUSTED"\n  }\n}\n',
+          code: 429,
+        },
+      },
+      rawValue: {
+        error: {
+          message:
+            '{\n  "error": {\n    "code": 429,\n    "message": "Resource has been exhausted (e.g. check quota).",\n    "status": "RESOURCE_EXHAUSTED"\n  }\n}\n',
+          code: 429,
+        },
+      },
+    });
+  });
+});

package/src/openai-error.ts

@@ -0,0 +1,22 @@
+import { z } from 'zod/v4';
+import { createJsonErrorResponseHandler } from '@ai-sdk/provider-utils';
+
+export const openaiErrorDataSchema = z.object({
+  error: z.object({
+    message: z.string(),
+
+    // The additional information below is handled loosely to support
+    // OpenAI-compatible providers that have slightly different error
+    // responses:
+    type: z.string().nullish(),
+    param: z.any().nullish(),
+    code: z.union([z.string(), z.number()]).nullish(),
+  }),
+});
+
+export type OpenAIErrorData = z.infer<typeof openaiErrorDataSchema>;
+
+export const openaiFailedResponseHandler = createJsonErrorResponseHandler({
+  errorSchema: openaiErrorDataSchema,
+  errorToMessage: data => data.error.message,
+});

package/src/openai-language-model-capabilities.test.ts

@@ -0,0 +1,93 @@
+import { describe, it, expect } from 'vitest';
+import { getOpenAILanguageModelCapabilities } from './openai-language-model-capabilities';
+
+describe('getOpenAILanguageModelCapabilities', () => {
+  describe('isReasoningModel', () => {
+    it.each([
+      ['gpt-4.1', false],
+      ['gpt-4.1-2025-04-14', false],
+      ['gpt-4.1-mini', false],
+      ['gpt-4.1-mini-2025-04-14', false],
+      ['gpt-4.1-nano', false],
+      ['gpt-4.1-nano-2025-04-14', false],
+      ['gpt-4o', false],
+      ['gpt-4o-2024-05-13', false],
+      ['gpt-4o-2024-08-06', false],
+      ['gpt-4o-2024-11-20', false],
+      ['gpt-4o-audio-preview', false],
+      ['gpt-4o-audio-preview-2024-10-01', false],
+      ['gpt-4o-audio-preview-2024-12-17', false],
+      ['gpt-4o-search-preview', false],
+      ['gpt-4o-search-preview-2025-03-11', false],
+      ['gpt-4o-mini-search-preview', false],
+      ['gpt-4o-mini-search-preview-2025-03-11', false],
+      ['gpt-4o-mini', false],
+      ['gpt-4o-mini-2024-07-18', false],
+      ['gpt-4-turbo', false],
+      ['gpt-4-turbo-2024-04-09', false],
+      ['gpt-4-turbo-preview', false],
+      ['gpt-4-0125-preview', false],
+      ['gpt-4-1106-preview', false],
+      ['gpt-4', false],
+      ['gpt-4-0613', false],
+      ['gpt-4.5-preview', false],
+      ['gpt-4.5-preview-2025-02-27', false],
+      ['gpt-3.5-turbo-0125', false],
+      ['gpt-3.5-turbo', false],
+      ['gpt-3.5-turbo-1106', false],
+      ['chatgpt-4o-latest', false],
+      ['gpt-5-chat-latest', false],
+      ['o1', true],
+      ['o1-2024-12-17', true],
+      ['o3-mini', true],
+      ['o3-mini-2025-01-31', true],
+      ['o3', true],
+      ['o3-2025-04-16', true],
+      ['o4-mini', true],
+      ['o4-mini-2025-04-16', true],
+      ['codex-mini-latest', true],
+      ['computer-use-preview', true],
+      ['gpt-5', true],
+      ['gpt-5-2025-08-07', true],
+      ['gpt-5-codex', true],
+      ['gpt-5-mini', true],
+      ['gpt-5-mini-2025-08-07', true],
+      ['gpt-5-nano', true],
+      ['gpt-5-nano-2025-08-07', true],
+      ['gpt-5-pro', true],
+      ['gpt-5-pro-2025-10-06', true],
+      ['new-unknown-model', false],
+      ['ft:gpt-4o-2024-08-06:org:custom:abc123', false],
+      ['custom-model', false],
+    ])('%s reasoning model: %s', (modelId, expectedCapabilities) => {
+      expect(
+        getOpenAILanguageModelCapabilities(modelId).isReasoningModel,
+      ).toEqual(expectedCapabilities);
+    });
+  });
+
+  describe('supportsNonReasoningParameters', () => {
+    it.each([
+      ['gpt-5.1', true],
+      ['gpt-5.1-chat-latest', true],
+      ['gpt-5.1-codex-mini', true],
+      ['gpt-5.1-codex', true],
+      ['gpt-5.2', true],
+      ['gpt-5.2-pro', true],
+      ['gpt-5.2-chat-latest', true],
+      ['gpt-5', false],
+      ['gpt-5-mini', false],
+      ['gpt-5-nano', false],
+      ['gpt-5-pro', false],
+      ['gpt-5-chat-latest', false],
+    ])(
+      '%s supports non-reasoning parameters: %s',
+      (modelId, expectedCapabilities) => {
+        expect(
+          getOpenAILanguageModelCapabilities(modelId)
+            .supportsNonReasoningParameters,
+        ).toEqual(expectedCapabilities);
+      },
+    );
+  });
+});

package/src/openai-language-model-capabilities.ts

@@ -0,0 +1,54 @@
+export type OpenAILanguageModelCapabilities = {
+  isReasoningModel: boolean;
+  systemMessageMode: 'remove' | 'system' | 'developer';
+  supportsFlexProcessing: boolean;
+  supportsPriorityProcessing: boolean;
+
+  /**
+   * Allow temperature, topP, logProbs when reasoningEffort is none.
+   */
+  supportsNonReasoningParameters: boolean;
+};
+
+export function getOpenAILanguageModelCapabilities(
+  modelId: string,
+): OpenAILanguageModelCapabilities {
+  const supportsFlexProcessing =
+    modelId.startsWith('o3') ||
+    modelId.startsWith('o4-mini') ||
+    (modelId.startsWith('gpt-5') && !modelId.startsWith('gpt-5-chat'));
+
+  const supportsPriorityProcessing =
+    modelId.startsWith('gpt-4') ||
+    modelId.startsWith('gpt-5-mini') ||
+    (modelId.startsWith('gpt-5') &&
+      !modelId.startsWith('gpt-5-nano') &&
+      !modelId.startsWith('gpt-5-chat')) ||
+    modelId.startsWith('o3') ||
+    modelId.startsWith('o4-mini');
+
+  // Use allowlist approach: only known reasoning models should use 'developer' role
+  // This prevents issues with fine-tuned models, third-party models, and custom models
+  const isReasoningModel =
+    modelId.startsWith('o1') ||
+    modelId.startsWith('o3') ||
+    modelId.startsWith('o4-mini') ||
+    modelId.startsWith('codex-mini') ||
+    modelId.startsWith('computer-use-preview') ||
+    (modelId.startsWith('gpt-5') && !modelId.startsWith('gpt-5-chat'));
+
+  // https://platform.openai.com/docs/guides/latest-model#gpt-5-1-parameter-compatibility
+  // GPT-5.1 and GPT-5.2 support temperature, topP, logProbs when reasoningEffort is none
+  const supportsNonReasoningParameters =
+    modelId.startsWith('gpt-5.1') || modelId.startsWith('gpt-5.2');
+
+  const systemMessageMode = isReasoningModel ? 'developer' : 'system';
+
+  return {
+    supportsFlexProcessing,
+    supportsPriorityProcessing,
+    isReasoningModel,
+    systemMessageMode,
+    supportsNonReasoningParameters,
+  };
+}

package/src/openai-provider.test.ts

@@ -0,0 +1,98 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { createOpenAI } from './openai-provider';
+
+vi.mock('./version', () => ({
+  VERSION: '0.0.0-test',
+}));
+
+const createSuccessfulResponse = () =>
+  new Response(
+    JSON.stringify({
+      object: 'list',
+      data: [
+        {
+          object: 'embedding',
+          index: 0,
+          embedding: [0.1, 0.2],
+        },
+      ],
+      model: 'text-embedding-3-small',
+      usage: { prompt_tokens: 1, total_tokens: 1 },
+    }),
+    {
+      status: 200,
+      headers: { 'Content-Type': 'application/json' },
+    },
+  );
+
+const createFetchMock = () =>
+  vi.fn().mockResolvedValue(createSuccessfulResponse());
+
+describe('createOpenAI', () => {
+  describe('baseURL configuration', () => {
+    const originalBaseUrl = process.env.OPENAI_BASE_URL;
+
+    beforeEach(() => {
+      vi.restoreAllMocks();
+    });
+
+    afterEach(() => {
+      process.env.OPENAI_BASE_URL = originalBaseUrl;
+    });
+
+    it('uses the default OpenAI base URL when not provided', async () => {
+      delete process.env.OPENAI_BASE_URL;
+
+      const fetchMock = createFetchMock();
+      const provider = createOpenAI({
+        apiKey: 'test-api-key',
+        fetch: fetchMock,
+      });
+
+      await provider.embedding('text-embedding-3-small').doEmbed({
+        values: ['hello'],
+      });
+
+      expect(fetchMock).toHaveBeenCalledTimes(1);
+      const call = fetchMock.mock.calls[0]!;
+      expect(call[0]).toBe('https://api.openai.com/v1/embeddings');
+    });
+
+    it('uses OPENAI_BASE_URL when set', async () => {
+      process.env.OPENAI_BASE_URL = 'https://proxy.openai.example/v1/';
+
+      const fetchMock = createFetchMock();
+      const provider = createOpenAI({
+        apiKey: 'test-api-key',
+        fetch: fetchMock,
+      });
+
+      await provider.embedding('text-embedding-3-small').doEmbed({
+        values: ['hello'],
+      });
+
+      expect(fetchMock).toHaveBeenCalledTimes(1);
+      const call = fetchMock.mock.calls[0]!;
+      expect(call[0]).toBe('https://proxy.openai.example/v1/embeddings');
+    });
+
+    it('prefers the baseURL option over OPENAI_BASE_URL', async () => {
+      process.env.OPENAI_BASE_URL = 'https://env.openai.example/v1';
+
+      const fetchMock = createFetchMock();
+      const provider = createOpenAI({
+        apiKey: 'test-api-key',
+        baseURL: 'https://option.openai.example/v1/',
+        fetch: fetchMock,
+      });
+
+      await provider.embedding('text-embedding-3-small').doEmbed({
+        values: ['hello'],
+      });
+
+      expect(fetchMock).toHaveBeenCalledTimes(1);
+      const call = fetchMock.mock.calls[0]!;
+      expect(call[0]).toBe('https://option.openai.example/v1/embeddings');
+    });
+  });
+});