@vibe-lark/larkpal 0.1.86 → 0.1.87

package/dist/openai-completions-CR_cS6gX.mjs

@@ -1,669 +0,0 @@
-import { r as __exportAll } from "./chunk-D6SyT4dJ.mjs";
-import { t as getEnvApiKey } from "./env-api-keys-BVvSg7T2.mjs";
-import { o as supportsXhigh, r as calculateCost, t as AssistantMessageEventStream } from "./event-stream-xaQWmyas.mjs";
-import { n as parseStreamingJson } from "./json-parse-v_HIJjjI.mjs";
-import { n as OpenAI } from "./openai-BDtIh3Ja.mjs";
-import { t as headersToRecord } from "./headers-R3HdCbAE.mjs";
-import { a as sanitizeSurrogates, i as clampReasoning, r as buildBaseOptions, t as transformMessages } from "./transform-messages-DbhIzTxq.mjs";
-import { n as hasCopilotVisionInput, t as buildCopilotDynamicHeaders } from "./github-copilot-headers-DjqWtUoP.mjs";
-//#region node_modules/.pnpm/@mariozechner+pi-ai@0.69.0_@modelcontextprotocol+sdk@1.29.0_zod@4.3.6__ws@8.21.0_zod@4.3.6/node_modules/@mariozechner/pi-ai/dist/providers/openai-completions.js
-var openai_completions_exports = /* @__PURE__ */ __exportAll({
-	convertMessages: () => convertMessages,
-	streamOpenAICompletions: () => streamOpenAICompletions,
-	streamSimpleOpenAICompletions: () => streamSimpleOpenAICompletions
-});
-/**
-* Check if conversation messages contain tool calls or tool results.
-* This is needed because Anthropic (via proxy) requires the tools param
-* to be present when messages include tool_calls or tool role messages.
-*/
-function hasToolHistory(messages) {
-	for (const msg of messages) {
-		if (msg.role === "toolResult") return true;
-		if (msg.role === "assistant") {
-			if (msg.content.some((block) => block.type === "toolCall")) return true;
-		}
-	}
-	return false;
-}
-function isTextContentBlock(block) {
-	return block.type === "text";
-}
-function isThinkingContentBlock(block) {
-	return block.type === "thinking";
-}
-function isToolCallBlock(block) {
-	return block.type === "toolCall";
-}
-function isImageContentBlock(block) {
-	return block.type === "image";
-}
-function resolveCacheRetention(cacheRetention) {
-	if (cacheRetention) return cacheRetention;
-	if (typeof process !== "undefined" && process.env.PI_CACHE_RETENTION === "long") return "long";
-	return "short";
-}
-const streamOpenAICompletions = (model, context, options) => {
-	const stream = new AssistantMessageEventStream();
-	(async () => {
-		const output = {
-			role: "assistant",
-			content: [],
-			api: model.api,
-			provider: model.provider,
-			model: model.id,
-			usage: {
-				input: 0,
-				output: 0,
-				cacheRead: 0,
-				cacheWrite: 0,
-				totalTokens: 0,
-				cost: {
-					input: 0,
-					output: 0,
-					cacheRead: 0,
-					cacheWrite: 0,
-					total: 0
-				}
-			},
-			stopReason: "stop",
-			timestamp: Date.now()
-		};
-		try {
-			const apiKey = options?.apiKey || getEnvApiKey(model.provider) || "";
-			const compat = getCompat(model);
-			const cacheRetention = resolveCacheRetention(options?.cacheRetention);
-			const cacheSessionId = cacheRetention === "none" ? void 0 : options?.sessionId;
-			const client = createClient(model, context, apiKey, options?.headers, cacheSessionId, compat);
-			let params = buildParams(model, context, options, compat, cacheRetention);
-			const nextParams = await options?.onPayload?.(params, model);
-			if (nextParams !== void 0) params = nextParams;
-			const { data: openaiStream, response } = await client.chat.completions.create(params, { signal: options?.signal }).withResponse();
-			await options?.onResponse?.({
-				status: response.status,
-				headers: headersToRecord(response.headers)
-			}, model);
-			stream.push({
-				type: "start",
-				partial: output
-			});
-			let currentBlock = null;
-			const blocks = output.content;
-			const blockIndex = () => blocks.length - 1;
-			const finishCurrentBlock = (block) => {
-				if (block) {
-					if (block.type === "text") stream.push({
-						type: "text_end",
-						contentIndex: blockIndex(),
-						content: block.text,
-						partial: output
-					});
-					else if (block.type === "thinking") stream.push({
-						type: "thinking_end",
-						contentIndex: blockIndex(),
-						content: block.thinking,
-						partial: output
-					});
-					else if (block.type === "toolCall") {
-						block.arguments = parseStreamingJson(block.partialArgs);
-						delete block.partialArgs;
-						stream.push({
-							type: "toolcall_end",
-							contentIndex: blockIndex(),
-							toolCall: block,
-							partial: output
-						});
-					}
-				}
-			};
-			for await (const chunk of openaiStream) {
-				if (!chunk || typeof chunk !== "object") continue;
-				output.responseId ||= chunk.id;
-				if (chunk.usage) output.usage = parseChunkUsage(chunk.usage, model);
-				const choice = Array.isArray(chunk.choices) ? chunk.choices[0] : void 0;
-				if (!choice) continue;
-				if (!chunk.usage && choice.usage) output.usage = parseChunkUsage(choice.usage, model);
-				if (choice.finish_reason) {
-					const finishReasonResult = mapStopReason(choice.finish_reason);
-					output.stopReason = finishReasonResult.stopReason;
-					if (finishReasonResult.errorMessage) output.errorMessage = finishReasonResult.errorMessage;
-				}
-				if (choice.delta) {
-					if (choice.delta.content !== null && choice.delta.content !== void 0 && choice.delta.content.length > 0) {
-						if (!currentBlock || currentBlock.type !== "text") {
-							finishCurrentBlock(currentBlock);
-							currentBlock = {
-								type: "text",
-								text: ""
-							};
-							output.content.push(currentBlock);
-							stream.push({
-								type: "text_start",
-								contentIndex: blockIndex(),
-								partial: output
-							});
-						}
-						if (currentBlock.type === "text") {
-							currentBlock.text += choice.delta.content;
-							stream.push({
-								type: "text_delta",
-								contentIndex: blockIndex(),
-								delta: choice.delta.content,
-								partial: output
-							});
-						}
-					}
-					const reasoningFields = [
-						"reasoning_content",
-						"reasoning",
-						"reasoning_text"
-					];
-					let foundReasoningField = null;
-					for (const field of reasoningFields) if (choice.delta[field] !== null && choice.delta[field] !== void 0 && choice.delta[field].length > 0) {
-						if (!foundReasoningField) {
-							foundReasoningField = field;
-							break;
-						}
-					}
-					if (foundReasoningField) {
-						if (!currentBlock || currentBlock.type !== "thinking") {
-							finishCurrentBlock(currentBlock);
-							currentBlock = {
-								type: "thinking",
-								thinking: "",
-								thinkingSignature: foundReasoningField
-							};
-							output.content.push(currentBlock);
-							stream.push({
-								type: "thinking_start",
-								contentIndex: blockIndex(),
-								partial: output
-							});
-						}
-						if (currentBlock.type === "thinking") {
-							const delta = choice.delta[foundReasoningField];
-							currentBlock.thinking += delta;
-							stream.push({
-								type: "thinking_delta",
-								contentIndex: blockIndex(),
-								delta,
-								partial: output
-							});
-						}
-					}
-					if (choice?.delta?.tool_calls) for (const toolCall of choice.delta.tool_calls) {
-						if (!currentBlock || currentBlock.type !== "toolCall" || toolCall.id && currentBlock.id !== toolCall.id) {
-							finishCurrentBlock(currentBlock);
-							currentBlock = {
-								type: "toolCall",
-								id: toolCall.id || "",
-								name: toolCall.function?.name || "",
-								arguments: {},
-								partialArgs: ""
-							};
-							output.content.push(currentBlock);
-							stream.push({
-								type: "toolcall_start",
-								contentIndex: blockIndex(),
-								partial: output
-							});
-						}
-						if (currentBlock.type === "toolCall") {
-							if (toolCall.id) currentBlock.id = toolCall.id;
-							if (toolCall.function?.name) currentBlock.name = toolCall.function.name;
-							let delta = "";
-							if (toolCall.function?.arguments) {
-								delta = toolCall.function.arguments;
-								currentBlock.partialArgs += toolCall.function.arguments;
-								currentBlock.arguments = parseStreamingJson(currentBlock.partialArgs);
-							}
-							stream.push({
-								type: "toolcall_delta",
-								contentIndex: blockIndex(),
-								delta,
-								partial: output
-							});
-						}
-					}
-					const reasoningDetails = choice.delta.reasoning_details;
-					if (reasoningDetails && Array.isArray(reasoningDetails)) {
-						for (const detail of reasoningDetails) if (detail.type === "reasoning.encrypted" && detail.id && detail.data) {
-							const matchingToolCall = output.content.find((b) => b.type === "toolCall" && b.id === detail.id);
-							if (matchingToolCall) matchingToolCall.thoughtSignature = JSON.stringify(detail);
-						}
-					}
-				}
-			}
-			finishCurrentBlock(currentBlock);
-			if (options?.signal?.aborted) throw new Error("Request was aborted");
-			if (output.stopReason === "aborted") throw new Error("Request was aborted");
-			if (output.stopReason === "error") throw new Error(output.errorMessage || "Provider returned an error stop reason");
-			stream.push({
-				type: "done",
-				reason: output.stopReason,
-				message: output
-			});
-			stream.end();
-		} catch (error) {
-			for (const block of output.content) {
-				delete block.index;
-				delete block.partialArgs;
-			}
-			output.stopReason = options?.signal?.aborted ? "aborted" : "error";
-			output.errorMessage = error instanceof Error ? error.message : JSON.stringify(error);
-			const rawMetadata = error?.error?.metadata?.raw;
-			if (rawMetadata) output.errorMessage += `\n${rawMetadata}`;
-			stream.push({
-				type: "error",
-				reason: output.stopReason,
-				error: output
-			});
-			stream.end();
-		}
-	})();
-	return stream;
-};
-const streamSimpleOpenAICompletions = (model, context, options) => {
-	const apiKey = options?.apiKey || getEnvApiKey(model.provider);
-	if (!apiKey) throw new Error(`No API key for provider: ${model.provider}`);
-	const base = buildBaseOptions(model, options, apiKey);
-	const reasoningEffort = supportsXhigh(model) ? options?.reasoning : clampReasoning(options?.reasoning);
-	const toolChoice = options?.toolChoice;
-	return streamOpenAICompletions(model, context, {
-		...base,
-		reasoningEffort,
-		toolChoice
-	});
-};
-function createClient(model, context, apiKey, optionsHeaders, sessionId, compat = getCompat(model)) {
-	if (!apiKey) {
-		if (!process.env.OPENAI_API_KEY) throw new Error("OpenAI API key is required. Set OPENAI_API_KEY environment variable or pass it as an argument.");
-		apiKey = process.env.OPENAI_API_KEY;
-	}
-	const headers = { ...model.headers };
-	if (model.provider === "github-copilot") {
-		const hasImages = hasCopilotVisionInput(context.messages);
-		const copilotHeaders = buildCopilotDynamicHeaders({
-			messages: context.messages,
-			hasImages
-		});
-		Object.assign(headers, copilotHeaders);
-	}
-	if (sessionId && compat.sendSessionAffinityHeaders) {
-		headers.session_id = sessionId;
-		headers["x-client-request-id"] = sessionId;
-		headers["x-session-affinity"] = sessionId;
-	}
-	if (optionsHeaders) Object.assign(headers, optionsHeaders);
-	return new OpenAI({
-		apiKey,
-		baseURL: model.baseUrl,
-		dangerouslyAllowBrowser: true,
-		defaultHeaders: headers
-	});
-}
-function buildParams(model, context, options, compat = getCompat(model), cacheRetention = resolveCacheRetention(options?.cacheRetention)) {
-	const messages = convertMessages(model, context, compat);
-	const cacheControl = getCompatCacheControl(model, compat, cacheRetention);
-	const params = {
-		model: model.id,
-		messages,
-		stream: true,
-		prompt_cache_key: model.baseUrl.includes("api.openai.com") && cacheRetention !== "none" ? options?.sessionId : void 0,
-		prompt_cache_retention: model.baseUrl.includes("api.openai.com") && cacheRetention === "long" ? "24h" : void 0
-	};
-	if (compat.supportsUsageInStreaming !== false) params.stream_options = { include_usage: true };
-	if (compat.supportsStore) params.store = false;
-	if (options?.maxTokens) if (compat.maxTokensField === "max_tokens") params.max_tokens = options.maxTokens;
-	else params.max_completion_tokens = options.maxTokens;
-	if (options?.temperature !== void 0) params.temperature = options.temperature;
-	if (context.tools) {
-		params.tools = convertTools(context.tools, compat);
-		if (compat.zaiToolStream) params.tool_stream = true;
-	} else if (hasToolHistory(context.messages)) params.tools = [];
-	if (cacheControl) applyAnthropicCacheControl(messages, params.tools, cacheControl);
-	if (options?.toolChoice) params.tool_choice = options.toolChoice;
-	if (compat.thinkingFormat === "zai" && model.reasoning) params.enable_thinking = !!options?.reasoningEffort;
-	else if (compat.thinkingFormat === "qwen" && model.reasoning) params.enable_thinking = !!options?.reasoningEffort;
-	else if (compat.thinkingFormat === "qwen-chat-template" && model.reasoning) params.chat_template_kwargs = {
-		enable_thinking: !!options?.reasoningEffort,
-		preserve_thinking: true
-	};
-	else if (compat.thinkingFormat === "openrouter" && model.reasoning) {
-		const openRouterParams = params;
-		if (options?.reasoningEffort) openRouterParams.reasoning = { effort: mapReasoningEffort(options.reasoningEffort, compat.reasoningEffortMap) };
-		else openRouterParams.reasoning = { effort: "none" };
-	} else if (options?.reasoningEffort && model.reasoning && compat.supportsReasoningEffort) params.reasoning_effort = mapReasoningEffort(options.reasoningEffort, compat.reasoningEffortMap);
-	if (model.baseUrl.includes("openrouter.ai") && model.compat?.openRouterRouting) params.provider = model.compat.openRouterRouting;
-	if (model.baseUrl.includes("ai-gateway.vercel.sh") && model.compat?.vercelGatewayRouting) {
-		const routing = model.compat.vercelGatewayRouting;
-		if (routing.only || routing.order) {
-			const gatewayOptions = {};
-			if (routing.only) gatewayOptions.only = routing.only;
-			if (routing.order) gatewayOptions.order = routing.order;
-			params.providerOptions = { gateway: gatewayOptions };
-		}
-	}
-	return params;
-}
-function mapReasoningEffort(effort, reasoningEffortMap) {
-	return reasoningEffortMap[effort] ?? effort;
-}
-function getCompatCacheControl(model, compat, cacheRetention) {
-	if (compat.cacheControlFormat !== "anthropic" || cacheRetention === "none") return;
-	const ttl = cacheRetention === "long" && model.baseUrl.includes("api.anthropic.com") ? "1h" : void 0;
-	return {
-		type: "ephemeral",
-		...ttl ? { ttl } : {}
-	};
-}
-function applyAnthropicCacheControl(messages, tools, cacheControl) {
-	addCacheControlToSystemPrompt(messages, cacheControl);
-	addCacheControlToLastTool(tools, cacheControl);
-	addCacheControlToLastConversationMessage(messages, cacheControl);
-}
-function addCacheControlToSystemPrompt(messages, cacheControl) {
-	for (const message of messages) if (message.role === "system" || message.role === "developer") {
-		addCacheControlToInstructionMessage(message, cacheControl);
-		return;
-	}
-}
-function addCacheControlToLastConversationMessage(messages, cacheControl) {
-	for (let i = messages.length - 1; i >= 0; i--) {
-		const message = messages[i];
-		if (message.role === "user" || message.role === "assistant") {
-			if (addCacheControlToMessage(message, cacheControl)) return;
-		}
-	}
-}
-function addCacheControlToLastTool(tools, cacheControl) {
-	if (!tools || tools.length === 0) return;
-	const lastTool = tools[tools.length - 1];
-	lastTool.cache_control = cacheControl;
-}
-function addCacheControlToInstructionMessage(message, cacheControl) {
-	return addCacheControlToTextContent(message, cacheControl);
-}
-function addCacheControlToMessage(message, cacheControl) {
-	if (message.role === "user" || message.role === "assistant") return addCacheControlToTextContent(message, cacheControl);
-	return false;
-}
-function addCacheControlToTextContent(message, cacheControl) {
-	const content = message.content;
-	if (typeof content === "string") {
-		if (content.length === 0) return false;
-		message.content = [{
-			type: "text",
-			text: content,
-			cache_control: cacheControl
-		}];
-		return true;
-	}
-	if (!Array.isArray(content)) return false;
-	for (let i = content.length - 1; i >= 0; i--) {
-		const part = content[i];
-		if (part?.type === "text") {
-			const textPart = part;
-			textPart.cache_control = cacheControl;
-			return true;
-		}
-	}
-	return false;
-}
-function convertMessages(model, context, compat) {
-	const params = [];
-	const normalizeToolCallId = (id) => {
-		if (id.includes("|")) {
-			const [callId] = id.split("|");
-			return callId.replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 40);
-		}
-		if (model.provider === "openai") return id.length > 40 ? id.slice(0, 40) : id;
-		return id;
-	};
-	const transformedMessages = transformMessages(context.messages, model, (id) => normalizeToolCallId(id));
-	if (context.systemPrompt) {
-		const role = model.reasoning && compat.supportsDeveloperRole ? "developer" : "system";
-		params.push({
-			role,
-			content: sanitizeSurrogates(context.systemPrompt)
-		});
-	}
-	let lastRole = null;
-	for (let i = 0; i < transformedMessages.length; i++) {
-		const msg = transformedMessages[i];
-		if (compat.requiresAssistantAfterToolResult && lastRole === "toolResult" && msg.role === "user") params.push({
-			role: "assistant",
-			content: "I have processed the tool results."
-		});
-		if (msg.role === "user") if (typeof msg.content === "string") params.push({
-			role: "user",
-			content: sanitizeSurrogates(msg.content)
-		});
-		else {
-			const content = msg.content.map((item) => {
-				if (item.type === "text") return {
-					type: "text",
-					text: sanitizeSurrogates(item.text)
-				};
-				else return {
-					type: "image_url",
-					image_url: { url: `data:${item.mimeType};base64,${item.data}` }
-				};
-			});
-			if (content.length === 0) continue;
-			params.push({
-				role: "user",
-				content
-			});
-		}
-		else if (msg.role === "assistant") {
-			const assistantMsg = {
-				role: "assistant",
-				content: compat.requiresAssistantAfterToolResult ? "" : null
-			};
-			const assistantTextParts = msg.content.filter(isTextContentBlock).filter((block) => block.text.trim().length > 0).map((block) => ({
-				type: "text",
-				text: sanitizeSurrogates(block.text)
-			}));
-			const assistantText = assistantTextParts.map((part) => part.text).join("");
-			const nonEmptyThinkingBlocks = msg.content.filter(isThinkingContentBlock).filter((block) => block.thinking.trim().length > 0);
-			if (nonEmptyThinkingBlocks.length > 0) if (compat.requiresThinkingAsText) assistantMsg.content = [{
-				type: "text",
-				text: nonEmptyThinkingBlocks.map((block) => sanitizeSurrogates(block.thinking)).join("\n\n")
-			}, ...assistantTextParts];
-			else {
-				if (assistantText.length > 0) assistantMsg.content = assistantText;
-				const signature = nonEmptyThinkingBlocks[0].thinkingSignature;
-				if (signature && signature.length > 0) assistantMsg[signature] = nonEmptyThinkingBlocks.map((block) => block.thinking).join("\n");
-			}
-			else if (assistantText.length > 0) assistantMsg.content = assistantText;
-			const toolCalls = msg.content.filter(isToolCallBlock);
-			if (toolCalls.length > 0) {
-				assistantMsg.tool_calls = toolCalls.map((tc) => ({
-					id: tc.id,
-					type: "function",
-					function: {
-						name: tc.name,
-						arguments: JSON.stringify(tc.arguments)
-					}
-				}));
-				const reasoningDetails = toolCalls.filter((tc) => tc.thoughtSignature).map((tc) => {
-					try {
-						return JSON.parse(tc.thoughtSignature);
-					} catch {
-						return null;
-					}
-				}).filter(Boolean);
-				if (reasoningDetails.length > 0) assistantMsg.reasoning_details = reasoningDetails;
-			}
-			const content = assistantMsg.content;
-			if (!(content !== null && content !== void 0 && (typeof content === "string" ? content.length > 0 : content.length > 0)) && !assistantMsg.tool_calls) continue;
-			params.push(assistantMsg);
-		} else if (msg.role === "toolResult") {
-			const imageBlocks = [];
-			let j = i;
-			for (; j < transformedMessages.length && transformedMessages[j].role === "toolResult"; j++) {
-				const toolMsg = transformedMessages[j];
-				const textResult = toolMsg.content.filter(isTextContentBlock).map((block) => block.text).join("\n");
-				const hasImages = toolMsg.content.some((c) => c.type === "image");
-				const toolResultMsg = {
-					role: "tool",
-					content: sanitizeSurrogates(textResult.length > 0 ? textResult : "(see attached image)"),
-					tool_call_id: toolMsg.toolCallId
-				};
-				if (compat.requiresToolResultName && toolMsg.toolName) toolResultMsg.name = toolMsg.toolName;
-				params.push(toolResultMsg);
-				if (hasImages && model.input.includes("image")) {
-					for (const block of toolMsg.content) if (isImageContentBlock(block)) imageBlocks.push({
-						type: "image_url",
-						image_url: { url: `data:${block.mimeType};base64,${block.data}` }
-					});
-				}
-			}
-			i = j - 1;
-			if (imageBlocks.length > 0) {
-				if (compat.requiresAssistantAfterToolResult) params.push({
-					role: "assistant",
-					content: "I have processed the tool results."
-				});
-				params.push({
-					role: "user",
-					content: [{
-						type: "text",
-						text: "Attached image(s) from tool result:"
-					}, ...imageBlocks]
-				});
-				lastRole = "user";
-			} else lastRole = "toolResult";
-			continue;
-		}
-		lastRole = msg.role;
-	}
-	return params;
-}
-function convertTools(tools, compat) {
-	return tools.map((tool) => ({
-		type: "function",
-		function: {
-			name: tool.name,
-			description: tool.description,
-			parameters: tool.parameters,
-			...compat.supportsStrictMode !== false && { strict: false }
-		}
-	}));
-}
-function parseChunkUsage(rawUsage, model) {
-	const promptTokens = rawUsage.prompt_tokens || 0;
-	const reportedCachedTokens = rawUsage.prompt_tokens_details?.cached_tokens || 0;
-	const cacheWriteTokens = rawUsage.prompt_tokens_details?.cache_write_tokens || 0;
-	const reasoningTokens = rawUsage.completion_tokens_details?.reasoning_tokens || 0;
-	const cacheReadTokens = cacheWriteTokens > 0 ? Math.max(0, reportedCachedTokens - cacheWriteTokens) : reportedCachedTokens;
-	const input = Math.max(0, promptTokens - cacheReadTokens - cacheWriteTokens);
-	const outputTokens = (rawUsage.completion_tokens || 0) + reasoningTokens;
-	const usage = {
-		input,
-		output: outputTokens,
-		cacheRead: cacheReadTokens,
-		cacheWrite: cacheWriteTokens,
-		totalTokens: input + outputTokens + cacheReadTokens + cacheWriteTokens,
-		cost: {
-			input: 0,
-			output: 0,
-			cacheRead: 0,
-			cacheWrite: 0,
-			total: 0
-		}
-	};
-	calculateCost(model, usage);
-	return usage;
-}
-function mapStopReason(reason) {
-	if (reason === null) return { stopReason: "stop" };
-	switch (reason) {
-		case "stop":
-		case "end": return { stopReason: "stop" };
-		case "length": return { stopReason: "length" };
-		case "function_call":
-		case "tool_calls": return { stopReason: "toolUse" };
-		case "content_filter": return {
-			stopReason: "error",
-			errorMessage: "Provider finish_reason: content_filter"
-		};
-		case "network_error": return {
-			stopReason: "error",
-			errorMessage: "Provider finish_reason: network_error"
-		};
-		default: return {
-			stopReason: "error",
-			errorMessage: `Provider finish_reason: ${reason}`
-		};
-	}
-}
-/**
-* Detect compatibility settings from provider and baseUrl for known providers.
-* Provider takes precedence over URL-based detection since it's explicitly configured.
-* Returns a fully resolved OpenAICompletionsCompat object with all fields set.
-*/
-function detectCompat(model) {
-	const provider = model.provider;
-	const baseUrl = model.baseUrl;
-	const isZai = provider === "zai" || baseUrl.includes("api.z.ai");
-	const isNonStandard = provider === "cerebras" || baseUrl.includes("cerebras.ai") || provider === "xai" || baseUrl.includes("api.x.ai") || baseUrl.includes("chutes.ai") || baseUrl.includes("deepseek.com") || isZai || provider === "opencode" || baseUrl.includes("opencode.ai");
-	const useMaxTokens = baseUrl.includes("chutes.ai");
-	const isGrok = provider === "xai" || baseUrl.includes("api.x.ai");
-	const isGroq = provider === "groq" || baseUrl.includes("groq.com");
-	const cacheControlFormat = provider === "openrouter" && model.id.startsWith("anthropic/") ? "anthropic" : void 0;
-	const reasoningEffortMap = isGroq && model.id === "qwen/qwen3-32b" ? {
-		minimal: "default",
-		low: "default",
-		medium: "default",
-		high: "default",
-		xhigh: "default"
-	} : {};
-	return {
-		supportsStore: !isNonStandard,
-		supportsDeveloperRole: !isNonStandard,
-		supportsReasoningEffort: !isGrok && !isZai,
-		reasoningEffortMap,
-		supportsUsageInStreaming: true,
-		maxTokensField: useMaxTokens ? "max_tokens" : "max_completion_tokens",
-		requiresToolResultName: false,
-		requiresAssistantAfterToolResult: false,
-		requiresThinkingAsText: false,
-		thinkingFormat: isZai ? "zai" : provider === "openrouter" || baseUrl.includes("openrouter.ai") ? "openrouter" : "openai",
-		openRouterRouting: {},
-		vercelGatewayRouting: {},
-		zaiToolStream: false,
-		supportsStrictMode: true,
-		cacheControlFormat,
-		sendSessionAffinityHeaders: false
-	};
-}
-/**
-* Get resolved compatibility settings for a model.
-* Uses explicit model.compat if provided, otherwise auto-detects from provider/URL.
-*/
-function getCompat(model) {
-	const detected = detectCompat(model);
-	if (!model.compat) return detected;
-	return {
-		supportsStore: model.compat.supportsStore ?? detected.supportsStore,
-		supportsDeveloperRole: model.compat.supportsDeveloperRole ?? detected.supportsDeveloperRole,
-		supportsReasoningEffort: model.compat.supportsReasoningEffort ?? detected.supportsReasoningEffort,
-		reasoningEffortMap: model.compat.reasoningEffortMap ?? detected.reasoningEffortMap,
-		supportsUsageInStreaming: model.compat.supportsUsageInStreaming ?? detected.supportsUsageInStreaming,
-		maxTokensField: model.compat.maxTokensField ?? detected.maxTokensField,
-		requiresToolResultName: model.compat.requiresToolResultName ?? detected.requiresToolResultName,
-		requiresAssistantAfterToolResult: model.compat.requiresAssistantAfterToolResult ?? detected.requiresAssistantAfterToolResult,
-		requiresThinkingAsText: model.compat.requiresThinkingAsText ?? detected.requiresThinkingAsText,
-		thinkingFormat: model.compat.thinkingFormat ?? detected.thinkingFormat,
-		openRouterRouting: model.compat.openRouterRouting ?? {},
-		vercelGatewayRouting: model.compat.vercelGatewayRouting ?? detected.vercelGatewayRouting,
-		zaiToolStream: model.compat.zaiToolStream ?? detected.zaiToolStream,
-		supportsStrictMode: model.compat.supportsStrictMode ?? detected.supportsStrictMode,
-		cacheControlFormat: model.compat.cacheControlFormat ?? detected.cacheControlFormat,
-		sendSessionAffinityHeaders: model.compat.sendSessionAffinityHeaders ?? detected.sendSessionAffinityHeaders
-	};
-}
-//#endregion
-export { openai_completions_exports as n, convertMessages as t };