@ai-sdk/openai 4.0.109 → 4.0.111

package/CHANGELOG.md

@@ -1,5 +1,40 @@
 # @ai-sdk/openai
 
+## 4.0.111
+
+### Patch Changes
+
+- 6400cf8: Add `resolveProviderOptions` to parse provider options that a model accepts under several `providerOptions` keys, either as aliases (`first`) or merged in order (`merge`), and use it for the existing multi-key lookups in the OpenAI, OpenAI-compatible, Anthropic, Google, and Amazon Bedrock models. Resolution behavior for these models is unchanged.
+- Updated dependencies [6400cf8]
+- Updated dependencies [f608c05]
+- Updated dependencies [cab9c1f]
+- Updated dependencies [c70adf6]
+  - @ai-sdk/provider-utils@5.0.76
+  - @ai-sdk/provider@4.0.37
+
+## 4.0.110
+
+### Patch Changes
+
+- c6efa4b: Refactor Azure model ID logic into a model catalog that declares capabilities and provider options, and generate provider capability documentation from it. Export the OpenAI catalog internally for Azure to reuse. Request behavior is unchanged.
+- f6dbf04: fix(openai): surface Chat Completions refusals as text content
+
+  The Chat Completions model ignored `message.refusal` (non-streaming) and `delta.refusal` (streaming). When the model refused to answer, `content` was `null`, so the AI SDK returned empty text with a `stop` finish reason and silently dropped the refusal. Refusal text is now emitted as text content in both `generateText` and `streamText` results, and it is emitted in addition to content when the API returns both. A refusal with a `stop` finish reason is now reported as a `content-filter` finish reason, matching the Anthropic provider and the Responses API.
+
+- 646a7e3: fix(openai,openai-compatible): surface refusal logprobs and openai-compatible refusals
+
+  `@ai-sdk/openai`: Chat Completions responses that contain a refusal can return `logprobs.refusal` next to `logprobs.content`. The provider previously read only `logprobs.content`, so `providerMetadata.openai.logprobs` was empty or missing for refusals. Refusal logprobs are now included in emission order (content logprobs followed by refusal logprobs) in both `generateText` and `streamText`.
+
+  Streaming logprobs are now collected across all chunks in `streamText`: previously only the logprobs of the last streamed chunk were reported. This applies to content logprobs as well, so `providerMetadata.openai.logprobs` now contains the logprobs of every streamed token instead of only the last chunk's tokens. Explicitly empty logprobs (`logprobs: { content: [], refusal: null }`) are reported as an empty array, as before.
+
+  A refusal that arrives in the same streamed chunk as the `finish_reason` is now taken into account: such a response is reported with a `content-filter` finish reason instead of `stop`.
+
+  `@ai-sdk/openai-compatible`: Chat Completions responses that carry `message.refusal` (non-streaming) or `delta.refusal` (streaming) were ignored, so providers such as OpenAI served through `createOpenAICompatible` lost the refusal text and reported an empty `stop` response. Refusals are now returned as text content after any content text, and a non-empty refusal with a `stop` finish reason is reported as a `content-filter` finish reason. This also applies when the refusal and the finish reason arrive in the same streamed chunk. Non-string refusals (for example `refusal: false` from servers that use booleans) are ignored instead of failing the response.
+
+- 6b97088: fix(openai): handle refusal content parts in the Responses API
+
+  The Responses API returns a `refusal` content part instead of `output_text` when the model declines a request. The response schema rejected these parts, so non-streaming calls failed with an `APICallError` ("Invalid JSON response"), and streamed `response.refusal.delta` / `response.refusal.done` events were dropped, producing empty text. Refusal content parts and stream events are now parsed: the refusal explanation is surfaced as text and the finish reason is mapped to `content-filter`. When the response also contains a client-side function call, the finish reason stays `tool-calls` so the tools are still executed.
+
 ## 4.0.109
 
 ### Patch Changes

package/dist/index.d.ts

@@ -297,6 +297,18 @@ declare const openaiResponsesChunkSchema: import("@ai-sdk/provider-utils").LazyS
       logprob: number;
     }[];
   }[] | null | undefined;
+} | {
+  type: "response.refusal.delta";
+  item_id: string;
+  delta: string;
+  output_index?: number | null | undefined;
+  content_index?: number | null | undefined;
+} | {
+  type: "response.refusal.done";
+  item_id: string;
+  refusal: string;
+  output_index?: number | null | undefined;
+  content_index?: number | null | undefined;
 } | {
   type: "response.completed" | "response.incomplete";
   response: {

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":["_$__tool_apply_patch0.ApplyPatchOperation","_$__tool_custom0.customToolFactory","_$_0.OpenAIComputerAction","_$_0.OpenAIComputerSafetyCheck","_$__responses_openai_responses_api0.OpenAIResponsesFileSearchToolComparisonFilter","_$__responses_openai_responses_api0.OpenAIResponsesFileSearchToolCompoundFilter","_$__tool_web_search0.webSearchToolFactory","RealtimeModelV4ClientSecretOptions","RealtimeModelV4ClientSecretResult","RealtimeModelV4SessionIntent","RealtimeModelV4ServerConnection","RealtimeModelV4ServerEvent","RealtimeModelV4ClientEvent","RealtimeModelV4SessionConfig","RealtimeModelV4","RealtimeModelV4SessionIntent","RealtimeModelV4SessionConfig","RealtimeModelV4ClientEvent","RealtimeModelV4","RealtimeModelV4","RealtimeFactoryV4","DecisionModelV4","SpeechTranslationModelV4","BatchV4","SpeechTranslationModelV4StreamOptions","SpeechTranslationModelV4"],"sources":["../src/openai-config.ts","../src/openai-decision-model.ts","../src/chat/openai-chat-language-model-options.ts","../src/completion/openai-completion-language-model-options.ts","../src/embedding/openai-embedding-model-options.ts","../src/image/openai-image-model-options.ts","../src/tool/apply-patch.ts","../src/tool/custom.ts","../src/responses/openai-responses-language-model-options.ts","../src/responses/openai-responses-api.ts","../src/tool/web-search.ts","../src/openai-tools.ts","../src/live/openai-realtime-model-live-options.ts","../src/realtime/openai-realtime-model.ts","../src/live/openai-realtime-model-live.ts","../src/openai-model-catalog.ts","../src/realtime/openai-realtime-factory.ts","../src/speech/openai-speech-model-options.ts","../src/transcription/openai-transcription-model-options.ts","../src/speech-translation/openai-speech-translation-model-options.ts","../src/openai-provider.ts","../src/responses/openai-responses-prepare-tools.ts","../src/speech-translation/openai-speech-translation-model.ts","../src/files/openai-files-options.ts","../src/tool/computer.ts","../src/responses/openai-responses-provider-metadata.ts","../src/version.ts","../src/openai-decision-model-options.ts"],"mappings":"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"}
+{"version":3,"file":"index.d.ts","names":["_$__tool_apply_patch0.ApplyPatchOperation","_$__tool_custom0.customToolFactory","_$_0.OpenAIComputerAction","_$_0.OpenAIComputerSafetyCheck","_$__responses_openai_responses_api0.OpenAIResponsesFileSearchToolComparisonFilter","_$__responses_openai_responses_api0.OpenAIResponsesFileSearchToolCompoundFilter","_$__tool_web_search0.webSearchToolFactory","RealtimeModelV4ClientSecretOptions","RealtimeModelV4ClientSecretResult","RealtimeModelV4SessionIntent","RealtimeModelV4ServerConnection","RealtimeModelV4ServerEvent","RealtimeModelV4ClientEvent","RealtimeModelV4SessionConfig","RealtimeModelV4","RealtimeModelV4SessionIntent","RealtimeModelV4SessionConfig","RealtimeModelV4ClientEvent","RealtimeModelV4","RealtimeModelV4","RealtimeFactoryV4","DecisionModelV4","SpeechTranslationModelV4","BatchV4","SpeechTranslationModelV4StreamOptions","SpeechTranslationModelV4"],"sources":["../src/openai-config.ts","../src/openai-decision-model.ts","../src/chat/openai-chat-language-model-options.ts","../src/completion/openai-completion-language-model-options.ts","../src/embedding/openai-embedding-model-options.ts","../src/image/openai-image-model-options.ts","../src/tool/apply-patch.ts","../src/tool/custom.ts","../src/responses/openai-responses-language-model-options.ts","../src/responses/openai-responses-api.ts","../src/tool/web-search.ts","../src/openai-tools.ts","../src/live/openai-realtime-model-live-options.ts","../src/realtime/openai-realtime-model.ts","../src/live/openai-realtime-model-live.ts","../src/openai-model-catalog.ts","../src/realtime/openai-realtime-factory.ts","../src/speech/openai-speech-model-options.ts","../src/transcription/openai-transcription-model-options.ts","../src/speech-translation/openai-speech-translation-model-options.ts","../src/openai-provider.ts","../src/responses/openai-responses-prepare-tools.ts","../src/speech-translation/openai-speech-translation-model.ts","../src/files/openai-files-options.ts","../src/tool/computer.ts","../src/responses/openai-responses-provider-metadata.ts","../src/version.ts","../src/openai-decision-model-options.ts"],"mappings":"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"}

package/dist/index.js

@@ -1,4 +1,4 @@
-import { EXPERIMENTAL_EMBEDDING_MODEL_MAX_INPUT_BYTES_PER_CALL, StreamingToolCallTracker, WORKFLOW_DESERIALIZE, WORKFLOW_SERIALIZE, combineHeaders, connectToWebSocket, convertAsyncIteratorToReadableStream, convertBase64ToUint8Array, convertInlineFileDataToUint8Array, convertToBase64, convertToFormData, convertUint8ArrayToBase64, createBinaryResponseHandler, createBinaryStreamResponseHandler, createEventSourceResponseHandler, createJsonErrorResponseHandler, createJsonLinesResponseHandler, createJsonResponseHandler, createLanguageModelResponseMetadata, createLanguageModelResponseMetadata as getResponseMetadata, createNullLanguageModelUsage, createProviderDefinedToolFactory, createProviderDefinedToolFactoryWithOutputSchema, createProviderExecutedToolFactory, createProviderStreamError, createToolNameMapping, deleteFromApi, detectMediaType, downloadBlob, encodePathSegment, experimental_toolCaller, generateId, getFromApi, getTopLevelMediaType, isCustomReasoning, isFullMediaType, isNonNullable, isRecord, lazySchema, loadApiKey, loadOptionalSetting, mapReasoningToProviderEffort, mediaTypeToExtension, normalizeBatchRequestCounts, parseJSON, parseProviderOptions, postFormDataToApi, postJsonToApi, postMultipartStreamToApi, postToApi, removeUndefinedEntries, resolve, resolveFullMediaType, resolveProviderReference, resolveWith, safeParseJSON, safeValidateTypes, secureJsonParse, serializeModelOptions, stringifyWithBigIntAndCycles, toWebSocketUrl, validateBaseURL, validateTypes, waitForWebSocketBufferDrain, withUserAgentSuffix, withoutTrailingSlash, zodSchema } from "@ai-sdk/provider-utils";
+import { EXPERIMENTAL_EMBEDDING_MODEL_MAX_INPUT_BYTES_PER_CALL, StreamingToolCallTracker, WORKFLOW_DESERIALIZE, WORKFLOW_SERIALIZE, combineHeaders, connectToWebSocket, convertAsyncIteratorToReadableStream, convertBase64ToUint8Array, convertInlineFileDataToUint8Array, convertToBase64, convertToFormData, convertUint8ArrayToBase64, createBinaryResponseHandler, createBinaryStreamResponseHandler, createEventSourceResponseHandler, createJsonErrorResponseHandler, createJsonLinesResponseHandler, createJsonResponseHandler, createLanguageModelResponseMetadata, createLanguageModelResponseMetadata as getResponseMetadata, createNullLanguageModelUsage, createProviderDefinedToolFactory, createProviderDefinedToolFactoryWithOutputSchema, createProviderExecutedToolFactory, createProviderStreamError, createToolNameMapping, deleteFromApi, detectMediaType, downloadBlob, encodePathSegment, experimental_toolCaller, generateId, getFromApi, getTopLevelMediaType, isCustomReasoning, isFullMediaType, isNonNullable, isRecord, lazySchema, loadApiKey, loadOptionalSetting, mapReasoningToProviderEffort, mediaTypeToExtension, normalizeBatchRequestCounts, parseJSON, parseProviderOptions, postFormDataToApi, postJsonToApi, postMultipartStreamToApi, postToApi, removeUndefinedEntries, resolve, resolveFullMediaType, resolveProviderOptions, resolveProviderReference, resolveWith, safeParseJSON, safeValidateTypes, secureJsonParse, serializeModelOptions, stringifyWithBigIntAndCycles, toWebSocketUrl, validateBaseURL, validateTypes, waitForWebSocketBufferDrain, withUserAgentSuffix, withoutTrailingSlash, zodSchema } from "@ai-sdk/provider-utils";
 import { APICallError, InvalidArgumentError, InvalidPromptError, InvalidResponseDataError, TooManyEmbeddingValuesForCallError, UnsupportedFunctionalityError, isJSONObject } from "@ai-sdk/provider";
 import { z } from "zod/v4";
 //#region src/openai-config.ts
@@ -1396,9 +1396,9 @@ function getResponseMetadata$1({ id, model, created }) {
 }
 //#endregion
 //#region src/chat/map-openai-finish-reason.ts
-function mapOpenAIFinishReason$1(finishReason) {
+function mapOpenAIFinishReason$1({ finishReason, hasRefusal = false }) {
 	switch (finishReason) {
-		case "stop": return "stop";
+		case "stop": return hasRefusal ? "content-filter" : "stop";
 		case "length": return "length";
 		case "content_filter": return "content-filter";
 		case "function_call":
@@ -1416,6 +1416,7 @@ const openaiChatResponseSchema = lazySchema(() => zodSchema(z.object({
 		message: z.object({
 			role: z.literal("assistant").nullish(),
 			content: z.string().nullish(),
+			refusal: z.string().nullish(),
 			audio: z.object({ transcript: z.string().nullish() }).nullish(),
 			tool_calls: z.array(z.object({
 				id: z.string().nullish(),
@@ -1436,14 +1437,24 @@ const openaiChatResponseSchema = lazySchema(() => zodSchema(z.object({
 			})).nullish()
 		}),
 		index: z.number(),
-		logprobs: z.object({ content: z.array(z.object({
-			token: z.string(),
-			logprob: z.number(),
-			top_logprobs: z.array(z.object({
+		logprobs: z.object({
+			content: z.array(z.object({
 				token: z.string(),
-				logprob: z.number()
-			}))
-		})).nullish() }).nullish(),
+				logprob: z.number(),
+				top_logprobs: z.array(z.object({
+					token: z.string(),
+					logprob: z.number()
+				}))
+			})).nullish(),
+			refusal: z.array(z.object({
+				token: z.string(),
+				logprob: z.number(),
+				top_logprobs: z.array(z.object({
+					token: z.string(),
+					logprob: z.number()
+				}))
+			})).nullish()
+		}).nullish(),
 		finish_reason: z.string().nullish()
 	})),
 	usage: z.object({
@@ -1469,6 +1480,7 @@ const openaiChatChunkSchema = lazySchema(() => zodSchema(z.union([z.object({
 		delta: z.object({
 			role: z.enum(["assistant"]).nullish(),
 			content: z.string().nullish(),
+			refusal: z.string().nullish(),
 			tool_calls: z.array(z.object({
 				index: z.number(),
 				id: z.string().nullish(),
@@ -1488,14 +1500,24 @@ const openaiChatChunkSchema = lazySchema(() => zodSchema(z.union([z.object({
 				})
 			})).nullish()
 		}).nullish(),
-		logprobs: z.object({ content: z.array(z.object({
-			token: z.string(),
-			logprob: z.number(),
-			top_logprobs: z.array(z.object({
+		logprobs: z.object({
+			content: z.array(z.object({
 				token: z.string(),
-				logprob: z.number()
-			}))
-		})).nullish() }).nullish(),
+				logprob: z.number(),
+				top_logprobs: z.array(z.object({
+					token: z.string(),
+					logprob: z.number()
+				}))
+			})).nullish(),
+			refusal: z.array(z.object({
+				token: z.string(),
+				logprob: z.number(),
+				top_logprobs: z.array(z.object({
+					token: z.string(),
+					logprob: z.number()
+				}))
+			})).nullish()
+		}).nullish(),
 		finish_reason: z.string().nullish(),
 		index: z.number()
 	})),
@@ -1725,11 +1747,13 @@ var OpenAIChatLanguageModel = class OpenAIChatLanguageModel {
 	}
 	async getArgs({ prompt, maxOutputTokens, temperature, topP, topK, frequencyPenalty, presencePenalty, stopSequences, responseFormat, seed, tools, toolChoice, reasoning, providerOptions }) {
 		const warnings = [];
-		const openaiOptions = await parseProviderOptions({
-			provider: "openai",
+		const providerOptionsNames = this.config.provider.includes("azure") ? ["openai", "azure"] : ["openai"];
+		const openaiOptions = (await resolveProviderOptions({
 			providerOptions,
+			namespaces: providerOptionsNames,
+			resolution: "merge",
 			schema: openaiLanguageModelChatOptions
-		}) ?? {};
+		})).options ?? {};
 		const { capabilities: { language: modelCapabilities }, requestConfig: { language: modelRequestConfig } } = getOpenAILanguageModelEntry(this.modelId);
 		const requiresNoReasoningEffort = !modelCapabilities.endpoints.chat.functionToolsWithReasoning && openaiOptions.reasoningEffort == null && (tools?.some((tool) => tool.type === "function") ?? false);
 		if (requiresNoReasoningEffort && isCustomReasoning(reasoning) && reasoning !== "none") warnings.push({
@@ -1748,7 +1772,7 @@ var OpenAIChatLanguageModel = class OpenAIChatLanguageModel {
 			type: "unsupported",
 			feature: "topK"
 		});
-		if (providerOptions?.openai?.reasoningSummary != null) warnings.push({
+		if (providerOptionsNames.some((name) => providerOptions?.[name]?.reasoningSummary != null)) warnings.push({
 			type: "unsupported",
 			feature: "reasoningSummary",
 			details: "reasoningSummary is only supported by the Responses API, not the Chat Completions API"
@@ -1930,6 +1954,12 @@ var OpenAIChatLanguageModel = class OpenAIChatLanguageModel {
 			type: "text",
 			text
 		});
+		const refusal = choice.message.refusal;
+		const hasRefusal = refusal != null && refusal.length > 0;
+		if (hasRefusal) content.push({
+			type: "text",
+			text: refusal
+		});
 		for (const toolCall of choice.message.tool_calls ?? []) content.push({
 			type: "tool-call",
 			toolCallId: toolCall.id || generateId(),
@@ -1947,11 +1977,16 @@ var OpenAIChatLanguageModel = class OpenAIChatLanguageModel {
 		const providerMetadata = { openai: {} };
 		if (completionTokenDetails?.accepted_prediction_tokens != null) providerMetadata.openai.acceptedPredictionTokens = completionTokenDetails?.accepted_prediction_tokens;
 		if (completionTokenDetails?.rejected_prediction_tokens != null) providerMetadata.openai.rejectedPredictionTokens = completionTokenDetails?.rejected_prediction_tokens;
-		if (choice.logprobs?.content != null) providerMetadata.openai.logprobs = choice.logprobs.content;
+		const contentLogprobs = choice.logprobs?.content;
+		const refusalLogprobs = choice.logprobs?.refusal;
+		if (contentLogprobs != null || refusalLogprobs != null) providerMetadata.openai.logprobs = [...contentLogprobs ?? [], ...refusalLogprobs ?? []];
 		return {
 			content,
 			finishReason: {
-				unified: mapOpenAIFinishReason$1(choice.finish_reason),
+				unified: mapOpenAIFinishReason$1({
+					finishReason: choice.finish_reason,
+					hasRefusal
+				}),
 				raw: choice.finish_reason ?? void 0
 			},
 			usage: convertOpenAIChatUsage(response.usage),
@@ -2004,6 +2039,10 @@ var OpenAIChatLanguageModel = class OpenAIChatLanguageModel {
 		let usage = void 0;
 		let metadataExtracted = false;
 		let isActiveText = false;
+		let hasRefusal = false;
+		let rawFinishReason = void 0;
+		let hasLogprobs = false;
+		const streamedLogprobs = [];
 		const providerMetadata = { openai: {} };
 		return {
 			stream: checkedResponse.pipeThrough(new TransformStream({
@@ -2027,6 +2066,7 @@ var OpenAIChatLanguageModel = class OpenAIChatLanguageModel {
 							unified: "error",
 							raw: void 0
 						};
+						rawFinishReason = void 0;
 						controller.enqueue({
 							type: "error",
 							error: chunk.error
@@ -2039,6 +2079,7 @@ var OpenAIChatLanguageModel = class OpenAIChatLanguageModel {
 							unified: "error",
 							raw: void 0
 						};
+						rawFinishReason = void 0;
 						controller.enqueue({
 							type: "error",
 							error: createOpenAIProviderStreamError(value.error) ?? value.error
@@ -2061,14 +2102,25 @@ var OpenAIChatLanguageModel = class OpenAIChatLanguageModel {
 						if (value.usage.completion_tokens_details?.rejected_prediction_tokens != null) providerMetadata.openai.rejectedPredictionTokens = value.usage.completion_tokens_details?.rejected_prediction_tokens;
 					}
 					const choice = value.choices[0];
-					if (choice?.finish_reason != null) finishReason = {
-						unified: mapOpenAIFinishReason$1(choice.finish_reason),
-						raw: choice.finish_reason
-					};
-					if (choice?.logprobs?.content != null) providerMetadata.openai.logprobs = choice.logprobs.content;
+					if (choice?.finish_reason != null) rawFinishReason = choice.finish_reason;
+					if (choice?.logprobs != null) {
+						const contentLogprobs = choice.logprobs.content;
+						const refusalLogprobs = choice.logprobs.refusal;
+						if (contentLogprobs != null || refusalLogprobs != null) {
+							hasLogprobs = true;
+							streamedLogprobs.push(...contentLogprobs ?? [], ...refusalLogprobs ?? []);
+						}
+					}
 					if (choice?.delta == null) return;
 					const delta = choice.delta;
-					if (delta.content != null) {
+					const textDeltas = [];
+					if (delta.content != null && delta.content.length > 0) textDeltas.push(delta.content);
+					if (delta.refusal != null && delta.refusal.length > 0) {
+						hasRefusal = true;
+						textDeltas.push(delta.refusal);
+					}
+					if (textDeltas.length === 0 && delta.content === "") textDeltas.push(delta.content);
+					for (const textDelta of textDeltas) {
 						if (!isActiveText) {
 							controller.enqueue({
 								type: "text-start",
@@ -2079,7 +2131,7 @@ var OpenAIChatLanguageModel = class OpenAIChatLanguageModel {
 						controller.enqueue({
 							type: "text-delta",
 							id: "0",
-							delta: delta.content
+							delta: textDelta
 						});
 					}
 					if (delta.tool_calls != null) for (const toolCallDelta of delta.tool_calls) toolCallTracker.processDelta(toolCallDelta);
@@ -2097,6 +2149,14 @@ var OpenAIChatLanguageModel = class OpenAIChatLanguageModel {
 						id: "0"
 					});
 					toolCallTracker.flush();
+					if (rawFinishReason != null) finishReason = {
+						unified: mapOpenAIFinishReason$1({
+							finishReason: rawFinishReason,
+							hasRefusal
+						}),
+						raw: rawFinishReason
+					};
+					if (hasLogprobs) providerMetadata.openai.logprobs = streamedLogprobs;
 					controller.enqueue({
 						type: "finish",
 						finishReason,
@@ -2117,7 +2177,7 @@ function isOpenAIChatOutputChunk(chunk) {
 	if ("error" in chunk) return false;
 	return chunk.choices.some((choice) => {
 		const delta = choice.delta;
-		return delta?.content != null && delta.content.length > 0 || delta?.tool_calls != null && delta.tool_calls.length > 0 || delta?.annotations != null && delta.annotations.length > 0;
+		return delta?.content != null && delta.content.length > 0 || delta?.refusal != null && delta.refusal.length > 0 || delta?.tool_calls != null && delta.tool_calls.length > 0 || delta?.annotations != null && delta.annotations.length > 0;
 	});
 }
 //#endregion
@@ -2303,18 +2363,12 @@ var OpenAICompletionLanguageModel = class OpenAICompletionLanguageModel {
 	}
 	async getArgs({ prompt, maxOutputTokens, temperature, topP, topK, frequencyPenalty, presencePenalty, stopSequences: userStopSequences, responseFormat, tools, toolChoice, seed, providerOptions }) {
 		const warnings = [];
-		const openaiOptions = {
-			...await parseProviderOptions({
-				provider: "openai",
-				providerOptions,
-				schema: openaiLanguageModelCompletionOptions
-			}),
-			...await parseProviderOptions({
-				provider: this.providerOptionsName,
-				providerOptions,
-				schema: openaiLanguageModelCompletionOptions
-			})
-		};
+		const openaiOptions = (await resolveProviderOptions({
+			providerOptions,
+			namespaces: ["openai", this.providerOptionsName],
+			resolution: "merge",
+			schema: openaiLanguageModelCompletionOptions
+		})).options ?? {};
 		if (topK != null) warnings.push({
 			type: "unsupported",
 			feature: "topK"
@@ -2873,7 +2927,12 @@ const baseImageModelOptionsObject = () => z.object({
 	safetyIdentifier: z.string().max(128).optional()
 });
 lazySchema(() => zodSchema(baseImageModelOptionsObject()));
-const openaiImageModelGenerationOptions = lazySchema(() => zodSchema(baseImageModelOptionsObject().extend({
+/**
+* Shape of the OpenAI image generation options. Exported so that routers
+* that also call the OpenAI image API (e.g. Azure) can accept these options
+* under their own providerOptions key.
+*/
+const openaiImageModelGenerationOptionsShape = () => baseImageModelOptionsObject().extend({
 	/**
 	* Style of the generated image. `vivid` produces hyper-real and
 	* dramatic images; `natural` produces more subdued, less hyper-real
@@ -2906,8 +2965,13 @@ const openaiImageModelGenerationOptions = lazySchema(() => zodSchema(baseImageMo
 	* less restrictive filtering.
 	*/
 	moderation: z.enum(["auto", "low"]).optional()
-})));
-const openaiImageModelEditOptions = lazySchema(() => zodSchema(baseImageModelOptionsObject().extend({
+}).shape;
+const openaiImageModelGenerationOptions = lazySchema(() => zodSchema(z.object(openaiImageModelGenerationOptionsShape())));
+/**
+* Shape of the OpenAI image edit options. Exported so that routers can accept
+* these options under their own providerOptions key.
+*/
+const openaiImageModelEditOptionsShape = () => baseImageModelOptionsObject().extend({
 	/**
 	* Fidelity of the output image(s) to the input image(s).
 	*/
@@ -2924,7 +2988,8 @@ const openaiImageModelEditOptions = lazySchema(() => zodSchema(baseImageModelOpt
 	* less restrictive filtering. Supported by GPT Image models.
 	*/
 	moderation: z.enum(["auto", "low"]).optional()
-})));
+}).shape;
+const openaiImageModelEditOptions = lazySchema(() => zodSchema(z.object(openaiImageModelEditOptionsShape())));
 //#endregion
 //#region src/image/openai-image-model.ts
 var OpenAIImageModel = class OpenAIImageModel {
@@ -3855,10 +3920,12 @@ function convertOpenAIResponsesUsage(usage) {
 }
 //#endregion
 //#region src/responses/map-openai-responses-finish-reason.ts
-function mapOpenAIResponseFinishReason({ finishReason, hasFunctionCall }) {
+function mapOpenAIResponseFinishReason({ finishReason, hasFunctionCall, hasRefusal = false }) {
 	switch (finishReason) {
 		case void 0:
-		case null: return hasFunctionCall ? "tool-calls" : "stop";
+		case null:
+			if (hasFunctionCall) return "tool-calls";
+			return hasRefusal ? "content-filter" : "stop";
 		case "max_output_tokens": return "length";
 		case "content_filter": return "content-filter";
 		default: return hasFunctionCall ? "tool-calls" : "other";
@@ -4038,6 +4105,8 @@ const openaiResponsesModeledChunkTypes = /* @__PURE__ */ 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"
@@ -4091,6 +4160,20 @@ const openaiResponsesChunkSchema = lazySchema(() => zodSchema(z.union([
 			}))
 		})).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({
@@ -4648,7 +4731,7 @@ const openaiResponsesResponseSchema = lazySchema(() => zodSchema(z.object({
 			role: z.literal("assistant"),
 			id: z.string(),
 			phase: z.enum(["commentary", "final_answer"]).nullish(),
-			content: z.array(z.object({
+			content: z.array(z.discriminatedUnion("type", [z.object({
 				type: z.literal("output_text"),
 				text: z.string(),
 				logprobs: z.array(z.object({
@@ -4687,7 +4770,10 @@ const openaiResponsesResponseSchema = lazySchema(() => zodSchema(z.object({
 						index: z.number()
 					})
 				]))
-			}))
+			}), z.object({
+				type: z.literal("refusal"),
+				refusal: z.string()
+			})]))
 		}),
 		z.object({
 			type: z.literal("web_search_call"),
@@ -6908,14 +6994,10 @@ var OpenAIResponsesLanguageModel = class OpenAIResponsesLanguageModel {
 			feature: "stopSequences"
 		});
 		const providerOptionsName = config.provider.includes("azure") ? "azure" : "openai";
-		let openaiOptions = await parseProviderOptions({
-			provider: providerOptionsName,
-			providerOptions,
-			schema: openaiLanguageModelResponsesOptionsSchema
-		});
-		if (openaiOptions == null && providerOptionsName !== "openai") openaiOptions = await parseProviderOptions({
-			provider: "openai",
+		const { options: openaiOptions } = await resolveProviderOptions({
 			providerOptions,
+			namespaces: [providerOptionsName, "openai"],
+			resolution: "first",
 			schema: openaiLanguageModelResponsesOptionsSchema
 		});
 		const resolvedReasoningEffort = resolveOpenAIReasoningEffort({
@@ -7220,6 +7302,7 @@ var OpenAIResponsesLanguageModel = class OpenAIResponsesLanguageModel {
 		const retrievedFileIds = /* @__PURE__ */ new Set();
 		let hasFunctionCall = false;
 		const hostedToolSearchCallIds = [];
+		let hasRefusal = false;
 		let structuredOutputText;
 		for (const part of response.output) switch (part.type) {
 			case "reasoning":
@@ -7321,8 +7404,20 @@ var OpenAIResponsesLanguageModel = class OpenAIResponsesLanguageModel {
 				});
 				break;
 			case "message":
-				if (options.responseFormat?.type === "json" && part.phase === "final_answer") structuredOutputText = part.content.map((contentPart) => contentPart.text).join("");
+				if (options.responseFormat?.type === "json" && part.phase === "final_answer") structuredOutputText = part.content.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 }
+							} }
+						});
+						continue;
+					}
 					if (options.providerOptions?.[providerOptionsName]?.logprobs && contentPart.logprobs) logprobs.push(contentPart.logprobs);
 					const providerMetadata = {
 						itemId: part.id,
@@ -7609,7 +7704,8 @@ var OpenAIResponsesLanguageModel = class OpenAIResponsesLanguageModel {
 			finishReason: {
 				unified: mapOpenAIResponseFinishReason({
 					finishReason: response.incomplete_details?.reason,
-					hasFunctionCall
+					hasFunctionCall,
+					hasRefusal
 				}),
 				raw: response.incomplete_details?.reason ?? void 0
 			},
@@ -7672,6 +7768,7 @@ var OpenAIResponsesLanguageModel = class OpenAIResponsesLanguageModel {
 		const fallbackAnnotations = [];
 		let activeMessagePhase;
 		let hasFunctionCall = false;
+		let hasRefusal = false;
 		const activeReasoning = {};
 		const activeOutputItemIds = {};
 		const resolveOutputItemId = ({ itemId, outputIndex }) => outputIndex == null ? itemId : activeOutputItemIds[outputIndex] ?? itemId;
@@ -8438,7 +8535,19 @@ var OpenAIResponsesLanguageModel = class OpenAIResponsesLanguageModel {
 							delta: value.delta
 						});
 						if (options.providerOptions?.[providerOptionsName]?.logprobs && value.logprobs) logprobs.push(value.logprobs);
-					} else if (value.type === "response.reasoning_summary_part.added") {
+					} 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,
 							outputIndex: value.output_index
@@ -8496,7 +8605,8 @@ var OpenAIResponsesLanguageModel = class OpenAIResponsesLanguageModel {
 						if (!encounteredStreamError) finishReason = {
 							unified: mapOpenAIResponseFinishReason({
 								finishReason: value.response.incomplete_details?.reason,
-								hasFunctionCall
+								hasFunctionCall,
+								hasRefusal
 							}),
 							raw: value.response.incomplete_details?.reason ?? void 0
 						};
@@ -8586,6 +8696,12 @@ var OpenAIResponsesLanguageModel = class OpenAIResponsesLanguageModel {
 function isTextDeltaChunk(chunk) {
 	return chunk.type === "response.output_text.delta";
 }
+function isRefusalDeltaChunk(chunk) {
+	return chunk.type === "response.refusal.delta";
+}
+function isRefusalDoneChunk(chunk) {
+	return chunk.type === "response.refusal.done";
+}
 function isOpenAIChatCompletionChunk(value) {
 	const chunk = asRecord(value);
 	return chunk != null && Array.isArray(chunk.choices) && typeof chunk.type !== "string";
@@ -9106,6 +9222,7 @@ async function convertOpenAIBatchResult(body) {
 	const content = [];
 	const logprobs = [];
 	let hasFunctionCall = false;
+	let hasRefusal = false;
 	for (const part of response.output) switch (part.type) {
 		case "reasoning": {
 			const summaries = part.summary.length > 0 ? part.summary : [{
@@ -9124,6 +9241,14 @@ async function convertOpenAIBatchResult(body) {
 		}
 		case "message":
 			for (const contentPart of part.content) {
+				if (contentPart.type === "refusal") {
+					hasRefusal = true;
+					content.push({
+						type: "text",
+						text: contentPart.refusal
+					});
+					continue;
+				}
 				content.push({
 					type: "text",
 					text: contentPart.text
@@ -9242,7 +9367,8 @@ async function convertOpenAIBatchResult(body) {
 			finishReason: {
 				unified: mapOpenAIResponseFinishReason({
 					finishReason: response.incomplete_details?.reason,
-					hasFunctionCall
+					hasFunctionCall,
+					hasRefusal
 				}),
 				raw: response.incomplete_details?.reason ?? void 0
 			},
@@ -10121,10 +10247,16 @@ function createOpenAIRealtimeFactory(config) {
 }
 //#endregion
 //#region src/speech/openai-speech-model-options.ts
-const openaiSpeechModelOptionsSchema = lazySchema(() => zodSchema(z.object({
+/**
+* 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.
+*/
+const openaiSpeechModelOptionsShape = () => ({
 	instructions: z.string().nullish(),
 	speed: z.number().min(.25).max(4).nullish()
-})));
+});
+const openaiSpeechModelOptionsSchema = lazySchema(() => zodSchema(z.object(openaiSpeechModelOptionsShape())));
 //#endregion
 //#region src/speech/openai-speech-model.ts
 var OpenAISpeechModel = class OpenAISpeechModel {
@@ -10258,7 +10390,12 @@ const openaiTranscriptionResponseSchema = lazySchema(() => zodSchema(z.object({
 })));
 //#endregion
 //#region src/transcription/openai-transcription-model-options.ts
-const openAITranscriptionModelOptions = lazySchema(() => zodSchema(z.object({
+/**
+* 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.
+*/
+const openAITranscriptionModelOptionsShape = () => ({
 	/**
 	* Additional information to include in the transcription response.
 	*/
@@ -10327,7 +10464,8 @@ const openAITranscriptionModelOptions = lazySchema(() => zodSchema(z.object({
 		*/
 		include: z.array(z.string()).optional()
 	}).optional()
-})));
+});
+const openAITranscriptionModelOptions = lazySchema(() => zodSchema(z.object(openAITranscriptionModelOptionsShape())));
 //#endregion
 //#region src/transcription/openai-transcription-model.ts
 const languageMap = {
@@ -11009,7 +11147,7 @@ var OpenAISkills = class {
 };
 //#endregion
 //#region src/version.ts
-const VERSION = "4.0.109";
+const VERSION = "4.0.111";
 //#endregion
 //#region src/openai-provider.ts
 /**