@prometheus-ai/ai 0.5.4 → 0.5.8

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

@@ -1,320 +1,20 @@
-import type { Model, OpenAICompat } from "../types";
+import { buildOpenAICompat } from "@prometheus-ai/catalog/compat/openai";
+import type { Model, ModelSpec, ResolvedOpenAICompat } from "../types";
 
-type OpenAIReasoningEffort = "minimal" | "low" | "medium" | "high" | "xhigh";
-type ResolvedToolStrictMode = NonNullable<OpenAICompat["toolStrictMode"]> | "mixed";
+export type { ResolvedOpenAICompat };
 
-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")
-	);
+function toCompatSpec(model: Model<"openai-completions">, resolvedBaseUrl?: string): ModelSpec<"openai-completions"> {
+	const { compat: _compat, ...spec } = model;
+	return resolvedBaseUrl === undefined ? spec : { ...spec, baseUrl: resolvedBaseUrl };
 }
 
-/**
- * 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",
-	};
+	return buildOpenAICompat(toCompatSpec(model, resolvedBaseUrl));
 }
 
-/**
- * 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,
-	};
+	return detectOpenAICompat(model, resolvedBaseUrl);
 }