@oh-my-pi/pi-catalog 16.0.4 → 16.0.6

package/src/compat/openai.ts

@@ -13,12 +13,22 @@ import {
 	isClaudeModelId,
 	isDeepseekModelIdOrName,
 	isGlm52ReasoningEffortModelId,
+	isGrokReasoningEffortCapable,
 	isKimiK26ModelId,
 	isKimiModelId,
 	isMimoModelIdOrName,
 	isQwenModelId,
+	modelFamilyToken,
 } from "../identity/family";
-import type { ModelSpec, OpenAICompat, ResolvedOpenAICompat, ResolvedOpenAIResponsesCompat } from "../types";
+import type {
+	ModelSpec,
+	OpenAICompat,
+	OpenAIStreamMarkupHealingPattern,
+	ResolvedOpenAICompat,
+	ResolvedOpenAIResponsesCompat,
+	ResolvedOpenAISharedCompat,
+	ResolvedOpenRouterCompat,
+} from "../types";
 import { applyCompatOverrides } from "./apply";
 
 /** GLM coding-plan SKUs idle for minutes mid-reasoning; see `streamIdleTimeoutMs`. */
@@ -28,6 +38,76 @@ const GLM_CODING_PLAN_STREAM_IDLE_TIMEOUT_MS = 600_000;
 const DEEPSEEK_REASONING_STREAM_IDLE_TIMEOUT_MS = 300_000;
 /** Kimi K2.6 can spend several minutes reasoning before the first visible token. */
 const KIMI_K26_REASONING_STREAM_IDLE_TIMEOUT_MS = 300_000;
+const MINIMAX_PROVIDER_OR_ID_PATTERN = /minimax/i;
+const DSML_HEALING_PROVIDERS = new Set([
+	"ollama",
+	"ollama-cloud",
+	"nvidia",
+	"deepseek",
+	"fireworks",
+	"nanogpt",
+	"opencode-go",
+	"openrouter",
+]);
+
+/**
+ * Ollama's OpenAI-compatible `reasoning.effort` only accepts
+ * `high|medium|low|max|none`; OMP's `minimal`/`xhigh` levels make the server
+ * reject the turn with HTTP 400 `invalid reasoning value`. Map the two
+ * unsupported levels onto the closest accepted ones. Stamped in the compat
+ * builder (not only at discovery) so stale-cached and custom `ollama`-provider
+ * specs are backfilled on every `buildModel`, not just on a fresh
+ * `omp models refresh`. Custom OpenAI-compatible providers pointed at a local
+ * Ollama port under a different provider id are not covered — they must set
+ * `compat.reasoningEffortMap` themselves.
+ */
+const OLLAMA_REASONING_EFFORT_MAP: ResolvedOpenAISharedCompat["reasoningEffortMap"] = { minimal: "low", xhigh: "max" };
+
+/**
+ * Merge the Ollama default effort map under any explicit overrides (overrides
+ * win). No-op off the local `ollama` provider or for non-reasoning models.
+ */
+function mergeOllamaReasoningEffortMap(
+	compat: ResolvedOpenAISharedCompat,
+	provider: string,
+	reasoning: boolean | undefined,
+): void {
+	if (provider !== "ollama" || !reasoning) return;
+	compat.reasoningEffortMap = { ...OLLAMA_REASONING_EFFORT_MAP, ...compat.reasoningEffortMap };
+}
+
+function resolveReasoningDisableMode(
+	thinkingFormat: ResolvedOpenAISharedCompat["thinkingFormat"],
+): ResolvedOpenAISharedCompat["reasoningDisableMode"] {
+	switch (thinkingFormat) {
+		case "openrouter":
+			return "openrouter-enabled-false";
+		case "zai":
+			return "zai-thinking-disabled";
+		case "qwen":
+			return "qwen-enable-thinking-false";
+		case "qwen-chat-template":
+			return "qwen-template-false";
+		default:
+			return "lowest-effort";
+	}
+}
+
+function detectStreamMarkupHealingPattern(
+	provider: string,
+	modelId: string,
+): OpenAIStreamMarkupHealingPattern | undefined {
+	if (MINIMAX_PROVIDER_OR_ID_PATTERN.test(provider) || MINIMAX_PROVIDER_OR_ID_PATTERN.test(modelId)) {
+		return "thinking";
+	}
+	if (provider === "kimi-code" || provider === "moonshot" || /kimi[-/_.]?k2/i.test(modelId)) {
+		return "kimi";
+	}
+	if (isDeepseekModelIdOrName(modelId) && DSML_HEALING_PROVIDERS.has(provider)) {
+		return "dsml";
+	}
+	return undefined;
+}
 
 /**
  * OpenCode's gateways (https://opencode.ai/zen|go) gate `reasoning_content`
@@ -196,6 +276,25 @@ export function buildOpenAICompat(spec: ModelSpec<"openai-completions">): Resolv
 					? DEEPSEEK_REASONING_STREAM_IDLE_TIMEOUT_MS
 					: undefined;
 
+	const wireModelIdMode: ResolvedOpenAISharedCompat["wireModelIdMode"] =
+		provider === "firepass"
+			? "firepass"
+			: provider === "fireworks"
+				? "fireworks"
+				: isOpenRouter
+					? "openrouter"
+					: "raw";
+	const thinkingFormat: ResolvedOpenAISharedCompat["thinkingFormat"] =
+		isZai || isZhipu || isMoonshotKimi || isXiaomiMimo
+			? "zai"
+			: isOpenRouter
+				? "openrouter"
+				: isQwen && isNvidiaNim
+					? "qwen-chat-template"
+					: isAlibaba || isQwen
+						? "qwen"
+						: "openai";
+
 	const compat: ResolvedOpenAICompat = {
 		supportsStore: !isNonStandard,
 		// `developer` is an OpenAI-Responses-era extension to the chat-completions schema. Almost
@@ -211,6 +310,10 @@ export function buildOpenAICompat(spec: ModelSpec<"openai-completions">): Resolv
 		supportsReasoningParams: provider !== "github-copilot",
 		reasoningEffortMap: {},
 		supportsUsageInStreaming: !isCerebras,
+		// pi-ai's thinking-loop guard is gemini-only; default the flag from the
+		// family classifier so OpenAI-compat proxies serving Gemini are covered.
+		// An opaque alias can opt in via `compat.enableGeminiThinkingLoopGuard`.
+		enableGeminiThinkingLoopGuard: modelFamilyToken(spec.id) === "gemini",
 		// Kimi (including via OpenRouter and Fireworks router-form IDs such as
 		// `accounts/fireworks/routers/kimi-*`) calculates TPM rate limits based on
 		// max_tokens, not actual output. The official Kimi K2 model guidance
@@ -224,7 +327,7 @@ export function buildOpenAICompat(spec: ModelSpec<"openai-completions">): Resolv
 		supportsForcedToolChoice: true,
 		maxTokensField: useMaxTokens ? "max_tokens" : "max_completion_tokens",
 		requiresToolResultName: isMistral,
-		requiresAssistantAfterToolResult: false,
+		requiresAssistantAfterToolResult: isMistral,
 		requiresThinkingAsText: isMistral,
 		requiresMistralToolIds: isMistral,
 		// Only Kimi's native hosts (Moonshot / Kimi-code, matched by `isMoonshotKimi`)
@@ -236,16 +339,11 @@ export function buildOpenAICompat(spec: ModelSpec<"openai-completions">): Resolv
 		// (`chat_template_kwargs.enable_thinking`); top-level `enable_thinking`
 		// is rejected by NIM's `additionalProperties: false` request schema
 		// (issue #2299).
-		thinkingFormat:
-			isZai || isZhipu || isMoonshotKimi || isXiaomiMimo
-				? "zai"
-				: isOpenRouter
-					? "openrouter"
-					: isQwen && isNvidiaNim
-						? "qwen-chat-template"
-						: isAlibaba || isQwen
-							? "qwen"
-							: "openai",
+		thinkingFormat,
+		reasoningDisableMode: resolveReasoningDisableMode(thinkingFormat),
+		omitReasoningEffort: false,
+		includeEncryptedReasoning: true,
+		filterReasoningHistory: false,
 		thinkingKeep: usesMoonshotKimiPreservedThinking ? "all" : undefined,
 		reasoningContentField: "reasoning_content",
 		// Backends that 400 follow-up requests when prior assistant tool-call turns lack `reasoning_content`:
@@ -266,6 +364,8 @@ export function buildOpenAICompat(spec: ModelSpec<"openai-completions">): Resolv
 			(isDeepseekFamily && Boolean(spec.reasoning)) ||
 			isXiaomiMimo ||
 			(isOpenRouter && Boolean(spec.reasoning)),
+		requiresReasoningContentForAllAssistantTurns:
+			((isDeepseekFamily && Boolean(spec.reasoning)) || isXiaomiMimo) && !isOpenRouter,
 		// 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 || !spec.reasoning) && !isXiaomiMimo,
@@ -274,20 +374,45 @@ export function buildOpenAICompat(spec: ModelSpec<"openai-completions">): Resolv
 		openRouterRouting: undefined,
 		vercelGatewayRouting: undefined,
 		isOpenRouterHost: isOpenRouter,
+		wireModelIdMode,
 		isVercelGatewayHost: isVercelGateway,
 		supportsStrictMode: detectStrictModeSupport(provider, baseUrl),
 		extraBody: isDirectDeepseekReasoning ? { thinking: { type: "enabled" } } : undefined,
 		toolStrictMode: isCerebras ? "all_strict" : "mixed",
+		toolSchemaFlavor: isMoonshotNative ? "moonshot-mfjs" : undefined,
 		streamIdleTimeoutMs,
+		stripDeepseekSpecialTokens:
+			isDeepseekModelIdOrName(spec.id) && (provider === "nvidia" || provider === "deepseek"),
+		streamMarkupHealingPattern: detectStreamMarkupHealingPattern(provider, spec.id),
+		reasoningDeltasMayBeCumulative:
+			MINIMAX_PROVIDER_OR_ID_PATTERN.test(provider) || MINIMAX_PROVIDER_OR_ID_PATTERN.test(spec.id),
+		emptyLengthFinishIsContextError: provider === "ollama",
+		usesOpenAIToolCallIdLimit: provider === "openai",
+		promptCacheSessionHeader: undefined,
+		dropThinkingWhenReasoningEffort: provider === "fireworks",
 	};
 
 	applyCompatOverrides(compat, spec.compat);
+	if (spec.compat?.reasoningDisableMode === undefined) {
+		compat.reasoningDisableMode = resolveReasoningDisableMode(compat.thinkingFormat);
+	}
+	if (spec.compat?.omitReasoningEffort === undefined && !compat.supportsReasoningEffort) {
+		compat.omitReasoningEffort = true;
+	}
+	mergeOllamaReasoningEffortMap(compat, provider, spec.reasoning);
 
 	const whenThinkingPolicy =
 		spec.compat?.whenThinking ?? (isOpenCodeProvider && spec.reasoning ? OPENCODE_WHEN_THINKING : undefined);
 	if (whenThinkingPolicy) {
 		const variant: ResolvedOpenAICompat = { ...compat };
 		applyCompatOverrides(variant, whenThinkingPolicy);
+		if (whenThinkingPolicy.reasoningDisableMode === undefined) {
+			variant.reasoningDisableMode = resolveReasoningDisableMode(variant.thinkingFormat);
+		}
+		if (whenThinkingPolicy.omitReasoningEffort === undefined && !variant.supportsReasoningEffort) {
+			variant.omitReasoningEffort = true;
+		}
+		mergeOllamaReasoningEffortMap(variant, provider, spec.reasoning);
 		compat.whenThinking = variant;
 	}
 
@@ -295,9 +420,11 @@ export function buildOpenAICompat(spec: ModelSpec<"openai-completions">): Resolv
 }
 
 interface OpenAIResponsesSpecLike {
+	id?: string;
 	provider: string;
 	name: string;
 	baseUrl: string;
+	reasoning?: boolean;
 	compat?: OpenAICompat;
 }
 
@@ -315,21 +442,88 @@ interface OpenAIResponsesSpecLike {
 export function buildOpenAIResponsesCompat(spec: OpenAIResponsesSpecLike): ResolvedOpenAIResponsesCompat {
 	const baseUrl = spec.baseUrl ?? "";
 	const isAzure = modelMatchesHost({ provider: spec.provider, baseUrl }, "azureOpenAI");
+	const isOpenRouter = modelMatchesHost({ provider: spec.provider, baseUrl }, "openrouter");
+	const isOpenAIUrl = hostMatchesUrl(baseUrl, "openai");
+	const id = spec.id ?? "";
+	const thinkingFormat: ResolvedOpenAISharedCompat["thinkingFormat"] = isOpenRouter ? "openrouter" : "openai";
+	const isKimiModel = id ? isKimiModelId(id) : false;
+	const isDeepseekFamily = id ? isDeepseekModelIdOrName(id) || isDeepseekModelIdOrName(spec.name) : false;
+	const reasoningCapable = Boolean(spec.reasoning);
+
 	const compat: ResolvedOpenAIResponsesCompat = {
-		supportsDeveloperRole: isAzure || hostMatchesUrl(baseUrl, "openai") || hostMatchesUrl(baseUrl, "githubCopilot"),
+		supportsDeveloperRole: isAzure || isOpenAIUrl || hostMatchesUrl(baseUrl, "githubCopilot"),
 		supportsStrictMode:
-			spec.provider === "openai" ||
-			isAzure ||
-			spec.provider === "github-copilot" ||
-			hostMatchesUrl(baseUrl, "openai"),
-		supportsReasoningEffort: true,
-		supportsLongPromptCacheRetention: hostMatchesUrl(baseUrl, "openai"),
+			spec.provider === "openai" || isAzure || spec.provider === "github-copilot" || isOpenRouter || isOpenAIUrl,
+		supportsReasoningEffort: spec.provider !== "xai-oauth" || isGrokReasoningEffortCapable(id),
+		supportsLongPromptCacheRetention: isOpenAIUrl,
 		// Azure OpenAI and GitHub Copilot Responses paths require tool results
 		// to strictly match prior tool calls when building Responses inputs.
 		strictResponsesPairing: isAzure || spec.provider === "github-copilot",
 		requiresJuiceZeroHack: spec.name.toLowerCase().startsWith("gpt-5"),
 		reasoningEffortMap: {},
+		supportsReasoningParams: true,
+		thinkingFormat,
+		reasoningDisableMode: resolveReasoningDisableMode(thinkingFormat),
+		omitReasoningEffort: false,
+		includeEncryptedReasoning: spec.provider !== "xai-oauth",
+		filterReasoningHistory: spec.provider === "xai-oauth",
+		disableReasoningOnForcedToolChoice: isKimiModel,
+		disableReasoningOnToolChoice: isDeepseekFamily && reasoningCapable && !isOpenRouter,
+		supportsToolChoice: true,
+		supportsForcedToolChoice: true,
+		reasoningContentField: "reasoning_content",
+		requiresReasoningContentForToolCalls:
+			(isKimiModel || (isDeepseekFamily && reasoningCapable) || (isOpenRouter && reasoningCapable)) &&
+			reasoningCapable,
+		requiresReasoningContentForAllAssistantTurns: isDeepseekFamily && reasoningCapable && !isOpenRouter,
+		allowsSyntheticReasoningContentForToolCalls: !isDeepseekFamily || !reasoningCapable,
+		requiresThinkingAsText: false,
+		requiresMistralToolIds: false,
+		requiresToolResultName: false,
+		requiresAssistantAfterToolResult: false,
+		requiresAssistantContentForToolCalls: isKimiModel,
+		openRouterRouting: undefined,
+		isOpenRouterHost: isOpenRouter,
+		wireModelIdMode: isOpenRouter ? "openrouter" : "raw",
+		alwaysSendMaxTokens: spec.id ? isKimiModelId(spec.id) : false,
+		enableGeminiThinkingLoopGuard: modelFamilyToken(spec.id ?? "") === "gemini",
+		supportsObfuscationOptOut: isOpenAIUrl || spec.provider === "openai",
+		stripDeepseekSpecialTokens:
+			Boolean(id) && isDeepseekModelIdOrName(id) && (spec.provider === "nvidia" || spec.provider === "deepseek"),
+		streamMarkupHealingPattern: id ? detectStreamMarkupHealingPattern(spec.provider, id) : undefined,
+		reasoningDeltasMayBeCumulative:
+			MINIMAX_PROVIDER_OR_ID_PATTERN.test(spec.provider) || (id ? MINIMAX_PROVIDER_OR_ID_PATTERN.test(id) : false),
+		emptyLengthFinishIsContextError: spec.provider === "ollama",
+		usesOpenAIToolCallIdLimit: spec.provider === "openai",
+		promptCacheSessionHeader: spec.provider === "xai-oauth" ? "x-grok-conv-id" : undefined,
 	};
 	applyCompatOverrides(compat, spec.compat);
+	if (spec.compat?.reasoningDisableMode === undefined) {
+		compat.reasoningDisableMode = resolveReasoningDisableMode(compat.thinkingFormat);
+	}
+	if (spec.compat?.omitReasoningEffort === undefined && !compat.supportsReasoningEffort) {
+		compat.omitReasoningEffort = true;
+	}
+	mergeOllamaReasoningEffortMap(compat, spec.provider, spec.reasoning);
 	return compat;
 }
+
+type ResponsesOnlyCompat = Omit<ResolvedOpenAIResponsesCompat, keyof ResolvedOpenAISharedCompat>;
+
+function pickResponsesOnly(compat: ResolvedOpenAIResponsesCompat): ResponsesOnlyCompat {
+	return {
+		supportsLongPromptCacheRetention: compat.supportsLongPromptCacheRetention,
+		strictResponsesPairing: compat.strictResponsesPairing,
+		requiresJuiceZeroHack: compat.requiresJuiceZeroHack,
+		supportsObfuscationOptOut: compat.supportsObfuscationOptOut,
+	} satisfies ResponsesOnlyCompat;
+}
+
+export function buildOpenRouterCompat(spec: ModelSpec<"openrouter">): ResolvedOpenRouterCompat {
+	const chat = buildOpenAICompat({
+		...spec,
+		api: "openai-completions",
+	} as ModelSpec<"openai-completions">);
+	const responses = buildOpenAIResponsesCompat(spec);
+	return { ...chat, ...pickResponsesOnly(responses) } as ResolvedOpenRouterCompat;
+}

package/src/discovery/antigravity.ts

@@ -1,13 +1,16 @@
-import { z } from "zod/v4";
+import { type } from "arktype";
 import type { ModelSpec } from "../types";
 import { toPositiveNumber } from "../utils";
-import { ANTIGRAVITY_VARIANT_COLLAPSE_TABLE, collapseEffortVariants } from "../variant-collapse";
+import {
+	ANTIGRAVITY_VARIANT_COLLAPSE_TABLE,
+	collapseEffortVariants,
+	type VariantCollapseTable,
+} from "../variant-collapse";
 import { getAntigravityUserAgent } from "../wire/gemini-headers";
 
-const DEFAULT_ANTIGRAVITY_DISCOVERY_ENDPOINTS = [
-	"https://daily-cloudcode-pa.googleapis.com",
-	"https://daily-cloudcode-pa.sandbox.googleapis.com",
-] as const;
+export const ANTIGRAVITY_PRIMARY_ENDPOINT = "https://daily-cloudcode-pa.googleapis.com";
+export const ANTIGRAVITY_SANDBOX_ENDPOINT = "https://daily-cloudcode-pa.sandbox.googleapis.com";
+const DEFAULT_ANTIGRAVITY_DISCOVERY_ENDPOINTS = [ANTIGRAVITY_PRIMARY_ENDPOINT, ANTIGRAVITY_SANDBOX_ENDPOINT] as const;
 const FETCH_AVAILABLE_MODELS_PATH = "/v1internal:fetchAvailableModels";
 
 const DEFAULT_CONTEXT_WINDOW = 200_000;
@@ -53,94 +56,78 @@ export interface AntigravityDiscoveryApiResponse {
 	models?: Record<string, AntigravityDiscoveryApiModel>;
 	agentModelSorts?: AntigravityDiscoveryAgentModelSort[];
 }
-const AntigravityDiscoveryApiModelSchema: z.ZodType<AntigravityDiscoveryApiModel> = z
-	.object({
-		displayName: z.preprocess(value => (typeof value === "string" ? value : undefined), z.string().optional()),
-		supportsImages: z.preprocess(value => (typeof value === "boolean" ? value : undefined), z.boolean().optional()),
-		supportsThinking: z.preprocess(value => (typeof value === "boolean" ? value : undefined), z.boolean().optional()),
-		thinkingBudget: z.preprocess(
-			value => (typeof value === "number" && Number.isFinite(value) ? value : undefined),
-			z.number().optional(),
-		),
-		recommended: z.preprocess(value => (typeof value === "boolean" ? value : undefined), z.boolean().optional()),
-		maxTokens: z.preprocess(
-			value => (typeof value === "number" && Number.isFinite(value) ? value : undefined),
-			z.number().optional(),
-		),
-		maxOutputTokens: z.preprocess(
-			value => (typeof value === "number" && Number.isFinite(value) ? value : undefined),
-			z.number().optional(),
-		),
-		model: z.preprocess(value => (typeof value === "string" ? value : undefined), z.string().optional()),
-		apiProvider: z.preprocess(value => (typeof value === "string" ? value : undefined), z.string().optional()),
-		modelProvider: z.preprocess(value => (typeof value === "string" ? value : undefined), z.string().optional()),
-		isInternal: z.preprocess(value => (typeof value === "boolean" ? value : undefined), z.boolean().optional()),
-		supportsVideo: z.preprocess(value => (typeof value === "boolean" ? value : undefined), z.boolean().optional()),
-	})
-	.loose();
-const AntigravityDiscoveryAgentModelGroupSchema: z.ZodType<AntigravityDiscoveryAgentModelGroup> = z
-	.object({
-		modelIds: z.preprocess(
-			value =>
-				Array.isArray(value)
-					? value.filter((modelId): modelId is string => typeof modelId === "string")
-					: undefined,
-			z.array(z.string()).optional(),
-		),
-	})
-	.loose();
-const AntigravityDiscoveryAgentModelSortSchema: z.ZodType<AntigravityDiscoveryAgentModelSort> = z
-	.object({
-		groups: z.preprocess(
-			value => (Array.isArray(value) ? value : undefined),
-			z
-				.array(z.unknown())
-				.transform(groups =>
-					groups.flatMap(group => {
-						const parsedGroup = AntigravityDiscoveryAgentModelGroupSchema.safeParse(group);
-						return parsedGroup.success ? [parsedGroup.data] : [];
-					}),
-				)
-				.optional(),
-		),
-	})
-	.loose();
-const AntigravityDiscoveryApiResponseSchema: z.ZodType<AntigravityDiscoveryApiResponse> = z
-	.object({
-		models: z.preprocess(
-			value => (typeof value === "object" && value !== null ? value : undefined),
-			z
-				.record(z.string(), z.unknown())
-				.transform(models => {
-					const normalized: Record<string, AntigravityDiscoveryApiModel> = {};
-					for (const [modelId, modelValue] of Object.entries(models)) {
-						if (typeof modelValue !== "object" || modelValue === null) {
-							continue;
-						}
-						const parsedModel = AntigravityDiscoveryApiModelSchema.safeParse(modelValue);
-						if (parsedModel.success) {
-							normalized[modelId] = parsedModel.data;
-						}
-					}
-					return normalized;
-				})
-				.optional(),
-		),
-		agentModelSorts: z.preprocess(
-			value => (Array.isArray(value) ? value : undefined),
-			z
-				.array(z.unknown())
-				.transform(sorts =>
-					sorts.flatMap(sort => {
-						const parsedSort = AntigravityDiscoveryAgentModelSortSchema.safeParse(sort);
-						return parsedSort.success ? [parsedSort.data] : [];
-					}),
-				)
-				.optional(),
-		),
-	})
-	.loose();
-
+const AntigravityDiscoveryApiModelSchema = type({
+	"displayName?": type("unknown").pipe(value => (typeof value === "string" ? value : undefined)),
+	"supportsImages?": type("unknown").pipe(value => (typeof value === "boolean" ? value : undefined)),
+	"supportsThinking?": type("unknown").pipe(value => (typeof value === "boolean" ? value : undefined)),
+	"thinkingBudget?": type("unknown").pipe(value =>
+		typeof value === "number" && Number.isFinite(value) ? value : undefined,
+	),
+	"recommended?": type("unknown").pipe(value => (typeof value === "boolean" ? value : undefined)),
+	"maxTokens?": type("unknown").pipe(value =>
+		typeof value === "number" && Number.isFinite(value) ? value : undefined,
+	),
+	"maxOutputTokens?": type("unknown").pipe(value =>
+		typeof value === "number" && Number.isFinite(value) ? value : undefined,
+	),
+	"model?": type("unknown").pipe(value => (typeof value === "string" ? value : undefined)),
+	"apiProvider?": type("unknown").pipe(value => (typeof value === "string" ? value : undefined)),
+	"modelProvider?": type("unknown").pipe(value => (typeof value === "string" ? value : undefined)),
+	"isInternal?": type("unknown").pipe(value => (typeof value === "boolean" ? value : undefined)),
+	"supportsVideo?": type("unknown").pipe(value => (typeof value === "boolean" ? value : undefined)),
+});
+
+const AntigravityDiscoveryAgentModelGroupSchema = type({
+	"modelIds?": type("unknown").pipe(value =>
+		Array.isArray(value) ? value.filter((modelId): modelId is string => typeof modelId === "string") : undefined,
+	),
+});
+
+const AntigravityDiscoveryAgentModelSortSchema = type({
+	"groups?": type("unknown").pipe(value => {
+		if (!Array.isArray(value)) return undefined;
+		const result: AntigravityDiscoveryAgentModelGroup[] = [];
+		for (const group of value) {
+			const parsedGroup = AntigravityDiscoveryAgentModelGroupSchema(group);
+			if (!(parsedGroup instanceof type.errors)) {
+				result.push(parsedGroup);
+			}
+		}
+		return result;
+	}),
+});
+
+const AntigravityDiscoveryApiResponseSchema = type({
+	"models?": type("unknown").pipe(value => {
+		if (typeof value !== "object" || value === null) {
+			return undefined;
+		}
+		const normalized: Record<string, AntigravityDiscoveryApiModel> = {};
+		for (const [modelId, modelValue] of Object.entries(value)) {
+			if (typeof modelValue !== "object" || modelValue === null) {
+				continue;
+			}
+			const parsedModel = AntigravityDiscoveryApiModelSchema(modelValue);
+			if (!(parsedModel instanceof type.errors)) {
+				normalized[modelId] = parsedModel;
+			}
+		}
+		return normalized;
+	}),
+	"agentModelSorts?": type("unknown").pipe(value => {
+		if (!Array.isArray(value)) {
+			return undefined;
+		}
+		const result: AntigravityDiscoveryAgentModelSort[] = [];
+		for (const sort of value) {
+			const parsedSort = AntigravityDiscoveryAgentModelSortSchema(sort);
+			if (!(parsedSort instanceof type.errors)) {
+				result.push(parsedSort);
+			}
+		}
+		return result;
+	}),
+});
 /**
  * Options for fetching Antigravity discovery models.
  */
@@ -157,6 +144,12 @@ export interface FetchAntigravityDiscoveryModelsOptions {
 	signal?: AbortSignal;
 	/** Optional fetch implementation override for tests. */
 	fetcher?: typeof fetch;
+	/**
+	 * Hand collapse table to apply to the discovered list. Defaults to the
+	 * Antigravity (budget-transport) table; `googleGeminiCli` passes the
+	 * level-transport table so cloudcode-pa keeps `thinkingLevel`.
+	 */
+	collapseTable?: VariantCollapseTable;
 }
 
 /**
@@ -239,7 +232,7 @@ export async function fetchAntigravityDiscoveryModels(
 		// Collapse effort-tier variants at the source so runtime discovery,
 		// the gemini-cli re-provision, and the catalog generator all see
 		// logical ids only.
-		const collapsed = collapseEffortVariants(models, ANTIGRAVITY_VARIANT_COLLAPSE_TABLE);
+		const collapsed = collapseEffortVariants(models, options.collapseTable ?? ANTIGRAVITY_VARIANT_COLLAPSE_TABLE);
 		collapsed.sort((a, b) => a.name.localeCompare(b.name) || a.id.localeCompare(b.id));
 		return collapsed;
 	}
@@ -248,11 +241,11 @@ export async function fetchAntigravityDiscoveryModels(
 }
 
 function parseAntigravityDiscoveryResponse(value: unknown): AntigravityDiscoveryApiResponse | null {
-	const parsed = AntigravityDiscoveryApiResponseSchema.safeParse(value);
-	if (!parsed.success) {
+	const parsed = AntigravityDiscoveryApiResponseSchema(value);
+	if (parsed instanceof type.errors) {
 		return null;
 	}
-	return parsed.data;
+	return parsed;
 }
 
 function trimTrailingSlashes(value: string): string {

package/src/discovery/codex.ts

@@ -1,4 +1,4 @@
-import { z } from "zod/v4";
+import { type } from "arktype";
 import type { ModelSpec } from "../types";
 import { isRecord } from "../utils";
 import { CODEX_BASE_URL, OPENAI_HEADER_VALUES, OPENAI_HEADERS } from "../wire/codex";
@@ -9,36 +9,29 @@ const DEFAULT_MAX_TOKENS = 128_000;
 const DEFAULT_CODEX_CLIENT_VERSION = "0.99.0";
 const NPM_CODEX_LATEST_URL = "https://registry.npmjs.org/@openai%2Fcodex/latest";
 
-const codexReasoningPresetSchema = z
-	.object({
-		effort: z.unknown().optional(),
-	})
-	.loose();
-
-const codexModelEntrySchema = z
-	.object({
-		slug: z.unknown().optional(),
-		id: z.unknown().optional(),
-		display_name: z.unknown().optional(),
-		context_window: z.unknown().optional(),
-		default_reasoning_level: z.unknown().optional(),
-		supported_reasoning_levels: z.unknown().optional(),
-		input_modalities: z.unknown().optional(),
-		supported_in_api: z.unknown().optional(),
-		priority: z.unknown().optional(),
-		prefer_websockets: z.unknown().optional(),
-	})
-	.loose();
-
-const codexModelsResponseSchema = z
-	.object({
-		models: z.array(z.unknown()).optional(),
-		data: z.array(z.unknown()).optional(),
-	})
-	.loose();
-
-type CodexModelEntry = z.infer<typeof codexModelEntrySchema>;
-
+const codexReasoningPresetSchema = type({
+	"effort?": "unknown",
+});
+
+const codexModelEntrySchema = type({
+	"slug?": "unknown",
+	"id?": "unknown",
+	"display_name?": "unknown",
+	"context_window?": "unknown",
+	"default_reasoning_level?": "unknown",
+	"supported_reasoning_levels?": "unknown",
+	"input_modalities?": "unknown",
+	"supported_in_api?": "unknown",
+	"priority?": "unknown",
+	"prefer_websockets?": "unknown",
+});
+
+const codexModelsResponseSchema = type({
+	"models?": "unknown[]",
+	"data?": "unknown[]",
+});
+
+type CodexModelEntry = typeof codexModelEntrySchema.infer;
 interface NormalizedCodexModel {
 	model: ModelSpec<"openai-codex-responses">;
 	priority: number;
@@ -216,12 +209,12 @@ function isAbortError(error: unknown): error is Error {
 }
 
 function normalizeCodexModels(payload: unknown, baseUrl: string): ModelSpec<"openai-codex-responses">[] | null {
-	const parsedResponse = codexModelsResponseSchema.safeParse(payload);
-	if (!parsedResponse.success) {
+	const parsedResponse = codexModelsResponseSchema(payload);
+	if (parsedResponse instanceof type.errors) {
 		return null;
 	}
 
-	const entries = parsedResponse.data.models ?? parsedResponse.data.data ?? [];
+	const entries = parsedResponse.models ?? parsedResponse.data ?? [];
 	const normalized: NormalizedCodexModel[] = [];
 	for (const entry of entries) {
 		const model = normalizeCodexModelEntry(entry, baseUrl);
@@ -241,12 +234,12 @@ function normalizeCodexModels(payload: unknown, baseUrl: string): ModelSpec<"ope
 }
 
 function normalizeCodexModelEntry(entry: unknown, baseUrl: string): NormalizedCodexModel | null {
-	const parsedEntry = codexModelEntrySchema.safeParse(entry);
-	if (!parsedEntry.success) {
+	const parsedEntry = codexModelEntrySchema(entry);
+	if (parsedEntry instanceof type.errors) {
 		return null;
 	}
 
-	const payload: CodexModelEntry = parsedEntry.data;
+	const payload: CodexModelEntry = parsedEntry;
 	const slug = toNonEmptyString(payload.slug) ?? toNonEmptyString(payload.id);
 	if (!slug) {
 		return null;
@@ -295,11 +288,11 @@ function supportsReasoning(defaultReasoningLevel: unknown, supportedReasoningLev
 	}
 
 	for (const level of supportedReasoningLevels) {
-		const parsedLevel = codexReasoningPresetSchema.safeParse(level);
-		if (!parsedLevel.success) {
+		const parsedLevel = codexReasoningPresetSchema(level);
+		if (parsedLevel instanceof type.errors) {
 			continue;
 		}
-		const effort = toNonEmptyString(parsedLevel.data.effort)?.toLowerCase();
+		const effort = toNonEmptyString(parsedLevel.effort)?.toLowerCase();
 		if (effort && effort !== "none") {
 			return true;
 		}