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

package/src/discovery/antigravity.ts

@@ -1,4 +1,4 @@
-import { z } from "zod/v4";
+import { type } from "arktype";
 import type { ModelSpec } from "../types";
 import { toPositiveNumber } from "../utils";
 import {
@@ -56,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.
  */
@@ -257,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;
 		}

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/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`,