release-note 0.0.1 → 0.0.3

package/dist/dist-Cjmk9o-a.cjs

@@ -0,0 +1,1362 @@
+const require_asyncToGenerator = require("./asyncToGenerator-OdY5smjc.cjs");
+const require_generate = require("./generate-DqPPuOfE.cjs");
+//#region node_modules/.pnpm/@ai-sdk+openai-compatible@2.0.48_zod@4.4.3/node_modules/@ai-sdk/openai-compatible/dist/index.mjs
+require_asyncToGenerator.init_objectSpread2();
+require_asyncToGenerator.init_asyncToGenerator();
+const _excluded = ["role", "content"];
+function toCamelCase(str) {
+	return str.replace(/[_-]([a-z])/g, (g) => g[1].toUpperCase());
+}
+function resolveProviderOptionsKey(rawName, providerOptions) {
+	const camelName = toCamelCase(rawName);
+	if (camelName !== rawName && (providerOptions == null ? void 0 : providerOptions[camelName]) != null) return camelName;
+	return rawName;
+}
+var defaultOpenAICompatibleErrorStructure = {
+	errorSchema: require_generate.object({ error: require_generate.object({
+		message: require_generate.string(),
+		type: require_generate.string().nullish(),
+		param: require_generate.any().nullish(),
+		code: require_generate.union([require_generate.string(), require_generate.number()]).nullish()
+	}) }),
+	errorToMessage: (data) => data.error.message
+};
+function convertOpenAICompatibleChatUsage(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 cacheReadTokens = (_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 - cacheReadTokens,
+			cacheRead: cacheReadTokens,
+			cacheWrite: void 0
+		},
+		outputTokens: {
+			total: completionTokens,
+			text: completionTokens - reasoningTokens,
+			reasoning: reasoningTokens
+		},
+		raw: usage
+	};
+}
+function getOpenAIMetadata(message) {
+	var _a, _b;
+	return (_b = (_a = message == null ? void 0 : message.providerOptions) == null ? void 0 : _a.openaiCompatible) != null ? _b : {};
+}
+function getAudioFormat(mediaType) {
+	switch (mediaType) {
+		case "audio/wav": return "wav";
+		case "audio/mp3":
+		case "audio/mpeg": return "mp3";
+		default: return null;
+	}
+}
+function convertToOpenAICompatibleChatMessages(prompt) {
+	var _a, _b, _c;
+	const messages = [];
+	for (const _ref of prompt) {
+		let { role, content } = _ref;
+		const metadata = getOpenAIMetadata(require_asyncToGenerator._objectSpread2({}, require_generate._objectWithoutProperties(_ref, _excluded)));
+		switch (role) {
+			case "system":
+				messages.push(require_asyncToGenerator._objectSpread2({
+					role: "system",
+					content
+				}, metadata));
+				break;
+			case "user":
+				if (content.length === 1 && content[0].type === "text") {
+					messages.push(require_asyncToGenerator._objectSpread2({
+						role: "user",
+						content: content[0].text
+					}, getOpenAIMetadata(content[0])));
+					break;
+				}
+				messages.push(require_asyncToGenerator._objectSpread2({
+					role: "user",
+					content: content.map((part) => {
+						var _a2;
+						const partMetadata = getOpenAIMetadata(part);
+						switch (part.type) {
+							case "text": return require_asyncToGenerator._objectSpread2({
+								type: "text",
+								text: part.text
+							}, partMetadata);
+							case "file":
+								if (part.mediaType.startsWith("image/")) {
+									const mediaType = part.mediaType === "image/*" ? "image/jpeg" : part.mediaType;
+									return require_asyncToGenerator._objectSpread2({
+										type: "image_url",
+										image_url: { url: part.data instanceof URL ? part.data.toString() : `data:${mediaType};base64,${require_generate.convertToBase64(part.data)}` }
+									}, partMetadata);
+								}
+								if (part.mediaType.startsWith("audio/")) {
+									if (part.data instanceof URL) throw new require_generate.UnsupportedFunctionalityError({ functionality: "audio file parts with URLs" });
+									const format = getAudioFormat(part.mediaType);
+									if (format === null) throw new require_generate.UnsupportedFunctionalityError({ functionality: `audio media type ${part.mediaType}` });
+									return require_asyncToGenerator._objectSpread2({
+										type: "input_audio",
+										input_audio: {
+											data: require_generate.convertToBase64(part.data),
+											format
+										}
+									}, partMetadata);
+								}
+								if (part.mediaType === "application/pdf") {
+									if (part.data instanceof URL) throw new require_generate.UnsupportedFunctionalityError({ functionality: "PDF file parts with URLs" });
+									return require_asyncToGenerator._objectSpread2({
+										type: "file",
+										file: {
+											filename: (_a2 = part.filename) != null ? _a2 : "document.pdf",
+											file_data: `data:application/pdf;base64,${require_generate.convertToBase64(part.data)}`
+										}
+									}, partMetadata);
+								}
+								if (part.mediaType.startsWith("text/")) return require_asyncToGenerator._objectSpread2({
+									type: "text",
+									text: part.data instanceof URL ? part.data.toString() : typeof part.data === "string" ? new TextDecoder().decode(require_generate.convertBase64ToUint8Array(part.data)) : new TextDecoder().decode(part.data)
+								}, partMetadata);
+								throw new require_generate.UnsupportedFunctionalityError({ functionality: `file part media type ${part.mediaType}` });
+						}
+					})
+				}, metadata));
+				break;
+			case "assistant": {
+				let text = "";
+				let reasoning = "";
+				const toolCalls = [];
+				for (const part of content) {
+					const partMetadata = getOpenAIMetadata(part);
+					switch (part.type) {
+						case "text":
+							text += part.text;
+							break;
+						case "reasoning":
+							reasoning += part.text;
+							break;
+						case "tool-call": {
+							const thoughtSignature = (_b = (_a = part.providerOptions) == null ? void 0 : _a.google) == null ? void 0 : _b.thoughtSignature;
+							toolCalls.push(require_asyncToGenerator._objectSpread2(require_asyncToGenerator._objectSpread2({
+								id: part.toolCallId,
+								type: "function",
+								function: {
+									name: part.toolName,
+									arguments: JSON.stringify(part.input)
+								}
+							}, partMetadata), thoughtSignature ? { extra_content: { google: { thought_signature: String(thoughtSignature) } } } : {}));
+							break;
+						}
+					}
+				}
+				messages.push(require_asyncToGenerator._objectSpread2(require_asyncToGenerator._objectSpread2({
+					role: "assistant",
+					content: toolCalls.length > 0 ? text || null : text
+				}, reasoning.length > 0 ? { reasoning_content: reasoning } : {}), {}, { tool_calls: toolCalls.length > 0 ? toolCalls : void 0 }, metadata));
+				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 = (_c = output.reason) != null ? _c : "Tool execution denied.";
+							break;
+						case "content":
+						case "json":
+						case "error-json":
+							contentValue = JSON.stringify(output.value);
+							break;
+					}
+					const toolResponseMetadata = getOpenAIMetadata(toolResponse);
+					messages.push(require_asyncToGenerator._objectSpread2({
+						role: "tool",
+						tool_call_id: toolResponse.toolCallId,
+						content: contentValue
+					}, toolResponseMetadata));
+				}
+				break;
+			default: throw new Error(`Unsupported role: ${role}`);
+		}
+	}
+	return messages;
+}
+function getResponseMetadata({ 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 mapOpenAICompatibleFinishReason(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 openaiCompatibleLanguageModelChatOptions = require_generate.object({
+	/**
+	* A unique identifier representing your end-user, which can help the provider to
+	* monitor and detect abuse.
+	*/
+	user: require_generate.string().optional(),
+	/**
+	* Reasoning effort for reasoning models. Defaults to `medium`.
+	*/
+	reasoningEffort: require_generate.string().optional(),
+	/**
+	* Controls the verbosity of the generated text. Defaults to `medium`.
+	*/
+	textVerbosity: require_generate.string().optional(),
+	/**
+	* Whether to use strict JSON schema validation.
+	* When true, the model uses constrained decoding to guarantee schema compliance.
+	* Only used when the provider supports structured outputs and a schema is provided.
+	*
+	* @default true
+	*/
+	strictJsonSchema: require_generate.boolean().optional()
+});
+function prepareTools({ 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 openaiCompatTools = [];
+	for (const tool of tools) if (tool.type === "provider") toolWarnings.push({
+		type: "unsupported",
+		feature: `provider-defined tool ${tool.id}`
+	});
+	else openaiCompatTools.push({
+		type: "function",
+		function: require_asyncToGenerator._objectSpread2({
+			name: tool.name,
+			description: tool.description,
+			parameters: tool.inputSchema
+		}, tool.strict != null ? { strict: tool.strict } : {})
+	});
+	if (toolChoice == null) return {
+		tools: openaiCompatTools,
+		toolChoice: void 0,
+		toolWarnings
+	};
+	const type = toolChoice.type;
+	switch (type) {
+		case "auto":
+		case "none":
+		case "required": return {
+			tools: openaiCompatTools,
+			toolChoice: type,
+			toolWarnings
+		};
+		case "tool": return {
+			tools: openaiCompatTools,
+			toolChoice: {
+				type: "function",
+				function: { name: toolChoice.toolName }
+			},
+			toolWarnings
+		};
+		default: throw new require_generate.UnsupportedFunctionalityError({ functionality: `tool choice type: ${type}` });
+	}
+}
+var OpenAICompatibleChatLanguageModel = class {
+	constructor(modelId, config) {
+		this.specificationVersion = "v3";
+		var _a, _b;
+		this.modelId = modelId;
+		this.config = config;
+		const errorStructure = (_a = config.errorStructure) != null ? _a : defaultOpenAICompatibleErrorStructure;
+		this.chunkSchema = createOpenAICompatibleChatChunkSchema(errorStructure.errorSchema);
+		this.failedResponseHandler = require_generate.createJsonErrorResponseHandler(errorStructure);
+		this.supportsStructuredOutputs = (_b = config.supportsStructuredOutputs) != null ? _b : false;
+	}
+	get provider() {
+		return this.config.provider;
+	}
+	get providerOptionsName() {
+		return this.config.provider.split(".")[0].trim();
+	}
+	get supportedUrls() {
+		var _a, _b, _c;
+		return (_c = (_b = (_a = this.config).supportedUrls) == null ? void 0 : _b.call(_a)) != null ? _c : {};
+	}
+	transformRequestBody(args) {
+		var _a, _b, _c;
+		return (_c = (_b = (_a = this.config).transformRequestBody) == null ? void 0 : _b.call(_a, args)) != null ? _c : args;
+	}
+	convertUsage(usage) {
+		var _a, _b, _c;
+		return (_c = (_b = (_a = this.config).convertUsage) == null ? void 0 : _b.call(_a, usage)) != null ? _c : convertOpenAICompatibleChatUsage(usage);
+	}
+	getArgs({ prompt, maxOutputTokens, temperature, topP, topK, frequencyPenalty, presencePenalty, providerOptions, stopSequences, responseFormat, seed, toolChoice, tools }) {
+		var _this = this;
+		return require_asyncToGenerator._asyncToGenerator(function* () {
+			var _a, _b, _c, _d, _e;
+			const warnings = [];
+			const deprecatedOptions = yield require_generate.parseProviderOptions({
+				provider: "openai-compatible",
+				providerOptions,
+				schema: openaiCompatibleLanguageModelChatOptions
+			});
+			if (deprecatedOptions != null) warnings.push({
+				type: "other",
+				message: `The 'openai-compatible' key in providerOptions is deprecated. Use 'openaiCompatible' instead.`
+			});
+			const compatibleOptions = Object.assign(deprecatedOptions != null ? deprecatedOptions : {}, (_a = yield require_generate.parseProviderOptions({
+				provider: "openaiCompatible",
+				providerOptions,
+				schema: openaiCompatibleLanguageModelChatOptions
+			})) != null ? _a : {}, (_b = yield require_generate.parseProviderOptions({
+				provider: _this.providerOptionsName,
+				providerOptions,
+				schema: openaiCompatibleLanguageModelChatOptions
+			})) != null ? _b : {}, (_c = yield require_generate.parseProviderOptions({
+				provider: toCamelCase(_this.providerOptionsName),
+				providerOptions,
+				schema: openaiCompatibleLanguageModelChatOptions
+			})) != null ? _c : {});
+			const strictJsonSchema = (_d = compatibleOptions == null ? void 0 : compatibleOptions.strictJsonSchema) != null ? _d : true;
+			if (topK != null) warnings.push({
+				type: "unsupported",
+				feature: "topK"
+			});
+			if ((responseFormat == null ? void 0 : responseFormat.type) === "json" && responseFormat.schema != null && !_this.supportsStructuredOutputs) warnings.push({
+				type: "unsupported",
+				feature: "responseFormat",
+				details: "JSON response format schema is only supported with structuredOutputs"
+			});
+			const { tools: openaiTools, toolChoice: openaiToolChoice, toolWarnings } = prepareTools({
+				tools,
+				toolChoice
+			});
+			return {
+				metadataKey: resolveProviderOptionsKey(_this.providerOptionsName, providerOptions),
+				args: require_asyncToGenerator._objectSpread2(require_asyncToGenerator._objectSpread2({
+					model: _this.modelId,
+					user: compatibleOptions.user,
+					max_tokens: maxOutputTokens,
+					temperature,
+					top_p: topP,
+					frequency_penalty: frequencyPenalty,
+					presence_penalty: presencePenalty,
+					response_format: (responseFormat == null ? void 0 : responseFormat.type) === "json" ? _this.supportsStructuredOutputs === true && 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
+				}, Object.fromEntries(Object.entries(require_asyncToGenerator._objectSpread2(require_asyncToGenerator._objectSpread2({}, providerOptions == null ? void 0 : providerOptions[_this.providerOptionsName]), providerOptions == null ? void 0 : providerOptions[toCamelCase(_this.providerOptionsName)])).filter(([key]) => !Object.keys(openaiCompatibleLanguageModelChatOptions.shape).includes(key)))), {}, {
+					reasoning_effort: compatibleOptions.reasoningEffort,
+					verbosity: compatibleOptions.textVerbosity,
+					messages: convertToOpenAICompatibleChatMessages(prompt),
+					tools: openaiTools,
+					tool_choice: openaiToolChoice
+				}),
+				warnings: [...warnings, ...toolWarnings]
+			};
+		})();
+	}
+	doGenerate(options) {
+		var _this2 = this;
+		return require_asyncToGenerator._asyncToGenerator(function* () {
+			var _a, _b, _c, _d, _e, _f, _g, _h;
+			const { args, warnings, metadataKey } = yield _this2.getArgs(require_asyncToGenerator._objectSpread2({}, options));
+			const transformedBody = _this2.transformRequestBody(args);
+			const body = JSON.stringify(transformedBody);
+			const { responseHeaders, value: responseBody, rawValue: rawResponse } = yield require_generate.postJsonToApi({
+				url: _this2.config.url({
+					path: "/chat/completions",
+					modelId: _this2.modelId
+				}),
+				headers: require_generate.combineHeaders(_this2.config.headers(), options.headers),
+				body: transformedBody,
+				failedResponseHandler: _this2.failedResponseHandler,
+				successfulResponseHandler: require_generate.createJsonResponseHandler(OpenAICompatibleChatResponseSchema),
+				abortSignal: options.abortSignal,
+				fetch: _this2.config.fetch
+			});
+			const choice = responseBody.choices[0];
+			const content = [];
+			const text = choice.message.content;
+			if (text != null && text.length > 0) content.push({
+				type: "text",
+				text
+			});
+			const reasoning = (_a = choice.message.reasoning_content) != null ? _a : choice.message.reasoning;
+			if (reasoning != null && reasoning.length > 0) content.push({
+				type: "reasoning",
+				text: reasoning
+			});
+			if (choice.message.tool_calls != null) for (const toolCall of choice.message.tool_calls) {
+				const thoughtSignature = (_c = (_b = toolCall.extra_content) == null ? void 0 : _b.google) == null ? void 0 : _c.thought_signature;
+				content.push(require_asyncToGenerator._objectSpread2({
+					type: "tool-call",
+					toolCallId: (_d = toolCall.id) != null ? _d : require_generate.generateId(),
+					toolName: toolCall.function.name,
+					input: toolCall.function.arguments
+				}, thoughtSignature ? { providerMetadata: { [metadataKey]: { thoughtSignature } } } : {}));
+			}
+			const providerMetadata = require_asyncToGenerator._objectSpread2({ [metadataKey]: {} }, yield (_f = (_e = _this2.config.metadataExtractor) == null ? void 0 : _e.extractMetadata) == null ? void 0 : _f.call(_e, { parsedBody: rawResponse }));
+			const completionTokenDetails = (_g = responseBody.usage) == null ? void 0 : _g.completion_tokens_details;
+			if ((completionTokenDetails == null ? void 0 : completionTokenDetails.accepted_prediction_tokens) != null) providerMetadata[metadataKey].acceptedPredictionTokens = completionTokenDetails == null ? void 0 : completionTokenDetails.accepted_prediction_tokens;
+			if ((completionTokenDetails == null ? void 0 : completionTokenDetails.rejected_prediction_tokens) != null) providerMetadata[metadataKey].rejectedPredictionTokens = completionTokenDetails == null ? void 0 : completionTokenDetails.rejected_prediction_tokens;
+			return {
+				content,
+				finishReason: {
+					unified: mapOpenAICompatibleFinishReason(choice.finish_reason),
+					raw: (_h = choice.finish_reason) != null ? _h : void 0
+				},
+				usage: _this2.convertUsage(responseBody.usage),
+				providerMetadata,
+				request: { body },
+				response: require_asyncToGenerator._objectSpread2(require_asyncToGenerator._objectSpread2({}, getResponseMetadata(responseBody)), {}, {
+					headers: responseHeaders,
+					body: rawResponse
+				}),
+				warnings
+			};
+		})();
+	}
+	doStream(options) {
+		var _this3 = this;
+		return require_asyncToGenerator._asyncToGenerator(function* () {
+			var _a;
+			const { args, warnings, metadataKey } = yield _this3.getArgs(require_asyncToGenerator._objectSpread2({}, options));
+			const body = _this3.transformRequestBody(require_asyncToGenerator._objectSpread2(require_asyncToGenerator._objectSpread2({}, args), {}, {
+				stream: true,
+				stream_options: _this3.config.includeUsage ? { include_usage: true } : void 0
+			}));
+			const metadataExtractor = (_a = _this3.config.metadataExtractor) == null ? void 0 : _a.createStreamExtractor();
+			const { responseHeaders, value: response } = yield require_generate.postJsonToApi({
+				url: _this3.config.url({
+					path: "/chat/completions",
+					modelId: _this3.modelId
+				}),
+				headers: require_generate.combineHeaders(_this3.config.headers(), options.headers),
+				body,
+				failedResponseHandler: _this3.failedResponseHandler,
+				successfulResponseHandler: require_generate.createEventSourceResponseHandler(_this3.chunkSchema),
+				abortSignal: options.abortSignal,
+				fetch: _this3.config.fetch
+			});
+			const toolCalls = [];
+			let finishReason = {
+				unified: "other",
+				raw: void 0
+			};
+			let usage = void 0;
+			let isFirstChunk = true;
+			const providerOptionsName = metadataKey;
+			let isActiveReasoning = false;
+			let isActiveText = false;
+			const convertUsage = (usage2) => _this3.convertUsage(usage2);
+			return {
+				stream: response.pipeThrough(new TransformStream({
+					start(controller) {
+						controller.enqueue({
+							type: "stream-start",
+							warnings
+						});
+					},
+					transform(chunk, controller) {
+						var _a2, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r;
+						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;
+						}
+						metadataExtractor == null || metadataExtractor.processChunk(chunk.rawValue);
+						if ("error" in chunk.value) {
+							finishReason = {
+								unified: "error",
+								raw: void 0
+							};
+							controller.enqueue({
+								type: "error",
+								error: chunk.value.error.message
+							});
+							return;
+						}
+						const value = chunk.value;
+						if (isFirstChunk) {
+							isFirstChunk = false;
+							controller.enqueue(require_asyncToGenerator._objectSpread2({ type: "response-metadata" }, getResponseMetadata(value)));
+						}
+						if (value.usage != null) usage = value.usage;
+						const choice = value.choices[0];
+						if ((choice == null ? void 0 : choice.finish_reason) != null) finishReason = {
+							unified: mapOpenAICompatibleFinishReason(choice.finish_reason),
+							raw: (_a2 = choice.finish_reason) != null ? _a2 : void 0
+						};
+						if ((choice == null ? void 0 : choice.delta) == null) return;
+						const delta = choice.delta;
+						const reasoningContent = (_b = delta.reasoning_content) != null ? _b : delta.reasoning;
+						if (reasoningContent) {
+							if (!isActiveReasoning) {
+								controller.enqueue({
+									type: "reasoning-start",
+									id: "reasoning-0"
+								});
+								isActiveReasoning = true;
+							}
+							controller.enqueue({
+								type: "reasoning-delta",
+								id: "reasoning-0",
+								delta: reasoningContent
+							});
+						}
+						if (delta.content) {
+							if (isActiveReasoning) {
+								controller.enqueue({
+									type: "reasoning-end",
+									id: "reasoning-0"
+								});
+								isActiveReasoning = false;
+							}
+							if (!isActiveText) {
+								controller.enqueue({
+									type: "text-start",
+									id: "txt-0"
+								});
+								isActiveText = true;
+							}
+							controller.enqueue({
+								type: "text-delta",
+								id: "txt-0",
+								delta: delta.content
+							});
+						}
+						if (delta.tool_calls != null) {
+							if (isActiveReasoning) {
+								controller.enqueue({
+									type: "reasoning-end",
+									id: "reasoning-0"
+								});
+								isActiveReasoning = false;
+							}
+							for (const toolCallDelta of delta.tool_calls) {
+								const index = (_c = toolCallDelta.index) != null ? _c : toolCalls.length;
+								if (toolCalls[index] == null) {
+									if (toolCallDelta.id == null) throw new require_generate.InvalidResponseDataError({
+										data: toolCallDelta,
+										message: `Expected 'id' to be a string.`
+									});
+									if (((_d = toolCallDelta.function) == null ? void 0 : _d.name) == null) throw new require_generate.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: (_e = toolCallDelta.function.arguments) != null ? _e : ""
+										},
+										hasFinished: false,
+										thoughtSignature: (_h = (_g = (_f = toolCallDelta.extra_content) == null ? void 0 : _f.google) == null ? void 0 : _g.thought_signature) != null ? _h : void 0
+									};
+									const toolCall2 = toolCalls[index];
+									if (((_i = toolCall2.function) == null ? void 0 : _i.name) != null && ((_j = toolCall2.function) == null ? void 0 : _j.arguments) != null) {
+										if (toolCall2.function.arguments.length > 0) controller.enqueue({
+											type: "tool-input-delta",
+											id: toolCall2.id,
+											delta: toolCall2.function.arguments
+										});
+										if (require_generate.isParsableJson(toolCall2.function.arguments)) {
+											controller.enqueue({
+												type: "tool-input-end",
+												id: toolCall2.id
+											});
+											controller.enqueue(require_asyncToGenerator._objectSpread2({
+												type: "tool-call",
+												toolCallId: (_k = toolCall2.id) != null ? _k : require_generate.generateId(),
+												toolName: toolCall2.function.name,
+												input: toolCall2.function.arguments
+											}, toolCall2.thoughtSignature ? { providerMetadata: { [providerOptionsName]: { thoughtSignature: toolCall2.thoughtSignature } } } : {}));
+											toolCall2.hasFinished = true;
+										}
+									}
+									continue;
+								}
+								const toolCall = toolCalls[index];
+								if (toolCall.hasFinished) continue;
+								if (((_l = toolCallDelta.function) == null ? void 0 : _l.arguments) != null) toolCall.function.arguments += (_n = (_m = toolCallDelta.function) == null ? void 0 : _m.arguments) != null ? _n : "";
+								controller.enqueue({
+									type: "tool-input-delta",
+									id: toolCall.id,
+									delta: (_o = toolCallDelta.function.arguments) != null ? _o : ""
+								});
+								if (((_p = toolCall.function) == null ? void 0 : _p.name) != null && ((_q = toolCall.function) == null ? void 0 : _q.arguments) != null && require_generate.isParsableJson(toolCall.function.arguments)) {
+									controller.enqueue({
+										type: "tool-input-end",
+										id: toolCall.id
+									});
+									controller.enqueue(require_asyncToGenerator._objectSpread2({
+										type: "tool-call",
+										toolCallId: (_r = toolCall.id) != null ? _r : require_generate.generateId(),
+										toolName: toolCall.function.name,
+										input: toolCall.function.arguments
+									}, toolCall.thoughtSignature ? { providerMetadata: { [providerOptionsName]: { thoughtSignature: toolCall.thoughtSignature } } } : {}));
+									toolCall.hasFinished = true;
+								}
+							}
+						}
+					},
+					flush(controller) {
+						var _a2, _b, _c, _d, _e;
+						if (isActiveReasoning) controller.enqueue({
+							type: "reasoning-end",
+							id: "reasoning-0"
+						});
+						if (isActiveText) controller.enqueue({
+							type: "text-end",
+							id: "txt-0"
+						});
+						for (const toolCall of toolCalls.filter((toolCall2) => !toolCall2.hasFinished)) {
+							controller.enqueue({
+								type: "tool-input-end",
+								id: toolCall.id
+							});
+							controller.enqueue(require_asyncToGenerator._objectSpread2({
+								type: "tool-call",
+								toolCallId: (_a2 = toolCall.id) != null ? _a2 : require_generate.generateId(),
+								toolName: toolCall.function.name,
+								input: toolCall.function.arguments
+							}, toolCall.thoughtSignature ? { providerMetadata: { [providerOptionsName]: { thoughtSignature: toolCall.thoughtSignature } } } : {}));
+						}
+						const providerMetadata = require_asyncToGenerator._objectSpread2({ [providerOptionsName]: {} }, metadataExtractor == null ? void 0 : metadataExtractor.buildMetadata());
+						if (((_b = usage == null ? void 0 : usage.completion_tokens_details) == null ? void 0 : _b.accepted_prediction_tokens) != null) providerMetadata[providerOptionsName].acceptedPredictionTokens = (_c = usage == null ? void 0 : usage.completion_tokens_details) == null ? void 0 : _c.accepted_prediction_tokens;
+						if (((_d = usage == null ? void 0 : usage.completion_tokens_details) == null ? void 0 : _d.rejected_prediction_tokens) != null) providerMetadata[providerOptionsName].rejectedPredictionTokens = (_e = usage == null ? void 0 : usage.completion_tokens_details) == null ? void 0 : _e.rejected_prediction_tokens;
+						controller.enqueue({
+							type: "finish",
+							finishReason,
+							usage: convertUsage(usage),
+							providerMetadata
+						});
+					}
+				})),
+				request: { body },
+				response: { headers: responseHeaders }
+			};
+		})();
+	}
+};
+var openaiCompatibleTokenUsageSchema = require_generate.looseObject({
+	prompt_tokens: require_generate.number().nullish(),
+	completion_tokens: require_generate.number().nullish(),
+	total_tokens: require_generate.number().nullish(),
+	prompt_tokens_details: require_generate.object({ cached_tokens: require_generate.number().nullish() }).nullish(),
+	completion_tokens_details: require_generate.object({
+		reasoning_tokens: require_generate.number().nullish(),
+		accepted_prediction_tokens: require_generate.number().nullish(),
+		rejected_prediction_tokens: require_generate.number().nullish()
+	}).nullish()
+}).nullish();
+var OpenAICompatibleChatResponseSchema = require_generate.looseObject({
+	id: require_generate.string().nullish(),
+	created: require_generate.number().nullish(),
+	model: require_generate.string().nullish(),
+	choices: require_generate.array(require_generate.object({
+		message: require_generate.object({
+			role: require_generate.literal("assistant").nullish(),
+			content: require_generate.string().nullish(),
+			reasoning_content: require_generate.string().nullish(),
+			reasoning: require_generate.string().nullish(),
+			tool_calls: require_generate.array(require_generate.object({
+				id: require_generate.string().nullish(),
+				function: require_generate.object({
+					name: require_generate.string(),
+					arguments: require_generate.string()
+				}),
+				extra_content: require_generate.object({ google: require_generate.object({ thought_signature: require_generate.string().nullish() }).nullish() }).nullish()
+			})).nullish()
+		}),
+		finish_reason: require_generate.string().nullish()
+	})),
+	usage: openaiCompatibleTokenUsageSchema
+});
+var chunkBaseSchema = require_generate.looseObject({
+	id: require_generate.string().nullish(),
+	created: require_generate.number().nullish(),
+	model: require_generate.string().nullish(),
+	choices: require_generate.array(require_generate.object({
+		delta: require_generate.object({
+			role: require_generate._enum(["assistant", ""]).nullish(),
+			content: require_generate.string().nullish(),
+			reasoning_content: require_generate.string().nullish(),
+			reasoning: require_generate.string().nullish(),
+			tool_calls: require_generate.array(require_generate.object({
+				index: require_generate.number().nullish(),
+				id: require_generate.string().nullish(),
+				function: require_generate.object({
+					name: require_generate.string().nullish(),
+					arguments: require_generate.string().nullish()
+				}),
+				extra_content: require_generate.object({ google: require_generate.object({ thought_signature: require_generate.string().nullish() }).nullish() }).nullish()
+			})).nullish()
+		}).nullish(),
+		finish_reason: require_generate.string().nullish()
+	})),
+	usage: openaiCompatibleTokenUsageSchema
+});
+var createOpenAICompatibleChatChunkSchema = (errorSchema) => require_generate.union([chunkBaseSchema, errorSchema]);
+function convertOpenAICompatibleCompletionUsage(usage) {
+	var _a, _b;
+	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: promptTokens,
+			noCache: promptTokens,
+			cacheRead: void 0,
+			cacheWrite: void 0
+		},
+		outputTokens: {
+			total: completionTokens,
+			text: completionTokens,
+			reasoning: void 0
+		},
+		raw: usage
+	};
+}
+function convertToOpenAICompatibleCompletionPrompt({ 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 require_generate.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 require_generate.UnsupportedFunctionalityError({ functionality: "tool-call messages" });
+				}
+			}).join("");
+			text += `${assistant}:
+${assistantMessage}
+
+`;
+			break;
+		}
+		case "tool": throw new require_generate.UnsupportedFunctionalityError({ functionality: "tool messages" });
+		default: throw new Error(`Unsupported role: ${role}`);
+	}
+	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 mapOpenAICompatibleFinishReason2(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 openaiCompatibleLanguageModelCompletionOptions = require_generate.object({
+	/**
+	* Echo back the prompt in addition to the completion.
+	*/
+	echo: require_generate.boolean().optional(),
+	/**
+	* Modify the likelihood of specified tokens appearing in the completion.
+	*
+	* Accepts a JSON object that maps tokens (specified by their token ID in
+	* the GPT tokenizer) to an associated bias value from -100 to 100.
+	*/
+	logitBias: require_generate.record(require_generate.string(), require_generate.number()).optional(),
+	/**
+	* The suffix that comes after a completion of inserted text.
+	*/
+	suffix: require_generate.string().optional(),
+	/**
+	* A unique identifier representing your end-user, which can help providers to
+	* monitor and detect abuse.
+	*/
+	user: require_generate.string().optional()
+});
+var OpenAICompatibleCompletionLanguageModel = class {
+	constructor(modelId, config) {
+		this.specificationVersion = "v3";
+		var _a;
+		this.modelId = modelId;
+		this.config = config;
+		const errorStructure = (_a = config.errorStructure) != null ? _a : defaultOpenAICompatibleErrorStructure;
+		this.chunkSchema = createOpenAICompatibleCompletionChunkSchema(errorStructure.errorSchema);
+		this.failedResponseHandler = require_generate.createJsonErrorResponseHandler(errorStructure);
+	}
+	get provider() {
+		return this.config.provider;
+	}
+	get providerOptionsName() {
+		return this.config.provider.split(".")[0].trim();
+	}
+	get supportedUrls() {
+		var _a, _b, _c;
+		return (_c = (_b = (_a = this.config).supportedUrls) == null ? void 0 : _b.call(_a)) != null ? _c : {};
+	}
+	getArgs({ prompt, maxOutputTokens, temperature, topP, topK, frequencyPenalty, presencePenalty, stopSequences: userStopSequences, responseFormat, seed, providerOptions, tools, toolChoice }) {
+		var _this4 = this;
+		return require_asyncToGenerator._asyncToGenerator(function* () {
+			var _a, _b;
+			const warnings = [];
+			const completionOptions = Object.assign((_a = yield require_generate.parseProviderOptions({
+				provider: _this4.providerOptionsName,
+				providerOptions,
+				schema: openaiCompatibleLanguageModelCompletionOptions
+			})) != null ? _a : {}, (_b = yield require_generate.parseProviderOptions({
+				provider: toCamelCase(_this4.providerOptionsName),
+				providerOptions,
+				schema: openaiCompatibleLanguageModelCompletionOptions
+			})) != null ? _b : {});
+			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 } = convertToOpenAICompatibleCompletionPrompt({ prompt });
+			const stop = [...stopSequences != null ? stopSequences : [], ...userStopSequences != null ? userStopSequences : []];
+			return {
+				args: require_asyncToGenerator._objectSpread2(require_asyncToGenerator._objectSpread2(require_asyncToGenerator._objectSpread2({
+					model: _this4.modelId,
+					echo: completionOptions.echo,
+					logit_bias: completionOptions.logitBias,
+					suffix: completionOptions.suffix,
+					user: completionOptions.user,
+					max_tokens: maxOutputTokens,
+					temperature,
+					top_p: topP,
+					frequency_penalty: frequencyPenalty,
+					presence_penalty: presencePenalty,
+					seed
+				}, providerOptions == null ? void 0 : providerOptions[_this4.providerOptionsName]), providerOptions == null ? void 0 : providerOptions[toCamelCase(_this4.providerOptionsName)]), {}, {
+					prompt: completionPrompt,
+					stop: stop.length > 0 ? stop : void 0
+				}),
+				warnings
+			};
+		})();
+	}
+	doGenerate(options) {
+		var _this5 = this;
+		return require_asyncToGenerator._asyncToGenerator(function* () {
+			const { args, warnings } = yield _this5.getArgs(options);
+			const { responseHeaders, value: response, rawValue: rawResponse } = yield require_generate.postJsonToApi({
+				url: _this5.config.url({
+					path: "/completions",
+					modelId: _this5.modelId
+				}),
+				headers: require_generate.combineHeaders(_this5.config.headers(), options.headers),
+				body: args,
+				failedResponseHandler: _this5.failedResponseHandler,
+				successfulResponseHandler: require_generate.createJsonResponseHandler(openaiCompatibleCompletionResponseSchema),
+				abortSignal: options.abortSignal,
+				fetch: _this5.config.fetch
+			});
+			const choice = response.choices[0];
+			const content = [];
+			if (choice.text != null && choice.text.length > 0) content.push({
+				type: "text",
+				text: choice.text
+			});
+			return {
+				content,
+				usage: convertOpenAICompatibleCompletionUsage(response.usage),
+				finishReason: {
+					unified: mapOpenAICompatibleFinishReason2(choice.finish_reason),
+					raw: choice.finish_reason
+				},
+				request: { body: args },
+				response: require_asyncToGenerator._objectSpread2(require_asyncToGenerator._objectSpread2({}, getResponseMetadata2(response)), {}, {
+					headers: responseHeaders,
+					body: rawResponse
+				}),
+				warnings
+			};
+		})();
+	}
+	doStream(options) {
+		var _this6 = this;
+		return require_asyncToGenerator._asyncToGenerator(function* () {
+			const { args, warnings } = yield _this6.getArgs(options);
+			const body = require_asyncToGenerator._objectSpread2(require_asyncToGenerator._objectSpread2({}, args), {}, {
+				stream: true,
+				stream_options: _this6.config.includeUsage ? { include_usage: true } : void 0
+			});
+			const { responseHeaders, value: response } = yield require_generate.postJsonToApi({
+				url: _this6.config.url({
+					path: "/completions",
+					modelId: _this6.modelId
+				}),
+				headers: require_generate.combineHeaders(_this6.config.headers(), options.headers),
+				body,
+				failedResponseHandler: _this6.failedResponseHandler,
+				successfulResponseHandler: require_generate.createEventSourceResponseHandler(_this6.chunkSchema),
+				abortSignal: options.abortSignal,
+				fetch: _this6.config.fetch
+			});
+			let finishReason = {
+				unified: "other",
+				raw: void 0
+			};
+			let usage = void 0;
+			let isFirstChunk = true;
+			return {
+				stream: response.pipeThrough(new TransformStream({
+					start(controller) {
+						controller.enqueue({
+							type: "stream-start",
+							warnings
+						});
+					},
+					transform(chunk, controller) {
+						var _a;
+						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(require_asyncToGenerator._objectSpread2({ 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: mapOpenAICompatibleFinishReason2(choice.finish_reason),
+							raw: (_a = choice.finish_reason) != null ? _a : void 0
+						};
+						if ((choice == null ? void 0 : choice.text) != null) 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,
+							usage: convertOpenAICompatibleCompletionUsage(usage)
+						});
+					}
+				})),
+				request: { body },
+				response: { headers: responseHeaders }
+			};
+		})();
+	}
+};
+var usageSchema = require_generate.object({
+	prompt_tokens: require_generate.number(),
+	completion_tokens: require_generate.number(),
+	total_tokens: require_generate.number()
+});
+var openaiCompatibleCompletionResponseSchema = require_generate.object({
+	id: require_generate.string().nullish(),
+	created: require_generate.number().nullish(),
+	model: require_generate.string().nullish(),
+	choices: require_generate.array(require_generate.object({
+		text: require_generate.string(),
+		finish_reason: require_generate.string()
+	})),
+	usage: usageSchema.nullish()
+});
+var createOpenAICompatibleCompletionChunkSchema = (errorSchema) => require_generate.union([require_generate.object({
+	id: require_generate.string().nullish(),
+	created: require_generate.number().nullish(),
+	model: require_generate.string().nullish(),
+	choices: require_generate.array(require_generate.object({
+		text: require_generate.string(),
+		finish_reason: require_generate.string().nullish(),
+		index: require_generate.number()
+	})),
+	usage: usageSchema.nullish()
+}), errorSchema]);
+var openaiCompatibleEmbeddingModelOptions = require_generate.object({
+	/**
+	* The number of dimensions the resulting output embeddings should have.
+	* Only supported in text-embedding-3 and later models.
+	*/
+	dimensions: require_generate.number().optional(),
+	/**
+	* A unique identifier representing your end-user, which can help providers to
+	* monitor and detect abuse.
+	*/
+	user: require_generate.string().optional()
+});
+var OpenAICompatibleEmbeddingModel = class {
+	constructor(modelId, config) {
+		this.specificationVersion = "v3";
+		this.modelId = modelId;
+		this.config = config;
+	}
+	get provider() {
+		return this.config.provider;
+	}
+	get maxEmbeddingsPerCall() {
+		var _a;
+		return (_a = this.config.maxEmbeddingsPerCall) != null ? _a : 2048;
+	}
+	get supportsParallelCalls() {
+		var _a;
+		return (_a = this.config.supportsParallelCalls) != null ? _a : true;
+	}
+	get providerOptionsName() {
+		return this.config.provider.split(".")[0].trim();
+	}
+	doEmbed({ values, headers, abortSignal, providerOptions }) {
+		var _this7 = this;
+		return require_asyncToGenerator._asyncToGenerator(function* () {
+			var _a, _b, _c;
+			const warnings = [];
+			const deprecatedOptions = yield require_generate.parseProviderOptions({
+				provider: "openai-compatible",
+				providerOptions,
+				schema: openaiCompatibleEmbeddingModelOptions
+			});
+			if (deprecatedOptions != null) warnings.push({
+				type: "other",
+				message: `The 'openai-compatible' key in providerOptions is deprecated. Use 'openaiCompatible' instead.`
+			});
+			const compatibleOptions = Object.assign(deprecatedOptions != null ? deprecatedOptions : {}, (_a = yield require_generate.parseProviderOptions({
+				provider: "openaiCompatible",
+				providerOptions,
+				schema: openaiCompatibleEmbeddingModelOptions
+			})) != null ? _a : {}, (_b = yield require_generate.parseProviderOptions({
+				provider: _this7.providerOptionsName,
+				providerOptions,
+				schema: openaiCompatibleEmbeddingModelOptions
+			})) != null ? _b : {});
+			if (values.length > _this7.maxEmbeddingsPerCall) throw new require_generate.TooManyEmbeddingValuesForCallError({
+				provider: _this7.provider,
+				modelId: _this7.modelId,
+				maxEmbeddingsPerCall: _this7.maxEmbeddingsPerCall,
+				values
+			});
+			const { responseHeaders, value: response, rawValue } = yield require_generate.postJsonToApi({
+				url: _this7.config.url({
+					path: "/embeddings",
+					modelId: _this7.modelId
+				}),
+				headers: require_generate.combineHeaders(_this7.config.headers(), headers),
+				body: {
+					model: _this7.modelId,
+					input: values,
+					encoding_format: "float",
+					dimensions: compatibleOptions.dimensions,
+					user: compatibleOptions.user
+				},
+				failedResponseHandler: require_generate.createJsonErrorResponseHandler((_c = _this7.config.errorStructure) != null ? _c : defaultOpenAICompatibleErrorStructure),
+				successfulResponseHandler: require_generate.createJsonResponseHandler(openaiTextEmbeddingResponseSchema),
+				abortSignal,
+				fetch: _this7.config.fetch
+			});
+			return {
+				warnings,
+				embeddings: response.data.map((item) => item.embedding),
+				usage: response.usage ? { tokens: response.usage.prompt_tokens } : void 0,
+				providerMetadata: response.providerMetadata,
+				response: {
+					headers: responseHeaders,
+					body: rawValue
+				}
+			};
+		})();
+	}
+};
+var openaiTextEmbeddingResponseSchema = require_generate.object({
+	data: require_generate.array(require_generate.object({ embedding: require_generate.array(require_generate.number()) })),
+	usage: require_generate.object({ prompt_tokens: require_generate.number() }).nullish(),
+	providerMetadata: require_generate.record(require_generate.string(), require_generate.record(require_generate.string(), require_generate.any())).optional()
+});
+var OpenAICompatibleImageModel = class {
+	constructor(modelId, config) {
+		this.modelId = modelId;
+		this.config = config;
+		this.specificationVersion = "v3";
+		this.maxImagesPerCall = 10;
+	}
+	get provider() {
+		return this.config.provider;
+	}
+	/**
+	* The provider options key used to extract provider-specific options.
+	*/
+	get providerOptionsKey() {
+		return this.config.provider.split(".")[0].trim();
+	}
+	getArgs(providerOptions) {
+		return require_asyncToGenerator._objectSpread2(require_asyncToGenerator._objectSpread2({}, providerOptions[this.providerOptionsKey]), providerOptions[toCamelCase(this.providerOptionsKey)]);
+	}
+	doGenerate({ prompt, n, size, aspectRatio, seed, providerOptions, headers, abortSignal, files, mask }) {
+		var _this8 = this;
+		return require_asyncToGenerator._asyncToGenerator(function* () {
+			var _a, _b, _c, _d, _e;
+			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 = _this8.config._internal) == null ? void 0 : _a.currentDate) == null ? void 0 : _b.call(_a)) != null ? _c : /* @__PURE__ */ new Date();
+			const args = _this8.getArgs(providerOptions);
+			if (files != null && files.length > 0) {
+				const { value: response2, responseHeaders: responseHeaders2 } = yield require_generate.postFormDataToApi({
+					url: _this8.config.url({
+						path: "/images/edits",
+						modelId: _this8.modelId
+					}),
+					headers: require_generate.combineHeaders(_this8.config.headers(), headers),
+					formData: require_generate.convertToFormData(require_asyncToGenerator._objectSpread2({
+						model: _this8.modelId,
+						prompt,
+						image: yield Promise.all(files.map((file) => fileToBlob(file))),
+						mask: mask != null ? yield fileToBlob(mask) : void 0,
+						n,
+						size
+					}, args)),
+					failedResponseHandler: require_generate.createJsonErrorResponseHandler((_d = _this8.config.errorStructure) != null ? _d : defaultOpenAICompatibleErrorStructure),
+					successfulResponseHandler: require_generate.createJsonResponseHandler(openaiCompatibleImageResponseSchema),
+					abortSignal,
+					fetch: _this8.config.fetch
+				});
+				return {
+					images: response2.data.map((item) => item.b64_json),
+					warnings,
+					response: {
+						timestamp: currentDate,
+						modelId: _this8.modelId,
+						headers: responseHeaders2
+					}
+				};
+			}
+			const { value: response, responseHeaders } = yield require_generate.postJsonToApi({
+				url: _this8.config.url({
+					path: "/images/generations",
+					modelId: _this8.modelId
+				}),
+				headers: require_generate.combineHeaders(_this8.config.headers(), headers),
+				body: require_asyncToGenerator._objectSpread2(require_asyncToGenerator._objectSpread2({
+					model: _this8.modelId,
+					prompt,
+					n,
+					size
+				}, args), {}, { response_format: "b64_json" }),
+				failedResponseHandler: require_generate.createJsonErrorResponseHandler((_e = _this8.config.errorStructure) != null ? _e : defaultOpenAICompatibleErrorStructure),
+				successfulResponseHandler: require_generate.createJsonResponseHandler(openaiCompatibleImageResponseSchema),
+				abortSignal,
+				fetch: _this8.config.fetch
+			});
+			return {
+				images: response.data.map((item) => item.b64_json),
+				warnings,
+				response: {
+					timestamp: currentDate,
+					modelId: _this8.modelId,
+					headers: responseHeaders
+				}
+			};
+		})();
+	}
+};
+var openaiCompatibleImageResponseSchema = require_generate.object({ data: require_generate.array(require_generate.object({ b64_json: require_generate.string() })) });
+function fileToBlob(_x) {
+	return _fileToBlob.apply(this, arguments);
+}
+function _fileToBlob() {
+	_fileToBlob = require_asyncToGenerator._asyncToGenerator(function* (file) {
+		if (file.type === "url") return require_generate.downloadBlob(file.url);
+		const data = file.data instanceof Uint8Array ? file.data : require_generate.convertBase64ToUint8Array(file.data);
+		return new Blob([data], { type: file.mediaType });
+	});
+	return _fileToBlob.apply(this, arguments);
+}
+var VERSION = "2.0.48";
+function createOpenAICompatible(options) {
+	const baseURL = require_generate.withoutTrailingSlash(options.baseURL);
+	const providerName = options.name;
+	const headers = require_asyncToGenerator._objectSpread2(require_asyncToGenerator._objectSpread2({}, options.apiKey && { Authorization: `Bearer ${options.apiKey}` }), options.headers);
+	const getHeaders = () => require_generate.withUserAgentSuffix(headers, `ai-sdk/openai-compatible/${VERSION}`);
+	const getCommonModelConfig = (modelType) => ({
+		provider: `${providerName}.${modelType}`,
+		url: ({ path }) => {
+			const url = new URL(`${baseURL}${path}`);
+			if (options.queryParams) url.search = new URLSearchParams(options.queryParams).toString();
+			return url.toString();
+		},
+		headers: getHeaders,
+		fetch: options.fetch
+	});
+	const createLanguageModel = (modelId) => createChatModel(modelId);
+	const createChatModel = (modelId) => new OpenAICompatibleChatLanguageModel(modelId, require_asyncToGenerator._objectSpread2(require_asyncToGenerator._objectSpread2({}, getCommonModelConfig("chat")), {}, {
+		includeUsage: options.includeUsage,
+		supportsStructuredOutputs: options.supportsStructuredOutputs,
+		supportedUrls: options.supportedUrls,
+		transformRequestBody: options.transformRequestBody,
+		metadataExtractor: options.metadataExtractor,
+		convertUsage: options.convertUsage
+	}));
+	const createCompletionModel = (modelId) => new OpenAICompatibleCompletionLanguageModel(modelId, require_asyncToGenerator._objectSpread2(require_asyncToGenerator._objectSpread2({}, getCommonModelConfig("completion")), {}, { includeUsage: options.includeUsage }));
+	const createEmbeddingModel = (modelId) => new OpenAICompatibleEmbeddingModel(modelId, require_asyncToGenerator._objectSpread2({}, getCommonModelConfig("embedding")));
+	const createImageModel = (modelId) => new OpenAICompatibleImageModel(modelId, getCommonModelConfig("image"));
+	const provider = (modelId) => createLanguageModel(modelId);
+	provider.specificationVersion = "v3";
+	provider.languageModel = createLanguageModel;
+	provider.chatModel = createChatModel;
+	provider.completionModel = createCompletionModel;
+	provider.embeddingModel = createEmbeddingModel;
+	provider.textEmbeddingModel = createEmbeddingModel;
+	provider.imageModel = createImageModel;
+	return provider;
+}
+//#endregion
+exports.OpenAICompatibleChatLanguageModel = OpenAICompatibleChatLanguageModel;
+exports.OpenAICompatibleCompletionLanguageModel = OpenAICompatibleCompletionLanguageModel;
+exports.OpenAICompatibleEmbeddingModel = OpenAICompatibleEmbeddingModel;
+exports.OpenAICompatibleImageModel = OpenAICompatibleImageModel;
+exports.VERSION = VERSION;
+exports.createOpenAICompatible = createOpenAICompatible;
+
+//# sourceMappingURL=dist-Cjmk9o-a.cjs.map