@ai-sdk/openai 4.0.109 → 4.0.111

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

@@ -869,6 +869,8 @@ const openaiResponsesModeledChunkTypes = new Set([
   'response.output_item.done',
   'response.output_text.annotation.added',
   'response.output_text.delta',
+  'response.refusal.delta',
+  'response.refusal.done',
   'response.reasoning_summary_part.added',
   'response.reasoning_summary_part.done',
   'response.reasoning_summary_text.delta',
@@ -948,6 +950,20 @@ export const openaiResponsesChunkSchema = lazySchema(() =>
           )
           .nullish(),
       }),
+      z.object({
+        type: z.literal('response.refusal.delta'),
+        item_id: z.string(),
+        output_index: z.number().nullish(),
+        content_index: z.number().nullish(),
+        delta: z.string(),
+      }),
+      z.object({
+        type: z.literal('response.refusal.done'),
+        item_id: z.string(),
+        output_index: z.number().nullish(),
+        content_index: z.number().nullish(),
+        refusal: z.string(),
+      }),
       z.object({
         type: z.enum(['response.completed', 'response.incomplete']),
         response: z.object({
@@ -1548,55 +1564,62 @@ export const openaiResponsesResponseSchema = lazySchema(() =>
               role: z.literal('assistant'),
               id: z.string(),
               phase: z.enum(['commentary', 'final_answer']).nullish(),
+              // the API returns either text or a refusal as content parts:
               content: z.array(
-                z.object({
-                  type: z.literal('output_text'),
-                  text: z.string(),
-                  logprobs: z
-                    .array(
-                      z.object({
-                        token: z.string(),
-                        logprob: z.number(),
-                        top_logprobs: z.array(
-                          z.object({
-                            token: z.string(),
-                            logprob: z.number(),
-                          }),
-                        ),
-                      }),
-                    )
-                    .nullish(),
-                  annotations: z.array(
-                    z.discriminatedUnion('type', [
-                      z.object({
-                        type: z.literal('url_citation'),
-                        start_index: z.number(),
-                        end_index: z.number(),
-                        url: z.string(),
-                        title: z.string(),
-                      }),
-                      z.object({
-                        type: z.literal('file_citation'),
-                        file_id: z.string(),
-                        filename: z.string(),
-                        index: z.number(),
-                      }),
-                      z.object({
-                        type: z.literal('container_file_citation'),
-                        container_id: z.string(),
-                        file_id: z.string(),
-                        filename: z.string(),
-                        start_index: z.number(),
-                        end_index: z.number(),
-                      }),
-                      z.object({
-                        type: z.literal('file_path'),
-                        file_id: z.string(),
-                        index: z.number(),
-                      }),
-                    ]),
-                  ),
-                }),
+                z.discriminatedUnion('type', [
+                  z.object({
+                    type: z.literal('output_text'),
+                    text: z.string(),
+                    logprobs: z
+                      .array(
+                        z.object({
+                          token: z.string(),
+                          logprob: z.number(),
+                          top_logprobs: z.array(
+                            z.object({
+                              token: z.string(),
+                              logprob: z.number(),
+                            }),
+                          ),
+                        }),
+                      )
+                      .nullish(),
+                    annotations: z.array(
+                      z.discriminatedUnion('type', [
+                        z.object({
+                          type: z.literal('url_citation'),
+                          start_index: z.number(),
+                          end_index: z.number(),
+                          url: z.string(),
+                          title: z.string(),
+                        }),
+                        z.object({
+                          type: z.literal('file_citation'),
+                          file_id: z.string(),
+                          filename: z.string(),
+                          index: z.number(),
+                        }),
+                        z.object({
+                          type: z.literal('container_file_citation'),
+                          container_id: z.string(),
+                          file_id: z.string(),
+                          filename: z.string(),
+                          start_index: z.number(),
+                          end_index: z.number(),
+                        }),
+                        z.object({
+                          type: z.literal('file_path'),
+                          file_id: z.string(),
+                          index: z.number(),
+                        }),
+                      ]),
+                    ),
+                  }),
+                  z.object({
+                    type: z.literal('refusal'),
+                    refusal: z.string(),
+                  }),
+                ]),
               ),
             }),
             z.object({

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

@@ -23,8 +23,8 @@ import {
   createJsonResponseHandler,
   createToolNameMapping,
   generateId,
-  parseProviderOptions,
   postJsonToApi,
+  resolveProviderOptions,
   serializeModelOptions,
   WORKFLOW_DESERIALIZE,
   WORKFLOW_SERIALIZE,
@@ -331,20 +331,15 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV4 {
     const providerOptionsName = config.provider.includes('azure')
       ? 'azure'
       : 'openai';
-    let openaiOptions = await parseProviderOptions({
-      provider: providerOptionsName,
+    // The provider key (`azure`) and `openai` are alternatives: the first
+    // present one is used as a whole.
+    const { options: openaiOptions } = await resolveProviderOptions({
       providerOptions,
+      namespaces: [providerOptionsName, 'openai'],
+      resolution: 'first',
       schema: openaiLanguageModelResponsesOptionsSchema,
     });
 
-    if (openaiOptions == null && providerOptionsName !== 'openai') {
-      openaiOptions = await parseProviderOptions({
-        provider: 'openai',
-        providerOptions,
-        schema: openaiLanguageModelResponsesOptionsSchema,
-      });
-    }
-
     const resolvedReasoningEffort = resolveOpenAIReasoningEffort({
       providerReasoningEffort: openaiOptions?.reasoningEffort,
       reasoning,
@@ -923,6 +918,9 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV4 {
     let hasFunctionCall = false;
     const hostedToolSearchCallIds: string[] = [];
 
+    // flag that checks if the model refused to answer:
+    let hasRefusal = false;
+
     let structuredOutputText: string | undefined;
 
     // map response content to content array
@@ -1092,11 +1090,32 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV4 {
             part.phase === 'final_answer'
           ) {
             structuredOutputText = part.content
-              .map(contentPart => contentPart.text)
+              .map(contentPart =>
+                contentPart.type === 'output_text'
+                  ? contentPart.text
+                  : contentPart.refusal,
+              )
               .join('');
           }
 
           for (const contentPart of part.content) {
+            if (contentPart.type === 'refusal') {
+              hasRefusal = true;
+
+              content.push({
+                type: 'text',
+                text: contentPart.refusal,
+                providerMetadata: {
+                  [providerOptionsName]: {
+                    itemId: part.id,
+                    ...(part.phase != null && { phase: part.phase }),
+                  } satisfies ResponsesTextProviderMetadata,
+                },
+              });
+
+              continue;
+            }
+
             if (
               options.providerOptions?.[providerOptionsName]?.logprobs &&
               contentPart.logprobs
@@ -1529,6 +1548,7 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV4 {
         unified: mapOpenAIResponseFinishReason({
           finishReason: response.incomplete_details?.reason,
           hasFunctionCall,
+          hasRefusal,
         }),
         raw: response.incomplete_details?.reason ?? undefined,
       },
@@ -1658,6 +1678,9 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV4 {
     // flag that checks if there have been client-side tool calls (not executed by openai)
     let hasFunctionCall = false;
 
+    // flag that checks if the model refused to answer:
+    let hasRefusal = false;
+
     const activeReasoning: Record<
       string,
       {
@@ -2772,6 +2795,20 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV4 {
               ) {
                 logprobs.push(value.logprobs);
               }
+            } else if (isRefusalDeltaChunk(value)) {
+              hasRefusal = true;
+
+              const itemId = resolveOutputItemId({
+                itemId: value.item_id,
+                outputIndex: value.output_index,
+              });
+              controller.enqueue({
+                type: 'text-delta',
+                id: itemId,
+                delta: value.delta,
+              });
+            } else if (isRefusalDoneChunk(value)) {
+              hasRefusal = true;
             } else if (value.type === 'response.reasoning_summary_part.added') {
               const itemId = resolveOutputItemId({
                 itemId: value.item_id,
@@ -2872,6 +2909,7 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV4 {
                   unified: mapOpenAIResponseFinishReason({
                     finishReason: value.response.incomplete_details?.reason,
                     hasFunctionCall,
+                    hasRefusal,
                   }),
                   raw: value.response.incomplete_details?.reason ?? undefined,
                 };
@@ -3014,6 +3052,18 @@ function isTextDeltaChunk(
   return chunk.type === 'response.output_text.delta';
 }
 
+function isRefusalDeltaChunk(
+  chunk: OpenAIResponsesChunk,
+): chunk is OpenAIResponsesChunk & { type: 'response.refusal.delta' } {
+  return chunk.type === 'response.refusal.delta';
+}
+
+function isRefusalDoneChunk(
+  chunk: OpenAIResponsesChunk,
+): chunk is OpenAIResponsesChunk & { type: 'response.refusal.done' } {
+  return chunk.type === 'response.refusal.done';
+}
+
 function isOpenAIChatCompletionChunk(value: unknown): boolean {
   const chunk = asRecord(value);
 

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

@@ -16,13 +16,18 @@ export type OpenAISpeechModelId =
   | (string & {});
 
 // https://platform.openai.com/docs/api-reference/audio/createSpeech
+/**
+ * Shape of the OpenAI speech model options. Exported so that routers that
+ * also call the OpenAI speech API (e.g. Azure) can accept these options under
+ * their own providerOptions key.
+ */
+export const openaiSpeechModelOptionsShape = () => ({
+  instructions: z.string().nullish(),
+  speed: z.number().min(0.25).max(4.0).nullish(),
+});
+
 export const openaiSpeechModelOptionsSchema = lazySchema(() =>
-  zodSchema(
-    z.object({
-      instructions: z.string().nullish(),
-      speed: z.number().min(0.25).max(4.0).nullish(),
-    }),
-  ),
+  zodSchema(z.object(openaiSpeechModelOptionsShape())),
 );
 
 export type OpenAISpeechModelOptions = InferSchema<

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

@@ -18,91 +18,92 @@ export type OpenAITranscriptionModelId =
   | (string & {});
 
 // https://platform.openai.com/docs/api-reference/audio/createTranscription
-export const openAITranscriptionModelOptions = lazySchema(() =>
-  zodSchema(
-    z.object({
-      /**
-       * Additional information to include in the transcription response.
-       */
+/**
+ * Shape of the OpenAI transcription model options. Exported so that routers
+ * that also call the OpenAI transcription API (e.g. Azure) can accept these
+ * options under their own providerOptions key.
+ */
+export const openAITranscriptionModelOptionsShape = () => ({
+  /**
+   * Additional information to include in the transcription response.
+   */
 
-      include: z.array(z.string()).optional(),
+  include: z.array(z.string()).optional(),
 
-      /**
-       * The language of the input audio in ISO-639-1 format.
-       */
-      language: z.string().optional(),
+  /**
+   * The language of the input audio in ISO-639-1 format.
+   */
+  language: z.string().optional(),
 
-      /**
-       * Expected languages for REST transcription, e.g. with gpt-transcribe.
-       * Use this instead of language. The API validates model support.
-       */
-      languages: z.array(z.string()).optional(),
+  /**
+   * Expected languages for REST transcription, e.g. with gpt-transcribe.
+   * Use this instead of language. The API validates model support.
+   */
+  languages: z.array(z.string()).optional(),
 
-      /**
-       * Vocabulary hints for REST transcription, e.g. names or technical terms.
-       * The API validates model support.
-       */
-      keywords: z.array(z.string()).optional(),
+  /**
+   * Vocabulary hints for REST transcription, e.g. names or technical terms.
+   * The API validates model support.
+   */
+  keywords: z.array(z.string()).optional(),
 
-      /**
-       * An optional text to guide the model's style or continue a previous audio segment.
-       */
-      prompt: z.string().optional(),
+  /**
+   * An optional text to guide the model's style or continue a previous audio segment.
+   */
+  prompt: z.string().optional(),
 
-      /**
-       * The sampling temperature, between 0 and 1.
-       * @default 0
-       */
-      temperature: z.number().min(0).max(1).default(0).optional(),
+  /**
+   * The sampling temperature, between 0 and 1.
+   * @default 0
+   */
+  temperature: z.number().min(0).max(1).default(0).optional(),
 
-      /**
-       * The timestamp granularities to populate for this transcription.
-       * Defaults to ['segment'] when the response format is verbose_json.
-       */
-      timestampGranularities: z.array(z.enum(['word', 'segment'])).optional(),
+  /**
+   * The timestamp granularities to populate for this transcription.
+   * Defaults to ['segment'] when the response format is verbose_json.
+   */
+  timestampGranularities: z.array(z.enum(['word', 'segment'])).optional(),
 
-      /**
-       * The format of the transcription response.
-       */
-      responseFormat: z
-        .enum(['json', 'verbose_json', 'diarized_json'])
-        .optional(),
+  /**
+   * The format of the transcription response.
+   */
+  responseFormat: z.enum(['json', 'verbose_json', 'diarized_json']).optional(),
+
+  /**
+   * Controls how the audio is split into chunks before transcription.
+   */
+  chunkingStrategy: z
+    .union([
+      z.literal('auto'),
+      z.object({
+        type: z.literal('server_vad'),
+        threshold: z.number().min(0).max(1).optional(),
+        prefixPaddingMs: z.number().int().min(0).optional(),
+        silenceDurationMs: z.number().int().min(0).optional(),
+      }),
+    ])
+    .optional(),
 
+  /**
+   * Options for streaming transcription models such as `gpt-live-transcribe`.
+   */
+  streaming: z
+    .object({
       /**
-       * Controls how the audio is split into chunks before transcription.
+       * Latency/accuracy tradeoff for realtime transcription.
        */
-      chunkingStrategy: z
-        .union([
-          z.literal('auto'),
-          z.object({
-            type: z.literal('server_vad'),
-            threshold: z.number().min(0).max(1).optional(),
-            prefixPaddingMs: z.number().int().min(0).optional(),
-            silenceDurationMs: z.number().int().min(0).optional(),
-          }),
-        ])
-        .optional(),
+      delay: z.enum(['minimal', 'low', 'medium', 'high', 'xhigh']).optional(),
 
       /**
-       * Options for streaming transcription models such as `gpt-live-transcribe`.
+       * Additional fields to include in realtime transcription events.
        */
-      streaming: z
-        .object({
-          /**
-           * Latency/accuracy tradeoff for realtime transcription.
-           */
-          delay: z
-            .enum(['minimal', 'low', 'medium', 'high', 'xhigh'])
-            .optional(),
+      include: z.array(z.string()).optional(),
+    })
+    .optional(),
+});
 
-          /**
-           * Additional fields to include in realtime transcription events.
-           */
-          include: z.array(z.string()).optional(),
-        })
-        .optional(),
-    }),
-  ),
+export const openAITranscriptionModelOptions = lazySchema(() =>
+  zodSchema(z.object(openAITranscriptionModelOptionsShape())),
 );
 
 export type OpenAITranscriptionModelOptions = InferSchema<