@vib-rato/ai 0.16.0

package/src/models.json.d.ts

@@ -0,0 +1,9 @@
+import type { Api } from "./types";
+
+/** Typed declaration for the generated models.json — only the `api` field matters for type inference. */
+declare const models: {
+	[provider: string]: {
+		[modelId: string]: { readonly api: Api; [key: string]: unknown };
+	};
+};
+export default models;

package/src/models.ts

@@ -0,0 +1,126 @@
+import { readFileSync } from "node:fs";
+import { registerProviderSafetyStopModel } from "./adapter-internals/provider-safety-stop";
+import { getOpenAIModelCost } from "./model-pricing";
+import { isRetiredModelKey } from "./model-retirements";
+import { applyGeneratedModelPolicies, enrichModelThinking } from "./model-thinking";
+// `with { type: "file" }` is embedded by `bun build --compile` and resolves to
+// the bunfs path inside standalone binaries (and to the on-disk path in dev).
+// A plain `createRequire` of a `.json` listed as an extra compile entrypoint is
+// NOT emitted into the bunfs, and its cwd-fallback masks the failure whenever
+// the process runs inside a repo checkout — see PR body for the minimal repro.
+import modelsJsonPath from "./models.json" with { type: "file" };
+import type { Api, KnownProvider, Model, Usage } from "./types";
+import { isClaudeForcedToolChoiceIncapableModelId } from "./utils/tool-choice-capability";
+
+/**
+ * Static bundled model registry loaded lazily from `models.json`.
+ *
+ * This module intentionally exposes compile-time defaults only.
+ * It does not include runtime discovery, models.dev overlays, or on-disk cache state.
+ *
+ * For runtime-aware resolution, use `createModelManager()` / `resolveProviderModels()`.
+ */
+type BundledCatalog = typeof import("./models.json");
+
+let bundledCatalog: BundledCatalog | undefined;
+let providerNames: KnownProvider[] | undefined;
+const providerModelRegistry: Map<string, Map<string, Model<Api>>> = new Map();
+
+function getBundledCatalog(): BundledCatalog {
+	// TS types a .json import as its contents; at runtime `with { type: "file" }`
+	// yields the file path (bunfs path in compiled binaries, disk path in dev).
+	if (bundledCatalog !== undefined) return bundledCatalog;
+	const resource = modelsJsonPath as unknown;
+	if (typeof resource === "string") {
+		bundledCatalog = JSON.parse(readFileSync(resource, "utf8")) as BundledCatalog;
+	} else if (resource !== null && typeof resource === "object") {
+		bundledCatalog = resource as BundledCatalog;
+	} else {
+		throw new Error("Bundled models catalog resource is invalid.");
+	}
+	return bundledCatalog;
+}
+
+function getProviderModels(provider: GeneratedProvider): Map<string, Model<Api>> | undefined {
+	const cached = providerModelRegistry.get(provider);
+	if (cached) return cached;
+	const models = getBundledCatalog()[provider];
+	if (!models) return undefined;
+	const providerModels = new Map<string, Model<Api>>();
+	for (const [id, model] of Object.entries(models)) {
+		if (isRetiredModelKey(provider, id)) {
+			continue;
+		}
+		const bundledModel = applyBundledCompatDefaults(enrichModelThinking(model as Model<Api>));
+		registerProviderSafetyStopModel(bundledModel);
+		providerModels.set(id, bundledModel);
+	}
+	providerModelRegistry.set(provider, providerModels);
+	return providerModels;
+}
+
+/**
+ * Bundled-catalog compat defaults applied at load time so stale committed
+ * models.json snapshots still receive policy-critical fields (e.g. Claude
+ * Mythos rejecting forced tool use) without a full regeneration.
+ */
+function applyBundledCompatDefaults(model: Model<Api>): Model<Api> {
+	let normalized = model;
+	if (normalized.id === "minimax-m3" && normalized.name === "MiniMax M3") {
+		normalized = { ...normalized, name: "MiniMax-M3" };
+	}
+	if (
+		(normalized.api === "anthropic-messages" || normalized.api === "bedrock-converse-stream") &&
+		isClaudeForcedToolChoiceIncapableModelId(normalized.id) &&
+		(normalized.compat as { toolChoiceSupport?: string } | undefined)?.toolChoiceSupport === undefined
+	) {
+		return {
+			...normalized,
+			compat: { ...(normalized.compat ?? {}), toolChoiceSupport: "auto" } as Model<Api>["compat"],
+		};
+	}
+	const policyModels = [normalized];
+	applyGeneratedModelPolicies(policyModels);
+	return policyModels[0] ?? normalized;
+}
+
+export type GeneratedProvider = keyof BundledCatalog;
+
+export function getBundledModel<TApi extends Api = Api>(provider: GeneratedProvider, modelId: string): Model<TApi> {
+	const providerModels = getProviderModels(provider);
+	return providerModels?.get(modelId) as Model<TApi>;
+}
+
+export function getBundledProviders(): KnownProvider[] {
+	// Defensive copy: the old eager path returned a fresh Array.from(...), so
+	// callers may freely mutate their result without corrupting enumeration.
+	providerNames ??= Object.keys(getBundledCatalog()) as KnownProvider[];
+	return providerNames.slice();
+}
+
+export function getBundledModels(provider: GeneratedProvider): Model<Api>[] {
+	const models = getProviderModels(provider);
+	return models ? (Array.from(models.values()) as Model<Api>[]) : [];
+}
+
+export function calculateCost<TApi extends Api>(model: Model<TApi>, usage: Usage): Usage["cost"] {
+	const inputTokens = usage.input + usage.cacheRead + usage.cacheWrite;
+	const pricing = getOpenAIModelCost(model, inputTokens) ?? model.cost;
+	usage.cost.input = (pricing.input / 1000000) * usage.input;
+	usage.cost.output = (pricing.output / 1000000) * usage.output;
+	usage.cost.cacheRead = (pricing.cacheRead / 1000000) * usage.cacheRead;
+	usage.cost.cacheWrite = (pricing.cacheWrite / 1000000) * usage.cacheWrite;
+	usage.cost.total = usage.cost.input + usage.cost.output + usage.cost.cacheRead + usage.cost.cacheWrite;
+	return usage.cost;
+}
+/**
+ * Check if two models are equal by comparing both their id and provider.
+ * Returns false if either model is null or undefined.
+ */
+export function modelsAreEqual<TApi extends Api>(
+	a: Model<TApi> | null | undefined,
+	b: Model<TApi> | null | undefined,
+): boolean {
+	if (!a || !b) return false;
+	return a.id === b.id && a.provider === b.provider;
+}

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

@@ -0,0 +1,34 @@
+import type { Model, OpenAICompat } from "./types";
+type ResolvedToolStrictMode = NonNullable<OpenAICompat["toolStrictMode"]> | "mixed";
+/** Returns whether the request endpoint is an audited reasoning-control transport. */
+export declare function isAuditedOpenAIReasoningTransport(model: {
+    provider: string;
+    baseUrl?: string;
+}, resolvedBaseUrl?: string): boolean;
+export type ResolvedOpenAICompat = Required<Omit<OpenAICompat, "openRouterRouting" | "vercelGatewayRouting" | "extraBody" | "toolStrictMode" | "toolChoiceSupport" | "supportsResponsesSessionAffinity" | "supportsServiceTier" | "reservedToolNames">> & {
+    openRouterRouting?: OpenAICompat["openRouterRouting"];
+    vercelGatewayRouting?: OpenAICompat["vercelGatewayRouting"];
+    extraBody?: OpenAICompat["extraBody"];
+    toolStrictMode: ResolvedToolStrictMode;
+    supportsResponsesSessionAffinity?: OpenAICompat["supportsResponsesSessionAffinity"];
+    supportsServiceTier?: OpenAICompat["supportsServiceTier"];
+    /** Optional explicit capability override; resolved via deriveToolChoiceSupport. */
+    toolChoiceSupport?: OpenAICompat["toolChoiceSupport"];
+};
+/**
+ * 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 declare function detectOpenAICompat(model: Model<"openai-completions">, resolvedBaseUrl?: string): ResolvedOpenAICompat;
+/**
+ * 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 declare function resolveOpenAICompat(model: Model<"openai-completions">, resolvedBaseUrl?: string): ResolvedOpenAICompat;
+export {};

package/src/openai-completions-compat.ts

@@ -0,0 +1,383 @@
+import type { Model, OpenAICompat } from "./types";
+
+type OpenAIReasoningEffort = "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
+type ResolvedToolStrictMode = NonNullable<OpenAICompat["toolStrictMode"]> | "mixed";
+
+const AUDITED_REASONING_EFFORT_HOST_SUFFIXES = [
+	"api.openai.com",
+	"chatgpt.com",
+	"openai.azure.com",
+	"models.inference.ai.azure.com",
+	"api.githubcopilot.com",
+	"openrouter.ai",
+	"api.cerebras.ai",
+	"api.together.xyz",
+	"fireworks.ai",
+	"api.groq.com",
+	"deepseek.com",
+	"deepinfra.com",
+	"mistral.ai",
+	"api.x.ai",
+	"api.z.ai",
+	"api.kilo.ai",
+	"opencode.ai",
+	"api.moonshot.ai",
+	"api.kimi.com",
+	"maas.aliyuncs.com",
+	"dashscope.aliyuncs.com",
+	"dashscope-intl.aliyuncs.com",
+	"bizrouter.ai",
+	"cloud.gitlab.com",
+	"huggingface.co",
+	"labs.jb.gg",
+	"mara.com",
+	"nano-gpt.com",
+	"nvidia.com",
+	"opengateway.ai",
+	"baidubce.com",
+	"venice.ai",
+	"xiaomimimo.com",
+	"zenmux.ai",
+] as const;
+
+function parseHostname(baseUrl: string): string | undefined {
+	try {
+		return new URL(baseUrl).hostname.toLowerCase();
+	} catch {
+		return undefined;
+	}
+}
+
+function hostnameMatches(hostname: string | undefined, suffix: string): boolean {
+	return hostname !== undefined && (hostname === suffix || hostname.endsWith(`.${suffix}`));
+}
+
+/** Returns whether the request endpoint is an audited reasoning-control transport. */
+export function isAuditedOpenAIReasoningTransport(
+	model: { provider: string; baseUrl?: string },
+	resolvedBaseUrl?: string,
+): boolean {
+	const baseUrl = resolvedBaseUrl ?? model.baseUrl ?? "";
+	if (!baseUrl && (model.provider === "openai" || model.provider === "azure-openai")) return true;
+	const hostname = parseHostname(baseUrl);
+	return AUDITED_REASONING_EFFORT_HOST_SUFFIXES.some(suffix => hostnameMatches(hostname, suffix));
+}
+
+export type ResolvedOpenAICompat = Required<
+	Omit<
+		OpenAICompat,
+		| "openRouterRouting"
+		| "vercelGatewayRouting"
+		| "extraBody"
+		| "toolStrictMode"
+		| "toolChoiceSupport"
+		| "supportsResponsesSessionAffinity"
+		| "supportsServiceTier"
+		| "reservedToolNames"
+	>
+> & {
+	openRouterRouting?: OpenAICompat["openRouterRouting"];
+	vercelGatewayRouting?: OpenAICompat["vercelGatewayRouting"];
+	extraBody?: OpenAICompat["extraBody"];
+	toolStrictMode: ResolvedToolStrictMode;
+	supportsResponsesSessionAffinity?: OpenAICompat["supportsResponsesSessionAffinity"];
+	supportsServiceTier?: OpenAICompat["supportsServiceTier"];
+	/** Optional explicit capability override; resolved via deriveToolChoiceSupport. */
+	toolChoiceSupport?: OpenAICompat["toolChoiceSupport"];
+};
+
+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 hostname = parseHostname(baseUrl);
+
+	const isCerebras = provider === "cerebras" || hostnameMatches(hostname, "cerebras.ai");
+	const isZai = hostnameMatches(hostname, "api.z.ai");
+	const isKilo = hostnameMatches(hostname, "api.kilo.ai");
+	const isKimiModel = model.id.includes("moonshotai/kimi") || /(^|\/)kimi[-.]/i.test(model.id);
+	const isMoonshotKimi =
+		isKimiModel && (hostnameMatches(hostname, "api.moonshot.ai") || hostnameMatches(hostname, "api.kimi.com"));
+	const isAnthropicModel =
+		provider === "anthropic" ||
+		baseUrl.includes("api.anthropic.com") ||
+		/(^|\/)claude[-.]/i.test(model.id) ||
+		/(^|\/)anthropic\//i.test(model.id);
+	const isAlibaba =
+		hostnameMatches(hostname, "maas.aliyuncs.com") ||
+		hostnameMatches(hostname, "dashscope.aliyuncs.com") ||
+		hostnameMatches(hostname, "dashscope-intl.aliyuncs.com");
+	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 isDeepseekFamily =
+		provider === "deepseek" ||
+		baseUrl.includes("deepseek.com") ||
+		lowerId.includes("deepseek") ||
+		lowerName.includes("deepseek");
+	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 ||
+		isKilo ||
+		isQwen ||
+		provider === "opencode-zen" ||
+		provider === "opencode-go" ||
+		baseUrl.includes("opencode.ai");
+	const isOpenCodeProvider = provider === "opencode-go" || provider === "opencode-zen";
+	const isOpenCodeGoReasoning = provider === "opencode-go" && Boolean(model.reasoning);
+	const isOpenCodeGoKimiReasoning = provider === "opencode-go" && isKimiModel && Boolean(model.reasoning);
+	const isOpenCodeGoKimi25Reasoning = isOpenCodeGoKimiReasoning && model.id === "kimi-k2.5";
+	const isOpenCodeGoKimi27CodeReasoning = isOpenCodeGoKimiReasoning && model.id === "kimi-k2.7-code";
+	const needsOpenCodeGoKimiEffortMap = isOpenCodeGoKimi25Reasoning || isOpenCodeGoKimi27CodeReasoning;
+
+	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 isDirectXaiReasoningEffortModel = provider === "xai" && (model.id === "grok-4.5" || model.id === "grok-4.6");
+	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 = hostnameMatches(hostname, "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";
+	const hasAuditedReasoningEffortTransport = isAuditedOpenAIReasoningTransport(model, resolvedBaseUrl);
+	// 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 ||
+			isCopilotHost ||
+			isZenmuxHost);
+
+	const reasoningEffortMap: NonNullable<OpenAICompat["reasoningEffortMap"]> =
+		provider === "groq" && model.id === "qwen/qwen3-32b"
+			? ({
+					minimal: "default",
+					low: "default",
+					medium: "default",
+					high: "default",
+					xhigh: "default",
+					max: "default",
+				} satisfies Partial<Record<OpenAIReasoningEffort, string>>)
+			: needsOpenCodeGoKimiEffortMap
+				? ({
+						// Live Go probes (2026-07-06) showed model-specific effort gaps:
+						// kimi-k2.5 rejects "minimal", while kimi-k2.7-code rejects
+						// OpenAI-style "xhigh" and "max"; all other Kimi efforts tested
+						// successfully and should pass through unchanged.
+						...(isOpenCodeGoKimi25Reasoning ? { minimal: "low" } : {}),
+						...(isOpenCodeGoKimi27CodeReasoning ? { xhigh: "high", max: "high" } : {}),
+					} satisfies Partial<Record<OpenAIReasoningEffort, string>>)
+				: isDeepseekFamily && model.reasoning
+					? ({
+							minimal: "high",
+							low: "high",
+							medium: "high",
+							high: "high",
+							xhigh: "max",
+							max: "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,
+		supportsDeveloperRole: !isNonStandard,
+		sendSessionHeaders: false,
+		supportsResponsesSessionAffinity: false,
+		supportsMultipleSystemMessages: supportsMultipleSystemMessagesDefault,
+		supportsReasoningEffort:
+			hasAuditedReasoningEffortTransport && ((!isGrok && !isZai) || isDirectXaiReasoningEffortModel),
+		reasoningEffortMap,
+		supportsUsageInStreaming: !isCerebras,
+		disableReasoningOnForcedToolChoice: isKimiModel || isAnthropicModel || isOpenCodeGoReasoning,
+		disableReasoningOnToolChoice: isDeepseekFamily && Boolean(model.reasoning) && !isOpenRouter,
+		supportsToolChoice: !isDirectDeepseekReasoning,
+		supportsForcedToolChoice: !isOpenCodeGoKimiReasoning,
+		maxTokensField: useMaxTokens ? "max_tokens" : "max_completion_tokens",
+		requiresToolResultName: isMistral,
+		requiresAssistantAfterToolResult: false,
+		requiresThinkingAsText: isMistral,
+		requiresMistralToolIds: isMistral,
+		thinkingFormat:
+			hasAuditedReasoningEffortTransport && (isZai || isMoonshotKimi)
+				? "zai"
+				: hasAuditedReasoningEffortTransport && isOpenRouter
+					? "openrouter"
+					: hasAuditedReasoningEffortTransport && isAlibaba && isQwen
+						? "qwen"
+						: "openai",
+		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.
+		//   - Any reasoning-capable model reached through OpenRouter: DeepSeek V4 Pro and similar enforce
+		//     this server-side whenever the request is in thinking mode. We can't translate Anthropic's
+		//     redacted/encrypted reasoning into DeepSeek's plaintext form, so cross-provider continuations
+		//     rely on a placeholder — see `convertMessages` for the placeholder injection.
+		//   - OpenCode-Go and OpenCode-Zen handle reasoning content internally and reject
+		//     `reasoning_content` in client-sent messages — exclude them even for Kimi models.
+		requiresReasoningContentForToolCalls:
+			(isKimiModel && !isOpenCodeProvider) ||
+			(isDeepseekFamily && Boolean(model.reasoning)) ||
+			((provider === "openrouter" || baseUrl.includes("openrouter.ai")) && Boolean(model.reasoning)),
+		// DeepSeek V4 rejects synthetic reasoning_content placeholders (".") on tool-call turns.
+		// Kimi and OpenRouter accept them when actual reasoning is unavailable.
+		allowsSyntheticReasoningContentForToolCalls: !isDeepseekFamily || !model.reasoning,
+		requiresAssistantContentForToolCalls: isKimiModel || isDirectDeepseekReasoning,
+		openRouterRouting: undefined,
+		vercelGatewayRouting: undefined,
+		supportsStrictMode: detectStrictModeSupport(provider, baseUrl) && !(isDeepseekFamily && isOpenRouter),
+		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,
+		sendSessionHeaders: model.compat.sendSessionHeaders ?? detected.sendSessionHeaders,
+		supportsResponsesSessionAffinity:
+			("supportsResponsesSessionAffinity" in model.compat
+				? model.compat.supportsResponsesSessionAffinity
+				: undefined) ?? detected.supportsResponsesSessionAffinity,
+		supportsServiceTier: model.compat.supportsServiceTier ?? detected.supportsServiceTier,
+		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,
+		supportsForcedToolChoice: model.compat.supportsForcedToolChoice ?? detected.supportsForcedToolChoice,
+		toolChoiceSupport: model.compat.toolChoiceSupport ?? detected.toolChoiceSupport,
+		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,
+		reasoningContentField: model.compat.reasoningContentField ?? detected.reasoningContentField,
+		requiresReasoningContentForToolCalls:
+			model.compat.requiresReasoningContentForToolCalls ?? detected.requiresReasoningContentForToolCalls,
+		allowsSyntheticReasoningContentForToolCalls:
+			model.compat.allowsSyntheticReasoningContentForToolCalls ??
+			detected.allowsSyntheticReasoningContentForToolCalls,
+		requiresAssistantContentForToolCalls:
+			model.compat.requiresAssistantContentForToolCalls ?? detected.requiresAssistantContentForToolCalls,
+		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,
+	};
+}

package/src/prompts/composer-bash-policy-recovery.md

@@ -0,0 +1 @@
+A Composer bash policy block interrupted a shell attempt. This is not a terminal condition: continue the same task now. Do not retry repository file I/O in bash. Use the dedicated find, search, read, and edit tools for repository work, then continue with the next safe step.

package/src/prompts/cursor-composer-bash-policy-recovery.md

@@ -0,0 +1 @@
+A Composer bash policy block interrupted a shell attempt. This is not a terminal condition: continue the same task now. Do not retry repository file I/O in shell. Use Cursor-native read for files or directories, grep for search or globs, write for changes, and delete only when deletion is required; then continue with the next safe step.

package/src/prompts/cursor-composer-edit-discipline.md

@@ -0,0 +1,7 @@
+File-editing discipline for this Cursor Composer harness (this OVERRIDES contrary habits from your training):
+
+- Inspect repository files ONLY with Cursor-native read and grep: use read for file bodies or directories, and grep for content search or glob discovery. NEVER inspect repository files through shell commands (ls, find, fd, cat, sed, awk, grep, rg, head, tail, less, more) or scripts.
+- Modify files ONLY with Cursor-native write, or delete only when deletion is required. NEVER mutate files through shell redirection, tee, sed -i, perl -pi, inline python/node/bun scripts, or other out-of-band writes.
+- Re-read a file after any write before relying on its contents again. Do not fabricate line anchors, paths, tool names, or tool-call arguments.
+- Tool-call arguments must be the exact schema object requested by the native tool. Do not include Markdown, commentary, analysis text, or invented fields inside tool arguments.
+- Use shell only for terminal operations such as tests, builds, package scripts, and git commands. A shell command string must contain only the command itself; NEVER interleave reasoning or commentary into command strings or heredocs.

package/src/prompts/turn-aborted-guidance.md

@@ -0,0 +1,4 @@
+<turn-aborted>
+The previous turn was aborted. Any running tools/commands were terminated. 
+If tools were aborted, they may have partially executed; verify current state before retrying.
+</turn-aborted>

package/src/provider-details.ts

@@ -0,0 +1,90 @@
+import { getOpenAICodexTransportDetails, type OpenAICodexTransportDetails } from "./providers/openai-codex-responses";
+import type { Api, Model, Provider, ProviderSessionState } from "./types";
+
+export interface ProviderDetailField {
+	label: string;
+	value: string;
+}
+
+export interface ProviderDetails {
+	provider: Provider;
+	api: Api;
+	fields: ProviderDetailField[];
+}
+
+export interface ProviderDetailsContext {
+	model: Model<Api>;
+	sessionId?: string;
+	authMode?: string;
+	/**
+	 * Human-readable description of the active credential, e.g.
+	 * `"broker http://can.internal:8765 · oauth #5 (foo@bar.com)"`.
+	 * Rendered as a `Source` field; omitted when undefined.
+	 */
+	credentialSource?: string;
+	preferWebsockets?: boolean;
+	providerSessionState?: Map<string, ProviderSessionState>;
+}
+
+export function getProviderDetails(context: ProviderDetailsContext): ProviderDetails {
+	const endpoint = formatEndpoint(context.model.baseUrl);
+	const fields: ProviderDetailField[] = [
+		{ label: "Model", value: context.model.id },
+		{ label: "API", value: context.model.api },
+		{ label: "Auth", value: context.authMode ?? "auto" },
+		{ label: "Endpoint", value: endpoint },
+	];
+	if (context.credentialSource) {
+		fields.push({ label: "Source", value: context.credentialSource });
+	}
+
+	if (context.model.api === "openai-codex-responses") {
+		const codexDetails = getOpenAICodexTransportDetails(context.model as Model<"openai-codex-responses">, {
+			sessionId: context.sessionId,
+			baseUrl: context.model.baseUrl,
+			preferWebsockets: context.preferWebsockets,
+			providerSessionState: context.providerSessionState,
+		});
+		fields.push({ label: "Transport", value: formatCodexTransport(codexDetails) });
+		fields.push({ label: "WebSocket", value: formatCodexWebSocket(codexDetails) });
+		fields.push({ label: "Reuse", value: formatCodexReuse(codexDetails, context.sessionId) });
+	}
+
+	return {
+		provider: context.model.provider,
+		api: context.model.api,
+		fields,
+	};
+}
+
+function formatEndpoint(baseUrl: string): string {
+	try {
+		const parsed = new URL(baseUrl);
+		const path = parsed.pathname.replace(/\/$/, "");
+		return `${parsed.origin}${path || "/"}`;
+	} catch {
+		return baseUrl;
+	}
+}
+
+function formatCodexTransport(details: OpenAICodexTransportDetails): string {
+	if (details.lastTransport === "websocket") return "websocket";
+	if (details.lastTransport === "sse" && (details.websocketDisabled || details.fallbackCount > 0)) {
+		return "sse (fallback)";
+	}
+	if (details.lastTransport === "sse") return "sse";
+	return details.websocketPreferred ? "websocket preferred" : "sse";
+}
+
+function formatCodexWebSocket(details: OpenAICodexTransportDetails): string {
+	if (!details.websocketPreferred) return "off";
+	if (details.websocketDisabled) return "disabled after fallback";
+	if (details.websocketConnected) return "connected";
+	if (details.prewarmed) return "prewarmed";
+	return details.hasSessionState ? "enabled" : "waiting for first request";
+}
+
+function formatCodexReuse(details: OpenAICodexTransportDetails, sessionId: string | undefined): string {
+	if (!sessionId) return "no session key";
+	return details.canAppend ? "append enabled" : "full request";
+}