@ai-sdk/openai 4.0.104 → 4.0.105

package/docs/03-openai.mdx

@@ -3695,8 +3695,10 @@ 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
+JSON state parts that hold an object or an array of objects are sent as native
+`input_json` parts when they fit its limits (32 container levels, 10,000 values, and
+256 KiB of compact UTF-8 JSON). Larger JSON state, other JSON state values, structured
+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.
 
@@ -3718,11 +3720,15 @@ state: [
 
 The factory respects `createOpenAI` settings, including custom fetch and base URL.
 Set `providerOptions.openai.safetyIdentifier` to an opaque end-user identifier for
-safety monitoring (up to 128 characters). For example:
+safety monitoring (up to 128 characters). Set `providerOptions.openai.promptCacheKey`
+to partition prompt cache reuse across requests that share `state`. For example:
 
 ```ts
 providerOptions: {
-  openai: { safetyIdentifier: 'user-123' } satisfies OpenAIDecisionModelOptions,
+  openai: {
+    safetyIdentifier: 'user-123',
+    promptCacheKey: 'tenant-42',
+  } satisfies OpenAIDecisionModelOptions,
 }
 ```
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/openai",
-  "version": "4.0.104",
+  "version": "4.0.105",
   "type": "module",
   "license": "Apache-2.0",
   "sideEffects": false,
@@ -36,7 +36,7 @@
   },
   "dependencies": {
     "@ai-sdk/provider": "4.0.34",
-    "@ai-sdk/provider-utils": "5.0.70"
+    "@ai-sdk/provider-utils": "5.0.71"
   },
   "devDependencies": {
     "@ai-sdk/test-server": "2.0.4",

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

@@ -26,7 +26,10 @@ import {
   type ParseResult,
 } from '@ai-sdk/provider-utils';
 import { openaiFailedResponseHandler } from '../openai-error';
-import { getOpenAILanguageModelCapabilities } from '../openai-language-model-capabilities';
+import {
+  getOpenAILanguageModelCapabilities,
+  resolveOpenAIReasoningEffort,
+} from '../openai-language-model-capabilities';
 import {
   createOpenAIProviderStreamError,
   throwIfOpenAIStreamErrorBeforeOutput,
@@ -121,26 +124,38 @@ export class OpenAIChatLanguageModel implements LanguageModelV4 {
 
     const modelCapabilities = getOpenAILanguageModelCapabilities(this.modelId);
 
-    // AI SDK reasoning values map directly to the OpenAI reasoning values.
-    let resolvedReasoningEffort =
-      openaiOptions.reasoningEffort ??
-      (isCustomReasoning(reasoning) ? reasoning : undefined);
+    // Some models reject function tools unless reasoning is disabled, even
+    // when no reasoning effort is sent, so reasoning is set to 'none'.
+    const requiresNoReasoningEffort =
+      !modelCapabilities.supportsChatFunctionToolsWithReasoning &&
+      openaiOptions.reasoningEffort == null &&
+      (tools?.some(tool => tool.type === 'function') ?? false);
 
     if (
-      resolvedReasoningEffort != null &&
-      modelCapabilities.supportedReasoningEfforts != null &&
-      !modelCapabilities.supportedReasoningEfforts.includes(
-        resolvedReasoningEffort,
-      )
+      requiresNoReasoningEffort &&
+      isCustomReasoning(reasoning) &&
+      reasoning !== 'none'
     ) {
       warnings.push({
-        type: 'unsupported',
-        feature: 'reasoningEffort',
-        details: `${this.modelId} only supports the following reasoning efforts: ${modelCapabilities.supportedReasoningEfforts.join(', ')}`,
+        type: 'compatibility',
+        feature: 'reasoning',
+        details: `${this.modelId} does not support function tools with reasoning in the Chat Completions API. reasoning effort set to "none". Use the Responses API to combine reasoning with function tools.`,
       });
-      resolvedReasoningEffort = undefined;
     }
 
+    const resolvedReasoningEffort = requiresNoReasoningEffort
+      ? 'none'
+      : resolveOpenAIReasoningEffort({
+          providerReasoningEffort: openaiOptions.reasoningEffort,
+          reasoning,
+          // Only the Responses API supports `max`.
+          supportedReasoningEfforts:
+            modelCapabilities.supportedReasoningEfforts?.filter(
+              effort => effort !== 'max',
+            ),
+          warnings,
+        });
+
     const isReasoningModel =
       openaiOptions.forceReasoning ?? modelCapabilities.isReasoningModel;
 
@@ -246,7 +261,7 @@ export class OpenAIChatLanguageModel implements LanguageModelV4 {
     };
 
     if (
-      modelCapabilities.supportedReasoningEfforts != null &&
+      modelCapabilities.supportsConfigurationUpdate &&
       baseArgs.prompt_cache_retention != null
     ) {
       baseArgs.prompt_cache_retention = undefined;

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

@@ -10,6 +10,7 @@ export const openaiDecisionModelOptions = lazySchema(() =>
     z.object({
       /** An opaque end-user identifier for safety monitoring, up to 128 characters. */
       safetyIdentifier: z.string().max(128).optional(),
+      promptCacheKey: z.string().optional(),
     }),
   ),
 );

package/src/openai-decision-model.ts

@@ -4,6 +4,8 @@ import {
   type Experimental_DecisionModelV4 as DecisionModelV4,
   type Experimental_DecisionModelV4Answer as DecisionModelV4Answer,
   type Experimental_DecisionModelV4Input as DecisionModelV4Input,
+  type JSONObject,
+  type JSONValue,
 } from '@ai-sdk/provider';
 import {
   lazySchema,
@@ -148,6 +150,7 @@ export class DecisionOpenAIModel implements DecisionModelV4 {
       body: {
         model: this.modelId,
         safety_identifier: openaiOptions?.safetyIdentifier,
+        prompt_cache_key: openaiOptions?.promptCacheKey,
         input: [
           {
             role: 'user',
@@ -155,10 +158,9 @@ export class DecisionOpenAIModel implements DecisionModelV4 {
               if (part.type === 'text')
                 return { type: 'input_text', text: part.text };
               if (part.type === 'json')
-                return {
-                  type: 'input_text',
-                  text: JSON.stringify(part.value),
-                };
+                return isInputJsonData(part.value)
+                  ? { type: 'input_json', data: part.value }
+                  : { type: 'input_text', text: JSON.stringify(part.value) };
               if (part.data.type !== 'data') {
                 throw new UnsupportedFunctionalityError({
                   functionality: `OpenAI decision file input: ${part.mediaType} (${part.data.type})`,
@@ -323,7 +325,7 @@ export class DecisionOpenAIModel implements DecisionModelV4 {
           ? [{ type: 'unsupported' as const, feature: 'reasoning' }]
           : []),
         ...Object.keys(providerOptions?.openai ?? {})
-          .filter(option => option !== 'safetyIdentifier')
+          .filter(option => !SUPPORTED_PROVIDER_OPTIONS.has(option))
           .map(option => ({
             type: 'unsupported' as const,
             feature: `providerOptions.openai.${option}`,
@@ -351,6 +353,45 @@ export class DecisionOpenAIModel implements DecisionModelV4 {
   }
 }
 
+const SUPPORTED_PROVIDER_OPTIONS = new Set([
+  'safetyIdentifier',
+  'promptCacheKey',
+]);
+
 function toText(input: DecisionModelV4Input): string {
   return typeof input === 'string' ? input : JSON.stringify(input);
 }
+
+const INPUT_JSON_MAX_DEPTH = 32;
+const INPUT_JSON_MAX_VALUES = 10_000;
+const INPUT_JSON_MAX_BYTES = 256 * 1024;
+
+function isInputJsonData(value: JSONValue): value is JSONObject | JSONObject[] {
+  const hasInputJsonShape = Array.isArray(value)
+    ? value.length > 0 && value.every(isJSONObject)
+    : isJSONObject(value);
+  return hasInputJsonShape && fitsInputJsonLimits(value);
+}
+
+function fitsInputJsonLimits(value: JSONValue): boolean {
+  let count = 0;
+  const visit = (node: JSONValue | undefined, depth: number): boolean => {
+    count += 1;
+    if (count > INPUT_JSON_MAX_VALUES) return false;
+    if (node === null || typeof node !== 'object') return true;
+    if (depth > INPUT_JSON_MAX_DEPTH) return false;
+    const children: readonly (JSONValue | undefined)[] = Array.isArray(node)
+      ? node
+      : Object.values(node);
+    return children.every(child => visit(child, depth + 1));
+  };
+  return (
+    visit(value, 1) &&
+    new TextEncoder().encode(JSON.stringify(value)).length <=
+      INPUT_JSON_MAX_BYTES
+  );
+}
+
+function isJSONObject(value: JSONValue): value is JSONObject {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}

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

@@ -1,3 +1,25 @@
+import type {
+  LanguageModelV4CallOptions,
+  SharedV4Warning,
+} from '@ai-sdk/provider';
+import { mapReasoningToProviderEffort } from '@ai-sdk/provider-utils';
+
+type OpenAIReasoningEffort = Exclude<
+  LanguageModelV4CallOptions['reasoning'],
+  'provider-default' | undefined
+>;
+
+// Unknown model families send the reasoning value directly.
+const ALL_OPENAI_REASONING_EFFORTS: readonly OpenAIReasoningEffort[] = [
+  'none',
+  'minimal',
+  'low',
+  'medium',
+  'high',
+  'xhigh',
+  'max',
+];
+
 export type OpenAILanguageModelCapabilities = {
   isReasoningModel: boolean;
   systemMessageMode: 'remove' | 'system' | 'developer';
@@ -5,7 +27,17 @@ export type OpenAILanguageModelCapabilities = {
   supportsPriorityProcessing: boolean;
   supportsConfigurationUpdate: boolean;
   supportsAsyncToolCalling: boolean;
-  supportedReasoningEfforts: readonly string[] | undefined;
+  /**
+   * Reasoning efforts supported by the model family, or `undefined` when they
+   * are not known.
+   */
+  supportedReasoningEfforts: readonly OpenAIReasoningEffort[] | undefined;
+
+  /**
+   * Whether function tools can be combined with a reasoning effort other than
+   * `none` in the Chat Completions API.
+   */
+  supportsChatFunctionToolsWithReasoning: boolean;
 
   /**
    * Allow temperature, topP, logProbs when reasoningEffort is none.
@@ -24,6 +56,15 @@ export function getOpenAILanguageModelCapabilities(
   const isGptNanoModel = gptVersion?.variant?.startsWith('nano') ?? false;
   const isGpt6OrLaterModel = gptVersion != null && gptVersion.major >= 6;
 
+  // Pro, codex, and chat variants are excluded because their supported
+  // efforts are not known.
+  const isStandardGpt5Model =
+    gptVersion?.major === 5 &&
+    (gptVersion.variant == null ||
+      /^(?:(?:mini|nano|sol|luna|terra)(?:-\d{4}-\d{2}-\d{2})?|\d{4}-\d{2}-\d{2})$/.test(
+        gptVersion.variant,
+      ));
+
   const isGpt6OrLaterModelWithNoneEffort =
     modelId === 'gpt-6-sol' ||
     modelId === 'gpt-6-luna' ||
@@ -68,13 +109,37 @@ export function getOpenAILanguageModelCapabilities(
       ? ['none', 'low', 'medium', 'high', 'xhigh', 'max']
       : isGpt6OrLaterModel
         ? ['low', 'medium', 'high', 'xhigh', 'max']
-        : undefined,
+        : isStandardGpt5Model
+          ? getGpt5ReasoningEfforts(gptVersion.minor ?? 0)
+          : undefined,
+    // GPT-5.6 rejects function tools with reasoning in the Chat Completions API.
+    supportsChatFunctionToolsWithReasoning: !(
+      gptVersion?.major === 5 && (gptVersion.minor ?? 0) >= 6
+    ),
     isReasoningModel,
     systemMessageMode,
     supportsNonReasoningParameters,
   };
 }
 
+function getGpt5ReasoningEfforts(
+  minor: number,
+): readonly OpenAIReasoningEffort[] {
+  if (minor === 0) {
+    return ['minimal', 'low', 'medium', 'high'];
+  }
+
+  if (minor === 1) {
+    return ['none', 'low', 'medium', 'high'];
+  }
+
+  if (minor < 6) {
+    return ['none', 'low', 'medium', 'high', 'xhigh'];
+  }
+
+  return ['none', 'low', 'medium', 'high', 'xhigh', 'max'];
+}
+
 function getOSeriesVersion(modelId: string): number | undefined {
   const match = /^o(\d+)(?:-|$)/.exec(modelId);
   return match == null ? undefined : Number(match[1]);
@@ -99,3 +164,33 @@ function getGptVersion(modelId: string):
     variant: match[3],
   };
 }
+
+/**
+ * Resolves the reasoning effort to send to OpenAI.
+ *
+ * A reasoning effort from provider options is sent unchanged. Otherwise the
+ * top-level reasoning value is mapped to the closest effort that the model
+ * family supports, or sent directly when the supported efforts are not known.
+ */
+export function resolveOpenAIReasoningEffort({
+  providerReasoningEffort,
+  reasoning,
+  supportedReasoningEfforts,
+  warnings,
+}: {
+  providerReasoningEffort: string | null | undefined;
+  reasoning: LanguageModelV4CallOptions['reasoning'];
+  supportedReasoningEfforts: readonly OpenAIReasoningEffort[] | undefined;
+  warnings: SharedV4Warning[];
+}): string | undefined {
+  return mapReasoningToProviderEffort({
+    reasoning,
+    providerOptionsEffort: providerReasoningEffort,
+    effortMap: Object.fromEntries(
+      (supportedReasoningEfforts ?? ALL_OPENAI_REASONING_EFFORTS).map(
+        effort => [effort, effort],
+      ),
+    ),
+    warnings,
+  });
+}

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

@@ -22,7 +22,6 @@ import {
   createJsonResponseHandler,
   createToolNameMapping,
   generateId,
-  isCustomReasoning,
   parseProviderOptions,
   postJsonToApi,
   serializeModelOptions,
@@ -37,7 +36,10 @@ import {
   type OpenAIConfig,
 } from '../openai-config';
 import { openaiFailedResponseHandler } from '../openai-error';
-import { getOpenAILanguageModelCapabilities } from '../openai-language-model-capabilities';
+import {
+  getOpenAILanguageModelCapabilities,
+  resolveOpenAIReasoningEffort,
+} from '../openai-language-model-capabilities';
 import {
   createOpenAIProviderStreamError,
   throwIfOpenAIStreamErrorBeforeOutput,
@@ -341,24 +343,12 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV4 {
       });
     }
 
-    let resolvedReasoningEffort =
-      openaiOptions?.reasoningEffort ??
-      (isCustomReasoning(reasoning) ? reasoning : undefined);
-
-    if (
-      resolvedReasoningEffort != null &&
-      modelCapabilities.supportedReasoningEfforts != null &&
-      !modelCapabilities.supportedReasoningEfforts.includes(
-        resolvedReasoningEffort,
-      )
-    ) {
-      warnings.push({
-        type: 'unsupported',
-        feature: 'reasoningEffort',
-        details: `${modelId} only supports the following reasoning efforts: ${modelCapabilities.supportedReasoningEfforts.join(', ')}`,
-      });
-      resolvedReasoningEffort = undefined;
-    }
+    const resolvedReasoningEffort = resolveOpenAIReasoningEffort({
+      providerReasoningEffort: openaiOptions?.reasoningEffort,
+      reasoning,
+      supportedReasoningEfforts: modelCapabilities.supportedReasoningEfforts,
+      warnings,
+    });
 
     const resolvedReasoningSummary =
       openaiOptions?.reasoningSummary !== undefined
@@ -458,10 +448,13 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV4 {
 
     // The schema accepts update efforts supported by any supported model. Check
     // whether this specific model supports the requested effort.
+    const supportedReasoningEfforts =
+      modelCapabilities.supportedReasoningEfforts as
+        | readonly string[]
+        | undefined;
     const getUpdateEffortUnsupportedReason = (effort: string | undefined) =>
-      effort != null &&
-      modelCapabilities.supportedReasoningEfforts?.includes(effort) === false
-        ? `${modelId} only supports the following reasoning efforts: ${modelCapabilities.supportedReasoningEfforts.join(', ')}`
+      effort != null && supportedReasoningEfforts?.includes(effort) === false
+        ? `${modelId} only supports the following reasoning efforts: ${supportedReasoningEfforts.join(', ')}`
         : undefined;
 
     // Reject configuration updates whose effort value is unsupported by the selected model.
@@ -725,7 +718,7 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV4 {
         }
 
         if (
-          modelCapabilities.supportedReasoningEfforts != null &&
+          modelCapabilities.supportsConfigurationUpdate &&
           (baseArgs.top_logprobs != null ||
             baseArgs.include?.includes('message.output_text.logprobs'))
         ) {