@ai-sdk/openai 3.0.13 → 3.0.15

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

@@ -0,0 +1,336 @@
+import {
+  LanguageModelV3,
+  LanguageModelV3CallOptions,
+  LanguageModelV3FinishReason,
+  LanguageModelV3GenerateResult,
+  LanguageModelV3StreamPart,
+  LanguageModelV3StreamResult,
+  SharedV3ProviderMetadata,
+  SharedV3Warning,
+} from '@ai-sdk/provider';
+import {
+  combineHeaders,
+  createEventSourceResponseHandler,
+  createJsonResponseHandler,
+  FetchFunction,
+  parseProviderOptions,
+  ParseResult,
+  postJsonToApi,
+} from '@ai-sdk/provider-utils';
+import { openaiFailedResponseHandler } from '../openai-error';
+import {
+  convertOpenAICompletionUsage,
+  OpenAICompletionUsage,
+} from './convert-openai-completion-usage';
+import { convertToOpenAICompletionPrompt } from './convert-to-openai-completion-prompt';
+import { getResponseMetadata } from './get-response-metadata';
+import { mapOpenAIFinishReason } from './map-openai-finish-reason';
+import {
+  OpenAICompletionChunk,
+  openaiCompletionChunkSchema,
+  openaiCompletionResponseSchema,
+} from './openai-completion-api';
+import {
+  OpenAICompletionModelId,
+  openaiCompletionProviderOptions,
+} from './openai-completion-options';
+
+type OpenAICompletionConfig = {
+  provider: string;
+  headers: () => Record<string, string | undefined>;
+  url: (options: { modelId: string; path: string }) => string;
+  fetch?: FetchFunction;
+};
+
+export class OpenAICompletionLanguageModel implements LanguageModelV3 {
+  readonly specificationVersion = 'v3';
+
+  readonly modelId: OpenAICompletionModelId;
+
+  private readonly config: OpenAICompletionConfig;
+
+  private get providerOptionsName(): string {
+    return this.config.provider.split('.')[0].trim();
+  }
+
+  constructor(
+    modelId: OpenAICompletionModelId,
+    config: OpenAICompletionConfig,
+  ) {
+    this.modelId = modelId;
+    this.config = config;
+  }
+
+  get provider(): string {
+    return this.config.provider;
+  }
+
+  readonly supportedUrls: Record<string, RegExp[]> = {
+    // No URLs are supported for completion models.
+  };
+
+  private async getArgs({
+    prompt,
+    maxOutputTokens,
+    temperature,
+    topP,
+    topK,
+    frequencyPenalty,
+    presencePenalty,
+    stopSequences: userStopSequences,
+    responseFormat,
+    tools,
+    toolChoice,
+    seed,
+    providerOptions,
+  }: LanguageModelV3CallOptions) {
+    const warnings: SharedV3Warning[] = [];
+
+    // Parse provider options
+    const openaiOptions = {
+      ...(await parseProviderOptions({
+        provider: 'openai',
+        providerOptions,
+        schema: openaiCompletionProviderOptions,
+      })),
+      ...(await parseProviderOptions({
+        provider: this.providerOptionsName,
+        providerOptions,
+        schema: openaiCompletionProviderOptions,
+      })),
+    };
+
+    if (topK != null) {
+      warnings.push({ type: 'unsupported', feature: 'topK' });
+    }
+
+    if (tools?.length) {
+      warnings.push({ type: 'unsupported', feature: 'tools' });
+    }
+
+    if (toolChoice != null) {
+      warnings.push({ type: 'unsupported', feature: 'toolChoice' });
+    }
+
+    if (responseFormat != null && responseFormat.type !== 'text') {
+      warnings.push({
+        type: 'unsupported',
+        feature: 'responseFormat',
+        details: 'JSON response format is not supported.',
+      });
+    }
+
+    const { prompt: completionPrompt, stopSequences } =
+      convertToOpenAICompletionPrompt({ prompt });
+
+    const stop = [...(stopSequences ?? []), ...(userStopSequences ?? [])];
+
+    return {
+      args: {
+        // model id:
+        model: this.modelId,
+
+        // model specific settings:
+        echo: openaiOptions.echo,
+        logit_bias: openaiOptions.logitBias,
+        logprobs:
+          openaiOptions?.logprobs === true
+            ? 0
+            : openaiOptions?.logprobs === false
+              ? undefined
+              : openaiOptions?.logprobs,
+        suffix: openaiOptions.suffix,
+        user: openaiOptions.user,
+
+        // standardized settings:
+        max_tokens: maxOutputTokens,
+        temperature,
+        top_p: topP,
+        frequency_penalty: frequencyPenalty,
+        presence_penalty: presencePenalty,
+        seed,
+
+        // prompt:
+        prompt: completionPrompt,
+
+        // stop sequences:
+        stop: stop.length > 0 ? stop : undefined,
+      },
+      warnings,
+    };
+  }
+
+  async doGenerate(
+    options: LanguageModelV3CallOptions,
+  ): Promise<LanguageModelV3GenerateResult> {
+    const { args, warnings } = await this.getArgs(options);
+
+    const {
+      responseHeaders,
+      value: response,
+      rawValue: rawResponse,
+    } = await postJsonToApi({
+      url: this.config.url({
+        path: '/completions',
+        modelId: this.modelId,
+      }),
+      headers: combineHeaders(this.config.headers(), options.headers),
+      body: args,
+      failedResponseHandler: openaiFailedResponseHandler,
+      successfulResponseHandler: createJsonResponseHandler(
+        openaiCompletionResponseSchema,
+      ),
+      abortSignal: options.abortSignal,
+      fetch: this.config.fetch,
+    });
+
+    const choice = response.choices[0];
+
+    const providerMetadata: SharedV3ProviderMetadata = { openai: {} };
+
+    if (choice.logprobs != null) {
+      providerMetadata.openai.logprobs = choice.logprobs;
+    }
+
+    return {
+      content: [{ type: 'text', text: choice.text }],
+      usage: convertOpenAICompletionUsage(response.usage),
+      finishReason: {
+        unified: mapOpenAIFinishReason(choice.finish_reason),
+        raw: choice.finish_reason ?? undefined,
+      },
+      request: { body: args },
+      response: {
+        ...getResponseMetadata(response),
+        headers: responseHeaders,
+        body: rawResponse,
+      },
+      providerMetadata,
+      warnings,
+    };
+  }
+
+  async doStream(
+    options: LanguageModelV3CallOptions,
+  ): Promise<LanguageModelV3StreamResult> {
+    const { args, warnings } = await this.getArgs(options);
+
+    const body = {
+      ...args,
+      stream: true,
+
+      stream_options: {
+        include_usage: true,
+      },
+    };
+
+    const { responseHeaders, value: response } = await postJsonToApi({
+      url: this.config.url({
+        path: '/completions',
+        modelId: this.modelId,
+      }),
+      headers: combineHeaders(this.config.headers(), options.headers),
+      body,
+      failedResponseHandler: openaiFailedResponseHandler,
+      successfulResponseHandler: createEventSourceResponseHandler(
+        openaiCompletionChunkSchema,
+      ),
+      abortSignal: options.abortSignal,
+      fetch: this.config.fetch,
+    });
+
+    let finishReason: LanguageModelV3FinishReason = {
+      unified: 'other',
+      raw: undefined,
+    };
+    const providerMetadata: SharedV3ProviderMetadata = { openai: {} };
+    let usage: OpenAICompletionUsage | undefined = undefined;
+    let isFirstChunk = true;
+
+    return {
+      stream: response.pipeThrough(
+        new TransformStream<
+          ParseResult<OpenAICompletionChunk>,
+          LanguageModelV3StreamPart
+        >({
+          start(controller) {
+            controller.enqueue({ type: 'stream-start', warnings });
+          },
+
+          transform(chunk, controller) {
+            if (options.includeRawChunks) {
+              controller.enqueue({ type: 'raw', rawValue: chunk.rawValue });
+            }
+
+            // handle failed chunk parsing / validation:
+            if (!chunk.success) {
+              finishReason = { unified: 'error', raw: undefined };
+              controller.enqueue({ type: 'error', error: chunk.error });
+              return;
+            }
+
+            const value = chunk.value;
+
+            // handle error chunks:
+            if ('error' in value) {
+              finishReason = { unified: 'error', raw: undefined };
+              controller.enqueue({ type: 'error', error: value.error });
+              return;
+            }
+
+            if (isFirstChunk) {
+              isFirstChunk = false;
+
+              controller.enqueue({
+                type: 'response-metadata',
+                ...getResponseMetadata(value),
+              });
+
+              controller.enqueue({ type: 'text-start', id: '0' });
+            }
+
+            if (value.usage != null) {
+              usage = value.usage;
+            }
+
+            const choice = value.choices[0];
+
+            if (choice?.finish_reason != null) {
+              finishReason = {
+                unified: mapOpenAIFinishReason(choice.finish_reason),
+                raw: choice.finish_reason,
+              };
+            }
+
+            if (choice?.logprobs != null) {
+              providerMetadata.openai.logprobs = choice.logprobs;
+            }
+
+            if (choice?.text != null && choice.text.length > 0) {
+              controller.enqueue({
+                type: 'text-delta',
+                id: '0',
+                delta: choice.text,
+              });
+            }
+          },
+
+          flush(controller) {
+            if (!isFirstChunk) {
+              controller.enqueue({ type: 'text-end', id: '0' });
+            }
+
+            controller.enqueue({
+              type: 'finish',
+              finishReason,
+              providerMetadata,
+              usage: convertOpenAICompletionUsage(usage),
+            });
+          },
+        }),
+      ),
+      request: { body },
+      response: { headers: responseHeaders },
+    };
+  }
+}

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

@@ -0,0 +1,58 @@
+import { InferSchema, lazySchema, zodSchema } from '@ai-sdk/provider-utils';
+import { z } from 'zod/v4';
+
+// https://platform.openai.com/docs/models
+export type OpenAICompletionModelId = 'gpt-3.5-turbo-instruct' | (string & {});
+
+export const openaiCompletionProviderOptions = lazySchema(() =>
+  zodSchema(
+    z.object({
+      /**
+Echo back the prompt in addition to the completion.
+   */
+      echo: z.boolean().optional(),
+
+      /**
+Modify the likelihood of specified tokens appearing in the completion.
+
+Accepts a JSON object that maps tokens (specified by their token ID in
+the GPT tokenizer) to an associated bias value from -100 to 100. You
+can use this tokenizer tool to convert text to token IDs. Mathematically,
+the bias is added to the logits generated by the model prior to sampling.
+The exact effect will vary per model, but values between -1 and 1 should
+decrease or increase likelihood of selection; values like -100 or 100
+should result in a ban or exclusive selection of the relevant token.
+
+As an example, you can pass {"50256": -100} to prevent the <|endoftext|>
+token from being generated.
+ */
+      logitBias: z.record(z.string(), z.number()).optional(),
+
+      /**
+The suffix that comes after a completion of inserted text.
+ */
+      suffix: z.string().optional(),
+
+      /**
+A unique identifier representing your end-user, which can help OpenAI to
+monitor and detect abuse. Learn more.
+ */
+      user: z.string().optional(),
+
+      /**
+Return the log probabilities of the tokens. Including logprobs will increase
+the response size and can slow down response times. However, it can
+be useful to better understand how the model is behaving.
+Setting to true will return the log probabilities of the tokens that
+were generated.
+Setting to a number will return the log probabilities of the top n
+tokens that were generated.
+   */
+      logprobs: z.union([z.boolean(), z.number()]).optional(),
+    }),
+  ),
+);
+
+export type OpenAICompletionProviderOptions = InferSchema<
+  typeof openaiCompletionProviderOptions
+>;

package/src/embedding/__snapshots__/openai-embedding-model.test.ts.snap

@@ -0,0 +1,43 @@
+// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
+
+exports[`doEmbed > should expose the raw response 1`] = `
+{
+  "body": {
+    "data": [
+      {
+        "embedding": [
+          0.1,
+          0.2,
+          0.3,
+          0.4,
+          0.5,
+        ],
+        "index": 0,
+        "object": "embedding",
+      },
+      {
+        "embedding": [
+          0.6,
+          0.7,
+          0.8,
+          0.9,
+          1,
+        ],
+        "index": 1,
+        "object": "embedding",
+      },
+    ],
+    "model": "text-embedding-3-large",
+    "object": "list",
+    "usage": {
+      "prompt_tokens": 8,
+      "total_tokens": 8,
+    },
+  },
+  "headers": {
+    "content-length": "236",
+    "content-type": "application/json",
+    "test-header": "test-value",
+  },
+}
+`;

package/src/embedding/openai-embedding-api.ts

@@ -0,0 +1,13 @@
+import { lazySchema, zodSchema } from '@ai-sdk/provider-utils';
+import { z } from 'zod/v4';
+
+// minimal version of the schema, focussed on what is needed for the implementation
+// this approach limits breakages when the API changes and increases efficiency
+export const openaiTextEmbeddingResponseSchema = lazySchema(() =>
+  zodSchema(
+    z.object({
+      data: z.array(z.object({ embedding: z.array(z.number()) })),
+      usage: z.object({ prompt_tokens: z.number() }).nullish(),
+    }),
+  ),
+);

package/src/embedding/openai-embedding-model.test.ts

@@ -0,0 +1,146 @@
+import { EmbeddingModelV3Embedding } from '@ai-sdk/provider';
+import { createTestServer } from '@ai-sdk/test-server/with-vitest';
+import { createOpenAI } from '../openai-provider';
+import { describe, it, expect, vi } from 'vitest';
+
+vi.mock('../version', () => ({
+  VERSION: '0.0.0-test',
+}));
+
+const dummyEmbeddings = [
+  [0.1, 0.2, 0.3, 0.4, 0.5],
+  [0.6, 0.7, 0.8, 0.9, 1.0],
+];
+const testValues = ['sunny day at the beach', 'rainy day in the city'];
+
+const provider = createOpenAI({ apiKey: 'test-api-key' });
+const model = provider.embedding('text-embedding-3-large');
+
+const server = createTestServer({
+  'https://api.openai.com/v1/embeddings': {},
+});
+
+describe('doEmbed', () => {
+  function prepareJsonResponse({
+    embeddings = dummyEmbeddings,
+    usage = { prompt_tokens: 8, total_tokens: 8 },
+    headers,
+  }: {
+    embeddings?: EmbeddingModelV3Embedding[];
+    usage?: { prompt_tokens: number; total_tokens: number };
+    headers?: Record<string, string>;
+  } = {}) {
+    server.urls['https://api.openai.com/v1/embeddings'].response = {
+      type: 'json-value',
+      headers,
+      body: {
+        object: 'list',
+        data: embeddings.map((embedding, i) => ({
+          object: 'embedding',
+          index: i,
+          embedding,
+        })),
+        model: 'text-embedding-3-large',
+        usage,
+      },
+    };
+  }
+
+  it('should extract embedding', async () => {
+    prepareJsonResponse();
+
+    const { embeddings } = await model.doEmbed({ values: testValues });
+
+    expect(embeddings).toStrictEqual(dummyEmbeddings);
+  });
+
+  it('should expose the raw response', async () => {
+    prepareJsonResponse({
+      headers: {
+        'test-header': 'test-value',
+      },
+    });
+
+    const { response } = await model.doEmbed({ values: testValues });
+
+    expect(response?.headers).toStrictEqual({
+      // default headers:
+      'content-length': '236',
+      'content-type': 'application/json',
+
+      // custom header
+      'test-header': 'test-value',
+    });
+    expect(response).toMatchSnapshot();
+  });
+
+  it('should extract usage', async () => {
+    prepareJsonResponse({
+      usage: { prompt_tokens: 20, total_tokens: 20 },
+    });
+
+    const { usage } = await model.doEmbed({ values: testValues });
+
+    expect(usage).toStrictEqual({ tokens: 20 });
+  });
+
+  it('should pass the model and the values', async () => {
+    prepareJsonResponse();
+
+    await model.doEmbed({ values: testValues });
+
+    expect(await server.calls[0].requestBodyJson).toStrictEqual({
+      model: 'text-embedding-3-large',
+      input: testValues,
+      encoding_format: 'float',
+    });
+  });
+
+  it('should pass the dimensions setting', async () => {
+    prepareJsonResponse();
+
+    await provider.embedding('text-embedding-3-large').doEmbed({
+      values: testValues,
+      providerOptions: { openai: { dimensions: 64 } },
+    });
+
+    expect(await server.calls[0].requestBodyJson).toStrictEqual({
+      model: 'text-embedding-3-large',
+      input: testValues,
+      encoding_format: 'float',
+      dimensions: 64,
+    });
+  });
+
+  it('should pass headers', async () => {
+    prepareJsonResponse();
+
+    const provider = createOpenAI({
+      apiKey: 'test-api-key',
+      organization: 'test-organization',
+      project: 'test-project',
+      headers: {
+        'Custom-Provider-Header': 'provider-header-value',
+      },
+    });
+
+    await provider.embedding('text-embedding-3-large').doEmbed({
+      values: testValues,
+      headers: {
+        'Custom-Request-Header': 'request-header-value',
+      },
+    });
+
+    expect(server.calls[0].requestHeaders).toStrictEqual({
+      authorization: 'Bearer test-api-key',
+      'content-type': 'application/json',
+      'custom-provider-header': 'provider-header-value',
+      'custom-request-header': 'request-header-value',
+      'openai-organization': 'test-organization',
+      'openai-project': 'test-project',
+    });
+    expect(server.calls[0].requestUserAgent).toContain(
+      `ai-sdk/openai/0.0.0-test`,
+    );
+  });
+});

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

@@ -0,0 +1,95 @@
+import {
+  EmbeddingModelV3,
+  TooManyEmbeddingValuesForCallError,
+} from '@ai-sdk/provider';
+import {
+  combineHeaders,
+  createJsonResponseHandler,
+  parseProviderOptions,
+  postJsonToApi,
+} from '@ai-sdk/provider-utils';
+import { OpenAIConfig } from '../openai-config';
+import { openaiFailedResponseHandler } from '../openai-error';
+import {
+  OpenAIEmbeddingModelId,
+  openaiEmbeddingProviderOptions,
+} from './openai-embedding-options';
+import { openaiTextEmbeddingResponseSchema } from './openai-embedding-api';
+
+export class OpenAIEmbeddingModel implements EmbeddingModelV3 {
+  readonly specificationVersion = 'v3';
+  readonly modelId: OpenAIEmbeddingModelId;
+  readonly maxEmbeddingsPerCall = 2048;
+  readonly supportsParallelCalls = true;
+
+  private readonly config: OpenAIConfig;
+
+  get provider(): string {
+    return this.config.provider;
+  }
+
+  constructor(modelId: OpenAIEmbeddingModelId, config: OpenAIConfig) {
+    this.modelId = modelId;
+    this.config = config;
+  }
+
+  async doEmbed({
+    values,
+    headers,
+    abortSignal,
+    providerOptions,
+  }: Parameters<EmbeddingModelV3['doEmbed']>[0]): Promise<
+    Awaited<ReturnType<EmbeddingModelV3['doEmbed']>>
+  > {
+    if (values.length > this.maxEmbeddingsPerCall) {
+      throw new TooManyEmbeddingValuesForCallError({
+        provider: this.provider,
+        modelId: this.modelId,
+        maxEmbeddingsPerCall: this.maxEmbeddingsPerCall,
+        values,
+      });
+    }
+
+    // Parse provider options
+    const openaiOptions =
+      (await parseProviderOptions({
+        provider: 'openai',
+        providerOptions,
+        schema: openaiEmbeddingProviderOptions,
+      })) ?? {};
+
+    const {
+      responseHeaders,
+      value: response,
+      rawValue,
+    } = await postJsonToApi({
+      url: this.config.url({
+        path: '/embeddings',
+        modelId: this.modelId,
+      }),
+      headers: combineHeaders(this.config.headers(), headers),
+      body: {
+        model: this.modelId,
+        input: values,
+        encoding_format: 'float',
+        dimensions: openaiOptions.dimensions,
+        user: openaiOptions.user,
+      },
+      failedResponseHandler: openaiFailedResponseHandler,
+      successfulResponseHandler: createJsonResponseHandler(
+        openaiTextEmbeddingResponseSchema,
+      ),
+      abortSignal,
+      fetch: this.config.fetch,
+    });
+
+    return {
+      warnings: [],
+      embeddings: response.data.map(item => item.embedding),
+      usage: response.usage
+        ? { tokens: response.usage.prompt_tokens }
+        : undefined,
+      response: { headers: responseHeaders, body: rawValue },
+    };
+  }
+}