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

package/src/discovery/cursor.ts

@@ -1,6 +1,6 @@
 import * as http2 from "node:http2";
 import { create, fromBinary, toBinary } from "@bufbuild/protobuf";
-import { z } from "zod/v4";
+import { type } from "arktype";
 import { getBundledModels } from "../models";
 import { toModelSpec } from "../provider-models/bundled-references";
 import type { Model, ModelSpec } from "../types";
@@ -13,27 +13,34 @@ const CURSOR_GET_USABLE_MODELS_PATH = "/agent.v1.AgentService/GetUsableModels";
 const DEFAULT_CONTEXT_WINDOW = 200_000;
 const DEFAULT_MAX_TOKENS = 64_000;
 
-const OptionalDisplayNameSchema = z.string().optional().catch(undefined);
-const CursorAliasesSchema = z
-	.array(z.unknown())
-	.optional()
-	.catch([])
-	.transform(aliases => (aliases ?? []).filter((alias: unknown): alias is string => typeof alias === "string"));
-
-const CursorModelDetailsSchema = z.object({
-	modelId: z.string(),
-	displayName: OptionalDisplayNameSchema,
-	displayNameShort: OptionalDisplayNameSchema,
-	displayModelId: OptionalDisplayNameSchema,
-	aliases: CursorAliasesSchema,
-	thinkingDetails: z.unknown().optional(),
+const OptionalDisplayNameSchema = type("unknown").pipe(raw => (typeof raw === "string" ? raw : undefined));
+const CursorAliasesSchema = type("unknown").pipe(raw => {
+	if (Array.isArray(raw)) {
+		return raw.filter((alias: unknown): alias is string => typeof alias === "string");
+	}
+	return [];
+});
+
+const CursorModelDetailsSchema = type({
+	modelId: "string",
+	displayName: OptionalDisplayNameSchema.default(undefined),
+	displayNameShort: OptionalDisplayNameSchema.default(undefined),
+	displayModelId: OptionalDisplayNameSchema.default(undefined),
+	aliases: CursorAliasesSchema.default(() => []),
+	"thinkingDetails?": "unknown",
+});
+
+const CursorModelsInnerSchema = type("unknown[]");
+const ResilientCursorModelsSchema = type("unknown").pipe(raw => {
+	const out = CursorModelsInnerSchema(raw);
+	return out instanceof type.errors ? [] : out;
 });
 
-const CursorDecodedResponseSchema = z.object({
-	models: z.array(z.unknown()).optional().catch([]),
+const CursorDecodedResponseSchema = type({
+	models: ResilientCursorModelsSchema.default(() => []),
 });
 
-type CursorModelDetailsValue = z.infer<typeof CursorModelDetailsSchema>;
+type CursorModelDetailsValue = typeof CursorModelDetailsSchema.infer;
 
 /**
  * Options for fetching dynamic Cursor models from `GetUsableModels`.
@@ -74,13 +81,13 @@ export async function fetchCursorUsableModels(
 			return null;
 		}
 		const decoded = decodeGetUsableModelsResponse(responseBuffer);
-		const parsedDecoded = CursorDecodedResponseSchema.safeParse(decoded);
-		if (!parsedDecoded.success) {
+		const parsedDecoded = CursorDecodedResponseSchema(decoded);
+		if (parsedDecoded instanceof type.errors) {
 			return null;
 		}
 
 		const references = createCursorReferenceMap();
-		return normalizeCursorModels(parsedDecoded.data.models, options.baseUrl, references);
+		return normalizeCursorModels(parsedDecoded.models, options.baseUrl, references);
 	} catch {
 		return null;
 	}
@@ -254,12 +261,12 @@ function normalizeCursorModel(
 	baseUrlOverride: string | undefined,
 	references: Map<string, ModelSpec<"cursor-agent">>,
 ): ModelSpec<"cursor-agent"> | null {
-	const parsedModel = CursorModelDetailsSchema.safeParse(model);
-	if (!parsedModel.success) {
+	const parsedModel = CursorModelDetailsSchema(model);
+	if (parsedModel instanceof type.errors) {
 		return null;
 	}
 
-	const details = parsedModel.data;
+	const details = parsedModel;
 	const id = details.modelId.trim();
 	if (!id) {
 		return null;

package/src/discovery/gemini.ts

@@ -1,4 +1,4 @@
-import { z } from "zod/v4";
+import { type } from "arktype";
 import { getBundledModels } from "../models";
 import { toModelSpec } from "../provider-models/bundled-references";
 import type { FetchImpl, Model, ModelSpec } from "../types";
@@ -7,36 +7,45 @@ const GOOGLE_GENERATIVE_AI_BASE_URL = "https://generativelanguage.googleapis.com
 const DEFAULT_PAGE_SIZE = 100;
 const DEFAULT_MAX_PAGES = 25;
 
-const geminiModelListItemSchema = z.object({
-	name: z.string().optional().catch(undefined),
-	displayName: z.string().optional().catch(undefined),
-	supportedGenerationMethods: z.array(z.string()).optional(),
-	inputTokenLimit: z.number().finite().optional().catch(undefined),
-	outputTokenLimit: z.number().finite().optional().catch(undefined),
+const resilientString = type("unknown").pipe(val => {
+	if (val === undefined) return undefined;
+	const out = type("string")(val);
+	return out instanceof type.errors ? undefined : out;
 });
 
-const geminiModelListResponseSchema = z.object({
-	models: z
-		.array(z.unknown())
-		.optional()
-		.transform(items => {
-			if (!items) {
-				return [];
-			}
-			const parsedItems: GeminiModelListItem[] = [];
-			for (const item of items) {
-				const parsed = geminiModelListItemSchema.safeParse(item);
-				if (parsed.success) {
-					parsedItems.push(parsed.data);
-				}
-			}
-			return parsedItems;
-		}),
-	nextPageToken: z.string().optional().catch(undefined),
+const resilientNumber = type("unknown").pipe(val => {
+	if (val === undefined) return undefined;
+	const out = type("number")(val);
+	return out instanceof type.errors ? undefined : out;
+});
+
+const geminiModelListItemSchema = type({
+	"name?": resilientString,
+	"displayName?": resilientString,
+	"supportedGenerationMethods?": "string[]",
+	"inputTokenLimit?": resilientNumber,
+	"outputTokenLimit?": resilientNumber,
 });
 
-type GeminiModelListItem = z.infer<typeof geminiModelListItemSchema>;
+type GeminiModelListItem = typeof geminiModelListItemSchema.infer;
 
+const modelsSchema = type("unknown[]")
+	.pipe(items => {
+		const parsedItems: GeminiModelListItem[] = [];
+		for (const item of items) {
+			const parsed = geminiModelListItemSchema(item);
+			if (!(parsed instanceof type.errors)) {
+				parsedItems.push(parsed);
+			}
+		}
+		return parsedItems;
+	})
+	.default(() => []);
+
+const geminiModelListResponseSchema = type({
+	models: modelsSchema,
+	"nextPageToken?": resilientString,
+});
 /**
  * Configuration for Google Generative AI model discovery.
  */
@@ -103,19 +112,19 @@ export async function fetchGeminiModels(
 			return null;
 		}
 
-		const parsed = geminiModelListResponseSchema.safeParse(payload);
-		if (!parsed.success) {
+		const parsed = geminiModelListResponseSchema(payload);
+		if (parsed instanceof type.errors) {
 			return null;
 		}
 
-		for (const item of parsed.data.models) {
+		for (const item of parsed.models) {
 			const model = normalizeModel(item, baseUrl, bundledById);
 			if (model) {
 				modelsById.set(model.id, model);
 			}
 		}
 
-		const token = normalizePageToken(parsed.data.nextPageToken);
+		const token = normalizePageToken(parsed.nextPageToken);
 		if (!token) {
 			break;
 		}

package/src/discovery/openai-compatible.ts

@@ -1,4 +1,4 @@
-import { z } from "zod/v4";
+import { type } from "arktype";
 import type { Api, FetchImpl, ModelSpec, Provider } from "../types";
 
 const MODELS_PATH = "/models";
@@ -32,28 +32,23 @@ export interface OpenAICompatibleModelsEnvelope {
 	[key: string]: unknown;
 }
 
-const openAICompatibleModelRecordSchema = z
-	.object({
-		id: z.string().min(1),
-		name: z.string().optional().nullable(),
-		object: z.unknown().optional(),
-		owned_by: z.unknown().optional(),
-	})
-	.loose();
+const openAICompatibleModelRecordSchema = type({
+	id: "string >= 1",
+	"name?": "string | null",
+	"object?": "unknown",
+	"owned_by?": "unknown",
+});
 
-const openAICompatibleModelsEnvelopeSchema = z
-	.object({
-		data: z.unknown().optional(),
-		models: z.unknown().optional(),
-		result: z.unknown().optional(),
-		items: z.unknown().optional(),
-	})
-	.loose();
+const openAICompatibleModelsEnvelopeSchema = type({
+	"data?": "unknown",
+	"models?": "unknown",
+	"result?": "unknown",
+	"items?": "unknown",
+});
 
-const openAICompatibleModelsPayloadSchema = z.union([z.array(z.unknown()), openAICompatibleModelsEnvelopeSchema]);
-
-type ParsedOpenAICompatibleModelRecord = z.infer<typeof openAICompatibleModelRecordSchema>;
+const openAICompatibleModelsPayloadSchema = type("unknown[]").or(openAICompatibleModelsEnvelopeSchema);
 
+type ParsedOpenAICompatibleModelRecord = typeof openAICompatibleModelRecordSchema.infer;
 /**
  * Context passed to custom OpenAI-compatible model mappers.
  */
@@ -196,22 +191,17 @@ function extractModelEntries(payload: unknown): ParsedOpenAICompatibleModelRecor
 }
 
 function extractModelEntriesFromNode(node: unknown): ParsedOpenAICompatibleModelRecord[] | null {
-	const parsedPayload = openAICompatibleModelsPayloadSchema.safeParse(node);
-	if (!parsedPayload.success) {
+	const parsedPayload = openAICompatibleModelsPayloadSchema(node);
+	if (parsedPayload instanceof type.errors) {
 		return null;
 	}
-	if (Array.isArray(parsedPayload.data)) {
-		const parsedEntries = parsedPayload.data
-			.map(entry => openAICompatibleModelRecordSchema.safeParse(entry))
-			.flatMap(entry => (entry.success ? [entry.data] : []));
+	if (Array.isArray(parsedPayload)) {
+		const parsedEntries = parsedPayload
+			.map(entry => openAICompatibleModelRecordSchema(entry))
+			.flatMap(entry => (entry instanceof type.errors ? [] : [entry]));
 		return parsedEntries;
 	}
-	for (const candidate of [
-		parsedPayload.data.data,
-		parsedPayload.data.models,
-		parsedPayload.data.result,
-		parsedPayload.data.items,
-	]) {
+	for (const candidate of [parsedPayload.data, parsedPayload.models, parsedPayload.result, parsedPayload.items]) {
 		if (candidate === undefined) {
 			continue;
 		}

package/src/identity/dialect.ts

@@ -11,7 +11,8 @@ export type Dialect =
 	| "pi"
 	| "qwen3"
 	| "gemini"
-	| "gemma";
+	| "gemma"
+	| "minimax";
 
 export const FALLBACK_DIALECT: Dialect = "xml";
 
@@ -31,6 +32,8 @@ export function preferredDialect(modelId: string): Dialect {
 			return "qwen3";
 		case "deepseek":
 			return "deepseek";
+		case "minimax":
+			return "minimax";
 		case "openai":
 		case "gpt-oss":
 			return "harmony";

package/src/identity/family.ts

@@ -56,6 +56,19 @@ export function isMimoModelIdOrName(value: string): boolean {
 	return value.toLowerCase().includes("mimo");
 }
 
+const GROK_EFFORT_CAPABLE_PREFIXES = ["grok-3-mini", "grok-4.20-multi-agent", "grok-4.3"] as const;
+
+/**
+ * Grok SKUs that expose the wire `reasoning.effort` dial. Other Grok reasoners
+ * (e.g. `grok-build`, `grok-4.20-0309-reasoning`) think natively but reject the
+ * param, so callers must omit reasoning effort for them.
+ */
+export function isGrokReasoningEffortCapable(modelId: string): boolean {
+	const bare = bareModelId(modelId).trim().toLowerCase();
+	if (!bare) return false;
+	return GROK_EFFORT_CAPABLE_PREFIXES.some(prefix => bare.startsWith(prefix));
+}
+
 /**
  * MiniMax M2-generation family (M2, M2.1, M2.5, M2.7, including `-highspeed`/
  * `-lightning`/`-her`/`-turbo` variants, dotless aliases like `minimax-m21`,
@@ -73,6 +86,13 @@ export function isMinimaxM2FamilyModelId(modelId: string): boolean {
 	return /(?:^|[/.-])m2\d*(?:[.-]\d+)?(?:[-.:_]|$)/i.test(lower);
 }
 
+/** MiniMax M3 family ids in bundled/default and aggregator namespace forms. */
+export function isMinimaxM3FamilyModelId(modelId: string): boolean {
+	const lower = modelId.toLowerCase();
+	if (!lower.includes("minimax")) return false;
+	return /(?:^|[/._-])(?:minimax[/._-])?m3(?:[-.:_]|$)/i.test(lower);
+}
+
 /**
  * OpenAI gpt-oss family (`gpt-oss-20b`, `gpt-oss-120b`, `gpt-oss:120b`,
  * `vendor/gpt-oss-…`). The Harmony reasoning format only accepts
@@ -139,7 +159,7 @@ export function modelFamilyToken(modelId: string): string {
 	if (isOpenAIModelId(modelId)) return "openai";
 	if (isKimiModelId(modelId)) return "kimi";
 	if (isQwenModelId(modelId)) return "qwen";
-	if (isMinimaxM2FamilyModelId(modelId)) return "minimax";
+	if (isMinimaxM2FamilyModelId(modelId) || isMinimaxM3FamilyModelId(modelId)) return "minimax";
 	if (isOpenAIGptOssModelId(modelId)) return "gpt-oss";
 	if (isDeepseekModelIdOrName(modelId)) return "deepseek";
 	if (isMimoModelIdOrName(modelId)) return "mimo";

package/src/model-cache.ts

@@ -7,12 +7,14 @@ import { getModelDbPath } from "@oh-my-pi/pi-utils";
 import type { Api, Model, ModelSpec } from "./types";
 
 // Rows persist ModelSpec JSON (sparse `compat`, never the resolved record);
-// the model manager rebuilds via `buildModel` on load. v6 invalidates rows
-// that may contain the retired unknown-limit sentinels (222222/8888); v5
-// invalidated rows predating effort-tier variant collapsing (raw
-// `-low`/`-high`/`-thinking` member ids); v4 dropped the pre-efforts
-// ThinkingConfig shape.
-const CACHE_SCHEMA_VERSION = 6;
+// the model manager rebuilds via `buildModel` on load. v7 invalidates rows
+// predating the Antigravity Gemini budget-mode migration (cached specs still
+// carrying `thinking.mode: "google-level"` and the old 3.5-flash effort
+// routing); v6 invalidates rows that may contain the retired unknown-limit
+// sentinels (222222/8888); v5 invalidated rows predating effort-tier variant
+// collapsing (raw `-low`/`-high`/`-thinking` member ids); v4 dropped the
+// pre-efforts ThinkingConfig shape.
+const CACHE_SCHEMA_VERSION = 7;
 
 interface CacheRow {
 	provider_id: string;

package/src/model-thinking.ts

@@ -57,6 +57,7 @@ const GEMINI_3_FLASH_EFFORTS: readonly Effort[] = [Effort.Minimal, Effort.Low, E
 const GPT_5_2_PLUS_EFFORTS: readonly Effort[] = [Effort.Low, Effort.Medium, Effort.High, Effort.XHigh];
 const GPT_5_1_CODEX_MINI_EFFORTS: readonly Effort[] = [Effort.Medium, Effort.High];
 const LOW_MEDIUM_HIGH_REASONING_EFFORTS: readonly Effort[] = [Effort.Low, Effort.Medium, Effort.High];
+const GLM_52_HIGH_MAX_REASONING_EFFORTS: readonly Effort[] = [Effort.High, Effort.XHigh];
 
 type EffortMap = Partial<Record<Effort, string>>;
 
@@ -84,6 +85,9 @@ const ZAI_GLM_52_REASONING_EFFORT_MAP: Readonly<EffortMap> = {
 	[Effort.High]: "high",
 	[Effort.XHigh]: "max",
 };
+const OLLAMA_CLOUD_GLM_52_REASONING_EFFORT_MAP: Readonly<EffortMap> = {
+	[Effort.XHigh]: "max",
+};
 
 /**
  * Effort → wire-value map for the 5-tier adaptive scale (Opus 4.7+ and
@@ -221,7 +225,7 @@ export function deriveThinking<TApi extends Api>(spec: ModelSpec<TApi>, compat:
  * True when the model reasons natively but rejects the wire `reasoning.effort`
  * param. Scoped to openai-responses* because that's the only API surface where
  * `compat.supportsReasoningEffort: false` means "omit the field entirely"
- * (xAI Grok off the GROK_EFFORT_CAPABLE_PREFIXES allowlist: grok-build,
+ * (xAI Grok off the `isGrokReasoningEffortCapable` allowlist: grok-build,
  * grok-4.20-0309-reasoning). openai-completions keeps its thinking config even
  * without effort support — binary thinking formats (zai/qwen) drive reasoning
  * through other request fields.
@@ -266,11 +270,18 @@ function sameEffortList(left: readonly Effort[], right: readonly Effort[]): bool
 	return true;
 }
 
+function isOpenAICompatReasoningApi(api: Api): boolean {
+	return api === "openai-completions" || api === "openrouter";
+}
+
 function getModelDefinedEfforts<TApi extends Api>(spec: ModelSpec<TApi>): readonly Effort[] | undefined {
-	if (spec.api === "openai-completions" && isZaiGlm52ReasoningEffortModel(spec)) {
+	if (isOpenAICompatReasoningApi(spec.api) && isZaiGlm52ReasoningEffortModel(spec)) {
 		return DEFAULT_REASONING_EFFORTS_WITH_XHIGH;
 	}
-	return spec.api === "openai-completions" && (isMinimaxM2FamilyModelId(spec.id) || isOpenAIGptOssModelId(spec.id))
+	if (isOllamaCloudGlm52ReasoningEffortModel(spec)) {
+		return GLM_52_HIGH_MAX_REASONING_EFFORTS;
+	}
+	return isOpenAICompatReasoningApi(spec.api) && (isMinimaxM2FamilyModelId(spec.id) || isOpenAIGptOssModelId(spec.id))
 		? LOW_MEDIUM_HIGH_REASONING_EFFORTS
 		: undefined;
 }
@@ -280,6 +291,10 @@ function isZaiGlm52ReasoningEffortModel<TApi extends Api>(spec: ModelSpec<TApi>)
 	return modelMatchesHost(spec, "zai") || modelMatchesHost(spec, "zhipu");
 }
 
+function isOllamaCloudGlm52ReasoningEffortModel<TApi extends Api>(spec: ModelSpec<TApi>): boolean {
+	return spec.api === "ollama-chat" && spec.provider === "ollama-cloud" && isGlm52ReasoningEffortModelId(spec.id);
+}
+
 function readCompatEffortMap(compat: CompatOf<Api>): EffortMap | undefined {
 	if (compat === undefined || !("reasoningEffortMap" in compat)) {
 		return undefined;
@@ -298,7 +313,10 @@ function inferDetectedEffortMap<TApi extends Api>(
 			? ANTHROPIC_ADAPTIVE_EFFORT_MAP_5_TIER
 			: ANTHROPIC_ADAPTIVE_EFFORT_MAP_4_TIER;
 	}
-	if (spec.api !== "openai-completions") {
+	if (isOllamaCloudGlm52ReasoningEffortModel(spec)) {
+		return OLLAMA_CLOUD_GLM_52_REASONING_EFFORT_MAP;
+	}
+	if (!isOpenAICompatReasoningApi(spec.api)) {
 		return undefined;
 	}
 	if (spec.provider === "groq" && spec.id === "qwen/qwen3-32b") {
@@ -437,7 +455,7 @@ function inferFallbackEfforts<TApi extends Api>(spec: ModelSpec<TApi>, compat: C
 	if (spec.api === "bedrock-converse-stream") {
 		return DEFAULT_REASONING_EFFORTS;
 	}
-	if (spec.api === "openai-completions") {
+	if (isOpenAICompatReasoningApi(spec.api)) {
 		const resolved = compat as ResolvedOpenAICompat;
 		if (resolved.thinkingFormat === "openai" && resolved.supportsReasoningEffort) {
 			return DEFAULT_REASONING_EFFORTS_WITH_XHIGH;
@@ -503,7 +521,7 @@ function isOpenRouterAnthropicAdaptiveReasoningModel<TApi extends Api>(
 	parsedModel: AnthropicModel,
 	spec: ModelSpec<TApi>,
 ): boolean {
-	if (spec.api !== "openai-completions") return false;
+	if (!isOpenAICompatReasoningApi(spec.api)) return false;
 	if (!modelMatchesHost(spec, "openrouter")) return false;
 	return isFableOrMythos(parsedModel.kind) || (parsedModel.kind === "opus" && semverGte(parsedModel.version, "4.6"));
 }