@ai-sdk/openai 4.0.108 → 4.0.110

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, 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, 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
@@ -537,6 +537,8 @@ function createGptImageEntry(sizes) {
 	};
 }
 const openaiImageModelEntries = {
+	"gpt-image-2.6-flare": createGptImageEntry(customImageSizes),
+	"gpt-image-2.6-sunburst": createGptImageEntry(customImageSizes),
 	"gpt-image-2.5-flare": createGptImageEntry(customImageSizes),
 	"gpt-image-2.5-sunburst": createGptImageEntry(customImageSizes),
 	"gpt-image-2": createGptImageEntry(gptImageSizes),
@@ -725,7 +727,7 @@ const realtimeModelEntry = {
 	capabilities: { realtime: {
 		conversation: "turn-based",
 		transports: ["websocket"],
-		connections: ["client-secret-websocket"]
+		connections: ["client-secret-websocket", "server-websocket"]
 	} },
 	requestConfig: { realtime: {
 		api: "realtime",
@@ -1004,347 +1006,6 @@ function convertOpenAIChatUsage(usage) {
 	};
 }
 //#endregion
-//#region src/chat/convert-to-openai-chat-messages.ts
-function serializeToolCallArguments$1(input) {
-	if (typeof input === "string") try {
-		const parsed = secureJsonParse(input);
-		if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return "{}";
-		return input;
-	} catch {
-		return "{}";
-	}
-	return stringifyWithBigIntAndCycles(typeof input === "object" && input !== null && !Array.isArray(input) ? input : {});
-}
-function getPromptCacheBreakpoint$1(providerOptions) {
-	return providerOptions?.openai?.promptCacheBreakpoint;
-}
-function convertToOpenAIChatMessages({ prompt, systemMessageMode = "system" }) {
-	const messages = [];
-	const warnings = [];
-	for (const { role, content, providerOptions } of prompt) switch (role) {
-		case "system":
-			switch (systemMessageMode) {
-				case "system": {
-					const promptCacheBreakpoint = getPromptCacheBreakpoint$1(providerOptions);
-					messages.push({
-						role: "system",
-						content: promptCacheBreakpoint == null ? content : [{
-							type: "text",
-							text: content,
-							prompt_cache_breakpoint: promptCacheBreakpoint
-						}]
-					});
-					break;
-				}
-				case "developer": {
-					const promptCacheBreakpoint = getPromptCacheBreakpoint$1(providerOptions);
-					messages.push({
-						role: "developer",
-						content: promptCacheBreakpoint == null ? content : [{
-							type: "text",
-							text: content,
-							prompt_cache_breakpoint: promptCacheBreakpoint
-						}]
-					});
-					break;
-				}
-				case "remove":
-					warnings.push({
-						type: "other",
-						message: "system messages are removed for this model"
-					});
-					break;
-				default: throw new Error(`Unsupported system message mode: ${systemMessageMode}`);
-			}
-			break;
-		case "user":
-			if (content.length === 1 && content[0].type === "text" && getPromptCacheBreakpoint$1(content[0].providerOptions) == null) {
-				messages.push({
-					role: "user",
-					content: content[0].text
-				});
-				break;
-			}
-			messages.push({
-				role: "user",
-				content: content.map((part, index) => {
-					switch (part.type) {
-						case "text": {
-							const promptCacheBreakpoint = getPromptCacheBreakpoint$1(part.providerOptions);
-							return {
-								type: "text",
-								text: part.text,
-								...promptCacheBreakpoint != null && { prompt_cache_breakpoint: promptCacheBreakpoint }
-							};
-						}
-						case "file": {
-							const promptCacheBreakpoint = getPromptCacheBreakpoint$1(part.providerOptions);
-							switch (part.data.type) {
-								case "reference": return {
-									type: "file",
-									file: { file_id: resolveProviderReference({
-										reference: part.data.reference,
-										provider: "openai"
-									}) },
-									...promptCacheBreakpoint != null && { prompt_cache_breakpoint: promptCacheBreakpoint }
-								};
-								case "text": throw new UnsupportedFunctionalityError({ functionality: "text file parts" });
-								case "url":
-								case "data": {
-									const topLevel = getTopLevelMediaType(part.mediaType);
-									if (topLevel === "image") return {
-										type: "image_url",
-										image_url: {
-											url: part.data.type === "url" ? part.data.url.toString() : `data:${resolveFullMediaType({ part })};base64,${convertToBase64(part.data.data)}`,
-											detail: part.providerOptions?.openai?.imageDetail
-										},
-										...promptCacheBreakpoint != null && { prompt_cache_breakpoint: promptCacheBreakpoint }
-									};
-									else if (topLevel === "audio") {
-										if (part.data.type === "url") throw new UnsupportedFunctionalityError({ functionality: "audio file parts with URLs" });
-										const fullMediaType = resolveFullMediaType({ part });
-										switch (fullMediaType) {
-											case "audio/wav": return {
-												type: "input_audio",
-												input_audio: {
-													data: convertToBase64(part.data.data),
-													format: "wav"
-												},
-												...promptCacheBreakpoint != null && { prompt_cache_breakpoint: promptCacheBreakpoint }
-											};
-											case "audio/mp3":
-											case "audio/mpeg": return {
-												type: "input_audio",
-												input_audio: {
-													data: convertToBase64(part.data.data),
-													format: "mp3"
-												},
-												...promptCacheBreakpoint != null && { prompt_cache_breakpoint: promptCacheBreakpoint }
-											};
-											default: throw new UnsupportedFunctionalityError({ functionality: `audio content parts with media type ${fullMediaType}` });
-										}
-									}
-									{
-										const fullMediaType = resolveFullMediaType({ part });
-										if (fullMediaType !== "application/pdf") throw new UnsupportedFunctionalityError({ functionality: `file part media type ${fullMediaType}` });
-										if (part.data.type === "url") throw new UnsupportedFunctionalityError({ functionality: "PDF file parts with URLs" });
-										return {
-											type: "file",
-											file: {
-												filename: part.filename ?? `part-${index}.pdf`,
-												file_data: `data:application/pdf;base64,${convertToBase64(part.data.data)}`
-											},
-											...promptCacheBreakpoint != null && { prompt_cache_breakpoint: promptCacheBreakpoint }
-										};
-									}
-								}
-							}
-						}
-					}
-				})
-			});
-			break;
-		case "assistant": {
-			let text = "";
-			const textParts = [];
-			let hasPromptCacheBreakpoint = false;
-			const toolCalls = [];
-			for (const part of content) switch (part.type) {
-				case "text": {
-					const promptCacheBreakpoint = getPromptCacheBreakpoint$1(part.providerOptions);
-					text += part.text;
-					textParts.push({
-						type: "text",
-						text: part.text,
-						...promptCacheBreakpoint != null && { prompt_cache_breakpoint: promptCacheBreakpoint }
-					});
-					hasPromptCacheBreakpoint ||= promptCacheBreakpoint != null;
-					break;
-				}
-				case "tool-call": toolCalls.push({
-					id: part.toolCallId,
-					type: "function",
-					function: {
-						name: part.toolName,
-						arguments: serializeToolCallArguments$1(part.input)
-					}
-				});
-			}
-			messages.push({
-				role: "assistant",
-				content: hasPromptCacheBreakpoint ? textParts : toolCalls.length > 0 ? text || null : text,
-				tool_calls: toolCalls.length > 0 ? toolCalls : void 0
-			});
-			break;
-		}
-		case "tool":
-			for (const toolResponse of content) {
-				if (toolResponse.type === "tool-approval-response") continue;
-				const output = toolResponse.output;
-				const promptCacheBreakpoint = (output.type === "content" ? output.value.map((part) => getPromptCacheBreakpoint$1(part.providerOptions)).find((breakpoint) => breakpoint != null) : getPromptCacheBreakpoint$1(output.providerOptions)) ?? getPromptCacheBreakpoint$1(toolResponse.providerOptions);
-				let contentValue;
-				switch (output.type) {
-					case "text":
-						contentValue = output.value;
-						break;
-					case "error-text":
-					case "error-json":
-						contentValue = stringifyWithBigIntAndCycles({ error: output.value });
-						break;
-					case "execution-denied":
-						contentValue = output.reason ?? "Tool call execution denied.";
-						break;
-					case "content":
-					case "json": contentValue = stringifyWithBigIntAndCycles(output.value);
-				}
-				messages.push({
-					role: "tool",
-					tool_call_id: toolResponse.toolCallId,
-					content: promptCacheBreakpoint == null ? contentValue : [{
-						type: "text",
-						text: contentValue,
-						prompt_cache_breakpoint: promptCacheBreakpoint
-					}]
-				});
-			}
-			break;
-		default: throw new Error(`Unsupported role: ${role}`);
-	}
-	return {
-		messages,
-		warnings
-	};
-}
-//#endregion
-//#region src/chat/get-response-metadata.ts
-function getResponseMetadata$1({ id, model, created }) {
-	return createLanguageModelResponseMetadata({
-		id,
-		model,
-		created: created || void 0
-	});
-}
-//#endregion
-//#region src/chat/map-openai-finish-reason.ts
-function mapOpenAIFinishReason$1(finishReason) {
-	switch (finishReason) {
-		case "stop": return "stop";
-		case "length": return "length";
-		case "content_filter": return "content-filter";
-		case "function_call":
-		case "tool_calls": return "tool-calls";
-		default: return "other";
-	}
-}
-//#endregion
-//#region src/chat/openai-chat-api.ts
-const openaiChatResponseSchema = lazySchema(() => zodSchema(z.object({
-	id: z.string().nullish(),
-	created: z.number().nullish(),
-	model: z.string().nullish(),
-	choices: z.array(z.object({
-		message: z.object({
-			role: z.literal("assistant").nullish(),
-			content: z.string().nullish(),
-			audio: z.object({ transcript: z.string().nullish() }).nullish(),
-			tool_calls: z.array(z.object({
-				id: z.string().nullish(),
-				type: z.literal("function"),
-				function: z.object({
-					name: z.string(),
-					arguments: z.string()
-				})
-			})).nullish(),
-			annotations: z.array(z.object({
-				type: z.literal("url_citation"),
-				url_citation: z.object({
-					start_index: z.number(),
-					end_index: z.number(),
-					url: z.string(),
-					title: z.string()
-				})
-			})).nullish()
-		}),
-		index: z.number(),
-		logprobs: z.object({ content: 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({
-		prompt_tokens: z.number().nullish(),
-		completion_tokens: z.number().nullish(),
-		total_tokens: z.number().nullish(),
-		prompt_tokens_details: z.object({
-			cached_tokens: z.number().nullish(),
-			cache_write_tokens: z.number().nullish()
-		}).nullish(),
-		completion_tokens_details: z.object({
-			reasoning_tokens: z.number().nullish(),
-			accepted_prediction_tokens: z.number().nullish(),
-			rejected_prediction_tokens: z.number().nullish()
-		}).nullish()
-	}).nullish()
-})));
-const openaiChatChunkSchema = lazySchema(() => zodSchema(z.union([z.object({
-	id: z.string().nullish(),
-	created: z.number().nullish(),
-	model: z.string().nullish(),
-	choices: z.array(z.object({
-		delta: z.object({
-			role: z.enum(["assistant"]).nullish(),
-			content: z.string().nullish(),
-			tool_calls: z.array(z.object({
-				index: z.number(),
-				id: z.string().nullish(),
-				type: z.literal("function").nullish(),
-				function: z.object({
-					name: z.string().nullish(),
-					arguments: z.string().nullish()
-				})
-			})).nullish(),
-			annotations: z.array(z.object({
-				type: z.literal("url_citation"),
-				url_citation: z.object({
-					start_index: z.number(),
-					end_index: z.number(),
-					url: z.string(),
-					title: z.string()
-				})
-			})).nullish()
-		}).nullish(),
-		logprobs: z.object({ content: 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()
-	})),
-	usage: z.object({
-		prompt_tokens: z.number().nullish(),
-		completion_tokens: z.number().nullish(),
-		total_tokens: z.number().nullish(),
-		prompt_tokens_details: z.object({
-			cached_tokens: z.number().nullish(),
-			cache_write_tokens: z.number().nullish()
-		}).nullish(),
-		completion_tokens_details: z.object({
-			reasoning_tokens: z.number().nullish(),
-			accepted_prediction_tokens: z.number().nullish(),
-			rejected_prediction_tokens: z.number().nullish()
-		}).nullish()
-	}).nullish()
-}), openaiErrorDataSchema()])));
-//#endregion
 //#region src/chat/openai-chat-language-model-options.ts
 const openaiLanguageModelChatOptions = lazySchema(() => zodSchema(z.object({
 	/**
@@ -1493,6 +1154,388 @@ const openaiLanguageModelChatOptions = lazySchema(() => zodSchema(z.object({
 	*/
 	forceReasoning: z.boolean().optional()
 })));
+const openaiChatMessageProviderOptions = lazySchema(() => zodSchema(z.object({ 
+/** The participant name on a system, developer, user, or assistant message. */
+name: z.string().optional() })));
+//#endregion
+//#region src/chat/convert-to-openai-chat-messages.ts
+function serializeToolCallArguments$1(input) {
+	if (typeof input === "string") try {
+		const parsed = secureJsonParse(input);
+		if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return "{}";
+		return input;
+	} catch {
+		return "{}";
+	}
+	return stringifyWithBigIntAndCycles(typeof input === "object" && input !== null && !Array.isArray(input) ? input : {});
+}
+function getPromptCacheBreakpoint$1(providerOptions) {
+	return providerOptions?.openai?.promptCacheBreakpoint;
+}
+async function convertToOpenAIChatMessages({ prompt, systemMessageMode = "system" }) {
+	const messages = [];
+	const warnings = [];
+	for (const { role, content, providerOptions } of prompt) {
+		const name = (await parseProviderOptions({
+			provider: "openai",
+			providerOptions,
+			schema: openaiChatMessageProviderOptions
+		}))?.name;
+		switch (role) {
+			case "system":
+				switch (systemMessageMode) {
+					case "system": {
+						const promptCacheBreakpoint = getPromptCacheBreakpoint$1(providerOptions);
+						messages.push({
+							role: "system",
+							...name != null && { name },
+							content: promptCacheBreakpoint == null ? content : [{
+								type: "text",
+								text: content,
+								prompt_cache_breakpoint: promptCacheBreakpoint
+							}]
+						});
+						break;
+					}
+					case "developer": {
+						const promptCacheBreakpoint = getPromptCacheBreakpoint$1(providerOptions);
+						messages.push({
+							role: "developer",
+							...name != null && { name },
+							content: promptCacheBreakpoint == null ? content : [{
+								type: "text",
+								text: content,
+								prompt_cache_breakpoint: promptCacheBreakpoint
+							}]
+						});
+						break;
+					}
+					case "remove":
+						warnings.push({
+							type: "other",
+							message: "system messages are removed for this model"
+						});
+						break;
+					default: throw new Error(`Unsupported system message mode: ${systemMessageMode}`);
+				}
+				break;
+			case "user":
+				if (content.length === 1 && content[0].type === "text" && getPromptCacheBreakpoint$1(content[0].providerOptions) == null) {
+					messages.push({
+						role: "user",
+						content: content[0].text,
+						...name != null && { name }
+					});
+					break;
+				}
+				messages.push({
+					role: "user",
+					...name != null && { name },
+					content: content.map((part, index) => {
+						switch (part.type) {
+							case "text": {
+								const promptCacheBreakpoint = getPromptCacheBreakpoint$1(part.providerOptions);
+								return {
+									type: "text",
+									text: part.text,
+									...promptCacheBreakpoint != null && { prompt_cache_breakpoint: promptCacheBreakpoint }
+								};
+							}
+							case "file": {
+								const promptCacheBreakpoint = getPromptCacheBreakpoint$1(part.providerOptions);
+								switch (part.data.type) {
+									case "reference": return {
+										type: "file",
+										file: { file_id: resolveProviderReference({
+											reference: part.data.reference,
+											provider: "openai"
+										}) },
+										...promptCacheBreakpoint != null && { prompt_cache_breakpoint: promptCacheBreakpoint }
+									};
+									case "text": throw new UnsupportedFunctionalityError({ functionality: "text file parts" });
+									case "url":
+									case "data": {
+										const topLevel = getTopLevelMediaType(part.mediaType);
+										if (topLevel === "image") return {
+											type: "image_url",
+											image_url: {
+												url: part.data.type === "url" ? part.data.url.toString() : `data:${resolveFullMediaType({ part })};base64,${convertToBase64(part.data.data)}`,
+												detail: part.providerOptions?.openai?.imageDetail
+											},
+											...promptCacheBreakpoint != null && { prompt_cache_breakpoint: promptCacheBreakpoint }
+										};
+										else if (topLevel === "audio") {
+											if (part.data.type === "url") throw new UnsupportedFunctionalityError({ functionality: "audio file parts with URLs" });
+											const fullMediaType = resolveFullMediaType({ part });
+											switch (fullMediaType) {
+												case "audio/wav": return {
+													type: "input_audio",
+													input_audio: {
+														data: convertToBase64(part.data.data),
+														format: "wav"
+													},
+													...promptCacheBreakpoint != null && { prompt_cache_breakpoint: promptCacheBreakpoint }
+												};
+												case "audio/mp3":
+												case "audio/mpeg": return {
+													type: "input_audio",
+													input_audio: {
+														data: convertToBase64(part.data.data),
+														format: "mp3"
+													},
+													...promptCacheBreakpoint != null && { prompt_cache_breakpoint: promptCacheBreakpoint }
+												};
+												default: throw new UnsupportedFunctionalityError({ functionality: `audio content parts with media type ${fullMediaType}` });
+											}
+										}
+										{
+											const fullMediaType = resolveFullMediaType({ part });
+											if (fullMediaType !== "application/pdf") throw new UnsupportedFunctionalityError({ functionality: `file part media type ${fullMediaType}` });
+											if (part.data.type === "url") throw new UnsupportedFunctionalityError({ functionality: "PDF file parts with URLs" });
+											return {
+												type: "file",
+												file: {
+													filename: part.filename ?? `part-${index}.pdf`,
+													file_data: `data:application/pdf;base64,${convertToBase64(part.data.data)}`
+												},
+												...promptCacheBreakpoint != null && { prompt_cache_breakpoint: promptCacheBreakpoint }
+											};
+										}
+									}
+								}
+							}
+						}
+					})
+				});
+				break;
+			case "assistant": {
+				let text = "";
+				const textParts = [];
+				let hasPromptCacheBreakpoint = false;
+				const toolCalls = [];
+				for (const part of content) switch (part.type) {
+					case "text": {
+						const promptCacheBreakpoint = getPromptCacheBreakpoint$1(part.providerOptions);
+						text += part.text;
+						textParts.push({
+							type: "text",
+							text: part.text,
+							...promptCacheBreakpoint != null && { prompt_cache_breakpoint: promptCacheBreakpoint }
+						});
+						hasPromptCacheBreakpoint ||= promptCacheBreakpoint != null;
+						break;
+					}
+					case "tool-call": toolCalls.push({
+						id: part.toolCallId,
+						type: "function",
+						function: {
+							name: part.toolName,
+							arguments: serializeToolCallArguments$1(part.input)
+						}
+					});
+				}
+				messages.push({
+					role: "assistant",
+					...name != null && { name },
+					content: hasPromptCacheBreakpoint ? textParts : toolCalls.length > 0 ? text || null : text,
+					tool_calls: toolCalls.length > 0 ? toolCalls : void 0
+				});
+				break;
+			}
+			case "tool":
+				if (name != null) warnings.push({
+					type: "unsupported",
+					feature: "message name on tool messages"
+				});
+				for (const toolResponse of content) {
+					if (toolResponse.type === "tool-approval-response") continue;
+					const output = toolResponse.output;
+					const promptCacheBreakpoint = (output.type === "content" ? output.value.map((part) => getPromptCacheBreakpoint$1(part.providerOptions)).find((breakpoint) => breakpoint != null) : getPromptCacheBreakpoint$1(output.providerOptions)) ?? getPromptCacheBreakpoint$1(toolResponse.providerOptions);
+					let contentValue;
+					switch (output.type) {
+						case "text":
+							contentValue = output.value;
+							break;
+						case "error-text":
+						case "error-json":
+							contentValue = stringifyWithBigIntAndCycles({ error: output.value });
+							break;
+						case "execution-denied":
+							contentValue = output.reason ?? "Tool call execution denied.";
+							break;
+						case "content":
+						case "json": contentValue = stringifyWithBigIntAndCycles(output.value);
+					}
+					messages.push({
+						role: "tool",
+						tool_call_id: toolResponse.toolCallId,
+						content: promptCacheBreakpoint == null ? contentValue : [{
+							type: "text",
+							text: contentValue,
+							prompt_cache_breakpoint: promptCacheBreakpoint
+						}]
+					});
+				}
+				break;
+			default: throw new Error(`Unsupported role: ${role}`);
+		}
+	}
+	return {
+		messages,
+		warnings
+	};
+}
+//#endregion
+//#region src/chat/get-response-metadata.ts
+function getResponseMetadata$1({ id, model, created }) {
+	return createLanguageModelResponseMetadata({
+		id,
+		model,
+		created: created || void 0
+	});
+}
+//#endregion
+//#region src/chat/map-openai-finish-reason.ts
+function mapOpenAIFinishReason$1({ finishReason, hasRefusal = false }) {
+	switch (finishReason) {
+		case "stop": return hasRefusal ? "content-filter" : "stop";
+		case "length": return "length";
+		case "content_filter": return "content-filter";
+		case "function_call":
+		case "tool_calls": return "tool-calls";
+		default: return "other";
+	}
+}
+//#endregion
+//#region src/chat/openai-chat-api.ts
+const openaiChatResponseSchema = lazySchema(() => zodSchema(z.object({
+	id: z.string().nullish(),
+	created: z.number().nullish(),
+	model: z.string().nullish(),
+	choices: z.array(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(),
+				type: z.literal("function"),
+				function: z.object({
+					name: z.string(),
+					arguments: z.string()
+				})
+			})).nullish(),
+			annotations: z.array(z.object({
+				type: z.literal("url_citation"),
+				url_citation: z.object({
+					start_index: z.number(),
+					end_index: z.number(),
+					url: z.string(),
+					title: z.string()
+				})
+			})).nullish()
+		}),
+		index: z.number(),
+		logprobs: z.object({
+			content: z.array(z.object({
+				token: z.string(),
+				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({
+		prompt_tokens: z.number().nullish(),
+		completion_tokens: z.number().nullish(),
+		total_tokens: z.number().nullish(),
+		prompt_tokens_details: z.object({
+			cached_tokens: z.number().nullish(),
+			cache_write_tokens: z.number().nullish()
+		}).nullish(),
+		completion_tokens_details: z.object({
+			reasoning_tokens: z.number().nullish(),
+			accepted_prediction_tokens: z.number().nullish(),
+			rejected_prediction_tokens: z.number().nullish()
+		}).nullish()
+	}).nullish()
+})));
+const openaiChatChunkSchema = lazySchema(() => zodSchema(z.union([z.object({
+	id: z.string().nullish(),
+	created: z.number().nullish(),
+	model: z.string().nullish(),
+	choices: z.array(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(),
+				type: z.literal("function").nullish(),
+				function: z.object({
+					name: z.string().nullish(),
+					arguments: z.string().nullish()
+				})
+			})).nullish(),
+			annotations: z.array(z.object({
+				type: z.literal("url_citation"),
+				url_citation: z.object({
+					start_index: z.number(),
+					end_index: z.number(),
+					url: z.string(),
+					title: z.string()
+				})
+			})).nullish()
+		}).nullish(),
+		logprobs: z.object({
+			content: z.array(z.object({
+				token: z.string(),
+				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()
+	})),
+	usage: z.object({
+		prompt_tokens: z.number().nullish(),
+		completion_tokens: z.number().nullish(),
+		total_tokens: z.number().nullish(),
+		prompt_tokens_details: z.object({
+			cached_tokens: z.number().nullish(),
+			cache_write_tokens: z.number().nullish()
+		}).nullish(),
+		completion_tokens_details: z.object({
+			reasoning_tokens: z.number().nullish(),
+			accepted_prediction_tokens: z.number().nullish(),
+			rejected_prediction_tokens: z.number().nullish()
+		}).nullish()
+	}).nullish()
+}), openaiErrorDataSchema()])));
 //#endregion
 //#region src/normalize-openai-json-schema.ts
 /**
@@ -1732,7 +1775,7 @@ var OpenAIChatLanguageModel = class OpenAIChatLanguageModel {
 			feature: "reasoningSummary",
 			details: "reasoningSummary is only supported by the Responses API, not the Chat Completions API"
 		});
-		const { messages, warnings: messageWarnings } = convertToOpenAIChatMessages({
+		const { messages, warnings: messageWarnings } = await convertToOpenAIChatMessages({
 			prompt,
 			systemMessageMode: openaiOptions.systemMessageMode ?? (isReasoningModel ? "developer" : modelRequestConfig.systemMessageMode)
 		});
@@ -1885,11 +1928,12 @@ var OpenAIChatLanguageModel = class OpenAIChatLanguageModel {
 	}
 	async doGenerate(options) {
 		const { args: body, warnings } = await this.getArgs(options);
+		const url = this.config.url({
+			path: "/chat/completions",
+			modelId: this.config.requestModelId ?? this.modelId
+		});
 		const { responseHeaders, value: response, rawValue: rawResponse } = await postJsonToApi({
-			url: this.config.url({
-				path: "/chat/completions",
-				modelId: this.config.requestModelId ?? this.modelId
-			}),
+			url,
 			headers: combineHeaders(await resolve(this.config.headers), options.headers),
 			body,
 			failedResponseHandler: openaiFailedResponseHandler,
@@ -1908,6 +1952,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(),
@@ -1925,15 +1975,23 @@ 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),
-			request: { body },
+			request: {
+				body,
+				url
+			},
 			response: {
 				...getResponseMetadata$1(response),
 				headers: responseHeaders,
@@ -1979,6 +2037,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({
@@ -2002,6 +2064,7 @@ var OpenAIChatLanguageModel = class OpenAIChatLanguageModel {
 							unified: "error",
 							raw: void 0
 						};
+						rawFinishReason = void 0;
 						controller.enqueue({
 							type: "error",
 							error: chunk.error
@@ -2014,6 +2077,7 @@ var OpenAIChatLanguageModel = class OpenAIChatLanguageModel {
 							unified: "error",
 							raw: void 0
 						};
+						rawFinishReason = void 0;
 						controller.enqueue({
 							type: "error",
 							error: createOpenAIProviderStreamError(value.error) ?? value.error
@@ -2036,14 +2100,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",
@@ -2054,7 +2129,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);
@@ -2072,6 +2147,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,
@@ -2080,7 +2163,10 @@ var OpenAIChatLanguageModel = class OpenAIChatLanguageModel {
 					});
 				}
 			})),
-			request: { body },
+			request: {
+				body,
+				url
+			},
 			response: { headers: responseHeaders }
 		};
 	}
@@ -2089,7 +2175,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
@@ -2819,6 +2905,15 @@ const baseImageModelOptionsObject = () => z.object({
 		"webp"
 	]).optional(),
 	/**
+	* How much detail the model puts into the image. Supported by GPT Image
+	* 2.6 models. The API defaults to `high`.
+	*/
+	complexity: z.enum([
+		"low",
+		"medium",
+		"high"
+	]).optional(),
+	/**
 	* Compression level (0-100) for the generated image(s). Applies to the
 	* `jpeg` and `webp` output formats.
 	*/
@@ -2827,7 +2922,13 @@ const baseImageModelOptionsObject = () => z.object({
 	* A unique identifier representing your end-user, which can help OpenAI
 	* to monitor and detect abuse.
 	*/
-	user: z.string().optional()
+	user: z.string().optional(),
+	/**
+	* A stable identifier used to help detect users of your application that
+	* may be violating OpenAI's usage policies. Should be a hashed username
+	* or email address.
+	*/
+	safetyIdentifier: z.string().max(128).optional()
 });
 lazySchema(() => zodSchema(baseImageModelOptionsObject()));
 const openaiImageModelGenerationOptions = lazySchema(() => zodSchema(baseImageModelOptionsObject().extend({
@@ -2838,16 +2939,50 @@ const openaiImageModelGenerationOptions = lazySchema(() => zodSchema(baseImageMo
 	*/
 	style: z.enum(["vivid", "natural"]).optional(),
 	/**
+	* Format in which the generated image(s) are returned. `gif` produces
+	* an animated GIF and is supported by GPT Image 2.6 models.
+	*/
+	outputFormat: z.enum([
+		"png",
+		"jpeg",
+		"webp",
+		"gif"
+	]).optional(),
+	/**
+	* Number of frames (2-64) of an animated GIF. Only applies to the `gif`
+	* output format. The API defaults to 9.
+	*/
+	frameCount: z.number().int().min(2).max(64).optional(),
+	/**
+	* Duration of each frame in milliseconds (20-2000) of an animated GIF.
+	* The API rounds it to the nearest 10 ms. Only applies to the `gif`
+	* output format. The API defaults to 200.
+	*/
+	frameDurationMs: z.number().int().min(20).max(2e3).optional(),
+	/**
 	* Content moderation level for the generated image(s). `low` applies
 	* less restrictive filtering.
 	*/
 	moderation: z.enum(["auto", "low"]).optional()
 })));
-const openaiImageModelEditOptions = lazySchema(() => zodSchema(baseImageModelOptionsObject().extend({ 
-/**
-* Fidelity of the output image(s) to the input image(s).
-*/
-inputFidelity: z.enum(["high", "low"]).optional() })));
+const openaiImageModelEditOptions = lazySchema(() => zodSchema(baseImageModelOptionsObject().extend({
+	/**
+	* Fidelity of the output image(s) to the input image(s).
+	*/
+	inputFidelity: z.enum(["high", "low"]).optional(),
+	/**
+	* A transparent PNG overlaid on the first input image to mark up the
+	* regions to change, as an HTTPS URL or a base64 data URL. It must match
+	* the dimensions of the first image. Supported by GPT Image 2.5 and 2.6
+	* models. Cannot be combined with a `mask`.
+	*/
+	markup: z.string().optional(),
+	/**
+	* Content moderation level for the edited image(s). `low` applies
+	* less restrictive filtering. Supported by GPT Image models.
+	*/
+	moderation: z.enum(["auto", "low"]).optional()
+})));
 //#endregion
 //#region src/image/openai-image-model.ts
 var OpenAIImageModel = class OpenAIImageModel {
@@ -2899,6 +3034,10 @@ var OpenAIImageModel = class OpenAIImageModel {
 				providerOptions,
 				schema: openaiImageModelEditOptions
 			}) ?? {};
+			if (mask != null && openaiOptions.markup != null) throw new InvalidArgumentError({
+				argument: "providerOptions.openai.markup",
+				message: "`markup` cannot be combined with `mask`."
+			});
 			const { value: response, responseHeaders } = await postFormDataToApi({
 				url: this.config.url({
 					path: "/images/edits",
@@ -2910,14 +3049,18 @@ var OpenAIImageModel = class OpenAIImageModel {
 					prompt,
 					image: await Promise.all(files.map((file) => file.type === "file" ? new Blob([file.data instanceof Uint8Array ? new Blob([file.data], { type: file.mediaType }) : new Blob([convertBase64ToUint8Array(file.data)], { type: file.mediaType })], { type: file.mediaType }) : downloadBlob(file.url, { abortSignal }))),
 					mask: mask != null ? await fileToBlob(mask, abortSignal) : void 0,
+					markup: openaiOptions.markup != null ? await markupToBlob(openaiOptions.markup, abortSignal) : void 0,
 					n,
 					size,
 					quality: openaiOptions.quality,
 					background: openaiOptions.background,
 					output_format: openaiOptions.outputFormat,
 					output_compression: openaiOptions.outputCompression,
+					complexity: openaiOptions.complexity,
 					input_fidelity: openaiOptions.inputFidelity,
-					user: openaiOptions.user
+					moderation: openaiOptions.moderation,
+					user: openaiOptions.user,
+					safety_identifier: openaiOptions.safetyIdentifier
 				}),
 				failedResponseHandler: openaiFailedResponseHandler,
 				successfulResponseHandler: createJsonResponseHandler(openaiImageResponseSchema),
@@ -2970,7 +3113,11 @@ var OpenAIImageModel = class OpenAIImageModel {
 				moderation: openaiOptions.moderation,
 				output_format: openaiOptions.outputFormat,
 				output_compression: openaiOptions.outputCompression,
+				complexity: openaiOptions.complexity,
+				frame_count: openaiOptions.frameCount,
+				frame_duration_ms: openaiOptions.frameDurationMs,
 				user: openaiOptions.user,
+				safety_identifier: openaiOptions.safetyIdentifier,
 				...!hasDefaultResponseFormat(this.modelId) ? { response_format: "b64_json" } : {}
 			},
 			failedResponseHandler: openaiFailedResponseHandler,
@@ -3023,6 +3170,15 @@ function distributeTokenDetails(details, index, total) {
 	}
 	return result;
 }
+async function markupToBlob(markup, abortSignal) {
+	const dataUrl = /^data:([^;,]*)(;base64)?,(.*)$/s.exec(markup);
+	if (dataUrl == null) return downloadBlob(markup, { abortSignal });
+	if (dataUrl[2] == null) throw new InvalidArgumentError({
+		argument: "providerOptions.openai.markup",
+		message: "`markup` data URLs must be base64 encoded."
+	});
+	return new Blob([convertBase64ToUint8Array(dataUrl[3])], { type: dataUrl[1] || "image/png" });
+}
 async function fileToBlob(file, abortSignal) {
 	if (!file) return void 0;
 	if (file.type === "url") return downloadBlob(file.url, { abortSignal });
@@ -3088,7 +3244,24 @@ const codeInterpreterOutputSchema = lazySchema(() => zodSchema(z.object({ output
 	type: z.literal("image"),
 	url: z.string()
 })])).nullish() })));
-const codeInterpreterArgsSchema = lazySchema(() => zodSchema(z.object({ container: z.union([z.string(), z.object({ fileIds: z.array(z.string()).optional() })]).optional() })));
+const codeInterpreterArgsSchema = lazySchema(() => zodSchema(z.object({ container: z.union([z.string(), z.object({
+	fileIds: z.array(z.string()).optional(),
+	memoryLimit: z.enum([
+		"1g",
+		"4g",
+		"16g",
+		"64g"
+	]).optional(),
+	networkPolicy: z.discriminatedUnion("type", [z.object({ type: z.literal("disabled") }), z.object({
+		type: z.literal("allowlist"),
+		allowedDomains: z.array(z.string()),
+		domainSecrets: z.array(z.object({
+			domain: z.string(),
+			name: z.string(),
+			value: z.string()
+		})).optional()
+	})]).optional()
+})]).optional() })));
 const codeInterpreterToolFactory = createProviderExecutedToolFactory({
 	id: "openai.code_interpreter",
 	inputSchema: codeInterpreterInputSchema,
@@ -3532,8 +3705,9 @@ const mcpArgsSchema = lazySchema(() => zodSchema(z.object({
 	headers: z.record(z.string(), z.string()).optional(),
 	requireApproval: z.union([z.enum(["always", "never"]), z.object({ never: z.object({ toolNames: z.array(z.string()).optional() }).optional() })]).optional(),
 	serverDescription: z.string().optional(),
-	serverUrl: z.string().optional()
-}).refine((v) => v.serverUrl != null || v.connectorId != null, "One of serverUrl or connectorId must be provided.")));
+	serverUrl: z.string().optional(),
+	tunnelId: z.string().optional()
+}).refine((v) => v.serverUrl != null || v.connectorId != null || v.tunnelId != null, "One of serverUrl, connectorId, or tunnelId must be provided.").refine((v) => v.tunnelId == null || v.serverUrl == null && v.connectorId == null, "tunnelId cannot be combined with serverUrl or connectorId.")));
 const mcpInputSchema = lazySchema(() => zodSchema(z.object({})));
 const mcpOutputSchema = lazySchema(() => zodSchema(z.object({
 	type: z.literal("call"),
@@ -3684,16 +3858,17 @@ const openaiTools = {
 	webSearch,
 	/**
 	* MCP (Model Context Protocol) allows models to call tools exposed by
-	* remote MCP servers or service connectors.
+	* remote MCP servers, service connectors, or Secure MCP tunnels.
 	*
 	* @param serverLabel - Label to identify the MCP server.
 	* @param allowedTools - Allowed tool names or filter object.
-	* @param authorization - OAuth access token for the MCP server/connector.
+	* @param authorization - OAuth access token for the MCP server or connector (including tunneled servers).
 	* @param connectorId - Identifier for a service connector.
 	* @param headers - Optional headers to include in MCP requests.
-	* // param requireApproval - Approval policy ('always'|'never'|filter object). (Removed - always 'never')
+	* @param requireApproval - Approval policy ('always'|'never'|filter object).
 	* @param serverDescription - Optional description of the server.
 	* @param serverUrl - URL for the MCP server.
+	* @param tunnelId - Identifier for an OpenAI Secure MCP tunnel.
 	*/
 	mcp,
 	/**
@@ -3738,10 +3913,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";
@@ -3921,6 +4098,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"
@@ -3974,6 +4153,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({
@@ -4531,7 +4724,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({
@@ -4570,7 +4763,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"),
@@ -6353,7 +6549,13 @@ async function prepareResponsesTools({ tools, toolChoice, allowedTools, toolName
 							file_ids: void 0
 						} : typeof args.container === "string" ? args.container : {
 							type: "auto",
-							file_ids: args.container.fileIds
+							file_ids: args.container.fileIds,
+							memory_limit: args.container.memoryLimit,
+							network_policy: args.container.networkPolicy == null ? void 0 : args.container.networkPolicy.type === "disabled" ? { type: "disabled" } : {
+								type: "allowlist",
+								allowed_domains: args.container.networkPolicy.allowedDomains,
+								domain_secrets: args.container.networkPolicy.domainSecrets
+							}
 						}
 					});
 					break;
@@ -6402,7 +6604,8 @@ async function prepareResponsesTools({ tools, toolChoice, allowedTools, toolName
 						headers: args.headers,
 						require_approval: requireApprovalParam ?? "never",
 						server_description: args.serverDescription,
-						server_url: args.serverUrl
+						server_url: args.serverUrl,
+						tunnel_id: args.tunnelId
 					});
 					break;
 				}
@@ -7096,6 +7299,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":
@@ -7197,8 +7401,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,
@@ -7485,7 +7701,8 @@ var OpenAIResponsesLanguageModel = class OpenAIResponsesLanguageModel {
 			finishReason: {
 				unified: mapOpenAIResponseFinishReason({
 					finishReason: response.incomplete_details?.reason,
-					hasFunctionCall
+					hasFunctionCall,
+					hasRefusal
 				}),
 				raw: response.incomplete_details?.reason ?? void 0
 			},
@@ -7548,6 +7765,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;
@@ -8314,7 +8532,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
@@ -8372,7 +8602,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
 						};
@@ -8462,6 +8693,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";
@@ -8982,6 +9219,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 : [{
@@ -9000,6 +9238,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
@@ -9118,7 +9364,8 @@ async function convertOpenAIBatchResult(body) {
 			finishReason: {
 				unified: mapOpenAIResponseFinishReason({
 					finishReason: response.incomplete_details?.reason,
-					hasFunctionCall
+					hasFunctionCall,
+					hasRefusal
 				}),
 				raw: response.incomplete_details?.reason ?? void 0
 			},
@@ -9471,7 +9718,8 @@ var OpenAIRealtimeModelLive = class {
 	getWebRTCConfig() {
 		return { dataChannelLabel: "oai-events" };
 	}
-	getServerWebSocketConfig() {
+	getServerWebSocketConfig(options) {
+		this.assertConversationIntent(options);
 		return resolveWith(this.config.headers, (configHeaders) => {
 			const url = new URL(`${this.config.baseURL}/live/sessions`);
 			url.protocol = url.protocol === "http:" ? "ws:" : "wss:";
@@ -9511,10 +9759,15 @@ var OpenAIRealtimeModelLive = class {
 	createServerEventParser() {
 		return createOpenAILiveServerEventParser();
 	}
-	serializeClientEvent(event) {
+	assertConversationIntent(options) {
+		if (options?.intent != null && options.intent !== "conversation") throw new Error(`OpenAI Live session intent '${options.intent}' is not supported.`);
+	}
+	serializeClientEvent(event, options) {
+		this.assertConversationIntent(options);
 		return serializeOpenAILiveClientEvent(event, this.modelId);
 	}
-	buildSessionConfig(config) {
+	buildSessionConfig(config, options) {
+		this.assertConversationIntent(options);
 		return buildOpenAILiveSessionConfig(config, this.modelId);
 	}
 };
@@ -9558,23 +9811,31 @@ function parseOpenAIRealtimeServerEvent(raw) {
 			item: event.item,
 			raw
 		};
-		case "conversation.item.input_audio_transcription.completed": return {
-			type: "input-transcription-completed",
-			itemId: event.item_id,
-			transcript: event.transcript ?? "",
-			raw
-		};
+		case "conversation.item.input_audio_transcription.completed": {
+			const usage = mapTranscriptionUsage(event.usage);
+			return {
+				type: "input-transcription-completed",
+				itemId: event.item_id,
+				transcript: event.transcript ?? "",
+				...usage != null ? { usage } : {},
+				raw
+			};
+		}
 		case "response.created": return {
 			type: "response-created",
 			responseId: event.response?.id ?? event.response_id,
 			raw
 		};
-		case "response.done": return {
-			type: "response-done",
-			responseId: event.response?.id ?? event.response_id,
-			status: event.response?.status ?? "completed",
-			raw
-		};
+		case "response.done": {
+			const usage = mapResponseUsage(event.response?.usage);
+			return {
+				type: "response-done",
+				responseId: event.response?.id ?? event.response_id,
+				status: event.response?.status ?? "completed",
+				...usage != null ? { usage } : {},
+				raw
+			};
+		}
 		case "response.output_item.added": return {
 			type: "output-item-added",
 			responseId: event.response_id,
@@ -9672,13 +9933,60 @@ function parseOpenAIRealtimeServerEvent(raw) {
 	}
 }
 /**
+* Maps OpenAI realtime `response.done` usage to normalized usage.
+*
+* Input buckets are reported gross (cache-inclusive) with the cached portion
+* surfaced separately, so consumers can apply their own cached-vs-uncached
+* billing split without re-reading `raw`.
+*/
+function mapResponseUsage(usage) {
+	if (usage == null) return void 0;
+	const input = usage.input_token_details;
+	const output = usage.output_token_details;
+	const cached = input?.cached_tokens_details;
+	return compactUsage({
+		inputTokens: usage.input_tokens,
+		outputTokens: usage.output_tokens,
+		cachedInputTokens: input?.cached_tokens,
+		inputAudioTokens: input?.audio_tokens,
+		inputTextTokens: input?.text_tokens,
+		outputAudioTokens: output?.audio_tokens,
+		outputTextTokens: output?.text_tokens,
+		cachedInputAudioTokens: cached?.audio_tokens,
+		cachedInputTextTokens: cached?.text_tokens
+	});
+}
+/**
+* Maps OpenAI realtime transcription-completed usage to normalized usage.
+* Duration-billed transcription reports `seconds`; token-billed reports tokens.
+*/
+function mapTranscriptionUsage(usage) {
+	if (usage == null) return void 0;
+	if (usage.type === "duration") return usage.seconds != null ? { seconds: usage.seconds } : void 0;
+	const input = usage.input_token_details;
+	return compactUsage({
+		inputTokens: usage.input_tokens,
+		outputTokens: usage.output_tokens,
+		inputAudioTokens: input?.audio_tokens,
+		inputTextTokens: input?.text_tokens,
+		outputTextTokens: usage.output_tokens
+	});
+}
+/** Drop `undefined` fields; return `undefined` when nothing is observable. */
+function compactUsage(usage) {
+	const result = {};
+	for (const [key, value] of Object.entries(usage)) if (value != null) result[key] = value;
+	return Object.keys(result).length > 0 ? result : void 0;
+}
+/**
 * Serializes a normalized client event into OpenAI's Realtime API format.
 */
-function serializeOpenAIRealtimeClientEvent(event, modelId) {
+function serializeOpenAIRealtimeClientEvent(event, modelId, options) {
+	assertSupportedOpenAIIntent(options?.intent);
 	switch (event.type) {
 		case "session-update": return {
 			type: "session.update",
-			session: buildOpenAISessionConfig(event.config, modelId),
+			session: buildOpenAISessionConfig(event.config, modelId, options),
 			...event.eventId != null ? { event_id: event.eventId } : {}
 		};
 		case "input-audio-append": return {
@@ -9744,15 +10052,27 @@ function serializeOpenAIRealtimeClientEvent(event, modelId) {
 /**
 * Builds an OpenAI-specific session configuration from a normalized config.
 */
-function buildOpenAISessionConfig(config, modelId) {
+function buildOpenAISessionConfig(config, modelId, options) {
+	const intent = options?.intent ?? "conversation";
+	assertSupportedOpenAIIntent(intent);
+	if (intent === "transcription") {
+		for (const key of [
+			"instructions",
+			"voice",
+			"outputModalities",
+			"outputAudioFormat",
+			"outputAudioTranscription",
+			"tools"
+		]) if (config[key] != null) throw new Error(`OpenAI realtime transcription sessions do not support '${key}'.`);
+	}
 	const session = {
-		type: "realtime",
-		model: modelId
+		type: intent === "transcription" ? "transcription" : "realtime",
+		...intent === "conversation" ? { model: modelId } : {}
 	};
-	if (config.instructions != null) session.instructions = config.instructions;
-	if (config.outputModalities != null) session.output_modalities = config.outputModalities;
+	if (intent === "conversation" && config.instructions != null) session.instructions = config.instructions;
+	if (intent === "conversation" && config.outputModalities != null) session.output_modalities = config.outputModalities;
 	const audio = {};
-	if (config.inputAudioFormat != null || config.inputAudioTranscription != null || config.turnDetection != null) {
+	if (intent === "transcription" || config.inputAudioFormat != null || config.inputAudioTranscription != null || config.turnDetection != null) {
 		const input = {};
 		if (config.inputAudioFormat != null) input.format = {
 			type: config.inputAudioFormat.type,
@@ -9768,14 +10088,19 @@ function buildOpenAISessionConfig(config, modelId) {
 				input.turn_detection = td;
 			}
 		}
-		if (config.inputAudioTranscription != null) input.transcription = {
+		if (intent === "transcription") input.transcription = {
+			model: config.inputAudioTranscription?.model ?? modelId,
+			...config.inputAudioTranscription?.language != null ? { language: config.inputAudioTranscription.language } : {},
+			...config.inputAudioTranscription?.prompt != null ? { prompt: config.inputAudioTranscription.prompt } : {}
+		};
+		else if (config.inputAudioTranscription != null) input.transcription = {
 			model: config.inputAudioTranscription.model ?? "gpt-realtime-whisper",
 			...config.inputAudioTranscription.language != null ? { language: config.inputAudioTranscription.language } : {},
 			...config.inputAudioTranscription.prompt != null ? { prompt: config.inputAudioTranscription.prompt } : {}
 		};
 		audio.input = input;
 	}
-	if (config.outputAudioFormat != null || config.voice != null) {
+	if (intent === "conversation" && (config.outputAudioFormat != null || config.voice != null)) {
 		const output = {};
 		if (config.outputAudioFormat != null) output.format = {
 			type: config.outputAudioFormat.type,
@@ -9785,7 +10110,7 @@ function buildOpenAISessionConfig(config, modelId) {
 		audio.output = output;
 	}
 	if (Object.keys(audio).length > 0) session.audio = audio;
-	if (config.tools != null && config.tools.length > 0) {
+	if (intent === "conversation" && config.tools != null && config.tools.length > 0) {
 		session.tools = config.tools.map((tool) => ({
 			type: tool.type,
 			name: tool.name,
@@ -9797,11 +10122,19 @@ function buildOpenAISessionConfig(config, modelId) {
 	if (config.providerOptions != null) Object.assign(session, config.providerOptions);
 	return session;
 }
+function assertSupportedOpenAIIntent(intent) {
+	if (intent != null && intent !== "conversation" && intent !== "transcription") throw new Error(`OpenAI realtime session intent '${intent}' is not supported.`);
+}
 //#endregion
 //#region src/realtime/openai-realtime-model.ts
 var OpenAIRealtimeModel = class {
 	constructor(modelId, config) {
 		this.specificationVersion = "v4";
+		this.capabilities = {
+			conversation: "turn-based",
+			transports: ["websocket"],
+			connections: ["client-secret-websocket", "server-websocket"]
+		};
 		this.modelId = modelId;
 		this.provider = config.provider;
 		this.config = config;
@@ -9844,16 +10177,36 @@ var OpenAIRealtimeModel = class {
 			protocols: ["realtime", `openai-insecure-api-key.${options.token}`]
 		};
 	}
+	getServerWebSocketConfig(options) {
+		return resolveWith(this.config.headers, (headers) => ({
+			url: buildServerUrl(this.config.baseURL, this.modelId, options?.intent ?? "conversation"),
+			headers: removeUndefinedEntries(headers)
+		}));
+	}
 	parseServerEvent(raw) {
 		return parseOpenAIRealtimeServerEvent(raw);
 	}
-	serializeClientEvent(event) {
-		return serializeOpenAIRealtimeClientEvent(event, this.modelId);
+	serializeClientEvent(event, options) {
+		return serializeOpenAIRealtimeClientEvent(event, this.modelId, options);
 	}
-	buildSessionConfig(config) {
-		return buildOpenAISessionConfig(config, this.modelId);
+	buildSessionConfig(config, options) {
+		return buildOpenAISessionConfig(config, this.modelId, options);
 	}
 };
+/**
+* Builds the upstream realtime WebSocket URL for a server-initiated connection.
+* Transcription keeps the model in `session.update`; a `?model=` here would
+* open a voice session instead.
+*/
+function buildServerUrl(baseURL, modelId, intent) {
+	const url = new URL(baseURL);
+	const base = `${url.protocol === "http:" ? "ws:" : "wss:"}//${url.host}${url.pathname.replace(/\/$/, "")}`;
+	switch (intent) {
+		case "transcription": return `${base}/realtime?intent=transcription`;
+		case "conversation": return `${base}/realtime?model=${encodeURIComponent(modelId)}`;
+		default: throw new Error(`OpenAI realtime session intent '${intent}' is not supported.`);
+	}
+}
 //#endregion
 //#region src/realtime/openai-realtime-factory.ts
 function resolveRealtimeApi(modelId, { api } = {}) {
@@ -10180,7 +10533,7 @@ var OpenAITranscriptionModel = class OpenAITranscriptionModel {
 		this.config = config;
 		this.specificationVersion = "v4";
 	}
-	async getArgs({ audio, mediaType, providerOptions }) {
+	async getArgs({ audio, mediaType, providerOptions, timestampGranularities: requestedTimestampGranularities }) {
 		const warnings = [];
 		const openAIOptions = await parseProviderOptions({
 			provider: "openai",
@@ -10194,7 +10547,17 @@ var OpenAITranscriptionModel = class OpenAITranscriptionModel {
 		formData.append("file", new File([blob], "audio", { type: mediaType }), `audio.${fileExtension}`);
 		const { transcription: requestConfig } = getOpenAITranscriptionModelEntry(this.modelId).requestConfig;
 		const responseFormat = openAIOptions?.responseFormat ?? requestConfig.responseFormat;
-		const timestampGranularities = openAIOptions?.timestampGranularities ?? (responseFormat === "verbose_json" ? ["segment"] : void 0);
+		const timestampGranularities = openAIOptions?.timestampGranularities ?? requestedTimestampGranularities ?? (responseFormat === "verbose_json" ? ["segment"] : void 0);
+		for (const granularity of requestedTimestampGranularities ?? []) if (openAIOptions?.timestampGranularities != null && !openAIOptions.timestampGranularities.includes(granularity)) warnings.push({
+			type: "unsupported",
+			feature: "timestampGranularities",
+			details: `The "${granularity}" timestamp granularity is excluded by providerOptions.openai.timestampGranularities.`
+		});
+		for (const granularity of timestampGranularities ?? []) if (responseFormat !== "verbose_json" && !(responseFormat === "diarized_json" && granularity === "segment")) warnings.push({
+			type: "unsupported",
+			feature: openAIOptions?.timestampGranularities != null ? "providerOptions.openai.timestampGranularities" : "timestampGranularities",
+			details: `OpenAI transcription with the ${responseFormat ?? "default JSON"} response format does not support ${granularity} timestamps.`
+		});
 		const chunkingStrategy = openAIOptions?.chunkingStrategy ?? requestConfig.chunkingStrategy;
 		const transcriptionModelOptions = {
 			response_format: responseFormat,
@@ -10204,7 +10567,7 @@ var OpenAITranscriptionModel = class OpenAITranscriptionModel {
 			keywords: openAIOptions?.keywords,
 			prompt: openAIOptions?.prompt,
 			temperature: openAIOptions?.temperature,
-			timestamp_granularities: timestampGranularities
+			timestamp_granularities: responseFormat === "verbose_json" ? timestampGranularities : void 0
 		};
 		for (const [key, value] of Object.entries(transcriptionModelOptions)) if (value != null) {
 			if (Array.isArray(value)) for (const item of value) formData.append(`${key}[]`, String(item));
@@ -10244,17 +10607,19 @@ var OpenAITranscriptionModel = class OpenAITranscriptionModel {
 			endSecond: segment.end,
 			speaker: segment.speaker
 		}] : []);
+		const words = response.words?.map((word) => ({
+			text: word.word,
+			startSecond: word.start,
+			endSecond: word.end
+		}));
 		return {
 			text: response.text,
 			segments: response.segments?.map((segment) => ({
 				text: segment.text,
 				startSecond: segment.start,
 				endSecond: segment.end
-			})) ?? response.words?.map((word) => ({
-				text: word.word,
-				startSecond: word.start,
-				endSecond: word.end
-			})) ?? [],
+			})) ?? words ?? [],
+			...words != null && words.length > 0 ? { words } : {},
 			language,
 			durationInSeconds: response.duration ?? (response.usage?.type === "duration" && typeof response.usage.seconds === "number" ? response.usage.seconds : void 0),
 			warnings,
@@ -10767,7 +11132,7 @@ var OpenAISkills = class {
 };
 //#endregion
 //#region src/version.ts
-const VERSION = "4.0.108";
+const VERSION = "4.0.110";
 //#endregion
 //#region src/openai-provider.ts
 /**