@ai-sdk/openai 4.0.108 → 4.0.110

package/dist/internal/index.js

@@ -1,4 +1,4 @@
-import { APICallError, InvalidPromptError, InvalidResponseDataError, TooManyEmbeddingValuesForCallError, UnsupportedFunctionalityError, isJSONObject } from "@ai-sdk/provider";
+import { APICallError, InvalidArgumentError, InvalidPromptError, InvalidResponseDataError, TooManyEmbeddingValuesForCallError, UnsupportedFunctionalityError, isJSONObject } from "@ai-sdk/provider";
 import { EXPERIMENTAL_EMBEDDING_MODEL_MAX_INPUT_BYTES_PER_CALL, StreamingToolCallTracker, WORKFLOW_DESERIALIZE, WORKFLOW_SERIALIZE, combineHeaders, connectToWebSocket, convertBase64ToUint8Array, convertToBase64, convertToFormData, createBinaryResponseHandler, createEventSourceResponseHandler, createJsonErrorResponseHandler, createJsonResponseHandler, createLanguageModelResponseMetadata, createLanguageModelResponseMetadata as getResponseMetadata, createNullLanguageModelUsage, createProviderDefinedToolFactory, createProviderDefinedToolFactoryWithOutputSchema, createProviderExecutedToolFactory, createProviderStreamError, createToolNameMapping, downloadBlob, experimental_toolCaller, generateId, getTopLevelMediaType, isCustomReasoning, isNonNullable, isRecord, lazySchema, mapReasoningToProviderEffort, mediaTypeToExtension, parseJSON, parseProviderOptions, postFormDataToApi, postJsonToApi, resolve, resolveFullMediaType, resolveProviderReference, safeParseJSON, safeValidateTypes, secureJsonParse, serializeModelOptions, stringifyWithBigIntAndCycles, toWebSocketUrl, validateTypes, waitForWebSocketBufferDrain, zodSchema } from "@ai-sdk/provider-utils";
 import { z } from "zod/v4";
 //#region src/openai-error.ts
@@ -263,6 +263,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),
@@ -453,7 +455,7 @@ const realtimeModelEntries = {
 		capabilities: { realtime: {
 			conversation: "turn-based",
 			transports: ["websocket"],
-			connections: ["client-secret-websocket"]
+			connections: ["client-secret-websocket", "server-websocket"]
 		} },
 		requestConfig: { realtime: {
 			api: "realtime",
@@ -716,6 +718,158 @@ function convertOpenAIChatUsage(usage) {
 	};
 }
 //#endregion
+//#region src/chat/openai-chat-language-model-options.ts
+const openaiLanguageModelChatOptions = lazySchema(() => zodSchema(z.object({
+	/**
+	* Modify the likelihood of specified tokens appearing in the completion.
+	*
+	* Accepts a JSON object that maps tokens (specified by their token ID in
+	* the GPT tokenizer) to an associated bias value from -100 to 100.
+	*/
+	logitBias: z.record(z.coerce.number(), z.number()).optional(),
+	/**
+	* Return the log probabilities of the tokens.
+	*
+	* Setting to true will return the log probabilities of the tokens that
+	* were generated.
+	*
+	* Setting to a number will return the log probabilities of the top n
+	* tokens that were generated.
+	*/
+	logprobs: z.union([z.boolean(), z.number()]).optional(),
+	/**
+	* Whether to enable parallel function calling during tool use. Default to true.
+	*/
+	parallelToolCalls: z.boolean().optional(),
+	/**
+	* A unique identifier representing your end-user, which can help OpenAI to
+	* monitor and detect abuse.
+	*/
+	user: z.string().optional(),
+	/**
+	* Reasoning effort for reasoning models. Defaults to `medium`.
+	*/
+	reasoningEffort: z.enum([
+		"none",
+		"minimal",
+		"low",
+		"medium",
+		"high",
+		"xhigh",
+		"max"
+	]).optional(),
+	/**
+	* Maximum number of completion tokens to generate. Useful for reasoning models.
+	*/
+	maxCompletionTokens: z.number().optional(),
+	/**
+	* Whether to enable persistence in responses API.
+	*/
+	store: z.boolean().optional(),
+	/**
+	* Metadata to associate with the request.
+	*/
+	metadata: z.record(z.string().max(64), z.string().max(512)).optional(),
+	/**
+	* Parameters for prediction mode.
+	*/
+	prediction: z.record(z.string(), z.any()).optional(),
+	/**
+	* Service tier for the request.
+	* - 'auto': Default service tier. The request will be processed with the service tier configured in the
+	*           Project settings. Unless otherwise configured, the Project will use 'default'.
+	* - 'flex': 50% cheaper processing at the cost of increased latency. Only available for o3 and o4-mini models.
+	* - 'priority': Higher-speed processing with predictably low latency at premium cost. Available for Enterprise customers.
+	* - 'fast': OpenAI's newer name for the 'priority' tier. Interchangeable with it.
+	* - 'ultrafast': Access-controlled Ultrafast processing. Only available for gpt-5.6-sol.
+	* - 'default': The request will be processed with the standard pricing and performance for the selected model.
+	*
+	* @default 'auto'
+	*/
+	serviceTier: z.enum([
+		"auto",
+		"flex",
+		"priority",
+		"fast",
+		"ultrafast",
+		"default"
+	]).optional(),
+	/**
+	* Whether to use strict JSON schema validation.
+	*
+	* @default true
+	*/
+	strictJsonSchema: z.boolean().optional(),
+	/**
+	* Controls the verbosity of the model's responses.
+	* Lower values will result in more concise responses, while higher values will result in more verbose responses.
+	*/
+	textVerbosity: z.enum([
+		"low",
+		"medium",
+		"high"
+	]).optional(),
+	/**
+	* A cache key for prompt caching. Allows manual control over prompt caching behavior.
+	* Useful for improving cache hit rates and working around automatic caching issues.
+	*/
+	promptCacheKey: z.string().optional(),
+	/**
+	* Prompt cache behavior for GPT-5.6 and later models.
+	* `mode` controls whether OpenAI also places an implicit breakpoint.
+	* `ttl` sets the minimum cache lifetime and currently only supports 30 minutes.
+	*/
+	promptCacheOptions: z.object({
+		mode: z.enum(["implicit", "explicit"]).optional(),
+		ttl: z.literal("30m").optional()
+	}).optional(),
+	/**
+	* The retention policy for the prompt cache.
+	* - 'in_memory': Default. Standard prompt caching behavior.
+	* - '24h': Extended prompt caching that keeps cached prefixes active for up to 24 hours.
+	*          Available for models before GPT-5.6 that support extended caching.
+	*
+	* @deprecated For GPT-5.6 and later models, use `promptCacheOptions.ttl`.
+	*
+	* @default 'in_memory'
+	*/
+	promptCacheRetention: z.enum(["in_memory", "24h"]).optional(),
+	/**
+	* A stable identifier used to help detect users of your application
+	* that may be violating OpenAI's usage policies. The IDs should be a
+	* string that uniquely identifies each user. We recommend hashing their
+	* username or email address, in order to avoid sending us any identifying
+	* information.
+	*/
+	safetyIdentifier: z.string().optional(),
+	/**
+	* Override the system message mode for this model.
+	* - 'system': Use the 'system' role for system messages (default for most models)
+	* - 'developer': Use the 'developer' role for system messages (used by reasoning models)
+	* - 'remove': Remove system messages entirely
+	*
+	* If not specified, the mode is automatically determined based on the model.
+	*/
+	systemMessageMode: z.enum([
+		"system",
+		"developer",
+		"remove"
+	]).optional(),
+	/**
+	* Force treating this model as a reasoning model.
+	*
+	* This is useful for "stealth" reasoning models (e.g. via a custom baseURL)
+	* where the model ID is not recognized by the SDK's allowlist.
+	*
+	* When enabled, the SDK applies reasoning-model parameter compatibility rules
+	* and defaults `systemMessageMode` to `developer` unless overridden.
+	*/
+	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 {
@@ -730,197 +884,213 @@ function serializeToolCallArguments$1(input) {
 function getPromptCacheBreakpoint$1(providerOptions) {
 	return providerOptions?.openai?.promptCacheBreakpoint;
 }
-function convertToOpenAIChatMessages({ prompt, systemMessageMode = "system" }) {
+async 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;
+	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}`);
 				}
-				case "developer": {
-					const promptCacheBreakpoint = getPromptCacheBreakpoint$1(providerOptions);
+				break;
+			case "user":
+				if (content.length === 1 && content[0].type === "text" && getPromptCacheBreakpoint$1(content[0].providerOptions) == null) {
 					messages.push({
-						role: "developer",
-						content: promptCacheBreakpoint == null ? content : [{
-							type: "text",
-							text: content,
-							prompt_cache_breakpoint: promptCacheBreakpoint
-						}]
+						role: "user",
+						content: content[0].text,
+						...name != null && { name }
 					});
 					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"
-									}) },
+					...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 "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
-										},
+							}
+							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 }
 									};
-									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"
+									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 }
 											};
-											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 "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 "content":
-					case "json": contentValue = stringifyWithBigIntAndCycles(output.value);
+					}
+					case "tool-call": toolCalls.push({
+						id: part.toolCallId,
+						type: "function",
+						function: {
+							name: part.toolName,
+							arguments: serializeToolCallArguments$1(part.input)
+						}
+					});
 				}
 				messages.push({
-					role: "tool",
-					tool_call_id: toolResponse.toolCallId,
-					content: promptCacheBreakpoint == null ? contentValue : [{
-						type: "text",
-						text: contentValue,
-						prompt_cache_breakpoint: promptCacheBreakpoint
-					}]
+					role: "assistant",
+					...name != null && { name },
+					content: hasPromptCacheBreakpoint ? textParts : toolCalls.length > 0 ? text || null : text,
+					tool_calls: toolCalls.length > 0 ? toolCalls : void 0
 				});
+				break;
 			}
-			break;
-		default: throw new Error(`Unsupported role: ${role}`);
+			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,
@@ -938,9 +1108,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":
@@ -958,6 +1128,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(),
@@ -978,14 +1149,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({
@@ -1011,6 +1192,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(),
@@ -1030,14 +1212,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({
-				token: z.string(),
-				logprob: z.number()
-			}))
-		})).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()
 	})),
@@ -1057,155 +1249,6 @@ const openaiChatChunkSchema = lazySchema(() => zodSchema(z.union([z.object({
 	}).nullish()
 }), openaiErrorDataSchema()])));
 //#endregion
-//#region src/chat/openai-chat-language-model-options.ts
-const openaiLanguageModelChatOptions = lazySchema(() => zodSchema(z.object({
-	/**
-	* Modify the likelihood of specified tokens appearing in the completion.
-	*
-	* Accepts a JSON object that maps tokens (specified by their token ID in
-	* the GPT tokenizer) to an associated bias value from -100 to 100.
-	*/
-	logitBias: z.record(z.coerce.number(), z.number()).optional(),
-	/**
-	* Return the log probabilities of the tokens.
-	*
-	* Setting to true will return the log probabilities of the tokens that
-	* were generated.
-	*
-	* Setting to a number will return the log probabilities of the top n
-	* tokens that were generated.
-	*/
-	logprobs: z.union([z.boolean(), z.number()]).optional(),
-	/**
-	* Whether to enable parallel function calling during tool use. Default to true.
-	*/
-	parallelToolCalls: z.boolean().optional(),
-	/**
-	* A unique identifier representing your end-user, which can help OpenAI to
-	* monitor and detect abuse.
-	*/
-	user: z.string().optional(),
-	/**
-	* Reasoning effort for reasoning models. Defaults to `medium`.
-	*/
-	reasoningEffort: z.enum([
-		"none",
-		"minimal",
-		"low",
-		"medium",
-		"high",
-		"xhigh",
-		"max"
-	]).optional(),
-	/**
-	* Maximum number of completion tokens to generate. Useful for reasoning models.
-	*/
-	maxCompletionTokens: z.number().optional(),
-	/**
-	* Whether to enable persistence in responses API.
-	*/
-	store: z.boolean().optional(),
-	/**
-	* Metadata to associate with the request.
-	*/
-	metadata: z.record(z.string().max(64), z.string().max(512)).optional(),
-	/**
-	* Parameters for prediction mode.
-	*/
-	prediction: z.record(z.string(), z.any()).optional(),
-	/**
-	* Service tier for the request.
-	* - 'auto': Default service tier. The request will be processed with the service tier configured in the
-	*           Project settings. Unless otherwise configured, the Project will use 'default'.
-	* - 'flex': 50% cheaper processing at the cost of increased latency. Only available for o3 and o4-mini models.
-	* - 'priority': Higher-speed processing with predictably low latency at premium cost. Available for Enterprise customers.
-	* - 'fast': OpenAI's newer name for the 'priority' tier. Interchangeable with it.
-	* - 'ultrafast': Access-controlled Ultrafast processing. Only available for gpt-5.6-sol.
-	* - 'default': The request will be processed with the standard pricing and performance for the selected model.
-	*
-	* @default 'auto'
-	*/
-	serviceTier: z.enum([
-		"auto",
-		"flex",
-		"priority",
-		"fast",
-		"ultrafast",
-		"default"
-	]).optional(),
-	/**
-	* Whether to use strict JSON schema validation.
-	*
-	* @default true
-	*/
-	strictJsonSchema: z.boolean().optional(),
-	/**
-	* Controls the verbosity of the model's responses.
-	* Lower values will result in more concise responses, while higher values will result in more verbose responses.
-	*/
-	textVerbosity: z.enum([
-		"low",
-		"medium",
-		"high"
-	]).optional(),
-	/**
-	* A cache key for prompt caching. Allows manual control over prompt caching behavior.
-	* Useful for improving cache hit rates and working around automatic caching issues.
-	*/
-	promptCacheKey: z.string().optional(),
-	/**
-	* Prompt cache behavior for GPT-5.6 and later models.
-	* `mode` controls whether OpenAI also places an implicit breakpoint.
-	* `ttl` sets the minimum cache lifetime and currently only supports 30 minutes.
-	*/
-	promptCacheOptions: z.object({
-		mode: z.enum(["implicit", "explicit"]).optional(),
-		ttl: z.literal("30m").optional()
-	}).optional(),
-	/**
-	* The retention policy for the prompt cache.
-	* - 'in_memory': Default. Standard prompt caching behavior.
-	* - '24h': Extended prompt caching that keeps cached prefixes active for up to 24 hours.
-	*          Available for models before GPT-5.6 that support extended caching.
-	*
-	* @deprecated For GPT-5.6 and later models, use `promptCacheOptions.ttl`.
-	*
-	* @default 'in_memory'
-	*/
-	promptCacheRetention: z.enum(["in_memory", "24h"]).optional(),
-	/**
-	* A stable identifier used to help detect users of your application
-	* that may be violating OpenAI's usage policies. The IDs should be a
-	* string that uniquely identifies each user. We recommend hashing their
-	* username or email address, in order to avoid sending us any identifying
-	* information.
-	*/
-	safetyIdentifier: z.string().optional(),
-	/**
-	* Override the system message mode for this model.
-	* - 'system': Use the 'system' role for system messages (default for most models)
-	* - 'developer': Use the 'developer' role for system messages (used by reasoning models)
-	* - 'remove': Remove system messages entirely
-	*
-	* If not specified, the mode is automatically determined based on the model.
-	*/
-	systemMessageMode: z.enum([
-		"system",
-		"developer",
-		"remove"
-	]).optional(),
-	/**
-	* Force treating this model as a reasoning model.
-	*
-	* This is useful for "stealth" reasoning models (e.g. via a custom baseURL)
-	* where the model ID is not recognized by the SDK's allowlist.
-	*
-	* When enabled, the SDK applies reasoning-model parameter compatibility rules
-	* and defaults `systemMessageMode` to `developer` unless overridden.
-	*/
-	forceReasoning: z.boolean().optional()
-})));
-//#endregion
 //#region src/normalize-openai-json-schema.ts
 /**
 * Normalizes JSON Schema for OpenAI structured outputs.
@@ -1444,7 +1487,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)
 		});
@@ -1597,11 +1640,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,
@@ -1620,6 +1664,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(),
@@ -1637,15 +1687,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,
@@ -1691,6 +1749,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({
@@ -1714,6 +1776,7 @@ var OpenAIChatLanguageModel = class OpenAIChatLanguageModel {
 							unified: "error",
 							raw: void 0
 						};
+						rawFinishReason = void 0;
 						controller.enqueue({
 							type: "error",
 							error: chunk.error
@@ -1726,6 +1789,7 @@ var OpenAIChatLanguageModel = class OpenAIChatLanguageModel {
 							unified: "error",
 							raw: void 0
 						};
+						rawFinishReason = void 0;
 						controller.enqueue({
 							type: "error",
 							error: createOpenAIProviderStreamError(value.error) ?? value.error
@@ -1748,14 +1812,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",
@@ -1766,7 +1841,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);
@@ -1784,6 +1859,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,
@@ -1792,7 +1875,10 @@ var OpenAIChatLanguageModel = class OpenAIChatLanguageModel {
 					});
 				}
 			})),
-			request: { body },
+			request: {
+				body,
+				url
+			},
 			response: { headers: responseHeaders }
 		};
 	}
@@ -1801,7 +1887,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
@@ -2343,6 +2429,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.
 	*/
@@ -2351,7 +2446,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()
 });
 const openaiImageModelOptions = lazySchema(() => zodSchema(baseImageModelOptionsObject()));
 const openaiImageModelGenerationOptions = lazySchema(() => zodSchema(baseImageModelOptionsObject().extend({
@@ -2362,16 +2463,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 {
@@ -2423,6 +2558,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",
@@ -2434,14 +2573,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),
@@ -2494,7 +2637,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,
@@ -2547,6 +2694,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 });
@@ -2740,7 +2896,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",
@@ -2754,7 +2910,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,
@@ -2764,7 +2930,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));
@@ -2804,17 +2970,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,
@@ -3692,7 +3860,7 @@ const shellArgsSchema = lazySchema(() => zodSchema(z.object({ environment: z.uni
 		})).optional()
 	})
 ]).optional() })));
-createProviderDefinedToolFactoryWithOutputSchema({
+const shell = createProviderDefinedToolFactoryWithOutputSchema({
 	id: "openai.shell",
 	inputSchema: shellInputSchema,
 	outputSchema: shellOutputSchema
@@ -4926,10 +5094,12 @@ function mapOpenAIResponsesCitations(annotations, providerOptionsName) {
 }
 //#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";
@@ -5109,6 +5279,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"
@@ -5162,6 +5334,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({
@@ -5719,7 +5905,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({
@@ -5758,7 +5944,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"),
@@ -5996,7 +6185,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,
@@ -6119,10 +6325,11 @@ const customArgsSchema = lazySchema(() => zodSchema(z.object({
 	}), z.object({ type: z.literal("text") })]).optional()
 })));
 const customInputSchema = lazySchema(() => zodSchema(z.string()));
-createProviderDefinedToolFactory({
+const customToolFactory = createProviderDefinedToolFactory({
 	id: "openai.custom",
 	inputSchema: customInputSchema
 });
+const customTool = (args) => customToolFactory(args);
 //#endregion
 //#region src/tool/mcp.ts
 let cachedJsonValueSchema;
@@ -6145,8 +6352,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"),
@@ -6355,7 +6563,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;
@@ -6404,7 +6618,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;
 				}
@@ -7098,6 +7313,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":
@@ -7199,8 +7415,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,
@@ -7487,7 +7715,8 @@ var OpenAIResponsesLanguageModel = class OpenAIResponsesLanguageModel {
 			finishReason: {
 				unified: mapOpenAIResponseFinishReason({
 					finishReason: response.incomplete_details?.reason,
-					hasFunctionCall
+					hasFunctionCall,
+					hasRefusal
 				}),
 				raw: response.incomplete_details?.reason ?? void 0
 			},
@@ -7550,6 +7779,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;
@@ -8316,7 +8546,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
@@ -8374,7 +8616,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
 						};
@@ -8464,6 +8707,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";
@@ -8563,6 +8812,6 @@ function escapeJSONDelta(delta) {
 	return JSON.stringify(delta).slice(1, -1);
 }
 //#endregion
-export { OpenAIChatLanguageModel, OpenAICompletionLanguageModel, OpenAIEmbeddingModel, OpenAIImageModel, OpenAIResponsesLanguageModel, OpenAISpeechModel, OpenAITranscriptionModel, applyPatch, applyPatchArgsSchema, applyPatchInputSchema, applyPatchOutputSchema, applyPatchToolFactory, codeInterpreter, codeInterpreterArgsSchema, codeInterpreterInputSchema, codeInterpreterOutputSchema, codeInterpreterToolFactory, fileSearch, fileSearchArgsSchema, fileSearchOutputSchema, getMaxImagesPerCall, hasDefaultResponseFormat, imageGeneration, imageGenerationArgsSchema, imageGenerationOutputSchema, mapWebSearchResult, modelMaxImagesPerCall, openAITranscriptionModelOptions, openaiEmbeddingModelOptions, openaiImageModelEditOptions, openaiImageModelGenerationOptions, openaiImageModelOptions, openaiLanguageModelChatOptions, openaiLanguageModelCompletionOptions, openaiResponsesSupportedUrls, openaiSpeechModelOptionsSchema, programmaticToolCalling, programmaticToolCallingInputSchema, programmaticToolCallingOutputSchema, toolSearch, toolSearchArgsSchema, toolSearchInputSchema, toolSearchOutputSchema, webSearch, webSearchArgsSchema, webSearchOutputSchema, webSearchPreview, webSearchPreviewArgsSchema, webSearchPreviewInputSchema, webSearchToolFactory };
+export { OpenAIChatLanguageModel, OpenAICompletionLanguageModel, OpenAIEmbeddingModel, OpenAIImageModel, OpenAIResponsesLanguageModel, OpenAISpeechModel, OpenAITranscriptionModel, applyPatch, applyPatchArgsSchema, applyPatchInputSchema, applyPatchOutputSchema, applyPatchToolFactory, codeInterpreter, codeInterpreterArgsSchema, codeInterpreterInputSchema, codeInterpreterOutputSchema, codeInterpreterToolFactory, customArgsSchema, customTool, customToolFactory, fileSearch, fileSearchArgsSchema, fileSearchOutputSchema, getMaxImagesPerCall, hasDefaultResponseFormat, imageGeneration, imageGenerationArgsSchema, imageGenerationOutputSchema, mapWebSearchResult, modelMaxImagesPerCall, openAITranscriptionModelOptions, openaiChatMessageProviderOptions, openaiEmbeddingModelOptions, openaiImageModelEditOptions, openaiImageModelGenerationOptions, openaiImageModelOptions, openaiLanguageModelChatOptions, openaiLanguageModelCompletionOptions, openaiModelCatalog, openaiResponsesSupportedUrls, openaiSpeechModelOptionsSchema, programmaticToolCalling, programmaticToolCallingInputSchema, programmaticToolCallingOutputSchema, shell, shellArgsSchema, shellInputSchema, shellOutputSchema, toolSearch, toolSearchArgsSchema, toolSearchInputSchema, toolSearchOutputSchema, webSearch, webSearchArgsSchema, webSearchOutputSchema, webSearchPreview, webSearchPreviewArgsSchema, webSearchPreviewInputSchema, webSearchToolFactory };
 
 //# sourceMappingURL=index.js.map