@ai-sdk/openai 4.0.108 → 4.0.109

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,6 +1006,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 {
@@ -1018,197 +1172,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;
 					}
-				})
-			});
-			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 }
+					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
+						}]
 					});
-					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;
+				break;
+			default: throw new Error(`Unsupported role: ${role}`);
 		}
-		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,
@@ -1345,155 +1515,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.
@@ -1732,7 +1753,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 +1906,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,
@@ -1933,7 +1955,10 @@ var OpenAIChatLanguageModel = class OpenAIChatLanguageModel {
 				raw: choice.finish_reason ?? void 0
 			},
 			usage: convertOpenAIChatUsage(response.usage),
-			request: { body },
+			request: {
+				body,
+				url
+			},
 			response: {
 				...getResponseMetadata$1(response),
 				headers: responseHeaders,
@@ -2080,7 +2105,10 @@ var OpenAIChatLanguageModel = class OpenAIChatLanguageModel {
 					});
 				}
 			})),
-			request: { body },
+			request: {
+				body,
+				url
+			},
 			response: { headers: responseHeaders }
 		};
 	}
@@ -2819,6 +2847,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 +2864,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 +2881,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 +2976,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 +2991,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 +3055,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 +3112,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 +3186,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 +3647,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 +3800,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,
 	/**
@@ -6353,7 +6470,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 +6525,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;
 				}
@@ -9471,7 +9595,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 +9636,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 +9688,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 +9810,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 +9929,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 +9965,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 +9987,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 +9999,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 +10054,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 +10410,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 +10424,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 +10444,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 +10484,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 +11009,7 @@ var OpenAISkills = class {
 };
 //#endregion
 //#region src/version.ts
-const VERSION = "4.0.108";
+const VERSION = "4.0.109";
 //#endregion
 //#region src/openai-provider.ts
 /**