@prometheus-ai/ai 0.5.0

package/src/providers/openai-completions-compat.ts

@@ -0,0 +1,320 @@
+import type { Model, OpenAICompat } from "../types";
+
+type OpenAIReasoningEffort = "minimal" | "low" | "medium" | "high" | "xhigh";
+type ResolvedToolStrictMode = NonNullable<OpenAICompat["toolStrictMode"]> | "mixed";
+
+export type ResolvedOpenAICompat = Required<
+	Omit<
+		OpenAICompat,
+		| "openRouterRouting"
+		| "vercelGatewayRouting"
+		| "extraBody"
+		| "toolStrictMode"
+		| "cacheControlFormat"
+		| "thinkingKeep"
+	>
+> & {
+	openRouterRouting?: OpenAICompat["openRouterRouting"];
+	vercelGatewayRouting?: OpenAICompat["vercelGatewayRouting"];
+	extraBody?: OpenAICompat["extraBody"];
+	cacheControlFormat?: OpenAICompat["cacheControlFormat"];
+	thinkingKeep?: OpenAICompat["thinkingKeep"];
+	toolStrictMode: ResolvedToolStrictMode;
+};
+
+function detectStrictModeSupport(provider: string, baseUrl: string): boolean {
+	if (
+		provider === "openai" ||
+		provider === "openrouter" ||
+		provider === "cerebras" ||
+		provider === "together" ||
+		provider === "github-copilot" ||
+		provider === "zenmux"
+	) {
+		return true;
+	}
+
+	const normalizedBaseUrl = baseUrl.toLowerCase();
+	return (
+		normalizedBaseUrl.includes("api.openai.com") ||
+		normalizedBaseUrl.includes(".openai.azure.com") ||
+		normalizedBaseUrl.includes("models.inference.ai.azure.com") ||
+		normalizedBaseUrl.includes("api.cerebras.ai") ||
+		normalizedBaseUrl.includes("api.together.xyz") ||
+		normalizedBaseUrl.includes("openrouter.ai") ||
+		normalizedBaseUrl.includes("api.deepseek.com") ||
+		normalizedBaseUrl.includes("deepseek.com")
+	);
+}
+
+/**
+ * Detect compatibility settings from provider and baseUrl for known providers.
+ * Provider takes precedence over URL-based detection since it's explicitly configured.
+ * @param model - The model configuration
+ * @param resolvedBaseUrl - Optional resolved base URL (e.g., after GitHub Copilot proxy-ep resolution).
+ *                           If provided, this takes precedence over model.baseUrl for URL-based checks.
+ */
+export function detectOpenAICompat(model: Model<"openai-completions">, resolvedBaseUrl?: string): ResolvedOpenAICompat {
+	const provider = model.provider;
+	// Use resolvedBaseUrl if provided (e.g., after GitHub Copilot proxy-ep resolution)
+	const baseUrl = resolvedBaseUrl ?? model.baseUrl;
+
+	const isCerebras = provider === "cerebras" || baseUrl.includes("cerebras.ai");
+	const isZai = provider === "zai" || baseUrl.includes("api.z.ai");
+	const isZhipu = provider === "zhipu-coding-plan" || baseUrl.includes("open.bigmodel.cn");
+	const isKilo = provider === "kilo" || baseUrl.includes("api.kilo.ai");
+	const isKimiModel = model.id.includes("moonshotai/kimi") || /(^|\/)kimi[-.]/i.test(model.id);
+	const isMoonshotNativeHost =
+		provider === "moonshot" || provider === "kimi-code" || /api\.moonshot\.ai|api\.kimi\.com/i.test(baseUrl);
+	const isMoonshotKimi = isKimiModel && isMoonshotNativeHost;
+	const usesMoonshotKimiPreservedThinking = isMoonshotKimi && /(^|\/)kimi-k2\.6(?:[-:]|$)/i.test(model.id);
+	const isAnthropicModel =
+		provider === "anthropic" ||
+		baseUrl.includes("api.anthropic.com") ||
+		/(^|\/)claude[-.]/i.test(model.id) ||
+		/(^|\/)anthropic\//i.test(model.id);
+	const isAlibaba = provider === "alibaba-coding-plan" || baseUrl.includes("dashscope");
+	const isQwen = model.id.toLowerCase().includes("qwen");
+	// DeepSeek V4 (and other reasoning-capable DeepSeek models) reject follow-up requests in
+	// thinking mode unless prior assistant tool-call turns include `reasoning_content`. The
+	// upstream model is reachable through many OpenAI-compat hosts (api.deepseek.com, Deepinfra,
+	// Kilo, NVIDIA NIM, Zenmux, OpenRouter, …), so we match by model id/name as well as by
+	// provider/baseUrl. The flag is gated by `model.reasoning` because the invariant only
+	// applies when thinking mode is actually engaged.
+	const lowerId = model.id.toLowerCase();
+	const lowerName = (model.name ?? "").toLowerCase();
+	const isXiaomiHost =
+		provider === "xiaomi" || provider.startsWith("xiaomi-token-plan-") || baseUrl.includes("xiaomimimo.com");
+	const isMimoModel = lowerId.includes("mimo") || lowerName.includes("mimo");
+	const isXiaomiMimo = isXiaomiHost && isMimoModel;
+	// OpenCode Zen's `big-pickle` is a DeepSeek reasoning alias; the upstream
+	// 400s come from DeepSeek and require exact reasoning_content replay.
+	const isOpenCodeDeepseekAlias =
+		provider === "opencode-zen" && (lowerId === "big-pickle" || lowerName === "big pickle");
+	const isDeepseekFamily =
+		provider === "deepseek" ||
+		baseUrl.includes("deepseek.com") ||
+		lowerId.includes("deepseek") ||
+		lowerName.includes("deepseek") ||
+		isOpenCodeDeepseekAlias;
+	const isDirectDeepseekApi = provider === "deepseek" || baseUrl.includes("api.deepseek.com");
+	const isDirectDeepseekReasoning = isDirectDeepseekApi && isDeepseekFamily && Boolean(model.reasoning);
+	const isNonStandard =
+		isCerebras ||
+		provider === "xai" ||
+		baseUrl.includes("api.x.ai") ||
+		provider === "mistral" ||
+		baseUrl.includes("mistral.ai") ||
+		baseUrl.includes("chutes.ai") ||
+		baseUrl.includes("deepseek.com") ||
+		baseUrl.includes("fireworks.ai") ||
+		isAlibaba ||
+		isZai ||
+		isZhipu ||
+		isKilo ||
+		isQwen ||
+		isXiaomiHost ||
+		provider === "opencode-zen" ||
+		provider === "opencode-go" ||
+		baseUrl.includes("opencode.ai");
+	const isOpenCodeProvider = provider === "opencode-go" || provider === "opencode-zen";
+
+	const useMaxTokens =
+		provider === "mistral" ||
+		baseUrl.includes("mistral.ai") ||
+		baseUrl.includes("chutes.ai") ||
+		baseUrl.includes("fireworks.ai") ||
+		isDirectDeepseekApi;
+	const isGrok = provider === "xai" || baseUrl.includes("api.x.ai");
+	const isMistral = provider === "mistral" || baseUrl.includes("mistral.ai");
+
+	// Hosts whose chat-completions endpoints are known to accept multiple
+	// leading `system`/`developer` messages (preferred for KV-cache reuse).
+	// Anything outside this allowlist defaults to coalescing because
+	// strict chat templates (Qwen 3.5+ via vLLM, MiniMax, etc.) reject
+	// follow-up system messages with a 400.
+	const isOpenAIHost = provider === "openai" || baseUrl.includes("api.openai.com");
+	const isAzureHost =
+		provider === "azure" ||
+		baseUrl.includes(".openai.azure.com") ||
+		baseUrl.includes("models.inference.ai.azure.com") ||
+		baseUrl.includes("azure.com/openai");
+	const isOpenRouter = provider === "openrouter" || baseUrl.includes("openrouter.ai");
+	const isTogether = provider === "together" || baseUrl.includes("api.together.xyz");
+	const isFireworks = baseUrl.includes("fireworks.ai");
+	const isGroqHost = provider === "groq" || baseUrl.includes("api.groq.com");
+	const isCopilotHost = provider === "github-copilot";
+	const isZenmuxHost = provider === "zenmux";
+	// Endpoints that MUST receive a single system block. MiniMax's OpenAI
+	// endpoint returns error 2013 on multiple system messages; Alibaba's
+	// Dashscope and Qwen Portal serve Qwen models whose chat template
+	// raises "System message must be at the beginning" if any system
+	// message appears past index 0.
+	const isMiniMaxHost =
+		provider === "minimax-code" ||
+		provider === "minimax-code-cn" ||
+		baseUrl.includes("api.minimax.io") ||
+		baseUrl.includes("api.minimaxi.com");
+	const isQwenPortal = provider === "qwen-portal" || baseUrl.includes("portal.qwen.ai");
+	const supportsMultipleSystemMessagesDefault =
+		!isMiniMaxHost &&
+		!isAlibaba &&
+		!isQwenPortal &&
+		(isOpenAIHost ||
+			isAzureHost ||
+			isOpenRouter ||
+			isCerebras ||
+			isTogether ||
+			isFireworks ||
+			isGroqHost ||
+			isDeepseekFamily ||
+			isMistral ||
+			isGrok ||
+			isZai ||
+			isZhipu ||
+			isCopilotHost ||
+			isZenmuxHost);
+
+	const reasoningEffortMap: NonNullable<OpenAICompat["reasoningEffortMap"]> =
+		provider === "groq" && model.id === "qwen/qwen3-32b"
+			? ({
+					minimal: "default",
+					low: "default",
+					medium: "default",
+					high: "default",
+					xhigh: "default",
+				} satisfies Partial<Record<OpenAIReasoningEffort, string>>)
+			: isDeepseekFamily && model.reasoning
+				? ({
+						minimal: "high",
+						low: "high",
+						medium: "high",
+						high: "high",
+						xhigh: "max",
+					} satisfies Partial<Record<OpenAIReasoningEffort, string>>)
+				: isFireworks
+					? ({
+							// Fireworks' OpenAI-compatible endpoint rejects OpenAI's
+							// `minimal` literal but accepts `none` for the lowest setting.
+							minimal: "none",
+						} satisfies Partial<Record<OpenAIReasoningEffort, string>>)
+					: {};
+
+	return {
+		supportsStore: !isNonStandard,
+		// `developer` is an OpenAI-Responses-era extension to the chat-completions schema. Almost
+		// every OpenAI-compatible host other than OpenAI itself (and Azure OpenAI, which mirrors
+		// the schema exactly) treats it as an unknown role: Moonshot returns a 400 "tokenization
+		// failed", Groq/Cerebras/etc. error or silently misroute. Default to `system` and require
+		// callers to opt in via `compat.supportsDeveloperRole: true` for hosts known to mirror
+		// OpenAI's reasoning-API surface.
+		supportsDeveloperRole: isOpenAIHost || isAzureHost,
+		supportsMultipleSystemMessages: supportsMultipleSystemMessagesDefault,
+		supportsReasoningEffort: !isGrok && !isZai && !isZhipu && !isXiaomiMimo,
+		reasoningEffortMap,
+		supportsUsageInStreaming: !isCerebras,
+		disableReasoningOnForcedToolChoice: isKimiModel || isAnthropicModel,
+		disableReasoningOnToolChoice: isDeepseekFamily && Boolean(model.reasoning) && !isOpenRouter,
+		supportsToolChoice: !isDirectDeepseekReasoning,
+		maxTokensField: useMaxTokens ? "max_tokens" : "max_completion_tokens",
+		requiresToolResultName: isMistral,
+		requiresAssistantAfterToolResult: false,
+		requiresThinkingAsText: isMistral,
+		requiresMistralToolIds: isMistral,
+		// Only Kimi's native hosts (Moonshot / Kimi-code, matched by `isMoonshotKimi`)
+		// speak the z.ai binary `thinking: { type }` field. Kimi reached through
+		// OpenAI-compatible proxies — Fireworks' Fire Pass router, OpenCode's gateway,
+		// etc. — drives reasoning via OpenAI-style `reasoning_effort`
+		// (low|medium|high|xhigh|max|none), so those stay on the "openai" path.
+		thinkingFormat:
+			isZai || isZhipu || isMoonshotKimi || isXiaomiMimo
+				? "zai"
+				: provider === "openrouter" || baseUrl.includes("openrouter.ai")
+					? "openrouter"
+					: isAlibaba || isQwen
+						? "qwen"
+						: "openai",
+		thinkingKeep: usesMoonshotKimiPreservedThinking ? "all" : undefined,
+		reasoningContentField: "reasoning_content",
+		// Backends that 400 follow-up requests when prior assistant tool-call turns lack `reasoning_content`:
+		//   - Kimi: documented invariant on its native API.
+		//   - DeepSeek-family reasoning models, including aliased OpenCode Zen models
+		//     like `big-pickle`, validate exact thinking-mode replay.
+		//   - Xiaomi MiMo models require exact `reasoning_content` replay on
+		//     thinking-mode tool-call continuations across standard and Token Plan hosts.
+		//   - Any reasoning-capable model reached through OpenRouter can enforce this
+		//     server-side whenever the request is in thinking mode. We can't translate
+		//     Anthropic's redacted/encrypted reasoning into provider-native plaintext,
+		//     so cross-provider continuations rely on a placeholder.
+		// OpenCode Kimi aliases handle reasoning content internally and reject
+		// client-sent `reasoning_content`, so exclude only that Kimi-on-OpenCode path.
+		requiresReasoningContentForToolCalls:
+			(isKimiModel && !isOpenCodeProvider) ||
+			(isDeepseekFamily && Boolean(model.reasoning)) ||
+			isXiaomiMimo ||
+			((provider === "openrouter" || baseUrl.includes("openrouter.ai")) && Boolean(model.reasoning)),
+		// DeepSeek V4 and Xiaomi MiMo reject synthetic reasoning_content placeholders (".") on tool-call turns.
+		// Kimi and OpenRouter accept them when actual reasoning is unavailable.
+		allowsSyntheticReasoningContentForToolCalls: (!isDeepseekFamily || !model.reasoning) && !isXiaomiMimo,
+		requiresAssistantContentForToolCalls: isKimiModel || isDirectDeepseekReasoning,
+		cacheControlFormat: isOpenRouter && model.id.startsWith("anthropic/") ? "anthropic" : undefined,
+		openRouterRouting: undefined,
+		vercelGatewayRouting: undefined,
+		supportsStrictMode: detectStrictModeSupport(provider, baseUrl),
+		extraBody: isDirectDeepseekReasoning ? { thinking: { type: "enabled" } } : undefined,
+		toolStrictMode: isCerebras ? "all_strict" : "mixed",
+	};
+}
+
+/**
+ * Resolve compatibility settings by layering explicit model.compat overrides onto
+ * the detected defaults. This is the canonical compat view for both metadata and transport.
+ * @param model - The model configuration
+ * @param resolvedBaseUrl - Optional resolved base URL (e.g., after GitHub Copilot proxy-ep resolution).
+ *                           If provided, this takes precedence over model.baseUrl for URL-based checks.
+ */
+export function resolveOpenAICompat(
+	model: Model<"openai-completions">,
+	resolvedBaseUrl?: string,
+): ResolvedOpenAICompat {
+	const detected = detectOpenAICompat(model, resolvedBaseUrl);
+	if (!model.compat) {
+		return detected;
+	}
+
+	return {
+		supportsStore: model.compat.supportsStore ?? detected.supportsStore,
+		supportsDeveloperRole: model.compat.supportsDeveloperRole ?? detected.supportsDeveloperRole,
+		supportsMultipleSystemMessages:
+			model.compat.supportsMultipleSystemMessages ?? detected.supportsMultipleSystemMessages,
+		supportsReasoningEffort: model.compat.supportsReasoningEffort ?? detected.supportsReasoningEffort,
+		reasoningEffortMap: { ...detected.reasoningEffortMap, ...(model.compat.reasoningEffortMap ?? {}) },
+		supportsUsageInStreaming: model.compat.supportsUsageInStreaming ?? detected.supportsUsageInStreaming,
+		supportsToolChoice: model.compat.supportsToolChoice ?? detected.supportsToolChoice,
+		maxTokensField: model.compat.maxTokensField ?? detected.maxTokensField,
+		requiresToolResultName: model.compat.requiresToolResultName ?? detected.requiresToolResultName,
+		requiresAssistantAfterToolResult:
+			model.compat.requiresAssistantAfterToolResult ?? detected.requiresAssistantAfterToolResult,
+		requiresThinkingAsText: model.compat.requiresThinkingAsText ?? detected.requiresThinkingAsText,
+		requiresMistralToolIds: model.compat.requiresMistralToolIds ?? detected.requiresMistralToolIds,
+		thinkingFormat: model.compat.thinkingFormat ?? detected.thinkingFormat,
+		thinkingKeep: model.compat.thinkingKeep ?? detected.thinkingKeep,
+		reasoningContentField: model.compat.reasoningContentField ?? detected.reasoningContentField,
+		requiresReasoningContentForToolCalls:
+			model.compat.requiresReasoningContentForToolCalls ?? detected.requiresReasoningContentForToolCalls,
+		allowsSyntheticReasoningContentForToolCalls:
+			model.compat.allowsSyntheticReasoningContentForToolCalls ??
+			detected.allowsSyntheticReasoningContentForToolCalls,
+		requiresAssistantContentForToolCalls:
+			model.compat.requiresAssistantContentForToolCalls ?? detected.requiresAssistantContentForToolCalls,
+		cacheControlFormat: model.compat.cacheControlFormat ?? detected.cacheControlFormat,
+		disableReasoningOnForcedToolChoice:
+			model.compat.disableReasoningOnForcedToolChoice ?? detected.disableReasoningOnForcedToolChoice,
+		disableReasoningOnToolChoice: model.compat.disableReasoningOnToolChoice ?? detected.disableReasoningOnToolChoice,
+		openRouterRouting: model.compat.openRouterRouting ?? detected.openRouterRouting,
+		vercelGatewayRouting: model.compat.vercelGatewayRouting ?? detected.vercelGatewayRouting,
+		supportsStrictMode: model.compat.supportsStrictMode ?? detected.supportsStrictMode,
+		extraBody: model.compat.extraBody ?? detected.extraBody,
+		toolStrictMode: model.compat.toolStrictMode ?? detected.toolStrictMode,
+	};
+}