@ls-stack/server-i18n 0.0.0-stage → 0.6.0

package/dist/dist-Dtrz_N2T.mjs

@@ -0,0 +1,4519 @@
+import { S as _coercedNumber, _ as string, a as any, d as literal, h as record, i as _null, l as discriminatedUnion, m as object, n as _enum, o as array, p as number$1, s as boolean, t as ZodNumber, u as lazy, v as union, y as unknown } from "./schemas-BfUoDuyI.mjs";
+import { $ as UnsupportedFunctionalityError, A as loadOptionalSetting, B as validateTypes, F as postJsonToApi, G as APICallError, H as withoutTrailingSlash, J as InvalidResponseDataError, N as parseProviderOptions, O as lazySchema, P as postFormDataToApi, T as isParsableJson, U as zodSchema, V as withUserAgentSuffix, Z as TooManyEmbeddingValuesForCallError, _ as downloadBlob, a as convertToBase64, c as createBinaryResponseHandler, d as createJsonErrorResponseHandler, f as createJsonResponseHandler, h as createToolNameMapping, i as convertBase64ToUint8Array, j as mediaTypeToExtension, k as loadApiKey, l as createEventSourceResponseHandler, m as createProviderToolFactoryWithOutputSchema, o as convertToFormData, q as InvalidPromptError, r as combineHeaders, w as isNonNullable, y as generateId } from "./dist-BA5qgNhB.mjs";
+
+//#region ../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/classic/coerce.js
+function number(params) {
+	return _coercedNumber(ZodNumber, params);
+}
+
+//#endregion
+//#region ../node_modules/.pnpm/@ai-sdk+openai@3.0.25_zod@4.3.6/node_modules/@ai-sdk/openai/dist/index.mjs
+var openaiErrorDataSchema = object({ error: object({
+	message: string(),
+	type: string().nullish(),
+	param: any().nullish(),
+	code: union([string(), number$1()]).nullish()
+}) });
+var openaiFailedResponseHandler = createJsonErrorResponseHandler({
+	errorSchema: openaiErrorDataSchema,
+	errorToMessage: (data) => data.error.message
+});
+function getOpenAILanguageModelCapabilities(modelId) {
+	const supportsFlexProcessing = modelId.startsWith("o3") || modelId.startsWith("o4-mini") || modelId.startsWith("gpt-5") && !modelId.startsWith("gpt-5-chat");
+	const supportsPriorityProcessing = modelId.startsWith("gpt-4") || modelId.startsWith("gpt-5-mini") || modelId.startsWith("gpt-5") && !modelId.startsWith("gpt-5-nano") && !modelId.startsWith("gpt-5-chat") || modelId.startsWith("o3") || modelId.startsWith("o4-mini");
+	const isReasoningModel = modelId.startsWith("o1") || modelId.startsWith("o3") || modelId.startsWith("o4-mini") || modelId.startsWith("codex-mini") || modelId.startsWith("computer-use-preview") || modelId.startsWith("gpt-5") && !modelId.startsWith("gpt-5-chat");
+	const supportsNonReasoningParameters = modelId.startsWith("gpt-5.1") || modelId.startsWith("gpt-5.2");
+	return {
+		supportsFlexProcessing,
+		supportsPriorityProcessing,
+		isReasoningModel,
+		systemMessageMode: isReasoningModel ? "developer" : "system",
+		supportsNonReasoningParameters
+	};
+}
+function convertOpenAIChatUsage(usage) {
+	var _a, _b, _c, _d, _e, _f;
+	if (usage == null) return {
+		inputTokens: {
+			total: void 0,
+			noCache: void 0,
+			cacheRead: void 0,
+			cacheWrite: void 0
+		},
+		outputTokens: {
+			total: void 0,
+			text: void 0,
+			reasoning: void 0
+		},
+		raw: void 0
+	};
+	const promptTokens = (_a = usage.prompt_tokens) != null ? _a : 0;
+	const completionTokens = (_b = usage.completion_tokens) != null ? _b : 0;
+	const cachedTokens = (_d = (_c = usage.prompt_tokens_details) == null ? void 0 : _c.cached_tokens) != null ? _d : 0;
+	const reasoningTokens = (_f = (_e = usage.completion_tokens_details) == null ? void 0 : _e.reasoning_tokens) != null ? _f : 0;
+	return {
+		inputTokens: {
+			total: promptTokens,
+			noCache: promptTokens - cachedTokens,
+			cacheRead: cachedTokens,
+			cacheWrite: void 0
+		},
+		outputTokens: {
+			total: completionTokens,
+			text: completionTokens - reasoningTokens,
+			reasoning: reasoningTokens
+		},
+		raw: usage
+	};
+}
+function convertToOpenAIChatMessages({ prompt, systemMessageMode = "system" }) {
+	var _a;
+	const messages = [];
+	const warnings = [];
+	for (const { role, content } of prompt) switch (role) {
+		case "system":
+			switch (systemMessageMode) {
+				case "system":
+					messages.push({
+						role: "system",
+						content
+					});
+					break;
+				case "developer":
+					messages.push({
+						role: "developer",
+						content
+					});
+					break;
+				case "remove":
+					warnings.push({
+						type: "other",
+						message: "system messages are removed for this model"
+					});
+					break;
+				default: {
+					const _exhaustiveCheck = systemMessageMode;
+					throw new Error(`Unsupported system message mode: ${_exhaustiveCheck}`);
+				}
+			}
+			break;
+		case "user":
+			if (content.length === 1 && content[0].type === "text") {
+				messages.push({
+					role: "user",
+					content: content[0].text
+				});
+				break;
+			}
+			messages.push({
+				role: "user",
+				content: content.map((part, index) => {
+					var _a2, _b, _c;
+					switch (part.type) {
+						case "text": return {
+							type: "text",
+							text: part.text
+						};
+						case "file": if (part.mediaType.startsWith("image/")) {
+							const mediaType = part.mediaType === "image/*" ? "image/jpeg" : part.mediaType;
+							return {
+								type: "image_url",
+								image_url: {
+									url: part.data instanceof URL ? part.data.toString() : `data:${mediaType};base64,${convertToBase64(part.data)}`,
+									detail: (_b = (_a2 = part.providerOptions) == null ? void 0 : _a2.openai) == null ? void 0 : _b.imageDetail
+								}
+							};
+						} else if (part.mediaType.startsWith("audio/")) {
+							if (part.data instanceof URL) throw new UnsupportedFunctionalityError({ functionality: "audio file parts with URLs" });
+							switch (part.mediaType) {
+								case "audio/wav": return {
+									type: "input_audio",
+									input_audio: {
+										data: convertToBase64(part.data),
+										format: "wav"
+									}
+								};
+								case "audio/mp3":
+								case "audio/mpeg": return {
+									type: "input_audio",
+									input_audio: {
+										data: convertToBase64(part.data),
+										format: "mp3"
+									}
+								};
+								default: throw new UnsupportedFunctionalityError({ functionality: `audio content parts with media type ${part.mediaType}` });
+							}
+						} else if (part.mediaType === "application/pdf") {
+							if (part.data instanceof URL) throw new UnsupportedFunctionalityError({ functionality: "PDF file parts with URLs" });
+							return {
+								type: "file",
+								file: typeof part.data === "string" && part.data.startsWith("file-") ? { file_id: part.data } : {
+									filename: (_c = part.filename) != null ? _c : `part-${index}.pdf`,
+									file_data: `data:application/pdf;base64,${convertToBase64(part.data)}`
+								}
+							};
+						} else throw new UnsupportedFunctionalityError({ functionality: `file part media type ${part.mediaType}` });
+					}
+				})
+			});
+			break;
+		case "assistant": {
+			let text = "";
+			const toolCalls = [];
+			for (const part of content) switch (part.type) {
+				case "text":
+					text += part.text;
+					break;
+				case "tool-call":
+					toolCalls.push({
+						id: part.toolCallId,
+						type: "function",
+						function: {
+							name: part.toolName,
+							arguments: JSON.stringify(part.input)
+						}
+					});
+					break;
+			}
+			messages.push({
+				role: "assistant",
+				content: 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;
+				let contentValue;
+				switch (output.type) {
+					case "text":
+					case "error-text":
+						contentValue = output.value;
+						break;
+					case "execution-denied":
+						contentValue = (_a = output.reason) != null ? _a : "Tool execution denied.";
+						break;
+					case "content":
+					case "json":
+					case "error-json":
+						contentValue = JSON.stringify(output.value);
+						break;
+				}
+				messages.push({
+					role: "tool",
+					tool_call_id: toolResponse.toolCallId,
+					content: contentValue
+				});
+			}
+			break;
+		default: {
+			const _exhaustiveCheck = role;
+			throw new Error(`Unsupported role: ${_exhaustiveCheck}`);
+		}
+	}
+	return {
+		messages,
+		warnings
+	};
+}
+function getResponseMetadata({ id, model, created }) {
+	return {
+		id: id != null ? id : void 0,
+		modelId: model != null ? model : void 0,
+		timestamp: created ? /* @__PURE__ */ new Date(created * 1e3) : void 0
+	};
+}
+function mapOpenAIFinishReason(finishReason) {
+	switch (finishReason) {
+		case "stop": return "stop";
+		case "length": return "length";
+		case "content_filter": return "content-filter";
+		case "function_call":
+		case "tool_calls": return "tool-calls";
+		default: return "other";
+	}
+}
+var openaiChatResponseSchema = lazySchema(() => zodSchema(object({
+	id: string().nullish(),
+	created: number$1().nullish(),
+	model: string().nullish(),
+	choices: array(object({
+		message: object({
+			role: literal("assistant").nullish(),
+			content: string().nullish(),
+			tool_calls: array(object({
+				id: string().nullish(),
+				type: literal("function"),
+				function: object({
+					name: string(),
+					arguments: string()
+				})
+			})).nullish(),
+			annotations: array(object({
+				type: literal("url_citation"),
+				url_citation: object({
+					start_index: number$1(),
+					end_index: number$1(),
+					url: string(),
+					title: string()
+				})
+			})).nullish()
+		}),
+		index: number$1(),
+		logprobs: object({ content: array(object({
+			token: string(),
+			logprob: number$1(),
+			top_logprobs: array(object({
+				token: string(),
+				logprob: number$1()
+			}))
+		})).nullish() }).nullish(),
+		finish_reason: string().nullish()
+	})),
+	usage: object({
+		prompt_tokens: number$1().nullish(),
+		completion_tokens: number$1().nullish(),
+		total_tokens: number$1().nullish(),
+		prompt_tokens_details: object({ cached_tokens: number$1().nullish() }).nullish(),
+		completion_tokens_details: object({
+			reasoning_tokens: number$1().nullish(),
+			accepted_prediction_tokens: number$1().nullish(),
+			rejected_prediction_tokens: number$1().nullish()
+		}).nullish()
+	}).nullish()
+})));
+var openaiChatChunkSchema = lazySchema(() => zodSchema(union([object({
+	id: string().nullish(),
+	created: number$1().nullish(),
+	model: string().nullish(),
+	choices: array(object({
+		delta: object({
+			role: _enum(["assistant"]).nullish(),
+			content: string().nullish(),
+			tool_calls: array(object({
+				index: number$1(),
+				id: string().nullish(),
+				type: literal("function").nullish(),
+				function: object({
+					name: string().nullish(),
+					arguments: string().nullish()
+				})
+			})).nullish(),
+			annotations: array(object({
+				type: literal("url_citation"),
+				url_citation: object({
+					start_index: number$1(),
+					end_index: number$1(),
+					url: string(),
+					title: string()
+				})
+			})).nullish()
+		}).nullish(),
+		logprobs: object({ content: array(object({
+			token: string(),
+			logprob: number$1(),
+			top_logprobs: array(object({
+				token: string(),
+				logprob: number$1()
+			}))
+		})).nullish() }).nullish(),
+		finish_reason: string().nullish(),
+		index: number$1()
+	})),
+	usage: object({
+		prompt_tokens: number$1().nullish(),
+		completion_tokens: number$1().nullish(),
+		total_tokens: number$1().nullish(),
+		prompt_tokens_details: object({ cached_tokens: number$1().nullish() }).nullish(),
+		completion_tokens_details: object({
+			reasoning_tokens: number$1().nullish(),
+			accepted_prediction_tokens: number$1().nullish(),
+			rejected_prediction_tokens: number$1().nullish()
+		}).nullish()
+	}).nullish()
+}), openaiErrorDataSchema])));
+var openaiChatLanguageModelOptions = lazySchema(() => zodSchema(object({
+	logitBias: record(number(), number$1()).optional(),
+	logprobs: union([boolean(), number$1()]).optional(),
+	parallelToolCalls: boolean().optional(),
+	user: string().optional(),
+	reasoningEffort: _enum([
+		"none",
+		"minimal",
+		"low",
+		"medium",
+		"high",
+		"xhigh"
+	]).optional(),
+	maxCompletionTokens: number$1().optional(),
+	store: boolean().optional(),
+	metadata: record(string().max(64), string().max(512)).optional(),
+	prediction: record(string(), any()).optional(),
+	serviceTier: _enum([
+		"auto",
+		"flex",
+		"priority",
+		"default"
+	]).optional(),
+	strictJsonSchema: boolean().optional(),
+	textVerbosity: _enum([
+		"low",
+		"medium",
+		"high"
+	]).optional(),
+	promptCacheKey: string().optional(),
+	promptCacheRetention: _enum(["in_memory", "24h"]).optional(),
+	safetyIdentifier: string().optional(),
+	systemMessageMode: _enum([
+		"system",
+		"developer",
+		"remove"
+	]).optional(),
+	forceReasoning: boolean().optional()
+})));
+function prepareChatTools({ tools, toolChoice }) {
+	tools = (tools == null ? void 0 : tools.length) ? tools : void 0;
+	const toolWarnings = [];
+	if (tools == null) return {
+		tools: void 0,
+		toolChoice: void 0,
+		toolWarnings
+	};
+	const openaiTools2 = [];
+	for (const tool of tools) switch (tool.type) {
+		case "function":
+			openaiTools2.push({
+				type: "function",
+				function: {
+					name: tool.name,
+					description: tool.description,
+					parameters: tool.inputSchema,
+					...tool.strict != null ? { strict: tool.strict } : {}
+				}
+			});
+			break;
+		default:
+			toolWarnings.push({
+				type: "unsupported",
+				feature: `tool type: ${tool.type}`
+			});
+			break;
+	}
+	if (toolChoice == null) return {
+		tools: openaiTools2,
+		toolChoice: void 0,
+		toolWarnings
+	};
+	const type = toolChoice.type;
+	switch (type) {
+		case "auto":
+		case "none":
+		case "required": return {
+			tools: openaiTools2,
+			toolChoice: type,
+			toolWarnings
+		};
+		case "tool": return {
+			tools: openaiTools2,
+			toolChoice: {
+				type: "function",
+				function: { name: toolChoice.toolName }
+			},
+			toolWarnings
+		};
+		default: throw new UnsupportedFunctionalityError({ functionality: `tool choice type: ${type}` });
+	}
+}
+var OpenAIChatLanguageModel = class {
+	constructor(modelId, config) {
+		this.specificationVersion = "v3";
+		this.supportedUrls = { "image/*": [/^https?:\/\/.*$/] };
+		this.modelId = modelId;
+		this.config = config;
+	}
+	get provider() {
+		return this.config.provider;
+	}
+	async getArgs({ prompt, maxOutputTokens, temperature, topP, topK, frequencyPenalty, presencePenalty, stopSequences, responseFormat, seed, tools, toolChoice, providerOptions }) {
+		var _a, _b, _c, _d, _e;
+		const warnings = [];
+		const openaiOptions = (_a = await parseProviderOptions({
+			provider: "openai",
+			providerOptions,
+			schema: openaiChatLanguageModelOptions
+		})) != null ? _a : {};
+		const modelCapabilities = getOpenAILanguageModelCapabilities(this.modelId);
+		const isReasoningModel = (_b = openaiOptions.forceReasoning) != null ? _b : modelCapabilities.isReasoningModel;
+		if (topK != null) warnings.push({
+			type: "unsupported",
+			feature: "topK"
+		});
+		const { messages, warnings: messageWarnings } = convertToOpenAIChatMessages({
+			prompt,
+			systemMessageMode: (_c = openaiOptions.systemMessageMode) != null ? _c : isReasoningModel ? "developer" : modelCapabilities.systemMessageMode
+		});
+		warnings.push(...messageWarnings);
+		const strictJsonSchema = (_d = openaiOptions.strictJsonSchema) != null ? _d : true;
+		const baseArgs = {
+			model: this.modelId,
+			logit_bias: openaiOptions.logitBias,
+			logprobs: openaiOptions.logprobs === true || typeof openaiOptions.logprobs === "number" ? true : void 0,
+			top_logprobs: typeof openaiOptions.logprobs === "number" ? openaiOptions.logprobs : typeof openaiOptions.logprobs === "boolean" ? openaiOptions.logprobs ? 0 : void 0 : void 0,
+			user: openaiOptions.user,
+			parallel_tool_calls: openaiOptions.parallelToolCalls,
+			max_tokens: maxOutputTokens,
+			temperature,
+			top_p: topP,
+			frequency_penalty: frequencyPenalty,
+			presence_penalty: presencePenalty,
+			response_format: (responseFormat == null ? void 0 : responseFormat.type) === "json" ? responseFormat.schema != null ? {
+				type: "json_schema",
+				json_schema: {
+					schema: responseFormat.schema,
+					strict: strictJsonSchema,
+					name: (_e = responseFormat.name) != null ? _e : "response",
+					description: responseFormat.description
+				}
+			} : { type: "json_object" } : void 0,
+			stop: stopSequences,
+			seed,
+			verbosity: openaiOptions.textVerbosity,
+			max_completion_tokens: openaiOptions.maxCompletionTokens,
+			store: openaiOptions.store,
+			metadata: openaiOptions.metadata,
+			prediction: openaiOptions.prediction,
+			reasoning_effort: openaiOptions.reasoningEffort,
+			service_tier: openaiOptions.serviceTier,
+			prompt_cache_key: openaiOptions.promptCacheKey,
+			prompt_cache_retention: openaiOptions.promptCacheRetention,
+			safety_identifier: openaiOptions.safetyIdentifier,
+			messages
+		};
+		if (isReasoningModel) {
+			if (openaiOptions.reasoningEffort !== "none" || !modelCapabilities.supportsNonReasoningParameters) {
+				if (baseArgs.temperature != null) {
+					baseArgs.temperature = void 0;
+					warnings.push({
+						type: "unsupported",
+						feature: "temperature",
+						details: "temperature is not supported for reasoning models"
+					});
+				}
+				if (baseArgs.top_p != null) {
+					baseArgs.top_p = void 0;
+					warnings.push({
+						type: "unsupported",
+						feature: "topP",
+						details: "topP is not supported for reasoning models"
+					});
+				}
+				if (baseArgs.logprobs != null) {
+					baseArgs.logprobs = void 0;
+					warnings.push({
+						type: "other",
+						message: "logprobs is not supported for reasoning models"
+					});
+				}
+			}
+			if (baseArgs.frequency_penalty != null) {
+				baseArgs.frequency_penalty = void 0;
+				warnings.push({
+					type: "unsupported",
+					feature: "frequencyPenalty",
+					details: "frequencyPenalty is not supported for reasoning models"
+				});
+			}
+			if (baseArgs.presence_penalty != null) {
+				baseArgs.presence_penalty = void 0;
+				warnings.push({
+					type: "unsupported",
+					feature: "presencePenalty",
+					details: "presencePenalty is not supported for reasoning models"
+				});
+			}
+			if (baseArgs.logit_bias != null) {
+				baseArgs.logit_bias = void 0;
+				warnings.push({
+					type: "other",
+					message: "logitBias is not supported for reasoning models"
+				});
+			}
+			if (baseArgs.top_logprobs != null) {
+				baseArgs.top_logprobs = void 0;
+				warnings.push({
+					type: "other",
+					message: "topLogprobs is not supported for reasoning models"
+				});
+			}
+			if (baseArgs.max_tokens != null) {
+				if (baseArgs.max_completion_tokens == null) baseArgs.max_completion_tokens = baseArgs.max_tokens;
+				baseArgs.max_tokens = void 0;
+			}
+		} else if (this.modelId.startsWith("gpt-4o-search-preview") || this.modelId.startsWith("gpt-4o-mini-search-preview")) {
+			if (baseArgs.temperature != null) {
+				baseArgs.temperature = void 0;
+				warnings.push({
+					type: "unsupported",
+					feature: "temperature",
+					details: "temperature is not supported for the search preview models and has been removed."
+				});
+			}
+		}
+		if (openaiOptions.serviceTier === "flex" && !modelCapabilities.supportsFlexProcessing) {
+			warnings.push({
+				type: "unsupported",
+				feature: "serviceTier",
+				details: "flex processing is only available for o3, o4-mini, and gpt-5 models"
+			});
+			baseArgs.service_tier = void 0;
+		}
+		if (openaiOptions.serviceTier === "priority" && !modelCapabilities.supportsPriorityProcessing) {
+			warnings.push({
+				type: "unsupported",
+				feature: "serviceTier",
+				details: "priority processing is only available for supported models (gpt-4, gpt-5, gpt-5-mini, o3, o4-mini) and requires Enterprise access. gpt-5-nano is not supported"
+			});
+			baseArgs.service_tier = void 0;
+		}
+		const { tools: openaiTools2, toolChoice: openaiToolChoice, toolWarnings } = prepareChatTools({
+			tools,
+			toolChoice
+		});
+		return {
+			args: {
+				...baseArgs,
+				tools: openaiTools2,
+				tool_choice: openaiToolChoice
+			},
+			warnings: [...warnings, ...toolWarnings]
+		};
+	}
+	async doGenerate(options) {
+		var _a, _b, _c, _d, _e, _f, _g;
+		const { args: body, warnings } = await this.getArgs(options);
+		const { responseHeaders, value: response, rawValue: rawResponse } = await postJsonToApi({
+			url: this.config.url({
+				path: "/chat/completions",
+				modelId: this.modelId
+			}),
+			headers: combineHeaders(this.config.headers(), options.headers),
+			body,
+			failedResponseHandler: openaiFailedResponseHandler,
+			successfulResponseHandler: createJsonResponseHandler(openaiChatResponseSchema),
+			abortSignal: options.abortSignal,
+			fetch: this.config.fetch
+		});
+		const choice = response.choices[0];
+		const content = [];
+		const text = choice.message.content;
+		if (text != null && text.length > 0) content.push({
+			type: "text",
+			text
+		});
+		for (const toolCall of (_a = choice.message.tool_calls) != null ? _a : []) content.push({
+			type: "tool-call",
+			toolCallId: (_b = toolCall.id) != null ? _b : generateId(),
+			toolName: toolCall.function.name,
+			input: toolCall.function.arguments
+		});
+		for (const annotation of (_c = choice.message.annotations) != null ? _c : []) content.push({
+			type: "source",
+			sourceType: "url",
+			id: generateId(),
+			url: annotation.url_citation.url,
+			title: annotation.url_citation.title
+		});
+		const completionTokenDetails = (_d = response.usage) == null ? void 0 : _d.completion_tokens_details;
+		(_e = response.usage) == null || _e.prompt_tokens_details;
+		const providerMetadata = { openai: {} };
+		if ((completionTokenDetails == null ? void 0 : completionTokenDetails.accepted_prediction_tokens) != null) providerMetadata.openai.acceptedPredictionTokens = completionTokenDetails == null ? void 0 : completionTokenDetails.accepted_prediction_tokens;
+		if ((completionTokenDetails == null ? void 0 : completionTokenDetails.rejected_prediction_tokens) != null) providerMetadata.openai.rejectedPredictionTokens = completionTokenDetails == null ? void 0 : completionTokenDetails.rejected_prediction_tokens;
+		if (((_f = choice.logprobs) == null ? void 0 : _f.content) != null) providerMetadata.openai.logprobs = choice.logprobs.content;
+		return {
+			content,
+			finishReason: {
+				unified: mapOpenAIFinishReason(choice.finish_reason),
+				raw: (_g = choice.finish_reason) != null ? _g : void 0
+			},
+			usage: convertOpenAIChatUsage(response.usage),
+			request: { body },
+			response: {
+				...getResponseMetadata(response),
+				headers: responseHeaders,
+				body: rawResponse
+			},
+			warnings,
+			providerMetadata
+		};
+	}
+	async doStream(options) {
+		const { args, warnings } = await this.getArgs(options);
+		const body = {
+			...args,
+			stream: true,
+			stream_options: { include_usage: true }
+		};
+		const { responseHeaders, value: response } = await postJsonToApi({
+			url: this.config.url({
+				path: "/chat/completions",
+				modelId: this.modelId
+			}),
+			headers: combineHeaders(this.config.headers(), options.headers),
+			body,
+			failedResponseHandler: openaiFailedResponseHandler,
+			successfulResponseHandler: createEventSourceResponseHandler(openaiChatChunkSchema),
+			abortSignal: options.abortSignal,
+			fetch: this.config.fetch
+		});
+		const toolCalls = [];
+		let finishReason = {
+			unified: "other",
+			raw: void 0
+		};
+		let usage = void 0;
+		let metadataExtracted = false;
+		let isActiveText = false;
+		const providerMetadata = { openai: {} };
+		return {
+			stream: response.pipeThrough(new TransformStream({
+				start(controller) {
+					controller.enqueue({
+						type: "stream-start",
+						warnings
+					});
+				},
+				transform(chunk, controller) {
+					var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q;
+					if (options.includeRawChunks) controller.enqueue({
+						type: "raw",
+						rawValue: chunk.rawValue
+					});
+					if (!chunk.success) {
+						finishReason = {
+							unified: "error",
+							raw: void 0
+						};
+						controller.enqueue({
+							type: "error",
+							error: chunk.error
+						});
+						return;
+					}
+					const value = chunk.value;
+					if ("error" in value) {
+						finishReason = {
+							unified: "error",
+							raw: void 0
+						};
+						controller.enqueue({
+							type: "error",
+							error: value.error
+						});
+						return;
+					}
+					if (!metadataExtracted) {
+						const metadata = getResponseMetadata(value);
+						if (Object.values(metadata).some(Boolean)) {
+							metadataExtracted = true;
+							controller.enqueue({
+								type: "response-metadata",
+								...getResponseMetadata(value)
+							});
+						}
+					}
+					if (value.usage != null) {
+						usage = value.usage;
+						if (((_a = value.usage.completion_tokens_details) == null ? void 0 : _a.accepted_prediction_tokens) != null) providerMetadata.openai.acceptedPredictionTokens = (_b = value.usage.completion_tokens_details) == null ? void 0 : _b.accepted_prediction_tokens;
+						if (((_c = value.usage.completion_tokens_details) == null ? void 0 : _c.rejected_prediction_tokens) != null) providerMetadata.openai.rejectedPredictionTokens = (_d = value.usage.completion_tokens_details) == null ? void 0 : _d.rejected_prediction_tokens;
+					}
+					const choice = value.choices[0];
+					if ((choice == null ? void 0 : choice.finish_reason) != null) finishReason = {
+						unified: mapOpenAIFinishReason(choice.finish_reason),
+						raw: choice.finish_reason
+					};
+					if (((_e = choice == null ? void 0 : choice.logprobs) == null ? void 0 : _e.content) != null) providerMetadata.openai.logprobs = choice.logprobs.content;
+					if ((choice == null ? void 0 : choice.delta) == null) return;
+					const delta = choice.delta;
+					if (delta.content != null) {
+						if (!isActiveText) {
+							controller.enqueue({
+								type: "text-start",
+								id: "0"
+							});
+							isActiveText = true;
+						}
+						controller.enqueue({
+							type: "text-delta",
+							id: "0",
+							delta: delta.content
+						});
+					}
+					if (delta.tool_calls != null) for (const toolCallDelta of delta.tool_calls) {
+						const index = toolCallDelta.index;
+						if (toolCalls[index] == null) {
+							if (toolCallDelta.type !== "function") throw new InvalidResponseDataError({
+								data: toolCallDelta,
+								message: `Expected 'function' type.`
+							});
+							if (toolCallDelta.id == null) throw new InvalidResponseDataError({
+								data: toolCallDelta,
+								message: `Expected 'id' to be a string.`
+							});
+							if (((_f = toolCallDelta.function) == null ? void 0 : _f.name) == null) throw new InvalidResponseDataError({
+								data: toolCallDelta,
+								message: `Expected 'function.name' to be a string.`
+							});
+							controller.enqueue({
+								type: "tool-input-start",
+								id: toolCallDelta.id,
+								toolName: toolCallDelta.function.name
+							});
+							toolCalls[index] = {
+								id: toolCallDelta.id,
+								type: "function",
+								function: {
+									name: toolCallDelta.function.name,
+									arguments: (_g = toolCallDelta.function.arguments) != null ? _g : ""
+								},
+								hasFinished: false
+							};
+							const toolCall2 = toolCalls[index];
+							if (((_h = toolCall2.function) == null ? void 0 : _h.name) != null && ((_i = toolCall2.function) == null ? void 0 : _i.arguments) != null) {
+								if (toolCall2.function.arguments.length > 0) controller.enqueue({
+									type: "tool-input-delta",
+									id: toolCall2.id,
+									delta: toolCall2.function.arguments
+								});
+								if (isParsableJson(toolCall2.function.arguments)) {
+									controller.enqueue({
+										type: "tool-input-end",
+										id: toolCall2.id
+									});
+									controller.enqueue({
+										type: "tool-call",
+										toolCallId: (_j = toolCall2.id) != null ? _j : generateId(),
+										toolName: toolCall2.function.name,
+										input: toolCall2.function.arguments
+									});
+									toolCall2.hasFinished = true;
+								}
+							}
+							continue;
+						}
+						const toolCall = toolCalls[index];
+						if (toolCall.hasFinished) continue;
+						if (((_k = toolCallDelta.function) == null ? void 0 : _k.arguments) != null) toolCall.function.arguments += (_m = (_l = toolCallDelta.function) == null ? void 0 : _l.arguments) != null ? _m : "";
+						controller.enqueue({
+							type: "tool-input-delta",
+							id: toolCall.id,
+							delta: (_n = toolCallDelta.function.arguments) != null ? _n : ""
+						});
+						if (((_o = toolCall.function) == null ? void 0 : _o.name) != null && ((_p = toolCall.function) == null ? void 0 : _p.arguments) != null && isParsableJson(toolCall.function.arguments)) {
+							controller.enqueue({
+								type: "tool-input-end",
+								id: toolCall.id
+							});
+							controller.enqueue({
+								type: "tool-call",
+								toolCallId: (_q = toolCall.id) != null ? _q : generateId(),
+								toolName: toolCall.function.name,
+								input: toolCall.function.arguments
+							});
+							toolCall.hasFinished = true;
+						}
+					}
+					if (delta.annotations != null) for (const annotation of delta.annotations) controller.enqueue({
+						type: "source",
+						sourceType: "url",
+						id: generateId(),
+						url: annotation.url_citation.url,
+						title: annotation.url_citation.title
+					});
+				},
+				flush(controller) {
+					if (isActiveText) controller.enqueue({
+						type: "text-end",
+						id: "0"
+					});
+					controller.enqueue({
+						type: "finish",
+						finishReason,
+						usage: convertOpenAIChatUsage(usage),
+						...providerMetadata != null ? { providerMetadata } : {}
+					});
+				}
+			})),
+			request: { body },
+			response: { headers: responseHeaders }
+		};
+	}
+};
+function convertOpenAICompletionUsage(usage) {
+	var _a, _b, _c, _d;
+	if (usage == null) return {
+		inputTokens: {
+			total: void 0,
+			noCache: void 0,
+			cacheRead: void 0,
+			cacheWrite: void 0
+		},
+		outputTokens: {
+			total: void 0,
+			text: void 0,
+			reasoning: void 0
+		},
+		raw: void 0
+	};
+	const promptTokens = (_a = usage.prompt_tokens) != null ? _a : 0;
+	const completionTokens = (_b = usage.completion_tokens) != null ? _b : 0;
+	return {
+		inputTokens: {
+			total: (_c = usage.prompt_tokens) != null ? _c : void 0,
+			noCache: promptTokens,
+			cacheRead: void 0,
+			cacheWrite: void 0
+		},
+		outputTokens: {
+			total: (_d = usage.completion_tokens) != null ? _d : void 0,
+			text: completionTokens,
+			reasoning: void 0
+		},
+		raw: usage
+	};
+}
+function convertToOpenAICompletionPrompt({ prompt, user = "user", assistant = "assistant" }) {
+	let text = "";
+	if (prompt[0].role === "system") {
+		text += `${prompt[0].content}
+
+`;
+		prompt = prompt.slice(1);
+	}
+	for (const { role, content } of prompt) switch (role) {
+		case "system": throw new InvalidPromptError({
+			message: "Unexpected system message in prompt: ${content}",
+			prompt
+		});
+		case "user": {
+			const userMessage = content.map((part) => {
+				switch (part.type) {
+					case "text": return part.text;
+				}
+			}).filter(Boolean).join("");
+			text += `${user}:
+${userMessage}
+
+`;
+			break;
+		}
+		case "assistant": {
+			const assistantMessage = content.map((part) => {
+				switch (part.type) {
+					case "text": return part.text;
+					case "tool-call": throw new UnsupportedFunctionalityError({ functionality: "tool-call messages" });
+				}
+			}).join("");
+			text += `${assistant}:
+${assistantMessage}
+
+`;
+			break;
+		}
+		case "tool": throw new UnsupportedFunctionalityError({ functionality: "tool messages" });
+		default: {
+			const _exhaustiveCheck = role;
+			throw new Error(`Unsupported role: ${_exhaustiveCheck}`);
+		}
+	}
+	text += `${assistant}:
+`;
+	return {
+		prompt: text,
+		stopSequences: [`
+${user}:`]
+	};
+}
+function getResponseMetadata2({ id, model, created }) {
+	return {
+		id: id != null ? id : void 0,
+		modelId: model != null ? model : void 0,
+		timestamp: created != null ? /* @__PURE__ */ new Date(created * 1e3) : void 0
+	};
+}
+function mapOpenAIFinishReason2(finishReason) {
+	switch (finishReason) {
+		case "stop": return "stop";
+		case "length": return "length";
+		case "content_filter": return "content-filter";
+		case "function_call":
+		case "tool_calls": return "tool-calls";
+		default: return "other";
+	}
+}
+var openaiCompletionResponseSchema = lazySchema(() => zodSchema(object({
+	id: string().nullish(),
+	created: number$1().nullish(),
+	model: string().nullish(),
+	choices: array(object({
+		text: string(),
+		finish_reason: string(),
+		logprobs: object({
+			tokens: array(string()),
+			token_logprobs: array(number$1()),
+			top_logprobs: array(record(string(), number$1())).nullish()
+		}).nullish()
+	})),
+	usage: object({
+		prompt_tokens: number$1(),
+		completion_tokens: number$1(),
+		total_tokens: number$1()
+	}).nullish()
+})));
+var openaiCompletionChunkSchema = lazySchema(() => zodSchema(union([object({
+	id: string().nullish(),
+	created: number$1().nullish(),
+	model: string().nullish(),
+	choices: array(object({
+		text: string(),
+		finish_reason: string().nullish(),
+		index: number$1(),
+		logprobs: object({
+			tokens: array(string()),
+			token_logprobs: array(number$1()),
+			top_logprobs: array(record(string(), number$1())).nullish()
+		}).nullish()
+	})),
+	usage: object({
+		prompt_tokens: number$1(),
+		completion_tokens: number$1(),
+		total_tokens: number$1()
+	}).nullish()
+}), openaiErrorDataSchema])));
+var openaiCompletionProviderOptions = lazySchema(() => zodSchema(object({
+	echo: boolean().optional(),
+	logitBias: record(string(), number$1()).optional(),
+	suffix: string().optional(),
+	user: string().optional(),
+	logprobs: union([boolean(), number$1()]).optional()
+})));
+var OpenAICompletionLanguageModel = class {
+	constructor(modelId, config) {
+		this.specificationVersion = "v3";
+		this.supportedUrls = {};
+		this.modelId = modelId;
+		this.config = config;
+	}
+	get providerOptionsName() {
+		return this.config.provider.split(".")[0].trim();
+	}
+	get provider() {
+		return this.config.provider;
+	}
+	async getArgs({ prompt, maxOutputTokens, temperature, topP, topK, frequencyPenalty, presencePenalty, stopSequences: userStopSequences, responseFormat, tools, toolChoice, seed, providerOptions }) {
+		const warnings = [];
+		const openaiOptions = {
+			...await parseProviderOptions({
+				provider: "openai",
+				providerOptions,
+				schema: openaiCompletionProviderOptions
+			}),
+			...await parseProviderOptions({
+				provider: this.providerOptionsName,
+				providerOptions,
+				schema: openaiCompletionProviderOptions
+			})
+		};
+		if (topK != null) warnings.push({
+			type: "unsupported",
+			feature: "topK"
+		});
+		if (tools == null ? void 0 : tools.length) warnings.push({
+			type: "unsupported",
+			feature: "tools"
+		});
+		if (toolChoice != null) warnings.push({
+			type: "unsupported",
+			feature: "toolChoice"
+		});
+		if (responseFormat != null && responseFormat.type !== "text") warnings.push({
+			type: "unsupported",
+			feature: "responseFormat",
+			details: "JSON response format is not supported."
+		});
+		const { prompt: completionPrompt, stopSequences } = convertToOpenAICompletionPrompt({ prompt });
+		const stop = [...stopSequences != null ? stopSequences : [], ...userStopSequences != null ? userStopSequences : []];
+		return {
+			args: {
+				model: this.modelId,
+				echo: openaiOptions.echo,
+				logit_bias: openaiOptions.logitBias,
+				logprobs: (openaiOptions == null ? void 0 : openaiOptions.logprobs) === true ? 0 : (openaiOptions == null ? void 0 : openaiOptions.logprobs) === false ? void 0 : openaiOptions == null ? void 0 : openaiOptions.logprobs,
+				suffix: openaiOptions.suffix,
+				user: openaiOptions.user,
+				max_tokens: maxOutputTokens,
+				temperature,
+				top_p: topP,
+				frequency_penalty: frequencyPenalty,
+				presence_penalty: presencePenalty,
+				seed,
+				prompt: completionPrompt,
+				stop: stop.length > 0 ? stop : void 0
+			},
+			warnings
+		};
+	}
+	async doGenerate(options) {
+		var _a;
+		const { args, warnings } = await this.getArgs(options);
+		const { responseHeaders, value: response, rawValue: rawResponse } = await postJsonToApi({
+			url: this.config.url({
+				path: "/completions",
+				modelId: this.modelId
+			}),
+			headers: combineHeaders(this.config.headers(), options.headers),
+			body: args,
+			failedResponseHandler: openaiFailedResponseHandler,
+			successfulResponseHandler: createJsonResponseHandler(openaiCompletionResponseSchema),
+			abortSignal: options.abortSignal,
+			fetch: this.config.fetch
+		});
+		const choice = response.choices[0];
+		const providerMetadata = { openai: {} };
+		if (choice.logprobs != null) providerMetadata.openai.logprobs = choice.logprobs;
+		return {
+			content: [{
+				type: "text",
+				text: choice.text
+			}],
+			usage: convertOpenAICompletionUsage(response.usage),
+			finishReason: {
+				unified: mapOpenAIFinishReason2(choice.finish_reason),
+				raw: (_a = choice.finish_reason) != null ? _a : void 0
+			},
+			request: { body: args },
+			response: {
+				...getResponseMetadata2(response),
+				headers: responseHeaders,
+				body: rawResponse
+			},
+			providerMetadata,
+			warnings
+		};
+	}
+	async doStream(options) {
+		const { args, warnings } = await this.getArgs(options);
+		const body = {
+			...args,
+			stream: true,
+			stream_options: { include_usage: true }
+		};
+		const { responseHeaders, value: response } = await postJsonToApi({
+			url: this.config.url({
+				path: "/completions",
+				modelId: this.modelId
+			}),
+			headers: combineHeaders(this.config.headers(), options.headers),
+			body,
+			failedResponseHandler: openaiFailedResponseHandler,
+			successfulResponseHandler: createEventSourceResponseHandler(openaiCompletionChunkSchema),
+			abortSignal: options.abortSignal,
+			fetch: this.config.fetch
+		});
+		let finishReason = {
+			unified: "other",
+			raw: void 0
+		};
+		const providerMetadata = { openai: {} };
+		let usage = void 0;
+		let isFirstChunk = true;
+		return {
+			stream: response.pipeThrough(new TransformStream({
+				start(controller) {
+					controller.enqueue({
+						type: "stream-start",
+						warnings
+					});
+				},
+				transform(chunk, controller) {
+					if (options.includeRawChunks) controller.enqueue({
+						type: "raw",
+						rawValue: chunk.rawValue
+					});
+					if (!chunk.success) {
+						finishReason = {
+							unified: "error",
+							raw: void 0
+						};
+						controller.enqueue({
+							type: "error",
+							error: chunk.error
+						});
+						return;
+					}
+					const value = chunk.value;
+					if ("error" in value) {
+						finishReason = {
+							unified: "error",
+							raw: void 0
+						};
+						controller.enqueue({
+							type: "error",
+							error: value.error
+						});
+						return;
+					}
+					if (isFirstChunk) {
+						isFirstChunk = false;
+						controller.enqueue({
+							type: "response-metadata",
+							...getResponseMetadata2(value)
+						});
+						controller.enqueue({
+							type: "text-start",
+							id: "0"
+						});
+					}
+					if (value.usage != null) usage = value.usage;
+					const choice = value.choices[0];
+					if ((choice == null ? void 0 : choice.finish_reason) != null) finishReason = {
+						unified: mapOpenAIFinishReason2(choice.finish_reason),
+						raw: choice.finish_reason
+					};
+					if ((choice == null ? void 0 : choice.logprobs) != null) providerMetadata.openai.logprobs = choice.logprobs;
+					if ((choice == null ? void 0 : choice.text) != null && choice.text.length > 0) controller.enqueue({
+						type: "text-delta",
+						id: "0",
+						delta: choice.text
+					});
+				},
+				flush(controller) {
+					if (!isFirstChunk) controller.enqueue({
+						type: "text-end",
+						id: "0"
+					});
+					controller.enqueue({
+						type: "finish",
+						finishReason,
+						providerMetadata,
+						usage: convertOpenAICompletionUsage(usage)
+					});
+				}
+			})),
+			request: { body },
+			response: { headers: responseHeaders }
+		};
+	}
+};
+var openaiEmbeddingProviderOptions = lazySchema(() => zodSchema(object({
+	dimensions: number$1().optional(),
+	user: string().optional()
+})));
+var openaiTextEmbeddingResponseSchema = lazySchema(() => zodSchema(object({
+	data: array(object({ embedding: array(number$1()) })),
+	usage: object({ prompt_tokens: number$1() }).nullish()
+})));
+var OpenAIEmbeddingModel = class {
+	constructor(modelId, config) {
+		this.specificationVersion = "v3";
+		this.maxEmbeddingsPerCall = 2048;
+		this.supportsParallelCalls = true;
+		this.modelId = modelId;
+		this.config = config;
+	}
+	get provider() {
+		return this.config.provider;
+	}
+	async doEmbed({ values, headers, abortSignal, providerOptions }) {
+		var _a;
+		if (values.length > this.maxEmbeddingsPerCall) throw new TooManyEmbeddingValuesForCallError({
+			provider: this.provider,
+			modelId: this.modelId,
+			maxEmbeddingsPerCall: this.maxEmbeddingsPerCall,
+			values
+		});
+		const openaiOptions = (_a = await parseProviderOptions({
+			provider: "openai",
+			providerOptions,
+			schema: openaiEmbeddingProviderOptions
+		})) != null ? _a : {};
+		const { responseHeaders, value: response, rawValue } = await postJsonToApi({
+			url: this.config.url({
+				path: "/embeddings",
+				modelId: this.modelId
+			}),
+			headers: combineHeaders(this.config.headers(), headers),
+			body: {
+				model: this.modelId,
+				input: values,
+				encoding_format: "float",
+				dimensions: openaiOptions.dimensions,
+				user: openaiOptions.user
+			},
+			failedResponseHandler: openaiFailedResponseHandler,
+			successfulResponseHandler: createJsonResponseHandler(openaiTextEmbeddingResponseSchema),
+			abortSignal,
+			fetch: this.config.fetch
+		});
+		return {
+			warnings: [],
+			embeddings: response.data.map((item) => item.embedding),
+			usage: response.usage ? { tokens: response.usage.prompt_tokens } : void 0,
+			response: {
+				headers: responseHeaders,
+				body: rawValue
+			}
+		};
+	}
+};
+var openaiImageResponseSchema = lazySchema(() => zodSchema(object({
+	created: number$1().nullish(),
+	data: array(object({
+		b64_json: string(),
+		revised_prompt: string().nullish()
+	})),
+	background: string().nullish(),
+	output_format: string().nullish(),
+	size: string().nullish(),
+	quality: string().nullish(),
+	usage: object({
+		input_tokens: number$1().nullish(),
+		output_tokens: number$1().nullish(),
+		total_tokens: number$1().nullish(),
+		input_tokens_details: object({
+			image_tokens: number$1().nullish(),
+			text_tokens: number$1().nullish()
+		}).nullish()
+	}).nullish()
+})));
+var modelMaxImagesPerCall = {
+	"dall-e-3": 1,
+	"dall-e-2": 10,
+	"gpt-image-1": 10,
+	"gpt-image-1-mini": 10,
+	"gpt-image-1.5": 10
+};
+var defaultResponseFormatPrefixes = [
+	"gpt-image-1-mini",
+	"gpt-image-1.5",
+	"gpt-image-1"
+];
+function hasDefaultResponseFormat(modelId) {
+	return defaultResponseFormatPrefixes.some((prefix) => modelId.startsWith(prefix));
+}
+var OpenAIImageModel = class {
+	constructor(modelId, config) {
+		this.modelId = modelId;
+		this.config = config;
+		this.specificationVersion = "v3";
+	}
+	get maxImagesPerCall() {
+		var _a;
+		return (_a = modelMaxImagesPerCall[this.modelId]) != null ? _a : 1;
+	}
+	get provider() {
+		return this.config.provider;
+	}
+	async doGenerate({ prompt, files, mask, n, size, aspectRatio, seed, providerOptions, headers, abortSignal }) {
+		var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k;
+		const warnings = [];
+		if (aspectRatio != null) warnings.push({
+			type: "unsupported",
+			feature: "aspectRatio",
+			details: "This model does not support aspect ratio. Use `size` instead."
+		});
+		if (seed != null) warnings.push({
+			type: "unsupported",
+			feature: "seed"
+		});
+		const currentDate = (_c = (_b = (_a = this.config._internal) == null ? void 0 : _a.currentDate) == null ? void 0 : _b.call(_a)) != null ? _c : /* @__PURE__ */ new Date();
+		if (files != null) {
+			const { value: response2, responseHeaders: responseHeaders2 } = await postFormDataToApi({
+				url: this.config.url({
+					path: "/images/edits",
+					modelId: this.modelId
+				}),
+				headers: combineHeaders(this.config.headers(), headers),
+				formData: convertToFormData({
+					model: this.modelId,
+					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))),
+					mask: mask != null ? await fileToBlob(mask) : void 0,
+					n,
+					size,
+					...(_d = providerOptions.openai) != null ? _d : {}
+				}),
+				failedResponseHandler: openaiFailedResponseHandler,
+				successfulResponseHandler: createJsonResponseHandler(openaiImageResponseSchema),
+				abortSignal,
+				fetch: this.config.fetch
+			});
+			return {
+				images: response2.data.map((item) => item.b64_json),
+				warnings,
+				usage: response2.usage != null ? {
+					inputTokens: (_e = response2.usage.input_tokens) != null ? _e : void 0,
+					outputTokens: (_f = response2.usage.output_tokens) != null ? _f : void 0,
+					totalTokens: (_g = response2.usage.total_tokens) != null ? _g : void 0
+				} : void 0,
+				response: {
+					timestamp: currentDate,
+					modelId: this.modelId,
+					headers: responseHeaders2
+				},
+				providerMetadata: { openai: { images: response2.data.map((item) => {
+					var _a2, _b2, _c2, _d2, _e2;
+					return {
+						...item.revised_prompt ? { revisedPrompt: item.revised_prompt } : {},
+						created: (_a2 = response2.created) != null ? _a2 : void 0,
+						size: (_b2 = response2.size) != null ? _b2 : void 0,
+						quality: (_c2 = response2.quality) != null ? _c2 : void 0,
+						background: (_d2 = response2.background) != null ? _d2 : void 0,
+						outputFormat: (_e2 = response2.output_format) != null ? _e2 : void 0
+					};
+				}) } }
+			};
+		}
+		const { value: response, responseHeaders } = await postJsonToApi({
+			url: this.config.url({
+				path: "/images/generations",
+				modelId: this.modelId
+			}),
+			headers: combineHeaders(this.config.headers(), headers),
+			body: {
+				model: this.modelId,
+				prompt,
+				n,
+				size,
+				...(_h = providerOptions.openai) != null ? _h : {},
+				...!hasDefaultResponseFormat(this.modelId) ? { response_format: "b64_json" } : {}
+			},
+			failedResponseHandler: openaiFailedResponseHandler,
+			successfulResponseHandler: createJsonResponseHandler(openaiImageResponseSchema),
+			abortSignal,
+			fetch: this.config.fetch
+		});
+		return {
+			images: response.data.map((item) => item.b64_json),
+			warnings,
+			usage: response.usage != null ? {
+				inputTokens: (_i = response.usage.input_tokens) != null ? _i : void 0,
+				outputTokens: (_j = response.usage.output_tokens) != null ? _j : void 0,
+				totalTokens: (_k = response.usage.total_tokens) != null ? _k : void 0
+			} : void 0,
+			response: {
+				timestamp: currentDate,
+				modelId: this.modelId,
+				headers: responseHeaders
+			},
+			providerMetadata: { openai: { images: response.data.map((item) => {
+				var _a2, _b2, _c2, _d2, _e2;
+				return {
+					...item.revised_prompt ? { revisedPrompt: item.revised_prompt } : {},
+					created: (_a2 = response.created) != null ? _a2 : void 0,
+					size: (_b2 = response.size) != null ? _b2 : void 0,
+					quality: (_c2 = response.quality) != null ? _c2 : void 0,
+					background: (_d2 = response.background) != null ? _d2 : void 0,
+					outputFormat: (_e2 = response.output_format) != null ? _e2 : void 0
+				};
+			}) } }
+		};
+	}
+};
+async function fileToBlob(file) {
+	if (!file) return void 0;
+	if (file.type === "url") return downloadBlob(file.url);
+	const data = file.data instanceof Uint8Array ? file.data : convertBase64ToUint8Array(file.data);
+	return new Blob([data], { type: file.mediaType });
+}
+var applyPatchInputSchema = lazySchema(() => zodSchema(object({
+	callId: string(),
+	operation: discriminatedUnion("type", [
+		object({
+			type: literal("create_file"),
+			path: string(),
+			diff: string()
+		}),
+		object({
+			type: literal("delete_file"),
+			path: string()
+		}),
+		object({
+			type: literal("update_file"),
+			path: string(),
+			diff: string()
+		})
+	])
+})));
+var applyPatchOutputSchema = lazySchema(() => zodSchema(object({
+	status: _enum(["completed", "failed"]),
+	output: string().optional()
+})));
+lazySchema(() => zodSchema(object({})));
+var applyPatch = createProviderToolFactoryWithOutputSchema({
+	id: "openai.apply_patch",
+	inputSchema: applyPatchInputSchema,
+	outputSchema: applyPatchOutputSchema
+});
+var codeInterpreterInputSchema = lazySchema(() => zodSchema(object({
+	code: string().nullish(),
+	containerId: string()
+})));
+var codeInterpreterOutputSchema = lazySchema(() => zodSchema(object({ outputs: array(discriminatedUnion("type", [object({
+	type: literal("logs"),
+	logs: string()
+}), object({
+	type: literal("image"),
+	url: string()
+})])).nullish() })));
+var codeInterpreterArgsSchema = lazySchema(() => zodSchema(object({ container: union([string(), object({ fileIds: array(string()).optional() })]).optional() })));
+var codeInterpreterToolFactory = createProviderToolFactoryWithOutputSchema({
+	id: "openai.code_interpreter",
+	inputSchema: codeInterpreterInputSchema,
+	outputSchema: codeInterpreterOutputSchema
+});
+var codeInterpreter = (args = {}) => {
+	return codeInterpreterToolFactory(args);
+};
+var comparisonFilterSchema = object({
+	key: string(),
+	type: _enum([
+		"eq",
+		"ne",
+		"gt",
+		"gte",
+		"lt",
+		"lte",
+		"in",
+		"nin"
+	]),
+	value: union([
+		string(),
+		number$1(),
+		boolean(),
+		array(string())
+	])
+});
+var compoundFilterSchema = object({
+	type: _enum(["and", "or"]),
+	filters: array(union([comparisonFilterSchema, lazy(() => compoundFilterSchema)]))
+});
+var fileSearchArgsSchema = lazySchema(() => zodSchema(object({
+	vectorStoreIds: array(string()),
+	maxNumResults: number$1().optional(),
+	ranking: object({
+		ranker: string().optional(),
+		scoreThreshold: number$1().optional()
+	}).optional(),
+	filters: union([comparisonFilterSchema, compoundFilterSchema]).optional()
+})));
+var fileSearchOutputSchema = lazySchema(() => zodSchema(object({
+	queries: array(string()),
+	results: array(object({
+		attributes: record(string(), unknown()),
+		fileId: string(),
+		filename: string(),
+		score: number$1(),
+		text: string()
+	})).nullable()
+})));
+var fileSearch = createProviderToolFactoryWithOutputSchema({
+	id: "openai.file_search",
+	inputSchema: object({}),
+	outputSchema: fileSearchOutputSchema
+});
+var imageGenerationArgsSchema = lazySchema(() => zodSchema(object({
+	background: _enum([
+		"auto",
+		"opaque",
+		"transparent"
+	]).optional(),
+	inputFidelity: _enum(["low", "high"]).optional(),
+	inputImageMask: object({
+		fileId: string().optional(),
+		imageUrl: string().optional()
+	}).optional(),
+	model: string().optional(),
+	moderation: _enum(["auto"]).optional(),
+	outputCompression: number$1().int().min(0).max(100).optional(),
+	outputFormat: _enum([
+		"png",
+		"jpeg",
+		"webp"
+	]).optional(),
+	partialImages: number$1().int().min(0).max(3).optional(),
+	quality: _enum([
+		"auto",
+		"low",
+		"medium",
+		"high"
+	]).optional(),
+	size: _enum([
+		"1024x1024",
+		"1024x1536",
+		"1536x1024",
+		"auto"
+	]).optional()
+}).strict()));
+var imageGenerationToolFactory = createProviderToolFactoryWithOutputSchema({
+	id: "openai.image_generation",
+	inputSchema: lazySchema(() => zodSchema(object({}))),
+	outputSchema: lazySchema(() => zodSchema(object({ result: string() })))
+});
+var imageGeneration = (args = {}) => {
+	return imageGenerationToolFactory(args);
+};
+var localShellInputSchema = lazySchema(() => zodSchema(object({ action: object({
+	type: literal("exec"),
+	command: array(string()),
+	timeoutMs: number$1().optional(),
+	user: string().optional(),
+	workingDirectory: string().optional(),
+	env: record(string(), string()).optional()
+}) })));
+var localShellOutputSchema = lazySchema(() => zodSchema(object({ output: string() })));
+var localShell = createProviderToolFactoryWithOutputSchema({
+	id: "openai.local_shell",
+	inputSchema: localShellInputSchema,
+	outputSchema: localShellOutputSchema
+});
+var shellInputSchema = lazySchema(() => zodSchema(object({ action: object({
+	commands: array(string()),
+	timeoutMs: number$1().optional(),
+	maxOutputLength: number$1().optional()
+}) })));
+var shellOutputSchema = lazySchema(() => zodSchema(object({ output: array(object({
+	stdout: string(),
+	stderr: string(),
+	outcome: discriminatedUnion("type", [object({ type: literal("timeout") }), object({
+		type: literal("exit"),
+		exitCode: number$1()
+	})])
+})) })));
+var shell = createProviderToolFactoryWithOutputSchema({
+	id: "openai.shell",
+	inputSchema: shellInputSchema,
+	outputSchema: shellOutputSchema
+});
+var webSearchArgsSchema = lazySchema(() => zodSchema(object({
+	externalWebAccess: boolean().optional(),
+	filters: object({ allowedDomains: array(string()).optional() }).optional(),
+	searchContextSize: _enum([
+		"low",
+		"medium",
+		"high"
+	]).optional(),
+	userLocation: object({
+		type: literal("approximate"),
+		country: string().optional(),
+		city: string().optional(),
+		region: string().optional(),
+		timezone: string().optional()
+	}).optional()
+})));
+var webSearchToolFactory = createProviderToolFactoryWithOutputSchema({
+	id: "openai.web_search",
+	inputSchema: lazySchema(() => zodSchema(object({}))),
+	outputSchema: lazySchema(() => zodSchema(object({
+		action: discriminatedUnion("type", [
+			object({
+				type: literal("search"),
+				query: string().optional()
+			}),
+			object({
+				type: literal("openPage"),
+				url: string().nullish()
+			}),
+			object({
+				type: literal("findInPage"),
+				url: string().nullish(),
+				pattern: string().nullish()
+			})
+		]),
+		sources: array(discriminatedUnion("type", [object({
+			type: literal("url"),
+			url: string()
+		}), object({
+			type: literal("api"),
+			name: string()
+		})])).optional()
+	})))
+});
+var webSearch = (args = {}) => webSearchToolFactory(args);
+var webSearchPreviewArgsSchema = lazySchema(() => zodSchema(object({
+	searchContextSize: _enum([
+		"low",
+		"medium",
+		"high"
+	]).optional(),
+	userLocation: object({
+		type: literal("approximate"),
+		country: string().optional(),
+		city: string().optional(),
+		region: string().optional(),
+		timezone: string().optional()
+	}).optional()
+})));
+var webSearchPreview = createProviderToolFactoryWithOutputSchema({
+	id: "openai.web_search_preview",
+	inputSchema: lazySchema(() => zodSchema(object({}))),
+	outputSchema: lazySchema(() => zodSchema(object({ action: discriminatedUnion("type", [
+		object({
+			type: literal("search"),
+			query: string().optional()
+		}),
+		object({
+			type: literal("openPage"),
+			url: string().nullish()
+		}),
+		object({
+			type: literal("findInPage"),
+			url: string().nullish(),
+			pattern: string().nullish()
+		})
+	]) })))
+});
+var jsonValueSchema = lazy(() => union([
+	string(),
+	number$1(),
+	boolean(),
+	_null(),
+	array(jsonValueSchema),
+	record(string(), jsonValueSchema)
+]));
+var mcpArgsSchema = lazySchema(() => zodSchema(object({
+	serverLabel: string(),
+	allowedTools: union([array(string()), object({
+		readOnly: boolean().optional(),
+		toolNames: array(string()).optional()
+	})]).optional(),
+	authorization: string().optional(),
+	connectorId: string().optional(),
+	headers: record(string(), string()).optional(),
+	requireApproval: union([_enum(["always", "never"]), object({ never: object({ toolNames: array(string()).optional() }).optional() })]).optional(),
+	serverDescription: string().optional(),
+	serverUrl: string().optional()
+}).refine((v) => v.serverUrl != null || v.connectorId != null, "One of serverUrl or connectorId must be provided.")));
+var mcpToolFactory = createProviderToolFactoryWithOutputSchema({
+	id: "openai.mcp",
+	inputSchema: lazySchema(() => zodSchema(object({}))),
+	outputSchema: lazySchema(() => zodSchema(object({
+		type: literal("call"),
+		serverLabel: string(),
+		name: string(),
+		arguments: string(),
+		output: string().nullish(),
+		error: union([string(), jsonValueSchema]).optional()
+	})))
+});
+var mcp = (args) => mcpToolFactory(args);
+var openaiTools = {
+	applyPatch,
+	codeInterpreter,
+	fileSearch,
+	imageGeneration,
+	localShell,
+	shell,
+	webSearchPreview,
+	webSearch,
+	mcp
+};
+function convertOpenAIResponsesUsage(usage) {
+	var _a, _b, _c, _d;
+	if (usage == null) return {
+		inputTokens: {
+			total: void 0,
+			noCache: void 0,
+			cacheRead: void 0,
+			cacheWrite: void 0
+		},
+		outputTokens: {
+			total: void 0,
+			text: void 0,
+			reasoning: void 0
+		},
+		raw: void 0
+	};
+	const inputTokens = usage.input_tokens;
+	const outputTokens = usage.output_tokens;
+	const cachedTokens = (_b = (_a = usage.input_tokens_details) == null ? void 0 : _a.cached_tokens) != null ? _b : 0;
+	const reasoningTokens = (_d = (_c = usage.output_tokens_details) == null ? void 0 : _c.reasoning_tokens) != null ? _d : 0;
+	return {
+		inputTokens: {
+			total: inputTokens,
+			noCache: inputTokens - cachedTokens,
+			cacheRead: cachedTokens,
+			cacheWrite: void 0
+		},
+		outputTokens: {
+			total: outputTokens,
+			text: outputTokens - reasoningTokens,
+			reasoning: reasoningTokens
+		},
+		raw: usage
+	};
+}
+function isFileId(data, prefixes) {
+	if (!prefixes) return false;
+	return prefixes.some((prefix) => data.startsWith(prefix));
+}
+async function convertToOpenAIResponsesInput({ prompt, toolNameMapping, systemMessageMode, providerOptionsName, fileIdPrefixes, store, hasConversation = false, hasLocalShellTool = false, hasShellTool = false, hasApplyPatchTool = false }) {
+	var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m;
+	const input = [];
+	const warnings = [];
+	const processedApprovalIds = /* @__PURE__ */ new Set();
+	for (const { role, content } of prompt) switch (role) {
+		case "system":
+			switch (systemMessageMode) {
+				case "system":
+					input.push({
+						role: "system",
+						content
+					});
+					break;
+				case "developer":
+					input.push({
+						role: "developer",
+						content
+					});
+					break;
+				case "remove":
+					warnings.push({
+						type: "other",
+						message: "system messages are removed for this model"
+					});
+					break;
+				default: {
+					const _exhaustiveCheck = systemMessageMode;
+					throw new Error(`Unsupported system message mode: ${_exhaustiveCheck}`);
+				}
+			}
+			break;
+		case "user":
+			input.push({
+				role: "user",
+				content: content.map((part, index) => {
+					var _a2, _b2, _c2;
+					switch (part.type) {
+						case "text": return {
+							type: "input_text",
+							text: part.text
+						};
+						case "file": if (part.mediaType.startsWith("image/")) {
+							const mediaType = part.mediaType === "image/*" ? "image/jpeg" : part.mediaType;
+							return {
+								type: "input_image",
+								...part.data instanceof URL ? { image_url: part.data.toString() } : typeof part.data === "string" && isFileId(part.data, fileIdPrefixes) ? { file_id: part.data } : { image_url: `data:${mediaType};base64,${convertToBase64(part.data)}` },
+								detail: (_b2 = (_a2 = part.providerOptions) == null ? void 0 : _a2[providerOptionsName]) == null ? void 0 : _b2.imageDetail
+							};
+						} else if (part.mediaType === "application/pdf") {
+							if (part.data instanceof URL) return {
+								type: "input_file",
+								file_url: part.data.toString()
+							};
+							return {
+								type: "input_file",
+								...typeof part.data === "string" && isFileId(part.data, fileIdPrefixes) ? { file_id: part.data } : {
+									filename: (_c2 = part.filename) != null ? _c2 : `part-${index}.pdf`,
+									file_data: `data:application/pdf;base64,${convertToBase64(part.data)}`
+								}
+							};
+						} else throw new UnsupportedFunctionalityError({ functionality: `file part media type ${part.mediaType}` });
+					}
+				})
+			});
+			break;
+		case "assistant": {
+			const reasoningMessages = {};
+			for (const part of content) switch (part.type) {
+				case "text": {
+					const id = (_b = (_a = part.providerOptions) == null ? void 0 : _a[providerOptionsName]) == null ? void 0 : _b.itemId;
+					if (hasConversation && id != null) break;
+					if (store && id != null) {
+						input.push({
+							type: "item_reference",
+							id
+						});
+						break;
+					}
+					input.push({
+						role: "assistant",
+						content: [{
+							type: "output_text",
+							text: part.text
+						}],
+						id
+					});
+					break;
+				}
+				case "tool-call": {
+					const id = (_g = (_d = (_c = part.providerOptions) == null ? void 0 : _c[providerOptionsName]) == null ? void 0 : _d.itemId) != null ? _g : (_f = (_e = part.providerMetadata) == null ? void 0 : _e[providerOptionsName]) == null ? void 0 : _f.itemId;
+					if (hasConversation && id != null) break;
+					if (part.providerExecuted) {
+						if (store && id != null) input.push({
+							type: "item_reference",
+							id
+						});
+						break;
+					}
+					if (store && id != null) {
+						input.push({
+							type: "item_reference",
+							id
+						});
+						break;
+					}
+					const resolvedToolName = toolNameMapping.toProviderToolName(part.toolName);
+					if (hasLocalShellTool && resolvedToolName === "local_shell") {
+						const parsedInput = await validateTypes({
+							value: part.input,
+							schema: localShellInputSchema
+						});
+						input.push({
+							type: "local_shell_call",
+							call_id: part.toolCallId,
+							id,
+							action: {
+								type: "exec",
+								command: parsedInput.action.command,
+								timeout_ms: parsedInput.action.timeoutMs,
+								user: parsedInput.action.user,
+								working_directory: parsedInput.action.workingDirectory,
+								env: parsedInput.action.env
+							}
+						});
+						break;
+					}
+					if (hasShellTool && resolvedToolName === "shell") {
+						const parsedInput = await validateTypes({
+							value: part.input,
+							schema: shellInputSchema
+						});
+						input.push({
+							type: "shell_call",
+							call_id: part.toolCallId,
+							id,
+							status: "completed",
+							action: {
+								commands: parsedInput.action.commands,
+								timeout_ms: parsedInput.action.timeoutMs,
+								max_output_length: parsedInput.action.maxOutputLength
+							}
+						});
+						break;
+					}
+					if (hasApplyPatchTool && resolvedToolName === "apply_patch") {
+						const parsedInput = await validateTypes({
+							value: part.input,
+							schema: applyPatchInputSchema
+						});
+						input.push({
+							type: "apply_patch_call",
+							call_id: parsedInput.callId,
+							id,
+							status: "completed",
+							operation: parsedInput.operation
+						});
+						break;
+					}
+					input.push({
+						type: "function_call",
+						call_id: part.toolCallId,
+						name: resolvedToolName,
+						arguments: JSON.stringify(part.input),
+						id
+					});
+					break;
+				}
+				case "tool-result":
+					if (part.output.type === "execution-denied" || part.output.type === "json" && typeof part.output.value === "object" && part.output.value != null && "type" in part.output.value && part.output.value.type === "execution-denied") break;
+					if (hasConversation) break;
+					if (store) {
+						const itemId = (_j = (_i = (_h = part.providerMetadata) == null ? void 0 : _h[providerOptionsName]) == null ? void 0 : _i.itemId) != null ? _j : part.toolCallId;
+						input.push({
+							type: "item_reference",
+							id: itemId
+						});
+					} else warnings.push({
+						type: "other",
+						message: `Results for OpenAI tool ${part.toolName} are not sent to the API when store is false`
+					});
+					break;
+				case "reasoning": {
+					const providerOptions = await parseProviderOptions({
+						provider: providerOptionsName,
+						providerOptions: part.providerOptions,
+						schema: openaiResponsesReasoningProviderOptionsSchema
+					});
+					const reasoningId = providerOptions == null ? void 0 : providerOptions.itemId;
+					if (hasConversation && reasoningId != null) break;
+					if (reasoningId != null) {
+						const reasoningMessage = reasoningMessages[reasoningId];
+						if (store) {
+							if (reasoningMessage === void 0) {
+								input.push({
+									type: "item_reference",
+									id: reasoningId
+								});
+								reasoningMessages[reasoningId] = {
+									type: "reasoning",
+									id: reasoningId,
+									summary: []
+								};
+							}
+						} else {
+							const summaryParts = [];
+							if (part.text.length > 0) summaryParts.push({
+								type: "summary_text",
+								text: part.text
+							});
+							else if (reasoningMessage !== void 0) warnings.push({
+								type: "other",
+								message: `Cannot append empty reasoning part to existing reasoning sequence. Skipping reasoning part: ${JSON.stringify(part)}.`
+							});
+							if (reasoningMessage === void 0) {
+								reasoningMessages[reasoningId] = {
+									type: "reasoning",
+									id: reasoningId,
+									encrypted_content: providerOptions == null ? void 0 : providerOptions.reasoningEncryptedContent,
+									summary: summaryParts
+								};
+								input.push(reasoningMessages[reasoningId]);
+							} else {
+								reasoningMessage.summary.push(...summaryParts);
+								if ((providerOptions == null ? void 0 : providerOptions.reasoningEncryptedContent) != null) reasoningMessage.encrypted_content = providerOptions.reasoningEncryptedContent;
+							}
+						}
+					} else warnings.push({
+						type: "other",
+						message: `Non-OpenAI reasoning parts are not supported. Skipping reasoning part: ${JSON.stringify(part)}.`
+					});
+					break;
+				}
+			}
+			break;
+		}
+		case "tool":
+			for (const part of content) {
+				if (part.type === "tool-approval-response") {
+					const approvalResponse = part;
+					if (processedApprovalIds.has(approvalResponse.approvalId)) continue;
+					processedApprovalIds.add(approvalResponse.approvalId);
+					if (store) input.push({
+						type: "item_reference",
+						id: approvalResponse.approvalId
+					});
+					input.push({
+						type: "mcp_approval_response",
+						approval_request_id: approvalResponse.approvalId,
+						approve: approvalResponse.approved
+					});
+					continue;
+				}
+				const output = part.output;
+				if (output.type === "execution-denied") {
+					if ((_l = (_k = output.providerOptions) == null ? void 0 : _k.openai) == null ? void 0 : _l.approvalId) continue;
+				}
+				const resolvedToolName = toolNameMapping.toProviderToolName(part.toolName);
+				if (hasLocalShellTool && resolvedToolName === "local_shell" && output.type === "json") {
+					const parsedOutput = await validateTypes({
+						value: output.value,
+						schema: localShellOutputSchema
+					});
+					input.push({
+						type: "local_shell_call_output",
+						call_id: part.toolCallId,
+						output: parsedOutput.output
+					});
+					continue;
+				}
+				if (hasShellTool && resolvedToolName === "shell" && output.type === "json") {
+					const parsedOutput = await validateTypes({
+						value: output.value,
+						schema: shellOutputSchema
+					});
+					input.push({
+						type: "shell_call_output",
+						call_id: part.toolCallId,
+						output: parsedOutput.output.map((item) => ({
+							stdout: item.stdout,
+							stderr: item.stderr,
+							outcome: item.outcome.type === "timeout" ? { type: "timeout" } : {
+								type: "exit",
+								exit_code: item.outcome.exitCode
+							}
+						}))
+					});
+					continue;
+				}
+				if (hasApplyPatchTool && part.toolName === "apply_patch" && output.type === "json") {
+					const parsedOutput = await validateTypes({
+						value: output.value,
+						schema: applyPatchOutputSchema
+					});
+					input.push({
+						type: "apply_patch_call_output",
+						call_id: part.toolCallId,
+						status: parsedOutput.status,
+						output: parsedOutput.output
+					});
+					continue;
+				}
+				let contentValue;
+				switch (output.type) {
+					case "text":
+					case "error-text":
+						contentValue = output.value;
+						break;
+					case "execution-denied":
+						contentValue = (_m = output.reason) != null ? _m : "Tool execution denied.";
+						break;
+					case "json":
+					case "error-json":
+						contentValue = JSON.stringify(output.value);
+						break;
+					case "content":
+						contentValue = output.value.map((item) => {
+							var _a2;
+							switch (item.type) {
+								case "text": return {
+									type: "input_text",
+									text: item.text
+								};
+								case "image-data": return {
+									type: "input_image",
+									image_url: `data:${item.mediaType};base64,${item.data}`
+								};
+								case "image-url": return {
+									type: "input_image",
+									image_url: item.url
+								};
+								case "file-data": return {
+									type: "input_file",
+									filename: (_a2 = item.filename) != null ? _a2 : "data",
+									file_data: `data:${item.mediaType};base64,${item.data}`
+								};
+								default:
+									warnings.push({
+										type: "other",
+										message: `unsupported tool content part type: ${item.type}`
+									});
+									return;
+							}
+						}).filter(isNonNullable);
+						break;
+				}
+				input.push({
+					type: "function_call_output",
+					call_id: part.toolCallId,
+					output: contentValue
+				});
+			}
+			break;
+		default: {
+			const _exhaustiveCheck = role;
+			throw new Error(`Unsupported role: ${_exhaustiveCheck}`);
+		}
+	}
+	return {
+		input,
+		warnings
+	};
+}
+var openaiResponsesReasoningProviderOptionsSchema = object({
+	itemId: string().nullish(),
+	reasoningEncryptedContent: string().nullish()
+});
+function mapOpenAIResponseFinishReason({ finishReason, hasFunctionCall }) {
+	switch (finishReason) {
+		case void 0:
+		case null: return hasFunctionCall ? "tool-calls" : "stop";
+		case "max_output_tokens": return "length";
+		case "content_filter": return "content-filter";
+		default: return hasFunctionCall ? "tool-calls" : "other";
+	}
+}
+var openaiResponsesChunkSchema = lazySchema(() => zodSchema(union([
+	object({
+		type: literal("response.output_text.delta"),
+		item_id: string(),
+		delta: string(),
+		logprobs: array(object({
+			token: string(),
+			logprob: number$1(),
+			top_logprobs: array(object({
+				token: string(),
+				logprob: number$1()
+			}))
+		})).nullish()
+	}),
+	object({
+		type: _enum(["response.completed", "response.incomplete"]),
+		response: object({
+			incomplete_details: object({ reason: string() }).nullish(),
+			usage: object({
+				input_tokens: number$1(),
+				input_tokens_details: object({ cached_tokens: number$1().nullish() }).nullish(),
+				output_tokens: number$1(),
+				output_tokens_details: object({ reasoning_tokens: number$1().nullish() }).nullish()
+			}),
+			service_tier: string().nullish()
+		})
+	}),
+	object({
+		type: literal("response.created"),
+		response: object({
+			id: string(),
+			created_at: number$1(),
+			model: string(),
+			service_tier: string().nullish()
+		})
+	}),
+	object({
+		type: literal("response.output_item.added"),
+		output_index: number$1(),
+		item: discriminatedUnion("type", [
+			object({
+				type: literal("message"),
+				id: string()
+			}),
+			object({
+				type: literal("reasoning"),
+				id: string(),
+				encrypted_content: string().nullish()
+			}),
+			object({
+				type: literal("function_call"),
+				id: string(),
+				call_id: string(),
+				name: string(),
+				arguments: string()
+			}),
+			object({
+				type: literal("web_search_call"),
+				id: string(),
+				status: string()
+			}),
+			object({
+				type: literal("computer_call"),
+				id: string(),
+				status: string()
+			}),
+			object({
+				type: literal("file_search_call"),
+				id: string()
+			}),
+			object({
+				type: literal("image_generation_call"),
+				id: string()
+			}),
+			object({
+				type: literal("code_interpreter_call"),
+				id: string(),
+				container_id: string(),
+				code: string().nullable(),
+				outputs: array(discriminatedUnion("type", [object({
+					type: literal("logs"),
+					logs: string()
+				}), object({
+					type: literal("image"),
+					url: string()
+				})])).nullable(),
+				status: string()
+			}),
+			object({
+				type: literal("mcp_call"),
+				id: string(),
+				status: string(),
+				approval_request_id: string().nullish()
+			}),
+			object({
+				type: literal("mcp_list_tools"),
+				id: string()
+			}),
+			object({
+				type: literal("mcp_approval_request"),
+				id: string()
+			}),
+			object({
+				type: literal("apply_patch_call"),
+				id: string(),
+				call_id: string(),
+				status: _enum(["in_progress", "completed"]),
+				operation: discriminatedUnion("type", [
+					object({
+						type: literal("create_file"),
+						path: string(),
+						diff: string()
+					}),
+					object({
+						type: literal("delete_file"),
+						path: string()
+					}),
+					object({
+						type: literal("update_file"),
+						path: string(),
+						diff: string()
+					})
+				])
+			}),
+			object({
+				type: literal("shell_call"),
+				id: string(),
+				call_id: string(),
+				status: _enum([
+					"in_progress",
+					"completed",
+					"incomplete"
+				]),
+				action: object({ commands: array(string()) })
+			})
+		])
+	}),
+	object({
+		type: literal("response.output_item.done"),
+		output_index: number$1(),
+		item: discriminatedUnion("type", [
+			object({
+				type: literal("message"),
+				id: string()
+			}),
+			object({
+				type: literal("reasoning"),
+				id: string(),
+				encrypted_content: string().nullish()
+			}),
+			object({
+				type: literal("function_call"),
+				id: string(),
+				call_id: string(),
+				name: string(),
+				arguments: string(),
+				status: literal("completed")
+			}),
+			object({
+				type: literal("code_interpreter_call"),
+				id: string(),
+				code: string().nullable(),
+				container_id: string(),
+				outputs: array(discriminatedUnion("type", [object({
+					type: literal("logs"),
+					logs: string()
+				}), object({
+					type: literal("image"),
+					url: string()
+				})])).nullable()
+			}),
+			object({
+				type: literal("image_generation_call"),
+				id: string(),
+				result: string()
+			}),
+			object({
+				type: literal("web_search_call"),
+				id: string(),
+				status: string(),
+				action: discriminatedUnion("type", [
+					object({
+						type: literal("search"),
+						query: string().nullish(),
+						sources: array(discriminatedUnion("type", [object({
+							type: literal("url"),
+							url: string()
+						}), object({
+							type: literal("api"),
+							name: string()
+						})])).nullish()
+					}),
+					object({
+						type: literal("open_page"),
+						url: string().nullish()
+					}),
+					object({
+						type: literal("find_in_page"),
+						url: string().nullish(),
+						pattern: string().nullish()
+					})
+				])
+			}),
+			object({
+				type: literal("file_search_call"),
+				id: string(),
+				queries: array(string()),
+				results: array(object({
+					attributes: record(string(), union([
+						string(),
+						number$1(),
+						boolean()
+					])),
+					file_id: string(),
+					filename: string(),
+					score: number$1(),
+					text: string()
+				})).nullish()
+			}),
+			object({
+				type: literal("local_shell_call"),
+				id: string(),
+				call_id: string(),
+				action: object({
+					type: literal("exec"),
+					command: array(string()),
+					timeout_ms: number$1().optional(),
+					user: string().optional(),
+					working_directory: string().optional(),
+					env: record(string(), string()).optional()
+				})
+			}),
+			object({
+				type: literal("computer_call"),
+				id: string(),
+				status: literal("completed")
+			}),
+			object({
+				type: literal("mcp_call"),
+				id: string(),
+				status: string(),
+				arguments: string(),
+				name: string(),
+				server_label: string(),
+				output: string().nullish(),
+				error: union([string(), object({
+					type: string().optional(),
+					code: union([number$1(), string()]).optional(),
+					message: string().optional()
+				}).loose()]).nullish(),
+				approval_request_id: string().nullish()
+			}),
+			object({
+				type: literal("mcp_list_tools"),
+				id: string(),
+				server_label: string(),
+				tools: array(object({
+					name: string(),
+					description: string().optional(),
+					input_schema: any(),
+					annotations: record(string(), unknown()).optional()
+				})),
+				error: union([string(), object({
+					type: string().optional(),
+					code: union([number$1(), string()]).optional(),
+					message: string().optional()
+				}).loose()]).optional()
+			}),
+			object({
+				type: literal("mcp_approval_request"),
+				id: string(),
+				server_label: string(),
+				name: string(),
+				arguments: string(),
+				approval_request_id: string().optional()
+			}),
+			object({
+				type: literal("apply_patch_call"),
+				id: string(),
+				call_id: string(),
+				status: _enum(["in_progress", "completed"]),
+				operation: discriminatedUnion("type", [
+					object({
+						type: literal("create_file"),
+						path: string(),
+						diff: string()
+					}),
+					object({
+						type: literal("delete_file"),
+						path: string()
+					}),
+					object({
+						type: literal("update_file"),
+						path: string(),
+						diff: string()
+					})
+				])
+			}),
+			object({
+				type: literal("shell_call"),
+				id: string(),
+				call_id: string(),
+				status: _enum([
+					"in_progress",
+					"completed",
+					"incomplete"
+				]),
+				action: object({ commands: array(string()) })
+			})
+		])
+	}),
+	object({
+		type: literal("response.function_call_arguments.delta"),
+		item_id: string(),
+		output_index: number$1(),
+		delta: string()
+	}),
+	object({
+		type: literal("response.image_generation_call.partial_image"),
+		item_id: string(),
+		output_index: number$1(),
+		partial_image_b64: string()
+	}),
+	object({
+		type: literal("response.code_interpreter_call_code.delta"),
+		item_id: string(),
+		output_index: number$1(),
+		delta: string()
+	}),
+	object({
+		type: literal("response.code_interpreter_call_code.done"),
+		item_id: string(),
+		output_index: number$1(),
+		code: string()
+	}),
+	object({
+		type: literal("response.output_text.annotation.added"),
+		annotation: discriminatedUnion("type", [
+			object({
+				type: literal("url_citation"),
+				start_index: number$1(),
+				end_index: number$1(),
+				url: string(),
+				title: string()
+			}),
+			object({
+				type: literal("file_citation"),
+				file_id: string(),
+				filename: string(),
+				index: number$1()
+			}),
+			object({
+				type: literal("container_file_citation"),
+				container_id: string(),
+				file_id: string(),
+				filename: string(),
+				start_index: number$1(),
+				end_index: number$1()
+			}),
+			object({
+				type: literal("file_path"),
+				file_id: string(),
+				index: number$1()
+			})
+		])
+	}),
+	object({
+		type: literal("response.reasoning_summary_part.added"),
+		item_id: string(),
+		summary_index: number$1()
+	}),
+	object({
+		type: literal("response.reasoning_summary_text.delta"),
+		item_id: string(),
+		summary_index: number$1(),
+		delta: string()
+	}),
+	object({
+		type: literal("response.reasoning_summary_part.done"),
+		item_id: string(),
+		summary_index: number$1()
+	}),
+	object({
+		type: literal("response.apply_patch_call_operation_diff.delta"),
+		item_id: string(),
+		output_index: number$1(),
+		delta: string(),
+		obfuscation: string().nullish()
+	}),
+	object({
+		type: literal("response.apply_patch_call_operation_diff.done"),
+		item_id: string(),
+		output_index: number$1(),
+		diff: string()
+	}),
+	object({
+		type: literal("error"),
+		sequence_number: number$1(),
+		error: object({
+			type: string(),
+			code: string(),
+			message: string(),
+			param: string().nullish()
+		})
+	}),
+	object({ type: string() }).loose().transform((value) => ({
+		type: "unknown_chunk",
+		message: value.type
+	}))
+])));
+var openaiResponsesResponseSchema = lazySchema(() => zodSchema(object({
+	id: string().optional(),
+	created_at: number$1().optional(),
+	error: object({
+		message: string(),
+		type: string(),
+		param: string().nullish(),
+		code: string()
+	}).nullish(),
+	model: string().optional(),
+	output: array(discriminatedUnion("type", [
+		object({
+			type: literal("message"),
+			role: literal("assistant"),
+			id: string(),
+			content: array(object({
+				type: literal("output_text"),
+				text: string(),
+				logprobs: array(object({
+					token: string(),
+					logprob: number$1(),
+					top_logprobs: array(object({
+						token: string(),
+						logprob: number$1()
+					}))
+				})).nullish(),
+				annotations: array(discriminatedUnion("type", [
+					object({
+						type: literal("url_citation"),
+						start_index: number$1(),
+						end_index: number$1(),
+						url: string(),
+						title: string()
+					}),
+					object({
+						type: literal("file_citation"),
+						file_id: string(),
+						filename: string(),
+						index: number$1()
+					}),
+					object({
+						type: literal("container_file_citation"),
+						container_id: string(),
+						file_id: string(),
+						filename: string(),
+						start_index: number$1(),
+						end_index: number$1()
+					}),
+					object({
+						type: literal("file_path"),
+						file_id: string(),
+						index: number$1()
+					})
+				]))
+			}))
+		}),
+		object({
+			type: literal("web_search_call"),
+			id: string(),
+			status: string(),
+			action: discriminatedUnion("type", [
+				object({
+					type: literal("search"),
+					query: string().nullish(),
+					sources: array(discriminatedUnion("type", [object({
+						type: literal("url"),
+						url: string()
+					}), object({
+						type: literal("api"),
+						name: string()
+					})])).nullish()
+				}),
+				object({
+					type: literal("open_page"),
+					url: string().nullish()
+				}),
+				object({
+					type: literal("find_in_page"),
+					url: string().nullish(),
+					pattern: string().nullish()
+				})
+			])
+		}),
+		object({
+			type: literal("file_search_call"),
+			id: string(),
+			queries: array(string()),
+			results: array(object({
+				attributes: record(string(), union([
+					string(),
+					number$1(),
+					boolean()
+				])),
+				file_id: string(),
+				filename: string(),
+				score: number$1(),
+				text: string()
+			})).nullish()
+		}),
+		object({
+			type: literal("code_interpreter_call"),
+			id: string(),
+			code: string().nullable(),
+			container_id: string(),
+			outputs: array(discriminatedUnion("type", [object({
+				type: literal("logs"),
+				logs: string()
+			}), object({
+				type: literal("image"),
+				url: string()
+			})])).nullable()
+		}),
+		object({
+			type: literal("image_generation_call"),
+			id: string(),
+			result: string()
+		}),
+		object({
+			type: literal("local_shell_call"),
+			id: string(),
+			call_id: string(),
+			action: object({
+				type: literal("exec"),
+				command: array(string()),
+				timeout_ms: number$1().optional(),
+				user: string().optional(),
+				working_directory: string().optional(),
+				env: record(string(), string()).optional()
+			})
+		}),
+		object({
+			type: literal("function_call"),
+			call_id: string(),
+			name: string(),
+			arguments: string(),
+			id: string()
+		}),
+		object({
+			type: literal("computer_call"),
+			id: string(),
+			status: string().optional()
+		}),
+		object({
+			type: literal("reasoning"),
+			id: string(),
+			encrypted_content: string().nullish(),
+			summary: array(object({
+				type: literal("summary_text"),
+				text: string()
+			}))
+		}),
+		object({
+			type: literal("mcp_call"),
+			id: string(),
+			status: string(),
+			arguments: string(),
+			name: string(),
+			server_label: string(),
+			output: string().nullish(),
+			error: union([string(), object({
+				type: string().optional(),
+				code: union([number$1(), string()]).optional(),
+				message: string().optional()
+			}).loose()]).nullish(),
+			approval_request_id: string().nullish()
+		}),
+		object({
+			type: literal("mcp_list_tools"),
+			id: string(),
+			server_label: string(),
+			tools: array(object({
+				name: string(),
+				description: string().optional(),
+				input_schema: any(),
+				annotations: record(string(), unknown()).optional()
+			})),
+			error: union([string(), object({
+				type: string().optional(),
+				code: union([number$1(), string()]).optional(),
+				message: string().optional()
+			}).loose()]).optional()
+		}),
+		object({
+			type: literal("mcp_approval_request"),
+			id: string(),
+			server_label: string(),
+			name: string(),
+			arguments: string(),
+			approval_request_id: string().optional()
+		}),
+		object({
+			type: literal("apply_patch_call"),
+			id: string(),
+			call_id: string(),
+			status: _enum(["in_progress", "completed"]),
+			operation: discriminatedUnion("type", [
+				object({
+					type: literal("create_file"),
+					path: string(),
+					diff: string()
+				}),
+				object({
+					type: literal("delete_file"),
+					path: string()
+				}),
+				object({
+					type: literal("update_file"),
+					path: string(),
+					diff: string()
+				})
+			])
+		}),
+		object({
+			type: literal("shell_call"),
+			id: string(),
+			call_id: string(),
+			status: _enum([
+				"in_progress",
+				"completed",
+				"incomplete"
+			]),
+			action: object({ commands: array(string()) })
+		})
+	])).optional(),
+	service_tier: string().nullish(),
+	incomplete_details: object({ reason: string() }).nullish(),
+	usage: object({
+		input_tokens: number$1(),
+		input_tokens_details: object({ cached_tokens: number$1().nullish() }).nullish(),
+		output_tokens: number$1(),
+		output_tokens_details: object({ reasoning_tokens: number$1().nullish() }).nullish()
+	}).optional()
+})));
+var TOP_LOGPROBS_MAX = 20;
+var openaiResponsesProviderOptionsSchema = lazySchema(() => zodSchema(object({
+	conversation: string().nullish(),
+	include: array(_enum([
+		"reasoning.encrypted_content",
+		"file_search_call.results",
+		"message.output_text.logprobs"
+	])).nullish(),
+	instructions: string().nullish(),
+	logprobs: union([boolean(), number$1().min(1).max(TOP_LOGPROBS_MAX)]).optional(),
+	maxToolCalls: number$1().nullish(),
+	metadata: any().nullish(),
+	parallelToolCalls: boolean().nullish(),
+	previousResponseId: string().nullish(),
+	promptCacheKey: string().nullish(),
+	promptCacheRetention: _enum(["in_memory", "24h"]).nullish(),
+	reasoningEffort: string().nullish(),
+	reasoningSummary: string().nullish(),
+	safetyIdentifier: string().nullish(),
+	serviceTier: _enum([
+		"auto",
+		"flex",
+		"priority",
+		"default"
+	]).nullish(),
+	store: boolean().nullish(),
+	strictJsonSchema: boolean().nullish(),
+	textVerbosity: _enum([
+		"low",
+		"medium",
+		"high"
+	]).nullish(),
+	truncation: _enum(["auto", "disabled"]).nullish(),
+	user: string().nullish(),
+	systemMessageMode: _enum([
+		"system",
+		"developer",
+		"remove"
+	]).optional(),
+	forceReasoning: boolean().optional()
+})));
+async function prepareResponsesTools({ tools, toolChoice }) {
+	tools = (tools == null ? void 0 : tools.length) ? tools : void 0;
+	const toolWarnings = [];
+	if (tools == null) return {
+		tools: void 0,
+		toolChoice: void 0,
+		toolWarnings
+	};
+	const openaiTools2 = [];
+	for (const tool of tools) switch (tool.type) {
+		case "function":
+			openaiTools2.push({
+				type: "function",
+				name: tool.name,
+				description: tool.description,
+				parameters: tool.inputSchema,
+				...tool.strict != null ? { strict: tool.strict } : {}
+			});
+			break;
+		case "provider":
+			switch (tool.id) {
+				case "openai.file_search": {
+					const args = await validateTypes({
+						value: tool.args,
+						schema: fileSearchArgsSchema
+					});
+					openaiTools2.push({
+						type: "file_search",
+						vector_store_ids: args.vectorStoreIds,
+						max_num_results: args.maxNumResults,
+						ranking_options: args.ranking ? {
+							ranker: args.ranking.ranker,
+							score_threshold: args.ranking.scoreThreshold
+						} : void 0,
+						filters: args.filters
+					});
+					break;
+				}
+				case "openai.local_shell":
+					openaiTools2.push({ type: "local_shell" });
+					break;
+				case "openai.shell":
+					openaiTools2.push({ type: "shell" });
+					break;
+				case "openai.apply_patch":
+					openaiTools2.push({ type: "apply_patch" });
+					break;
+				case "openai.web_search_preview": {
+					const args = await validateTypes({
+						value: tool.args,
+						schema: webSearchPreviewArgsSchema
+					});
+					openaiTools2.push({
+						type: "web_search_preview",
+						search_context_size: args.searchContextSize,
+						user_location: args.userLocation
+					});
+					break;
+				}
+				case "openai.web_search": {
+					const args = await validateTypes({
+						value: tool.args,
+						schema: webSearchArgsSchema
+					});
+					openaiTools2.push({
+						type: "web_search",
+						filters: args.filters != null ? { allowed_domains: args.filters.allowedDomains } : void 0,
+						external_web_access: args.externalWebAccess,
+						search_context_size: args.searchContextSize,
+						user_location: args.userLocation
+					});
+					break;
+				}
+				case "openai.code_interpreter": {
+					const args = await validateTypes({
+						value: tool.args,
+						schema: codeInterpreterArgsSchema
+					});
+					openaiTools2.push({
+						type: "code_interpreter",
+						container: args.container == null ? {
+							type: "auto",
+							file_ids: void 0
+						} : typeof args.container === "string" ? args.container : {
+							type: "auto",
+							file_ids: args.container.fileIds
+						}
+					});
+					break;
+				}
+				case "openai.image_generation": {
+					const args = await validateTypes({
+						value: tool.args,
+						schema: imageGenerationArgsSchema
+					});
+					openaiTools2.push({
+						type: "image_generation",
+						background: args.background,
+						input_fidelity: args.inputFidelity,
+						input_image_mask: args.inputImageMask ? {
+							file_id: args.inputImageMask.fileId,
+							image_url: args.inputImageMask.imageUrl
+						} : void 0,
+						model: args.model,
+						moderation: args.moderation,
+						partial_images: args.partialImages,
+						quality: args.quality,
+						output_compression: args.outputCompression,
+						output_format: args.outputFormat,
+						size: args.size
+					});
+					break;
+				}
+				case "openai.mcp": {
+					const args = await validateTypes({
+						value: tool.args,
+						schema: mcpArgsSchema
+					});
+					const mapApprovalFilter = (filter) => ({ tool_names: filter.toolNames });
+					const requireApproval = args.requireApproval;
+					const requireApprovalParam = requireApproval == null ? void 0 : typeof requireApproval === "string" ? requireApproval : requireApproval.never != null ? { never: mapApprovalFilter(requireApproval.never) } : void 0;
+					openaiTools2.push({
+						type: "mcp",
+						server_label: args.serverLabel,
+						allowed_tools: Array.isArray(args.allowedTools) ? args.allowedTools : args.allowedTools ? {
+							read_only: args.allowedTools.readOnly,
+							tool_names: args.allowedTools.toolNames
+						} : void 0,
+						authorization: args.authorization,
+						connector_id: args.connectorId,
+						headers: args.headers,
+						require_approval: requireApprovalParam != null ? requireApprovalParam : "never",
+						server_description: args.serverDescription,
+						server_url: args.serverUrl
+					});
+					break;
+				}
+			}
+			break;
+		default:
+			toolWarnings.push({
+				type: "unsupported",
+				feature: `function tool ${tool}`
+			});
+			break;
+	}
+	if (toolChoice == null) return {
+		tools: openaiTools2,
+		toolChoice: void 0,
+		toolWarnings
+	};
+	const type = toolChoice.type;
+	switch (type) {
+		case "auto":
+		case "none":
+		case "required": return {
+			tools: openaiTools2,
+			toolChoice: type,
+			toolWarnings
+		};
+		case "tool": return {
+			tools: openaiTools2,
+			toolChoice: toolChoice.toolName === "code_interpreter" || toolChoice.toolName === "file_search" || toolChoice.toolName === "image_generation" || toolChoice.toolName === "web_search_preview" || toolChoice.toolName === "web_search" || toolChoice.toolName === "mcp" || toolChoice.toolName === "apply_patch" ? { type: toolChoice.toolName } : {
+				type: "function",
+				name: toolChoice.toolName
+			},
+			toolWarnings
+		};
+		default: throw new UnsupportedFunctionalityError({ functionality: `tool choice type: ${type}` });
+	}
+}
+function extractApprovalRequestIdToToolCallIdMapping(prompt) {
+	var _a, _b;
+	const mapping = {};
+	for (const message of prompt) {
+		if (message.role !== "assistant") continue;
+		for (const part of message.content) {
+			if (part.type !== "tool-call") continue;
+			const approvalRequestId = (_b = (_a = part.providerOptions) == null ? void 0 : _a.openai) == null ? void 0 : _b.approvalRequestId;
+			if (approvalRequestId != null) mapping[approvalRequestId] = part.toolCallId;
+		}
+	}
+	return mapping;
+}
+var OpenAIResponsesLanguageModel = class {
+	constructor(modelId, config) {
+		this.specificationVersion = "v3";
+		this.supportedUrls = {
+			"image/*": [/^https?:\/\/.*$/],
+			"application/pdf": [/^https?:\/\/.*$/]
+		};
+		this.modelId = modelId;
+		this.config = config;
+	}
+	get provider() {
+		return this.config.provider;
+	}
+	async getArgs({ maxOutputTokens, temperature, stopSequences, topP, topK, presencePenalty, frequencyPenalty, seed, prompt, providerOptions, tools, toolChoice, responseFormat }) {
+		var _a, _b, _c, _d, _e, _f;
+		const warnings = [];
+		const modelCapabilities = getOpenAILanguageModelCapabilities(this.modelId);
+		if (topK != null) warnings.push({
+			type: "unsupported",
+			feature: "topK"
+		});
+		if (seed != null) warnings.push({
+			type: "unsupported",
+			feature: "seed"
+		});
+		if (presencePenalty != null) warnings.push({
+			type: "unsupported",
+			feature: "presencePenalty"
+		});
+		if (frequencyPenalty != null) warnings.push({
+			type: "unsupported",
+			feature: "frequencyPenalty"
+		});
+		if (stopSequences != null) warnings.push({
+			type: "unsupported",
+			feature: "stopSequences"
+		});
+		const providerOptionsName = this.config.provider.includes("azure") ? "azure" : "openai";
+		let openaiOptions = await parseProviderOptions({
+			provider: providerOptionsName,
+			providerOptions,
+			schema: openaiResponsesProviderOptionsSchema
+		});
+		if (openaiOptions == null && providerOptionsName !== "openai") openaiOptions = await parseProviderOptions({
+			provider: "openai",
+			providerOptions,
+			schema: openaiResponsesProviderOptionsSchema
+		});
+		const isReasoningModel = (_a = openaiOptions == null ? void 0 : openaiOptions.forceReasoning) != null ? _a : modelCapabilities.isReasoningModel;
+		if ((openaiOptions == null ? void 0 : openaiOptions.conversation) && (openaiOptions == null ? void 0 : openaiOptions.previousResponseId)) warnings.push({
+			type: "unsupported",
+			feature: "conversation",
+			details: "conversation and previousResponseId cannot be used together"
+		});
+		const toolNameMapping = createToolNameMapping({
+			tools,
+			providerToolNames: {
+				"openai.code_interpreter": "code_interpreter",
+				"openai.file_search": "file_search",
+				"openai.image_generation": "image_generation",
+				"openai.local_shell": "local_shell",
+				"openai.shell": "shell",
+				"openai.web_search": "web_search",
+				"openai.web_search_preview": "web_search_preview",
+				"openai.mcp": "mcp",
+				"openai.apply_patch": "apply_patch"
+			}
+		});
+		const { input, warnings: inputWarnings } = await convertToOpenAIResponsesInput({
+			prompt,
+			toolNameMapping,
+			systemMessageMode: (_b = openaiOptions == null ? void 0 : openaiOptions.systemMessageMode) != null ? _b : isReasoningModel ? "developer" : modelCapabilities.systemMessageMode,
+			providerOptionsName,
+			fileIdPrefixes: this.config.fileIdPrefixes,
+			store: (_c = openaiOptions == null ? void 0 : openaiOptions.store) != null ? _c : true,
+			hasConversation: (openaiOptions == null ? void 0 : openaiOptions.conversation) != null,
+			hasLocalShellTool: hasOpenAITool("openai.local_shell"),
+			hasShellTool: hasOpenAITool("openai.shell"),
+			hasApplyPatchTool: hasOpenAITool("openai.apply_patch")
+		});
+		warnings.push(...inputWarnings);
+		const strictJsonSchema = (_d = openaiOptions == null ? void 0 : openaiOptions.strictJsonSchema) != null ? _d : true;
+		let include = openaiOptions == null ? void 0 : openaiOptions.include;
+		function addInclude(key) {
+			if (include == null) include = [key];
+			else if (!include.includes(key)) include = [...include, key];
+		}
+		function hasOpenAITool(id) {
+			return (tools == null ? void 0 : tools.find((tool) => tool.type === "provider" && tool.id === id)) != null;
+		}
+		const topLogprobs = typeof (openaiOptions == null ? void 0 : openaiOptions.logprobs) === "number" ? openaiOptions == null ? void 0 : openaiOptions.logprobs : (openaiOptions == null ? void 0 : openaiOptions.logprobs) === true ? TOP_LOGPROBS_MAX : void 0;
+		if (topLogprobs) addInclude("message.output_text.logprobs");
+		const webSearchToolName = (_e = tools == null ? void 0 : tools.find((tool) => tool.type === "provider" && (tool.id === "openai.web_search" || tool.id === "openai.web_search_preview"))) == null ? void 0 : _e.name;
+		if (webSearchToolName) addInclude("web_search_call.action.sources");
+		if (hasOpenAITool("openai.code_interpreter")) addInclude("code_interpreter_call.outputs");
+		const store = openaiOptions == null ? void 0 : openaiOptions.store;
+		if (store === false && isReasoningModel) addInclude("reasoning.encrypted_content");
+		const baseArgs = {
+			model: this.modelId,
+			input,
+			temperature,
+			top_p: topP,
+			max_output_tokens: maxOutputTokens,
+			...((responseFormat == null ? void 0 : responseFormat.type) === "json" || (openaiOptions == null ? void 0 : openaiOptions.textVerbosity)) && { text: {
+				...(responseFormat == null ? void 0 : responseFormat.type) === "json" && { format: responseFormat.schema != null ? {
+					type: "json_schema",
+					strict: strictJsonSchema,
+					name: (_f = responseFormat.name) != null ? _f : "response",
+					description: responseFormat.description,
+					schema: responseFormat.schema
+				} : { type: "json_object" } },
+				...(openaiOptions == null ? void 0 : openaiOptions.textVerbosity) && { verbosity: openaiOptions.textVerbosity }
+			} },
+			conversation: openaiOptions == null ? void 0 : openaiOptions.conversation,
+			max_tool_calls: openaiOptions == null ? void 0 : openaiOptions.maxToolCalls,
+			metadata: openaiOptions == null ? void 0 : openaiOptions.metadata,
+			parallel_tool_calls: openaiOptions == null ? void 0 : openaiOptions.parallelToolCalls,
+			previous_response_id: openaiOptions == null ? void 0 : openaiOptions.previousResponseId,
+			store,
+			user: openaiOptions == null ? void 0 : openaiOptions.user,
+			instructions: openaiOptions == null ? void 0 : openaiOptions.instructions,
+			service_tier: openaiOptions == null ? void 0 : openaiOptions.serviceTier,
+			include,
+			prompt_cache_key: openaiOptions == null ? void 0 : openaiOptions.promptCacheKey,
+			prompt_cache_retention: openaiOptions == null ? void 0 : openaiOptions.promptCacheRetention,
+			safety_identifier: openaiOptions == null ? void 0 : openaiOptions.safetyIdentifier,
+			top_logprobs: topLogprobs,
+			truncation: openaiOptions == null ? void 0 : openaiOptions.truncation,
+			...isReasoningModel && ((openaiOptions == null ? void 0 : openaiOptions.reasoningEffort) != null || (openaiOptions == null ? void 0 : openaiOptions.reasoningSummary) != null) && { reasoning: {
+				...(openaiOptions == null ? void 0 : openaiOptions.reasoningEffort) != null && { effort: openaiOptions.reasoningEffort },
+				...(openaiOptions == null ? void 0 : openaiOptions.reasoningSummary) != null && { summary: openaiOptions.reasoningSummary }
+			} }
+		};
+		if (isReasoningModel) {
+			if (!((openaiOptions == null ? void 0 : openaiOptions.reasoningEffort) === "none" && modelCapabilities.supportsNonReasoningParameters)) {
+				if (baseArgs.temperature != null) {
+					baseArgs.temperature = void 0;
+					warnings.push({
+						type: "unsupported",
+						feature: "temperature",
+						details: "temperature is not supported for reasoning models"
+					});
+				}
+				if (baseArgs.top_p != null) {
+					baseArgs.top_p = void 0;
+					warnings.push({
+						type: "unsupported",
+						feature: "topP",
+						details: "topP is not supported for reasoning models"
+					});
+				}
+			}
+		} else {
+			if ((openaiOptions == null ? void 0 : openaiOptions.reasoningEffort) != null) warnings.push({
+				type: "unsupported",
+				feature: "reasoningEffort",
+				details: "reasoningEffort is not supported for non-reasoning models"
+			});
+			if ((openaiOptions == null ? void 0 : openaiOptions.reasoningSummary) != null) warnings.push({
+				type: "unsupported",
+				feature: "reasoningSummary",
+				details: "reasoningSummary is not supported for non-reasoning models"
+			});
+		}
+		if ((openaiOptions == null ? void 0 : openaiOptions.serviceTier) === "flex" && !modelCapabilities.supportsFlexProcessing) {
+			warnings.push({
+				type: "unsupported",
+				feature: "serviceTier",
+				details: "flex processing is only available for o3, o4-mini, and gpt-5 models"
+			});
+			delete baseArgs.service_tier;
+		}
+		if ((openaiOptions == null ? void 0 : openaiOptions.serviceTier) === "priority" && !modelCapabilities.supportsPriorityProcessing) {
+			warnings.push({
+				type: "unsupported",
+				feature: "serviceTier",
+				details: "priority processing is only available for supported models (gpt-4, gpt-5, gpt-5-mini, o3, o4-mini) and requires Enterprise access. gpt-5-nano is not supported"
+			});
+			delete baseArgs.service_tier;
+		}
+		const { tools: openaiTools2, toolChoice: openaiToolChoice, toolWarnings } = await prepareResponsesTools({
+			tools,
+			toolChoice
+		});
+		return {
+			webSearchToolName,
+			args: {
+				...baseArgs,
+				tools: openaiTools2,
+				tool_choice: openaiToolChoice
+			},
+			warnings: [...warnings, ...toolWarnings],
+			store,
+			toolNameMapping,
+			providerOptionsName
+		};
+	}
+	async doGenerate(options) {
+		var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y;
+		const { args: body, warnings, webSearchToolName, toolNameMapping, providerOptionsName } = await this.getArgs(options);
+		const url = this.config.url({
+			path: "/responses",
+			modelId: this.modelId
+		});
+		const approvalRequestIdToDummyToolCallIdFromPrompt = extractApprovalRequestIdToToolCallIdMapping(options.prompt);
+		const { responseHeaders, value: response, rawValue: rawResponse } = await postJsonToApi({
+			url,
+			headers: combineHeaders(this.config.headers(), options.headers),
+			body,
+			failedResponseHandler: openaiFailedResponseHandler,
+			successfulResponseHandler: createJsonResponseHandler(openaiResponsesResponseSchema),
+			abortSignal: options.abortSignal,
+			fetch: this.config.fetch
+		});
+		if (response.error) throw new APICallError({
+			message: response.error.message,
+			url,
+			requestBodyValues: body,
+			statusCode: 400,
+			responseHeaders,
+			responseBody: rawResponse,
+			isRetryable: false
+		});
+		const content = [];
+		const logprobs = [];
+		let hasFunctionCall = false;
+		for (const part of response.output) switch (part.type) {
+			case "reasoning":
+				if (part.summary.length === 0) part.summary.push({
+					type: "summary_text",
+					text: ""
+				});
+				for (const summary of part.summary) content.push({
+					type: "reasoning",
+					text: summary.text,
+					providerMetadata: { [providerOptionsName]: {
+						itemId: part.id,
+						reasoningEncryptedContent: (_a = part.encrypted_content) != null ? _a : null
+					} }
+				});
+				break;
+			case "image_generation_call":
+				content.push({
+					type: "tool-call",
+					toolCallId: part.id,
+					toolName: toolNameMapping.toCustomToolName("image_generation"),
+					input: "{}",
+					providerExecuted: true
+				});
+				content.push({
+					type: "tool-result",
+					toolCallId: part.id,
+					toolName: toolNameMapping.toCustomToolName("image_generation"),
+					result: { result: part.result }
+				});
+				break;
+			case "local_shell_call":
+				content.push({
+					type: "tool-call",
+					toolCallId: part.call_id,
+					toolName: toolNameMapping.toCustomToolName("local_shell"),
+					input: JSON.stringify({ action: part.action }),
+					providerMetadata: { [providerOptionsName]: { itemId: part.id } }
+				});
+				break;
+			case "shell_call":
+				content.push({
+					type: "tool-call",
+					toolCallId: part.call_id,
+					toolName: toolNameMapping.toCustomToolName("shell"),
+					input: JSON.stringify({ action: { commands: part.action.commands } }),
+					providerMetadata: { [providerOptionsName]: { itemId: part.id } }
+				});
+				break;
+			case "message":
+				for (const contentPart of part.content) {
+					if (((_c = (_b = options.providerOptions) == null ? void 0 : _b[providerOptionsName]) == null ? void 0 : _c.logprobs) && contentPart.logprobs) logprobs.push(contentPart.logprobs);
+					const providerMetadata2 = {
+						itemId: part.id,
+						...contentPart.annotations.length > 0 && { annotations: contentPart.annotations }
+					};
+					content.push({
+						type: "text",
+						text: contentPart.text,
+						providerMetadata: { [providerOptionsName]: providerMetadata2 }
+					});
+					for (const annotation of contentPart.annotations) if (annotation.type === "url_citation") content.push({
+						type: "source",
+						sourceType: "url",
+						id: (_f = (_e = (_d = this.config).generateId) == null ? void 0 : _e.call(_d)) != null ? _f : generateId(),
+						url: annotation.url,
+						title: annotation.title
+					});
+					else if (annotation.type === "file_citation") content.push({
+						type: "source",
+						sourceType: "document",
+						id: (_i = (_h = (_g = this.config).generateId) == null ? void 0 : _h.call(_g)) != null ? _i : generateId(),
+						mediaType: "text/plain",
+						title: annotation.filename,
+						filename: annotation.filename,
+						providerMetadata: { [providerOptionsName]: {
+							type: annotation.type,
+							fileId: annotation.file_id,
+							index: annotation.index
+						} }
+					});
+					else if (annotation.type === "container_file_citation") content.push({
+						type: "source",
+						sourceType: "document",
+						id: (_l = (_k = (_j = this.config).generateId) == null ? void 0 : _k.call(_j)) != null ? _l : generateId(),
+						mediaType: "text/plain",
+						title: annotation.filename,
+						filename: annotation.filename,
+						providerMetadata: { [providerOptionsName]: {
+							type: annotation.type,
+							fileId: annotation.file_id,
+							containerId: annotation.container_id
+						} }
+					});
+					else if (annotation.type === "file_path") content.push({
+						type: "source",
+						sourceType: "document",
+						id: (_o = (_n = (_m = this.config).generateId) == null ? void 0 : _n.call(_m)) != null ? _o : generateId(),
+						mediaType: "application/octet-stream",
+						title: annotation.file_id,
+						filename: annotation.file_id,
+						providerMetadata: { [providerOptionsName]: {
+							type: annotation.type,
+							fileId: annotation.file_id,
+							index: annotation.index
+						} }
+					});
+				}
+				break;
+			case "function_call":
+				hasFunctionCall = true;
+				content.push({
+					type: "tool-call",
+					toolCallId: part.call_id,
+					toolName: part.name,
+					input: part.arguments,
+					providerMetadata: { [providerOptionsName]: { itemId: part.id } }
+				});
+				break;
+			case "web_search_call":
+				content.push({
+					type: "tool-call",
+					toolCallId: part.id,
+					toolName: toolNameMapping.toCustomToolName(webSearchToolName != null ? webSearchToolName : "web_search"),
+					input: JSON.stringify({}),
+					providerExecuted: true
+				});
+				content.push({
+					type: "tool-result",
+					toolCallId: part.id,
+					toolName: toolNameMapping.toCustomToolName(webSearchToolName != null ? webSearchToolName : "web_search"),
+					result: mapWebSearchOutput(part.action)
+				});
+				break;
+			case "mcp_call": {
+				const toolCallId = part.approval_request_id != null ? (_p = approvalRequestIdToDummyToolCallIdFromPrompt[part.approval_request_id]) != null ? _p : part.id : part.id;
+				const toolName = `mcp.${part.name}`;
+				content.push({
+					type: "tool-call",
+					toolCallId,
+					toolName,
+					input: part.arguments,
+					providerExecuted: true,
+					dynamic: true
+				});
+				content.push({
+					type: "tool-result",
+					toolCallId,
+					toolName,
+					result: {
+						type: "call",
+						serverLabel: part.server_label,
+						name: part.name,
+						arguments: part.arguments,
+						...part.output != null ? { output: part.output } : {},
+						...part.error != null ? { error: part.error } : {}
+					},
+					providerMetadata: { [providerOptionsName]: { itemId: part.id } }
+				});
+				break;
+			}
+			case "mcp_list_tools": break;
+			case "mcp_approval_request": {
+				const approvalRequestId = (_q = part.approval_request_id) != null ? _q : part.id;
+				const dummyToolCallId = (_t = (_s = (_r = this.config).generateId) == null ? void 0 : _s.call(_r)) != null ? _t : generateId();
+				const toolName = `mcp.${part.name}`;
+				content.push({
+					type: "tool-call",
+					toolCallId: dummyToolCallId,
+					toolName,
+					input: part.arguments,
+					providerExecuted: true,
+					dynamic: true
+				});
+				content.push({
+					type: "tool-approval-request",
+					approvalId: approvalRequestId,
+					toolCallId: dummyToolCallId
+				});
+				break;
+			}
+			case "computer_call":
+				content.push({
+					type: "tool-call",
+					toolCallId: part.id,
+					toolName: toolNameMapping.toCustomToolName("computer_use"),
+					input: "",
+					providerExecuted: true
+				});
+				content.push({
+					type: "tool-result",
+					toolCallId: part.id,
+					toolName: toolNameMapping.toCustomToolName("computer_use"),
+					result: {
+						type: "computer_use_tool_result",
+						status: part.status || "completed"
+					}
+				});
+				break;
+			case "file_search_call":
+				content.push({
+					type: "tool-call",
+					toolCallId: part.id,
+					toolName: toolNameMapping.toCustomToolName("file_search"),
+					input: "{}",
+					providerExecuted: true
+				});
+				content.push({
+					type: "tool-result",
+					toolCallId: part.id,
+					toolName: toolNameMapping.toCustomToolName("file_search"),
+					result: {
+						queries: part.queries,
+						results: (_v = (_u = part.results) == null ? void 0 : _u.map((result) => ({
+							attributes: result.attributes,
+							fileId: result.file_id,
+							filename: result.filename,
+							score: result.score,
+							text: result.text
+						}))) != null ? _v : null
+					}
+				});
+				break;
+			case "code_interpreter_call":
+				content.push({
+					type: "tool-call",
+					toolCallId: part.id,
+					toolName: toolNameMapping.toCustomToolName("code_interpreter"),
+					input: JSON.stringify({
+						code: part.code,
+						containerId: part.container_id
+					}),
+					providerExecuted: true
+				});
+				content.push({
+					type: "tool-result",
+					toolCallId: part.id,
+					toolName: toolNameMapping.toCustomToolName("code_interpreter"),
+					result: { outputs: part.outputs }
+				});
+				break;
+			case "apply_patch_call":
+				content.push({
+					type: "tool-call",
+					toolCallId: part.call_id,
+					toolName: toolNameMapping.toCustomToolName("apply_patch"),
+					input: JSON.stringify({
+						callId: part.call_id,
+						operation: part.operation
+					}),
+					providerMetadata: { [providerOptionsName]: { itemId: part.id } }
+				});
+				break;
+		}
+		const providerMetadata = { [providerOptionsName]: {
+			responseId: response.id,
+			...logprobs.length > 0 ? { logprobs } : {},
+			...typeof response.service_tier === "string" ? { serviceTier: response.service_tier } : {}
+		} };
+		const usage = response.usage;
+		return {
+			content,
+			finishReason: {
+				unified: mapOpenAIResponseFinishReason({
+					finishReason: (_w = response.incomplete_details) == null ? void 0 : _w.reason,
+					hasFunctionCall
+				}),
+				raw: (_y = (_x = response.incomplete_details) == null ? void 0 : _x.reason) != null ? _y : void 0
+			},
+			usage: convertOpenAIResponsesUsage(usage),
+			request: { body },
+			response: {
+				id: response.id,
+				timestamp: /* @__PURE__ */ new Date(response.created_at * 1e3),
+				modelId: response.model,
+				headers: responseHeaders,
+				body: rawResponse
+			},
+			providerMetadata,
+			warnings
+		};
+	}
+	async doStream(options) {
+		const { args: body, warnings, webSearchToolName, toolNameMapping, store, providerOptionsName } = await this.getArgs(options);
+		const { responseHeaders, value: response } = await postJsonToApi({
+			url: this.config.url({
+				path: "/responses",
+				modelId: this.modelId
+			}),
+			headers: combineHeaders(this.config.headers(), options.headers),
+			body: {
+				...body,
+				stream: true
+			},
+			failedResponseHandler: openaiFailedResponseHandler,
+			successfulResponseHandler: createEventSourceResponseHandler(openaiResponsesChunkSchema),
+			abortSignal: options.abortSignal,
+			fetch: this.config.fetch
+		});
+		const self = this;
+		const approvalRequestIdToDummyToolCallIdFromPrompt = extractApprovalRequestIdToToolCallIdMapping(options.prompt);
+		const approvalRequestIdToDummyToolCallIdFromStream = /* @__PURE__ */ new Map();
+		let finishReason = {
+			unified: "other",
+			raw: void 0
+		};
+		let usage = void 0;
+		const logprobs = [];
+		let responseId = null;
+		const ongoingToolCalls = {};
+		const ongoingAnnotations = [];
+		let hasFunctionCall = false;
+		const activeReasoning = {};
+		let serviceTier;
+		return {
+			stream: response.pipeThrough(new TransformStream({
+				start(controller) {
+					controller.enqueue({
+						type: "stream-start",
+						warnings
+					});
+				},
+				transform(chunk, controller) {
+					var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _A, _B, _C, _D;
+					if (options.includeRawChunks) controller.enqueue({
+						type: "raw",
+						rawValue: chunk.rawValue
+					});
+					if (!chunk.success) {
+						finishReason = {
+							unified: "error",
+							raw: void 0
+						};
+						controller.enqueue({
+							type: "error",
+							error: chunk.error
+						});
+						return;
+					}
+					const value = chunk.value;
+					if (isResponseOutputItemAddedChunk(value)) {
+						if (value.item.type === "function_call") {
+							ongoingToolCalls[value.output_index] = {
+								toolName: value.item.name,
+								toolCallId: value.item.call_id
+							};
+							controller.enqueue({
+								type: "tool-input-start",
+								id: value.item.call_id,
+								toolName: value.item.name
+							});
+						} else if (value.item.type === "web_search_call") {
+							ongoingToolCalls[value.output_index] = {
+								toolName: toolNameMapping.toCustomToolName(webSearchToolName != null ? webSearchToolName : "web_search"),
+								toolCallId: value.item.id
+							};
+							controller.enqueue({
+								type: "tool-input-start",
+								id: value.item.id,
+								toolName: toolNameMapping.toCustomToolName(webSearchToolName != null ? webSearchToolName : "web_search"),
+								providerExecuted: true
+							});
+							controller.enqueue({
+								type: "tool-input-end",
+								id: value.item.id
+							});
+							controller.enqueue({
+								type: "tool-call",
+								toolCallId: value.item.id,
+								toolName: toolNameMapping.toCustomToolName(webSearchToolName != null ? webSearchToolName : "web_search"),
+								input: JSON.stringify({}),
+								providerExecuted: true
+							});
+						} else if (value.item.type === "computer_call") {
+							ongoingToolCalls[value.output_index] = {
+								toolName: toolNameMapping.toCustomToolName("computer_use"),
+								toolCallId: value.item.id
+							};
+							controller.enqueue({
+								type: "tool-input-start",
+								id: value.item.id,
+								toolName: toolNameMapping.toCustomToolName("computer_use"),
+								providerExecuted: true
+							});
+						} else if (value.item.type === "code_interpreter_call") {
+							ongoingToolCalls[value.output_index] = {
+								toolName: toolNameMapping.toCustomToolName("code_interpreter"),
+								toolCallId: value.item.id,
+								codeInterpreter: { containerId: value.item.container_id }
+							};
+							controller.enqueue({
+								type: "tool-input-start",
+								id: value.item.id,
+								toolName: toolNameMapping.toCustomToolName("code_interpreter"),
+								providerExecuted: true
+							});
+							controller.enqueue({
+								type: "tool-input-delta",
+								id: value.item.id,
+								delta: `{"containerId":"${value.item.container_id}","code":"`
+							});
+						} else if (value.item.type === "file_search_call") controller.enqueue({
+							type: "tool-call",
+							toolCallId: value.item.id,
+							toolName: toolNameMapping.toCustomToolName("file_search"),
+							input: "{}",
+							providerExecuted: true
+						});
+						else if (value.item.type === "image_generation_call") controller.enqueue({
+							type: "tool-call",
+							toolCallId: value.item.id,
+							toolName: toolNameMapping.toCustomToolName("image_generation"),
+							input: "{}",
+							providerExecuted: true
+						});
+						else if (value.item.type === "mcp_call" || value.item.type === "mcp_list_tools" || value.item.type === "mcp_approval_request") {} else if (value.item.type === "apply_patch_call") {
+							const { call_id: callId, operation } = value.item;
+							ongoingToolCalls[value.output_index] = {
+								toolName: toolNameMapping.toCustomToolName("apply_patch"),
+								toolCallId: callId,
+								applyPatch: {
+									hasDiff: operation.type === "delete_file",
+									endEmitted: operation.type === "delete_file"
+								}
+							};
+							controller.enqueue({
+								type: "tool-input-start",
+								id: callId,
+								toolName: toolNameMapping.toCustomToolName("apply_patch")
+							});
+							if (operation.type === "delete_file") {
+								const inputString = JSON.stringify({
+									callId,
+									operation
+								});
+								controller.enqueue({
+									type: "tool-input-delta",
+									id: callId,
+									delta: inputString
+								});
+								controller.enqueue({
+									type: "tool-input-end",
+									id: callId
+								});
+							} else controller.enqueue({
+								type: "tool-input-delta",
+								id: callId,
+								delta: `{"callId":"${escapeJSONDelta(callId)}","operation":{"type":"${escapeJSONDelta(operation.type)}","path":"${escapeJSONDelta(operation.path)}","diff":"`
+							});
+						} else if (value.item.type === "shell_call") ongoingToolCalls[value.output_index] = {
+							toolName: toolNameMapping.toCustomToolName("shell"),
+							toolCallId: value.item.call_id
+						};
+						else if (value.item.type === "message") {
+							ongoingAnnotations.splice(0, ongoingAnnotations.length);
+							controller.enqueue({
+								type: "text-start",
+								id: value.item.id,
+								providerMetadata: { [providerOptionsName]: { itemId: value.item.id } }
+							});
+						} else if (isResponseOutputItemAddedChunk(value) && value.item.type === "reasoning") {
+							activeReasoning[value.item.id] = {
+								encryptedContent: value.item.encrypted_content,
+								summaryParts: { 0: "active" }
+							};
+							controller.enqueue({
+								type: "reasoning-start",
+								id: `${value.item.id}:0`,
+								providerMetadata: { [providerOptionsName]: {
+									itemId: value.item.id,
+									reasoningEncryptedContent: (_a = value.item.encrypted_content) != null ? _a : null
+								} }
+							});
+						}
+					} else if (isResponseOutputItemDoneChunk(value)) {
+						if (value.item.type === "message") controller.enqueue({
+							type: "text-end",
+							id: value.item.id,
+							providerMetadata: { [providerOptionsName]: {
+								itemId: value.item.id,
+								...ongoingAnnotations.length > 0 && { annotations: ongoingAnnotations }
+							} }
+						});
+						else if (value.item.type === "function_call") {
+							ongoingToolCalls[value.output_index] = void 0;
+							hasFunctionCall = true;
+							controller.enqueue({
+								type: "tool-input-end",
+								id: value.item.call_id
+							});
+							controller.enqueue({
+								type: "tool-call",
+								toolCallId: value.item.call_id,
+								toolName: value.item.name,
+								input: value.item.arguments,
+								providerMetadata: { [providerOptionsName]: { itemId: value.item.id } }
+							});
+						} else if (value.item.type === "web_search_call") {
+							ongoingToolCalls[value.output_index] = void 0;
+							controller.enqueue({
+								type: "tool-result",
+								toolCallId: value.item.id,
+								toolName: toolNameMapping.toCustomToolName(webSearchToolName != null ? webSearchToolName : "web_search"),
+								result: mapWebSearchOutput(value.item.action)
+							});
+						} else if (value.item.type === "computer_call") {
+							ongoingToolCalls[value.output_index] = void 0;
+							controller.enqueue({
+								type: "tool-input-end",
+								id: value.item.id
+							});
+							controller.enqueue({
+								type: "tool-call",
+								toolCallId: value.item.id,
+								toolName: toolNameMapping.toCustomToolName("computer_use"),
+								input: "",
+								providerExecuted: true
+							});
+							controller.enqueue({
+								type: "tool-result",
+								toolCallId: value.item.id,
+								toolName: toolNameMapping.toCustomToolName("computer_use"),
+								result: {
+									type: "computer_use_tool_result",
+									status: value.item.status || "completed"
+								}
+							});
+						} else if (value.item.type === "file_search_call") {
+							ongoingToolCalls[value.output_index] = void 0;
+							controller.enqueue({
+								type: "tool-result",
+								toolCallId: value.item.id,
+								toolName: toolNameMapping.toCustomToolName("file_search"),
+								result: {
+									queries: value.item.queries,
+									results: (_c = (_b = value.item.results) == null ? void 0 : _b.map((result) => ({
+										attributes: result.attributes,
+										fileId: result.file_id,
+										filename: result.filename,
+										score: result.score,
+										text: result.text
+									}))) != null ? _c : null
+								}
+							});
+						} else if (value.item.type === "code_interpreter_call") {
+							ongoingToolCalls[value.output_index] = void 0;
+							controller.enqueue({
+								type: "tool-result",
+								toolCallId: value.item.id,
+								toolName: toolNameMapping.toCustomToolName("code_interpreter"),
+								result: { outputs: value.item.outputs }
+							});
+						} else if (value.item.type === "image_generation_call") controller.enqueue({
+							type: "tool-result",
+							toolCallId: value.item.id,
+							toolName: toolNameMapping.toCustomToolName("image_generation"),
+							result: { result: value.item.result }
+						});
+						else if (value.item.type === "mcp_call") {
+							ongoingToolCalls[value.output_index] = void 0;
+							const approvalRequestId = (_d = value.item.approval_request_id) != null ? _d : void 0;
+							const aliasedToolCallId = approvalRequestId != null ? (_f = (_e = approvalRequestIdToDummyToolCallIdFromStream.get(approvalRequestId)) != null ? _e : approvalRequestIdToDummyToolCallIdFromPrompt[approvalRequestId]) != null ? _f : value.item.id : value.item.id;
+							const toolName = `mcp.${value.item.name}`;
+							controller.enqueue({
+								type: "tool-call",
+								toolCallId: aliasedToolCallId,
+								toolName,
+								input: value.item.arguments,
+								providerExecuted: true,
+								dynamic: true
+							});
+							controller.enqueue({
+								type: "tool-result",
+								toolCallId: aliasedToolCallId,
+								toolName,
+								result: {
+									type: "call",
+									serverLabel: value.item.server_label,
+									name: value.item.name,
+									arguments: value.item.arguments,
+									...value.item.output != null ? { output: value.item.output } : {},
+									...value.item.error != null ? { error: value.item.error } : {}
+								},
+								providerMetadata: { [providerOptionsName]: { itemId: value.item.id } }
+							});
+						} else if (value.item.type === "mcp_list_tools") ongoingToolCalls[value.output_index] = void 0;
+						else if (value.item.type === "apply_patch_call") {
+							const toolCall = ongoingToolCalls[value.output_index];
+							if ((toolCall == null ? void 0 : toolCall.applyPatch) && !toolCall.applyPatch.endEmitted && value.item.operation.type !== "delete_file") {
+								if (!toolCall.applyPatch.hasDiff) controller.enqueue({
+									type: "tool-input-delta",
+									id: toolCall.toolCallId,
+									delta: escapeJSONDelta(value.item.operation.diff)
+								});
+								controller.enqueue({
+									type: "tool-input-delta",
+									id: toolCall.toolCallId,
+									delta: "\"}}"
+								});
+								controller.enqueue({
+									type: "tool-input-end",
+									id: toolCall.toolCallId
+								});
+								toolCall.applyPatch.endEmitted = true;
+							}
+							if (toolCall && value.item.status === "completed") controller.enqueue({
+								type: "tool-call",
+								toolCallId: toolCall.toolCallId,
+								toolName: toolNameMapping.toCustomToolName("apply_patch"),
+								input: JSON.stringify({
+									callId: value.item.call_id,
+									operation: value.item.operation
+								}),
+								providerMetadata: { [providerOptionsName]: { itemId: value.item.id } }
+							});
+							ongoingToolCalls[value.output_index] = void 0;
+						} else if (value.item.type === "mcp_approval_request") {
+							ongoingToolCalls[value.output_index] = void 0;
+							const dummyToolCallId = (_i = (_h = (_g = self.config).generateId) == null ? void 0 : _h.call(_g)) != null ? _i : generateId();
+							const approvalRequestId = (_j = value.item.approval_request_id) != null ? _j : value.item.id;
+							approvalRequestIdToDummyToolCallIdFromStream.set(approvalRequestId, dummyToolCallId);
+							const toolName = `mcp.${value.item.name}`;
+							controller.enqueue({
+								type: "tool-call",
+								toolCallId: dummyToolCallId,
+								toolName,
+								input: value.item.arguments,
+								providerExecuted: true,
+								dynamic: true
+							});
+							controller.enqueue({
+								type: "tool-approval-request",
+								approvalId: approvalRequestId,
+								toolCallId: dummyToolCallId
+							});
+						} else if (value.item.type === "local_shell_call") {
+							ongoingToolCalls[value.output_index] = void 0;
+							controller.enqueue({
+								type: "tool-call",
+								toolCallId: value.item.call_id,
+								toolName: toolNameMapping.toCustomToolName("local_shell"),
+								input: JSON.stringify({ action: {
+									type: "exec",
+									command: value.item.action.command,
+									timeoutMs: value.item.action.timeout_ms,
+									user: value.item.action.user,
+									workingDirectory: value.item.action.working_directory,
+									env: value.item.action.env
+								} }),
+								providerMetadata: { [providerOptionsName]: { itemId: value.item.id } }
+							});
+						} else if (value.item.type === "shell_call") {
+							ongoingToolCalls[value.output_index] = void 0;
+							controller.enqueue({
+								type: "tool-call",
+								toolCallId: value.item.call_id,
+								toolName: toolNameMapping.toCustomToolName("shell"),
+								input: JSON.stringify({ action: { commands: value.item.action.commands } }),
+								providerMetadata: { [providerOptionsName]: { itemId: value.item.id } }
+							});
+						} else if (value.item.type === "reasoning") {
+							const activeReasoningPart = activeReasoning[value.item.id];
+							const summaryPartIndices = Object.entries(activeReasoningPart.summaryParts).filter(([_, status]) => status === "active" || status === "can-conclude").map(([summaryIndex]) => summaryIndex);
+							for (const summaryIndex of summaryPartIndices) controller.enqueue({
+								type: "reasoning-end",
+								id: `${value.item.id}:${summaryIndex}`,
+								providerMetadata: { [providerOptionsName]: {
+									itemId: value.item.id,
+									reasoningEncryptedContent: (_k = value.item.encrypted_content) != null ? _k : null
+								} }
+							});
+							delete activeReasoning[value.item.id];
+						}
+					} else if (isResponseFunctionCallArgumentsDeltaChunk(value)) {
+						const toolCall = ongoingToolCalls[value.output_index];
+						if (toolCall != null) controller.enqueue({
+							type: "tool-input-delta",
+							id: toolCall.toolCallId,
+							delta: value.delta
+						});
+					} else if (isResponseApplyPatchCallOperationDiffDeltaChunk(value)) {
+						const toolCall = ongoingToolCalls[value.output_index];
+						if (toolCall == null ? void 0 : toolCall.applyPatch) {
+							controller.enqueue({
+								type: "tool-input-delta",
+								id: toolCall.toolCallId,
+								delta: escapeJSONDelta(value.delta)
+							});
+							toolCall.applyPatch.hasDiff = true;
+						}
+					} else if (isResponseApplyPatchCallOperationDiffDoneChunk(value)) {
+						const toolCall = ongoingToolCalls[value.output_index];
+						if ((toolCall == null ? void 0 : toolCall.applyPatch) && !toolCall.applyPatch.endEmitted) {
+							if (!toolCall.applyPatch.hasDiff) {
+								controller.enqueue({
+									type: "tool-input-delta",
+									id: toolCall.toolCallId,
+									delta: escapeJSONDelta(value.diff)
+								});
+								toolCall.applyPatch.hasDiff = true;
+							}
+							controller.enqueue({
+								type: "tool-input-delta",
+								id: toolCall.toolCallId,
+								delta: "\"}}"
+							});
+							controller.enqueue({
+								type: "tool-input-end",
+								id: toolCall.toolCallId
+							});
+							toolCall.applyPatch.endEmitted = true;
+						}
+					} else if (isResponseImageGenerationCallPartialImageChunk(value)) controller.enqueue({
+						type: "tool-result",
+						toolCallId: value.item_id,
+						toolName: toolNameMapping.toCustomToolName("image_generation"),
+						result: { result: value.partial_image_b64 },
+						preliminary: true
+					});
+					else if (isResponseCodeInterpreterCallCodeDeltaChunk(value)) {
+						const toolCall = ongoingToolCalls[value.output_index];
+						if (toolCall != null) controller.enqueue({
+							type: "tool-input-delta",
+							id: toolCall.toolCallId,
+							delta: escapeJSONDelta(value.delta)
+						});
+					} else if (isResponseCodeInterpreterCallCodeDoneChunk(value)) {
+						const toolCall = ongoingToolCalls[value.output_index];
+						if (toolCall != null) {
+							controller.enqueue({
+								type: "tool-input-delta",
+								id: toolCall.toolCallId,
+								delta: "\"}"
+							});
+							controller.enqueue({
+								type: "tool-input-end",
+								id: toolCall.toolCallId
+							});
+							controller.enqueue({
+								type: "tool-call",
+								toolCallId: toolCall.toolCallId,
+								toolName: toolNameMapping.toCustomToolName("code_interpreter"),
+								input: JSON.stringify({
+									code: value.code,
+									containerId: toolCall.codeInterpreter.containerId
+								}),
+								providerExecuted: true
+							});
+						}
+					} else if (isResponseCreatedChunk(value)) {
+						responseId = value.response.id;
+						controller.enqueue({
+							type: "response-metadata",
+							id: value.response.id,
+							timestamp: /* @__PURE__ */ new Date(value.response.created_at * 1e3),
+							modelId: value.response.model
+						});
+					} else if (isTextDeltaChunk(value)) {
+						controller.enqueue({
+							type: "text-delta",
+							id: value.item_id,
+							delta: value.delta
+						});
+						if (((_m = (_l = options.providerOptions) == null ? void 0 : _l[providerOptionsName]) == null ? void 0 : _m.logprobs) && value.logprobs) logprobs.push(value.logprobs);
+					} else if (value.type === "response.reasoning_summary_part.added") {
+						if (value.summary_index > 0) {
+							const activeReasoningPart = activeReasoning[value.item_id];
+							activeReasoningPart.summaryParts[value.summary_index] = "active";
+							for (const summaryIndex of Object.keys(activeReasoningPart.summaryParts)) if (activeReasoningPart.summaryParts[summaryIndex] === "can-conclude") {
+								controller.enqueue({
+									type: "reasoning-end",
+									id: `${value.item_id}:${summaryIndex}`,
+									providerMetadata: { [providerOptionsName]: { itemId: value.item_id } }
+								});
+								activeReasoningPart.summaryParts[summaryIndex] = "concluded";
+							}
+							controller.enqueue({
+								type: "reasoning-start",
+								id: `${value.item_id}:${value.summary_index}`,
+								providerMetadata: { [providerOptionsName]: {
+									itemId: value.item_id,
+									reasoningEncryptedContent: (_o = (_n = activeReasoning[value.item_id]) == null ? void 0 : _n.encryptedContent) != null ? _o : null
+								} }
+							});
+						}
+					} else if (value.type === "response.reasoning_summary_text.delta") controller.enqueue({
+						type: "reasoning-delta",
+						id: `${value.item_id}:${value.summary_index}`,
+						delta: value.delta,
+						providerMetadata: { [providerOptionsName]: { itemId: value.item_id } }
+					});
+					else if (value.type === "response.reasoning_summary_part.done") if (store) {
+						controller.enqueue({
+							type: "reasoning-end",
+							id: `${value.item_id}:${value.summary_index}`,
+							providerMetadata: { [providerOptionsName]: { itemId: value.item_id } }
+						});
+						activeReasoning[value.item_id].summaryParts[value.summary_index] = "concluded";
+					} else activeReasoning[value.item_id].summaryParts[value.summary_index] = "can-conclude";
+					else if (isResponseFinishedChunk(value)) {
+						finishReason = {
+							unified: mapOpenAIResponseFinishReason({
+								finishReason: (_p = value.response.incomplete_details) == null ? void 0 : _p.reason,
+								hasFunctionCall
+							}),
+							raw: (_r = (_q = value.response.incomplete_details) == null ? void 0 : _q.reason) != null ? _r : void 0
+						};
+						usage = value.response.usage;
+						if (typeof value.response.service_tier === "string") serviceTier = value.response.service_tier;
+					} else if (isResponseAnnotationAddedChunk(value)) {
+						ongoingAnnotations.push(value.annotation);
+						if (value.annotation.type === "url_citation") controller.enqueue({
+							type: "source",
+							sourceType: "url",
+							id: (_u = (_t = (_s = self.config).generateId) == null ? void 0 : _t.call(_s)) != null ? _u : generateId(),
+							url: value.annotation.url,
+							title: value.annotation.title
+						});
+						else if (value.annotation.type === "file_citation") controller.enqueue({
+							type: "source",
+							sourceType: "document",
+							id: (_x = (_w = (_v = self.config).generateId) == null ? void 0 : _w.call(_v)) != null ? _x : generateId(),
+							mediaType: "text/plain",
+							title: value.annotation.filename,
+							filename: value.annotation.filename,
+							providerMetadata: { [providerOptionsName]: {
+								type: value.annotation.type,
+								fileId: value.annotation.file_id,
+								index: value.annotation.index
+							} }
+						});
+						else if (value.annotation.type === "container_file_citation") controller.enqueue({
+							type: "source",
+							sourceType: "document",
+							id: (_A = (_z = (_y = self.config).generateId) == null ? void 0 : _z.call(_y)) != null ? _A : generateId(),
+							mediaType: "text/plain",
+							title: value.annotation.filename,
+							filename: value.annotation.filename,
+							providerMetadata: { [providerOptionsName]: {
+								type: value.annotation.type,
+								fileId: value.annotation.file_id,
+								containerId: value.annotation.container_id
+							} }
+						});
+						else if (value.annotation.type === "file_path") controller.enqueue({
+							type: "source",
+							sourceType: "document",
+							id: (_D = (_C = (_B = self.config).generateId) == null ? void 0 : _C.call(_B)) != null ? _D : generateId(),
+							mediaType: "application/octet-stream",
+							title: value.annotation.file_id,
+							filename: value.annotation.file_id,
+							providerMetadata: { [providerOptionsName]: {
+								type: value.annotation.type,
+								fileId: value.annotation.file_id,
+								index: value.annotation.index
+							} }
+						});
+					} else if (isErrorChunk(value)) controller.enqueue({
+						type: "error",
+						error: value
+					});
+				},
+				flush(controller) {
+					const providerMetadata = { [providerOptionsName]: {
+						responseId,
+						...logprobs.length > 0 ? { logprobs } : {},
+						...serviceTier !== void 0 ? { serviceTier } : {}
+					} };
+					controller.enqueue({
+						type: "finish",
+						finishReason,
+						usage: convertOpenAIResponsesUsage(usage),
+						providerMetadata
+					});
+				}
+			})),
+			request: { body },
+			response: { headers: responseHeaders }
+		};
+	}
+};
+function isTextDeltaChunk(chunk) {
+	return chunk.type === "response.output_text.delta";
+}
+function isResponseOutputItemDoneChunk(chunk) {
+	return chunk.type === "response.output_item.done";
+}
+function isResponseFinishedChunk(chunk) {
+	return chunk.type === "response.completed" || chunk.type === "response.incomplete";
+}
+function isResponseCreatedChunk(chunk) {
+	return chunk.type === "response.created";
+}
+function isResponseFunctionCallArgumentsDeltaChunk(chunk) {
+	return chunk.type === "response.function_call_arguments.delta";
+}
+function isResponseImageGenerationCallPartialImageChunk(chunk) {
+	return chunk.type === "response.image_generation_call.partial_image";
+}
+function isResponseCodeInterpreterCallCodeDeltaChunk(chunk) {
+	return chunk.type === "response.code_interpreter_call_code.delta";
+}
+function isResponseCodeInterpreterCallCodeDoneChunk(chunk) {
+	return chunk.type === "response.code_interpreter_call_code.done";
+}
+function isResponseApplyPatchCallOperationDiffDeltaChunk(chunk) {
+	return chunk.type === "response.apply_patch_call_operation_diff.delta";
+}
+function isResponseApplyPatchCallOperationDiffDoneChunk(chunk) {
+	return chunk.type === "response.apply_patch_call_operation_diff.done";
+}
+function isResponseOutputItemAddedChunk(chunk) {
+	return chunk.type === "response.output_item.added";
+}
+function isResponseAnnotationAddedChunk(chunk) {
+	return chunk.type === "response.output_text.annotation.added";
+}
+function isErrorChunk(chunk) {
+	return chunk.type === "error";
+}
+function mapWebSearchOutput(action) {
+	var _a;
+	switch (action.type) {
+		case "search": return {
+			action: {
+				type: "search",
+				query: (_a = action.query) != null ? _a : void 0
+			},
+			...action.sources != null && { sources: action.sources }
+		};
+		case "open_page": return { action: {
+			type: "openPage",
+			url: action.url
+		} };
+		case "find_in_page": return { action: {
+			type: "findInPage",
+			url: action.url,
+			pattern: action.pattern
+		} };
+	}
+}
+function escapeJSONDelta(delta) {
+	return JSON.stringify(delta).slice(1, -1);
+}
+var openaiSpeechProviderOptionsSchema = lazySchema(() => zodSchema(object({
+	instructions: string().nullish(),
+	speed: number$1().min(.25).max(4).default(1).nullish()
+})));
+var OpenAISpeechModel = class {
+	constructor(modelId, config) {
+		this.modelId = modelId;
+		this.config = config;
+		this.specificationVersion = "v3";
+	}
+	get provider() {
+		return this.config.provider;
+	}
+	async getArgs({ text, voice = "alloy", outputFormat = "mp3", speed, instructions, language, providerOptions }) {
+		const warnings = [];
+		const openAIOptions = await parseProviderOptions({
+			provider: "openai",
+			providerOptions,
+			schema: openaiSpeechProviderOptionsSchema
+		});
+		const requestBody = {
+			model: this.modelId,
+			input: text,
+			voice,
+			response_format: "mp3",
+			speed,
+			instructions
+		};
+		if (outputFormat) if ([
+			"mp3",
+			"opus",
+			"aac",
+			"flac",
+			"wav",
+			"pcm"
+		].includes(outputFormat)) requestBody.response_format = outputFormat;
+		else warnings.push({
+			type: "unsupported",
+			feature: "outputFormat",
+			details: `Unsupported output format: ${outputFormat}. Using mp3 instead.`
+		});
+		if (openAIOptions) {
+			const speechModelOptions = {};
+			for (const key in speechModelOptions) {
+				const value = speechModelOptions[key];
+				if (value !== void 0) requestBody[key] = value;
+			}
+		}
+		if (language) warnings.push({
+			type: "unsupported",
+			feature: "language",
+			details: `OpenAI speech models do not support language selection. Language parameter "${language}" was ignored.`
+		});
+		return {
+			requestBody,
+			warnings
+		};
+	}
+	async doGenerate(options) {
+		var _a, _b, _c;
+		const currentDate = (_c = (_b = (_a = this.config._internal) == null ? void 0 : _a.currentDate) == null ? void 0 : _b.call(_a)) != null ? _c : /* @__PURE__ */ new Date();
+		const { requestBody, warnings } = await this.getArgs(options);
+		const { value: audio, responseHeaders, rawValue: rawResponse } = await postJsonToApi({
+			url: this.config.url({
+				path: "/audio/speech",
+				modelId: this.modelId
+			}),
+			headers: combineHeaders(this.config.headers(), options.headers),
+			body: requestBody,
+			failedResponseHandler: openaiFailedResponseHandler,
+			successfulResponseHandler: createBinaryResponseHandler(),
+			abortSignal: options.abortSignal,
+			fetch: this.config.fetch
+		});
+		return {
+			audio,
+			warnings,
+			request: { body: JSON.stringify(requestBody) },
+			response: {
+				timestamp: currentDate,
+				modelId: this.modelId,
+				headers: responseHeaders,
+				body: rawResponse
+			}
+		};
+	}
+};
+var openaiTranscriptionResponseSchema = lazySchema(() => zodSchema(object({
+	text: string(),
+	language: string().nullish(),
+	duration: number$1().nullish(),
+	words: array(object({
+		word: string(),
+		start: number$1(),
+		end: number$1()
+	})).nullish(),
+	segments: array(object({
+		id: number$1(),
+		seek: number$1(),
+		start: number$1(),
+		end: number$1(),
+		text: string(),
+		tokens: array(number$1()),
+		temperature: number$1(),
+		avg_logprob: number$1(),
+		compression_ratio: number$1(),
+		no_speech_prob: number$1()
+	})).nullish()
+})));
+var openAITranscriptionProviderOptions = lazySchema(() => zodSchema(object({
+	include: array(string()).optional(),
+	language: string().optional(),
+	prompt: string().optional(),
+	temperature: number$1().min(0).max(1).default(0).optional(),
+	timestampGranularities: array(_enum(["word", "segment"])).default(["segment"]).optional()
+})));
+var languageMap = {
+	afrikaans: "af",
+	arabic: "ar",
+	armenian: "hy",
+	azerbaijani: "az",
+	belarusian: "be",
+	bosnian: "bs",
+	bulgarian: "bg",
+	catalan: "ca",
+	chinese: "zh",
+	croatian: "hr",
+	czech: "cs",
+	danish: "da",
+	dutch: "nl",
+	english: "en",
+	estonian: "et",
+	finnish: "fi",
+	french: "fr",
+	galician: "gl",
+	german: "de",
+	greek: "el",
+	hebrew: "he",
+	hindi: "hi",
+	hungarian: "hu",
+	icelandic: "is",
+	indonesian: "id",
+	italian: "it",
+	japanese: "ja",
+	kannada: "kn",
+	kazakh: "kk",
+	korean: "ko",
+	latvian: "lv",
+	lithuanian: "lt",
+	macedonian: "mk",
+	malay: "ms",
+	marathi: "mr",
+	maori: "mi",
+	nepali: "ne",
+	norwegian: "no",
+	persian: "fa",
+	polish: "pl",
+	portuguese: "pt",
+	romanian: "ro",
+	russian: "ru",
+	serbian: "sr",
+	slovak: "sk",
+	slovenian: "sl",
+	spanish: "es",
+	swahili: "sw",
+	swedish: "sv",
+	tagalog: "tl",
+	tamil: "ta",
+	thai: "th",
+	turkish: "tr",
+	ukrainian: "uk",
+	urdu: "ur",
+	vietnamese: "vi",
+	welsh: "cy"
+};
+var OpenAITranscriptionModel = class {
+	constructor(modelId, config) {
+		this.modelId = modelId;
+		this.config = config;
+		this.specificationVersion = "v3";
+	}
+	get provider() {
+		return this.config.provider;
+	}
+	async getArgs({ audio, mediaType, providerOptions }) {
+		const warnings = [];
+		const openAIOptions = await parseProviderOptions({
+			provider: "openai",
+			providerOptions,
+			schema: openAITranscriptionProviderOptions
+		});
+		const formData = new FormData();
+		const blob = audio instanceof Uint8Array ? new Blob([audio]) : new Blob([convertBase64ToUint8Array(audio)]);
+		formData.append("model", this.modelId);
+		const fileExtension = mediaTypeToExtension(mediaType);
+		formData.append("file", new File([blob], "audio", { type: mediaType }), `audio.${fileExtension}`);
+		if (openAIOptions) {
+			const transcriptionModelOptions = {
+				include: openAIOptions.include,
+				language: openAIOptions.language,
+				prompt: openAIOptions.prompt,
+				response_format: ["gpt-4o-transcribe", "gpt-4o-mini-transcribe"].includes(this.modelId) ? "json" : "verbose_json",
+				temperature: openAIOptions.temperature,
+				timestamp_granularities: openAIOptions.timestampGranularities
+			};
+			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));
+			else formData.append(key, String(value));
+		}
+		return {
+			formData,
+			warnings
+		};
+	}
+	async doGenerate(options) {
+		var _a, _b, _c, _d, _e, _f, _g, _h;
+		const currentDate = (_c = (_b = (_a = this.config._internal) == null ? void 0 : _a.currentDate) == null ? void 0 : _b.call(_a)) != null ? _c : /* @__PURE__ */ new Date();
+		const { formData, warnings } = await this.getArgs(options);
+		const { value: response, responseHeaders, rawValue: rawResponse } = await postFormDataToApi({
+			url: this.config.url({
+				path: "/audio/transcriptions",
+				modelId: this.modelId
+			}),
+			headers: combineHeaders(this.config.headers(), options.headers),
+			formData,
+			failedResponseHandler: openaiFailedResponseHandler,
+			successfulResponseHandler: createJsonResponseHandler(openaiTranscriptionResponseSchema),
+			abortSignal: options.abortSignal,
+			fetch: this.config.fetch
+		});
+		const language = response.language != null && response.language in languageMap ? languageMap[response.language] : void 0;
+		return {
+			text: response.text,
+			segments: (_g = (_f = (_d = response.segments) == null ? void 0 : _d.map((segment) => ({
+				text: segment.text,
+				startSecond: segment.start,
+				endSecond: segment.end
+			}))) != null ? _f : (_e = response.words) == null ? void 0 : _e.map((word) => ({
+				text: word.word,
+				startSecond: word.start,
+				endSecond: word.end
+			}))) != null ? _g : [],
+			language,
+			durationInSeconds: (_h = response.duration) != null ? _h : void 0,
+			warnings,
+			response: {
+				timestamp: currentDate,
+				modelId: this.modelId,
+				headers: responseHeaders,
+				body: rawResponse
+			}
+		};
+	}
+};
+var VERSION = "3.0.25";
+function createOpenAI(options = {}) {
+	var _a, _b;
+	const baseURL = (_a = withoutTrailingSlash(loadOptionalSetting({
+		settingValue: options.baseURL,
+		environmentVariableName: "OPENAI_BASE_URL"
+	}))) != null ? _a : "https://api.openai.com/v1";
+	const providerName = (_b = options.name) != null ? _b : "openai";
+	const getHeaders = () => withUserAgentSuffix({
+		Authorization: `Bearer ${loadApiKey({
+			apiKey: options.apiKey,
+			environmentVariableName: "OPENAI_API_KEY",
+			description: "OpenAI"
+		})}`,
+		"OpenAI-Organization": options.organization,
+		"OpenAI-Project": options.project,
+		...options.headers
+	}, `ai-sdk/openai/${VERSION}`);
+	const createChatModel = (modelId) => new OpenAIChatLanguageModel(modelId, {
+		provider: `${providerName}.chat`,
+		url: ({ path }) => `${baseURL}${path}`,
+		headers: getHeaders,
+		fetch: options.fetch
+	});
+	const createCompletionModel = (modelId) => new OpenAICompletionLanguageModel(modelId, {
+		provider: `${providerName}.completion`,
+		url: ({ path }) => `${baseURL}${path}`,
+		headers: getHeaders,
+		fetch: options.fetch
+	});
+	const createEmbeddingModel = (modelId) => new OpenAIEmbeddingModel(modelId, {
+		provider: `${providerName}.embedding`,
+		url: ({ path }) => `${baseURL}${path}`,
+		headers: getHeaders,
+		fetch: options.fetch
+	});
+	const createImageModel = (modelId) => new OpenAIImageModel(modelId, {
+		provider: `${providerName}.image`,
+		url: ({ path }) => `${baseURL}${path}`,
+		headers: getHeaders,
+		fetch: options.fetch
+	});
+	const createTranscriptionModel = (modelId) => new OpenAITranscriptionModel(modelId, {
+		provider: `${providerName}.transcription`,
+		url: ({ path }) => `${baseURL}${path}`,
+		headers: getHeaders,
+		fetch: options.fetch
+	});
+	const createSpeechModel = (modelId) => new OpenAISpeechModel(modelId, {
+		provider: `${providerName}.speech`,
+		url: ({ path }) => `${baseURL}${path}`,
+		headers: getHeaders,
+		fetch: options.fetch
+	});
+	const createLanguageModel = (modelId) => {
+		if (new.target) throw new Error("The OpenAI model function cannot be called with the new keyword.");
+		return createResponsesModel(modelId);
+	};
+	const createResponsesModel = (modelId) => {
+		return new OpenAIResponsesLanguageModel(modelId, {
+			provider: `${providerName}.responses`,
+			url: ({ path }) => `${baseURL}${path}`,
+			headers: getHeaders,
+			fetch: options.fetch,
+			fileIdPrefixes: ["file-"]
+		});
+	};
+	const provider = function(modelId) {
+		return createLanguageModel(modelId);
+	};
+	provider.specificationVersion = "v3";
+	provider.languageModel = createLanguageModel;
+	provider.chat = createChatModel;
+	provider.completion = createCompletionModel;
+	provider.responses = createResponsesModel;
+	provider.embedding = createEmbeddingModel;
+	provider.embeddingModel = createEmbeddingModel;
+	provider.textEmbedding = createEmbeddingModel;
+	provider.textEmbeddingModel = createEmbeddingModel;
+	provider.image = createImageModel;
+	provider.imageModel = createImageModel;
+	provider.transcription = createTranscriptionModel;
+	provider.transcriptionModel = createTranscriptionModel;
+	provider.speech = createSpeechModel;
+	provider.speechModel = createSpeechModel;
+	provider.tools = openaiTools;
+	return provider;
+}
+var openai = createOpenAI();
+
+//#endregion
+export { openai };
+//# sourceMappingURL=dist-Dtrz_N2T.mjs.map