@ai-sdk/openai 4.0.84 → 4.0.86

package/docs/03-openai.mdx

@@ -36,6 +36,15 @@ const openai = createOpenAI({
 
 You can use the following optional settings to customize the OpenAI provider instance:
 
+- **batchResultDownloads** _object_
+
+  Settings for downloading JSON Lines batch results.
+  - **maxLineBytes** _number_
+
+    Maximum UTF-8 bytes per row, excluding the LF delimiter. Defaults to 64 MiB
+    (67,108,864 bytes). Must be a positive safe integer. Oversized rows throw a
+    `DownloadError` and cancel the download.
+
 - **baseURL** _string_
 
   Use a different URL prefix for API calls, e.g. to use proxy servers.
@@ -3472,8 +3481,8 @@ const result = await generateSpeech({
 ## Decision Models
 
 Create an experimental decision model with `openai.decisionModel(modelId)`.
-It uses the Responses API with structured output to answer Choice, Score, and
-Boolean questions. Choose a model that supports structured output, such as `gpt-6-luna`.
+It uses the native [Decisions API](https://developers.openai.com/api/docs/guides/decisions)
+to answer Choice, Score, and Boolean questions with `gpt-6-luna`.
 
 ```ts
 import { openai } from '@ai-sdk/openai';
@@ -3496,17 +3505,37 @@ const { answers } = await experimental_decide({
 });
 ```
 
-Scores are finite fractional positions on the ordered rubric. Choice labels are
-returned exactly as supplied. These are model judgments: no probability
-distributions are returned for Choice or Score. Boolean answers contain a prompted
-estimate of P(true), validated to be finite and in `[0, 1]`. These estimates are
-not guaranteed to be calibrated. Apply thresholds in application code, for example
+Scores are probability-weighted fractional positions on the ordered rubric, starting
+at zero. Choice labels are returned exactly as supplied. Choice and Score answers
+include probability distributions. Boolean questions use the API's predicate
+primitive and return P(true). Apply thresholds in application code, for example
 `answers.requestsRefund.probability >= 0.5`.
 
+Structured state, instructions, and criterion descriptions are serialized as JSON
+text. Score levels receive zero-based index labels. Non-null Boolean criteria are
+appended to predicate instructions under `Criteria for true:` and `Criteria for false:`.
+String criteria are passed through; structured criteria are serialized as JSON text.
+
 The factory respects `createOpenAI` settings, including custom fetch and base URL.
-Pass Responses options through `providerOptions.openai`. Usage, warnings,
-response information, and provider metadata are preserved. Refusals, truncated
-output, or invalid answers fail the entire call. See [Decisions](/docs/ai-sdk-core/decisions).
+Set `providerOptions.openai.safetyIdentifier` to an opaque end-user identifier for
+safety monitoring (up to 128 characters). For example:
+
+```ts
+providerOptions: {
+  openai: { safetyIdentifier: 'user-123' } satisfies OpenAIDecisionModelOptions,
+}
+```
+
+Import `OpenAIDecisionModelOptions` from `@ai-sdk/openai` when using the type above.
+Other OpenAI options are unsupported and produce warnings. Native confidence
+values are available in `providerMetadata.openai.confidence`, keyed by question ID.
+Input and output token counts are available in `usage`. The full native token usage
+(including cache, reasoning, and total counts) is preserved in
+`providerMetadata.openai.usage`. Response headers, the returned model ID, and the
+raw response body are preserved. If OpenAI refuses a question, the entire call
+throws `InvalidResponseDataError` with the question name and the raw response in
+`error.data`. Invalid answers also fail the entire decision.
+See [Decisions](/docs/ai-sdk-core/decisions).
 
 Decision models can also be accessed through `customProvider` aliases or
 `createProviderRegistry().decisionModel('provider:model')`. Direct string IDs

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/openai",
-  "version": "4.0.84",
+  "version": "4.0.86",
   "type": "module",
   "license": "Apache-2.0",
   "sideEffects": false,
@@ -35,15 +35,15 @@
     }
   },
   "dependencies": {
-    "@ai-sdk/provider": "4.0.22",
-    "@ai-sdk/provider-utils": "5.0.54"
+    "@ai-sdk/provider": "4.0.24",
+    "@ai-sdk/provider-utils": "5.0.56"
   },
   "devDependencies": {
-    "@ai-sdk/test-server": "2.0.3",
+    "@ai-sdk/test-server": "2.0.4",
     "@types/node": "22.19.19",
     "@vercel/ai-tsconfig": "0.0.0",
     "tsdown": "^0.23.0",
-    "typescript": "5.8.3",
+    "typescript": "6.0.3",
     "zod": "3.25.76"
   },
   "peerDependencies": {

package/src/files/openai-files.ts

@@ -148,7 +148,7 @@ export class OpenAIFiles implements FilesV4 {
     } else {
       const fileBytes = convertInlineFileDataToUint8Array(data);
 
-      const blob = new Blob([fileBytes], {
+      const blob = new Blob([fileBytes as Uint8Array<ArrayBuffer>], {
         type: mediaType,
       });
 

package/src/index.ts

@@ -60,3 +60,5 @@ export type {
   OpenaiResponsesSourceDocumentProviderMetadata,
 } from './responses/openai-responses-provider-metadata';
 export { VERSION } from './version';
+export type { OpenAIDecisionModelId } from './openai-decision-model';
+export type { OpenAIDecisionModelOptions } from './openai-decision-model-options';

package/src/openai-batch.ts

@@ -181,6 +181,7 @@ export class OpenAIBatch implements BatchV4<OpenAIBatchModelIds> {
     private readonly options: {
       provider: string;
       config: OpenAIConfig;
+      maxLineBytes?: number;
     },
   ) {
     this.provider = options.provider;
@@ -466,6 +467,7 @@ export class OpenAIBatch implements BatchV4<OpenAIBatchModelIds> {
         failedResponseHandler: openaiFailedResponseHandler,
         successfulResponseHandler: createJsonLinesResponseHandler(
           openaiBatchResultLineSchema,
+          { maxLineBytes: this.options.maxLineBytes },
         ),
         abortSignal: options.abortSignal,
         fetch: this.options.config.fetch,

package/src/openai-decision-model-options.ts

@@ -0,0 +1,19 @@
+import {
+  lazySchema,
+  zodSchema,
+  type InferSchema,
+} from '@ai-sdk/provider-utils';
+import { z } from 'zod/v4';
+
+export const openaiDecisionModelOptions = lazySchema(() =>
+  zodSchema(
+    z.object({
+      /** An opaque end-user identifier for safety monitoring, up to 128 characters. */
+      safetyIdentifier: z.string().max(128).optional(),
+    }),
+  ),
+);
+
+export type OpenAIDecisionModelOptions = InferSchema<
+  typeof openaiDecisionModelOptions
+>;

package/src/openai-decision-model.ts

@@ -0,0 +1,285 @@
+import {
+  InvalidResponseDataError,
+  type Experimental_DecisionModelV4 as DecisionModelV4,
+  type Experimental_DecisionModelV4Answer as DecisionModelV4Answer,
+  type Experimental_DecisionModelV4Input as DecisionModelV4Input,
+} from '@ai-sdk/provider';
+import {
+  combineHeaders,
+  createJsonResponseHandler,
+  postJsonToApi,
+  parseProviderOptions,
+  serializeModelOptions,
+  WORKFLOW_DESERIALIZE,
+  WORKFLOW_SERIALIZE,
+} from '@ai-sdk/provider-utils';
+import { z } from 'zod/v4';
+import {
+  prepareOpenAIConfigForWorkflowDeserialize,
+  type OpenAIConfig,
+} from './openai-config';
+import { openaiFailedResponseHandler } from './openai-error';
+import { openaiDecisionModelOptions } from './openai-decision-model-options';
+
+export type OpenAIDecisionModelId = 'gpt-6-luna' | (string & {});
+
+const probability = z.number().min(0).max(1);
+const responseSchema = z.object({
+  model: z.string().nullish(),
+  usage: z
+    .object({
+      input_tokens: z.number().nullish(),
+      input_tokens_details: z
+        .object({
+          cached_tokens: z.number().nullish(),
+          cache_write_tokens: z.number().nullish(),
+        })
+        .nullish(),
+      output_tokens: z.number().nullish(),
+      output_tokens_details: z
+        .object({
+          reasoning_tokens: z.number().nullish(),
+        })
+        .nullish(),
+      total_tokens: z.number().nullish(),
+    })
+    .nullish(),
+  answers: z.array(
+    z.discriminatedUnion('type', [
+      z.object({ type: z.literal('refusal'), name: z.string().nullable() }),
+      z.object({
+        type: z.literal('predicate'),
+        name: z.string(),
+        probability,
+      }),
+      z.object({
+        type: z.literal('choice'),
+        name: z.string(),
+        choice: z.string(),
+        confidence: probability.nullish(),
+        probabilities: z.array(z.object({ value: z.string(), probability })),
+      }),
+      z.object({
+        type: z.literal('score'),
+        name: z.string(),
+        score: z.number(),
+        confidence: probability.nullish(),
+        probabilities: z.array(
+          z.object({ value: z.number().int().nonnegative(), probability }),
+        ),
+      }),
+    ]),
+  ),
+});
+
+function toText(input: DecisionModelV4Input): string {
+  return typeof input === 'string' ? input : JSON.stringify(input);
+}
+
+export class DecisionOpenAIModel implements DecisionModelV4 {
+  readonly specificationVersion = 'v4';
+  readonly supportedQuestionTypes = ['choice', 'score', 'boolean'] as const;
+
+  constructor(
+    readonly modelId: OpenAIDecisionModelId,
+    private readonly config: OpenAIConfig,
+  ) {}
+
+  get provider() {
+    return this.config.provider;
+  }
+
+  static [WORKFLOW_SERIALIZE](model: DecisionOpenAIModel) {
+    return serializeModelOptions({
+      modelId: model.modelId,
+      config: model.config,
+    });
+  }
+
+  static [WORKFLOW_DESERIALIZE](options: {
+    modelId: OpenAIDecisionModelId;
+    config: Parameters<typeof prepareOpenAIConfigForWorkflowDeserialize>[0];
+  }) {
+    return new DecisionOpenAIModel(
+      options.modelId,
+      prepareOpenAIConfigForWorkflowDeserialize(options.config),
+    );
+  }
+
+  /** @deprecated Use `doDecide` instead. */
+  doEvaluate(options: Parameters<DecisionModelV4['doDecide']>[0]) {
+    return this.doDecide(options);
+  }
+
+  async doDecide({
+    state,
+    questions,
+    headers,
+    abortSignal,
+    providerOptions,
+  }: Parameters<DecisionModelV4['doDecide']>[0]): Promise<
+    Awaited<ReturnType<DecisionModelV4['doDecide']>>
+  > {
+    const openaiOptions = await parseProviderOptions({
+      provider: 'openai',
+      providerOptions,
+      schema: openaiDecisionModelOptions,
+    });
+    const {
+      value: response,
+      rawValue,
+      responseHeaders,
+    } = await postJsonToApi({
+      url: this.config.url({ path: '/decisions', modelId: this.modelId }),
+      headers: combineHeaders(this.config.headers?.(), headers),
+      body: {
+        model: this.modelId,
+        safety_identifier: openaiOptions?.safetyIdentifier,
+        input: toText(state),
+        questions: Object.entries(questions).map(([name, question]) => {
+          const instructions = toText(question.instructions);
+          switch (question.type) {
+            case 'boolean':
+              return {
+                type: 'predicate',
+                name,
+                instructions: [
+                  instructions,
+                  question.criteria?.true == null
+                    ? undefined
+                    : `Criteria for true:\n${toText(question.criteria.true)}`,
+                  question.criteria?.false == null
+                    ? undefined
+                    : `Criteria for false:\n${toText(question.criteria.false)}`,
+                ]
+                  .filter(part => part !== undefined)
+                  .join('\n\n'),
+              };
+            case 'choice':
+              return {
+                type: 'choice',
+                name,
+                instructions,
+                choices: Object.entries(question.criteria).map(
+                  ([value, description]) => ({
+                    value,
+                    ...(description == null
+                      ? {}
+                      : { description: toText(description) }),
+                  }),
+                ),
+              };
+            case 'score':
+              return {
+                type: 'score',
+                name,
+                instructions,
+                levels: question.criteria.map((description, index) => ({
+                  // Score criteria have no separate labels; indices identify each level.
+                  label: String(index),
+                  ...(description == null
+                    ? {}
+                    : { description: toText(description) }),
+                })),
+              };
+          }
+        }),
+      },
+      abortSignal,
+      fetch: this.config.fetch,
+      failedResponseHandler: openaiFailedResponseHandler,
+      successfulResponseHandler: createJsonResponseHandler(responseSchema),
+    });
+
+    const answers = Object.fromEntries(
+      response.answers.map((answer): [string, DecisionModelV4Answer] => {
+        if (answer.type === 'refusal') {
+          if (answer.name === null) {
+            throw new InvalidResponseDataError({
+              data: rawValue,
+              message: 'OpenAI Decisions refused an unnamed question.',
+            });
+          }
+          return [answer.name, { type: 'refusal' }];
+        }
+        if (answer.type === 'predicate') {
+          return [
+            answer.name,
+            { type: 'boolean', probability: answer.probability },
+          ];
+        }
+        const probabilities = Object.fromEntries(
+          answer.probabilities.map(({ value, probability }) => [
+            value,
+            probability,
+          ]),
+        );
+        if (Object.keys(probabilities).length !== answer.probabilities.length) {
+          throw new InvalidResponseDataError({
+            data: rawValue,
+            message: 'Decisions returned duplicate probability values.',
+          });
+        }
+        return [
+          answer.name,
+          answer.type === 'choice'
+            ? { type: 'choice', choice: answer.choice, probabilities }
+            : { type: 'score', score: answer.score, probabilities },
+        ];
+      }),
+    );
+
+    const names = response.answers.map(answer => answer.name);
+    if (
+      names.length !== Object.keys(questions).length ||
+      new Set(names).size !== names.length ||
+      names.some(
+        name =>
+          typeof name !== 'string' ||
+          !Object.prototype.hasOwnProperty.call(questions, name),
+      )
+    ) {
+      throw new InvalidResponseDataError({
+        data: rawValue,
+        message: 'Decisions must return exactly one answer for every question.',
+      });
+    }
+
+    return {
+      answers,
+      usage:
+        response.usage == null
+          ? undefined
+          : {
+              inputTokens: response.usage.input_tokens ?? undefined,
+              outputTokens: response.usage.output_tokens ?? undefined,
+            },
+      // The Decisions API reports probabilities and scores to two decimal places.
+      rounding: { probabilityDecimals: 2, scoreDecimals: 2 },
+      warnings: Object.keys(providerOptions?.openai ?? {})
+        .filter(option => option !== 'safetyIdentifier')
+        .map(option => ({
+          type: 'unsupported',
+          feature: `providerOptions.openai.${option}`,
+        })),
+      providerMetadata: {
+        openai: {
+          ...(response.usage == null ? {} : { usage: response.usage }),
+          confidence: Object.fromEntries(
+            response.answers.flatMap(answer =>
+              (answer.type === 'choice' || answer.type === 'score') &&
+              answer.confidence != null
+                ? [[answer.name, answer.confidence]]
+                : [],
+            ),
+          ),
+        },
+      },
+      response: {
+        modelId: response.model ?? this.modelId,
+        headers: responseHeaders,
+        body: rawValue,
+      },
+    };
+  }
+}

package/src/openai-provider.ts

@@ -20,7 +20,10 @@ import {
   type FetchFunction,
   type WebSocketConstructor,
 } from '@ai-sdk/provider-utils';
-import { Experimental_DecisionLanguageModel as DecisionLanguageModel } from '@ai-sdk/provider-utils/experimental-decision';
+import {
+  DecisionOpenAIModel,
+  type OpenAIDecisionModelId,
+} from './openai-decision-model';
 import { OpenAIChatLanguageModel } from './chat/openai-chat-language-model';
 import type { OpenAIChatModelId } from './chat/openai-chat-language-model-options';
 import { OpenAICompletionLanguageModel } from './completion/openai-completion-language-model';
@@ -50,10 +53,10 @@ import { VERSION } from './version';
 export interface OpenAIProvider extends ProviderV4 {
   (modelId: OpenAIResponsesModelId): LanguageModelV4;
 
-  /** Creates an experimental Choice/Score/Boolean decision model using the Responses API. */
-  decisionModel(modelId: OpenAIResponsesModelId): DecisionModelV4;
+  /** Creates an experimental Choice/Score/Boolean decision model using the Decisions API. */
+  decisionModel(modelId: OpenAIDecisionModelId): DecisionModelV4;
   /** @deprecated Use `decisionModel` instead. */
-  evaluationModel(modelId: OpenAIResponsesModelId): DecisionModelV4 & {
+  evaluationModel(modelId: OpenAIDecisionModelId): DecisionModelV4 & {
     doEvaluate: DecisionModelV4['doDecide'];
   };
 
@@ -159,6 +162,12 @@ export interface OpenAIProvider extends ProviderV4 {
 }
 
 export interface OpenAIProviderSettings {
+  /** Settings for downloading JSON Lines batch results. */
+  batchResultDownloads?: {
+    /** Maximum UTF-8 bytes per row, excluding LF. Defaults to 64 MiB. */
+    maxLineBytes?: number;
+  };
+
   /**
    * Base URL for the OpenAI API calls.
    */
@@ -336,6 +345,7 @@ export function createOpenAI(
   const createBatch = () =>
     new OpenAIBatch({
       provider: `${providerName}.batch`,
+      maxLineBytes: options.batchResultDownloads?.maxLineBytes,
       config: {
         provider: `${providerName}.responses`,
         baseURL,
@@ -356,9 +366,12 @@ export function createOpenAI(
   provider.chat = createChatModel;
   provider.completion = createCompletionModel;
   provider.responses = createResponsesModel;
-  provider.decisionModel = (modelId: OpenAIResponsesModelId) =>
-    new DecisionLanguageModel({
-      model: createResponsesModel(modelId),
+  provider.decisionModel = (modelId: OpenAIDecisionModelId) =>
+    new DecisionOpenAIModel(modelId, {
+      baseURL,
+      url: ({ path }) => `${baseURL}${path}`,
+      headers: getHeaders,
+      fetch: options.fetch,
       provider: `${providerName}.decision`,
     });
   provider.evaluationModel =

package/src/skills/openai-skills.ts

@@ -41,7 +41,11 @@ export class OpenAISkills implements SkillsV4 {
 
     for (const file of params.files) {
       const content = convertInlineFileDataToUint8Array(file.data);
-      formData.append('files[]', new Blob([content]), file.path);
+      formData.append(
+        'files[]',
+        new Blob([content as Uint8Array<ArrayBuffer>]),
+        file.path,
+      );
     }
 
     const { value: response } = await postFormDataToApi({

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

@@ -180,7 +180,7 @@ export class OpenAITranscriptionModel implements TranscriptionModelV4 {
     const formData = new FormData();
     const blob =
       audio instanceof Uint8Array
-        ? new Blob([audio])
+        ? new Blob([audio as Uint8Array<ArrayBuffer>])
         : new Blob([convertBase64ToUint8Array(audio)]);
 
     formData.append('model', this.modelId);