@oh-my-pi/pi-catalog 17.3.5 → 17.3.8

package/src/discovery/cursor.ts

@@ -28,6 +28,15 @@ const CURSOR_MAX_MODE_1M_ID_PATTERN = /claude|gemini/;
 /** Kimi's official bare K3 id (`k3`, `kimi/k3`); `k3-256k` is the 256k SKU and stays out. */
 const CURSOR_KIMI_K3_BARE_ID_PATTERN = /(^|\/)k3$/i;
 
+/**
+ * Versioned Cursor Grok ids (`cursor-grok-4.5`, `cursor-grok-4.6-high`) are
+ * reasoning models whose effort is carried in the per-tier sibling id.
+ * `GetUsableModels` ships no `thinkingDetails` and the bundled references read
+ * `reasoning: false`, so classification falls back to the id. The non-reasoning
+ * `grok-code-*` coding models lack the version digit and stay out.
+ */
+const CURSOR_GROK_REASONING_ID_PATTERN = /^cursor-grok-\d/i;
+
 /**
  * Model-id families whose native catalogs (anthropic, openai/openai-codex,
  * google) are multimodal. Cursor-only or text-only families (`composer-*`,
@@ -297,7 +306,11 @@ function normalizeCursorModel(
 
 	const name = pickModelDisplayName(details, id);
 	const reference = references.get(id);
-	const reasoning = isKimiK3ModelId(id) || Boolean(details.thinkingDetails) || reference?.reasoning === true;
+	const reasoning =
+		isKimiK3ModelId(id) ||
+		CURSOR_GROK_REASONING_ID_PATTERN.test(id) ||
+		Boolean(details.thinkingDetails) ||
+		reference?.reasoning === true;
 
 	if (reference) {
 		return {

package/src/identity/family.ts

@@ -73,6 +73,25 @@ export const isQwenModelId = memo((modelId: string): boolean => {
 	return modelId.toLowerCase().includes("qwen");
 });
 
+/**
+ * Open-weight Qwen 3.8+ releases (`qwen3.8-27b`, `qwen3.8-2.4t-a95b`, GGUF
+ * names like `Qwen3.8-27B-UD-Q6_K_XL`) whose chat template steers thinking
+ * depth through a `reasoning_effort` template kwarg (`low`/`medium`/`xhigh`,
+ * template default `xhigh`; thinking itself cannot be disabled). Compared
+ * component-wise so `qwen3.10` sorts after `qwen3.8`. API-only `-max` SKUs are
+ * excluded — Dashscope drives them through OpenAI-style `reasoning_effort`
+ * with curated compat. The trailing guard rejects parameter-count lookalikes
+ * (`qwen-3.8b`) without breaking `qwen3.8-27b`.
+ */
+export const isQwen38PlusTemplateEffortModelId = memo((modelId: string): boolean => {
+	const match = /qwen[-_ ]?(\d+)\.(\d+)(?![\dbB])/i.exec(modelId);
+	if (!match) return false;
+	const major = Number.parseInt(match[1], 10);
+	const minor = Number.parseInt(match[2], 10);
+	if (major < 3 || (major === 3 && minor < 8)) return false;
+	return !/^-max(?:$|[-.:])/i.test(modelId.slice(match.index + match[0].length));
+});
+
 /** Gemma open-weights family (`gemma-3-27b-it`, `google/gemma-4-E2B-it`, `gemma2-9b`). */
 export const isGemmaModelId = memo((modelId: string): boolean => {
 	return /(^|\/)gemma[-.]?\d/i.test(modelId);
@@ -121,7 +140,8 @@ const GROK_EFFORT_CAPABLE_PREFIXES = [
 /**
  * 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.
+ * param, so callers must omit reasoning effort for them. `grok-4.6` accepts
+ * `low`/`medium`/`high`/`xhigh` and 400s on `max`.
  */
 export const isGrokReasoningEffortCapable = memo((modelId: string): boolean => {
 	const bare = bareModelId(modelId).trim().toLowerCase();

package/src/model-cache.ts

@@ -3,7 +3,8 @@
  * Replaces per-provider JSON files with a single cache.db.
  */
 import { Database } from "bun:sqlite";
-import { getModelDbPath } from "@oh-my-pi/pi-utils";
+import { renameSync } from "node:fs";
+import { getModelDbPath, isEnoent, isSqliteCorruptionError, logger } from "@oh-my-pi/pi-utils";
 import type { Api, Model, ModelSpec } from "./types";
 
 // Rows persist ModelSpec JSON (sparse `compat`, never the resolved record);
@@ -91,13 +92,14 @@ function openDb(resolvedPath: string): Database {
 	return db;
 }
 
-function getSharedDb(): Database {
-	const resolvedPath = getModelDbPath();
+function getSharedDb(resolvedPath: string): Database {
 	if (sharedDb && sharedDbPath === resolvedPath) {
 		return sharedDb;
 	}
 	if (sharedDb) {
 		sharedDb.close();
+		sharedDb = null;
+		sharedDbPath = null;
 	}
 	const db = openDb(resolvedPath);
 	sharedDb = db;
@@ -105,9 +107,9 @@ function getSharedDb(): Database {
 	return db;
 }
 
-function withModelCacheDb<T>(dbPath: string | undefined, useDb: (db: Database) => T): T {
-	if (!dbPath) return useDb(getSharedDb());
-	const db = openDb(dbPath);
+function runModelCacheDb<T>(resolvedPath: string, shared: boolean, useDb: (db: Database) => T): T {
+	if (shared) return useDb(getSharedDb(resolvedPath));
+	const db = openDb(resolvedPath);
 	try {
 		return useDb(db);
 	} finally {
@@ -115,6 +117,65 @@ function withModelCacheDb<T>(dbPath: string | undefined, useDb: (db: Database) =
 	}
 }
 
+// Paths already reported corrupt this process: the first unrecoverable failure
+// is logged at `error`, later heals at `debug`, so a dying disk cannot spam.
+const reportedCorruptPaths = new Set<string>();
+
+/**
+ * Move a physically corrupt `models.db` (plus its `-wal`/`-shm` sidecars) aside
+ * so {@link openDb} can recreate a fresh cache at the original path. Renames are
+ * best-effort: a vanished sidecar (already healed by a peer process) is fine,
+ * and any other rename failure is left for {@link openDb} to surface.
+ */
+function quarantineCorruptModelCache(resolvedPath: string): void {
+	const stamp = Date.now();
+	for (const suffix of ["", "-wal", "-shm"]) {
+		try {
+			renameSync(`${resolvedPath}${suffix}`, `${resolvedPath}.corrupt-${stamp}${suffix}`);
+		} catch (err) {
+			if (!isEnoent(err)) {
+				logger.debug("model cache: could not quarantine corrupt file", { path: `${resolvedPath}${suffix}` });
+			}
+		}
+	}
+}
+
+/**
+ * Recover from unrecoverable `models.db` corruption: drop the cached handle,
+ * quarantine the broken files, and let the next open recreate the cache. A
+ * corrupt cache would otherwise be re-queried on every read/write forever,
+ * permanently masking a successful live catalog (issue #8867). Only
+ * {@link isSqliteCorruptionError} codes reach here; BUSY/permission errors keep
+ * their existing best-effort paths.
+ */
+function healCorruptModelCache(resolvedPath: string, shared: boolean, err: unknown): void {
+	if (shared && sharedDb) {
+		sharedDb.close();
+		sharedDb = null;
+		sharedDbPath = null;
+	}
+	quarantineCorruptModelCache(resolvedPath);
+	const code = err && typeof err === "object" && "code" in err ? err.code : undefined;
+	if (reportedCorruptPaths.has(resolvedPath)) {
+		logger.debug("model cache: re-healed corrupt database", { path: resolvedPath, code });
+	} else {
+		reportedCorruptPaths.add(resolvedPath);
+		logger.error("model cache corrupt; quarantined and recreated a fresh cache", { path: resolvedPath, code });
+	}
+}
+
+function withModelCacheDb<T>(dbPath: string | undefined, useDb: (db: Database) => T): T {
+	const resolvedPath = dbPath ?? getModelDbPath();
+	const shared = dbPath === undefined;
+	try {
+		return runModelCacheDb(resolvedPath, shared, useDb);
+	} catch (err) {
+		if (!isSqliteCorruptionError(err)) throw err;
+		healCorruptModelCache(resolvedPath, shared, err);
+		return runModelCacheDb(resolvedPath, shared, useDb);
+	}
+}
+
 function migrateCacheSchema(db: Database): void {
 	const stmt = db.prepare("PRAGMA table_info(model_cache)");
 	try {

package/src/model-thinking.ts

@@ -71,6 +71,11 @@ const LOW_HIGH_MAX_REASONING_EFFORTS: readonly Effort[] = [Effort.Low, Effort.Hi
 const HIGH_MAX_REASONING_EFFORTS: readonly Effort[] = [Effort.High, Effort.Max];
 /** OpenRouter's DeepSeek route accepts only `high`. */
 const HIGH_ONLY_REASONING_EFFORTS: readonly Effort[] = [Effort.High];
+/**
+ * Qwen 3.8+ open-weight chat template: prompt-steered `reasoning_effort`
+ * kwarg with exactly three wire tiers (template default is `xhigh`).
+ */
+const QWEN38_TEMPLATE_REASONING_EFFORTS: readonly Effort[] = [Effort.Low, Effort.Medium, Effort.XHigh];
 /**
  * Five wire tiers with a `low` floor: GPT-5.6+, Anthropic adaptive models
  * with the real xhigh tier (Opus 4.7+, Sonnet 5+, Fable/Mythos 5), and the
@@ -179,7 +184,9 @@ function fillThinkingWireDefaults<TApi extends Api>(
 		thinking.supportsDisplay === undefined &&
 		(spec.api === "anthropic-messages" || spec.api === "bedrock-converse-stream") &&
 		supportsAdaptiveThinkingDisplay(spec.id);
-	const needsRequiresEffort = thinking.requiresEffort === undefined && impliesMandatoryReasoning(parsed, spec.id);
+	const needsRequiresEffort =
+		thinking.requiresEffort === undefined &&
+		(impliesMandatoryReasoning(parsed, spec.id) || isQwenTemplateReasoningEffortCompat(compat));
 	const needsDefaultLevel =
 		thinking.defaultLevel === undefined && (isKimiK3ModelId(spec.id) || isGlm53ReasoningEffortModelId(spec.id));
 	if (!effortsChanged && !shouldReplaceEffortMap && !needsDisplay && !needsRequiresEffort && !needsDefaultLevel) {
@@ -232,7 +239,7 @@ export function deriveThinking<TApi extends Api>(spec: ModelSpec<TApi>, compat:
 	) {
 		config.supportsDisplay = true;
 	}
-	if (impliesMandatoryReasoning(parsed, spec.id)) {
+	if (impliesMandatoryReasoning(parsed, spec.id) || isQwenTemplateReasoningEffortCompat(compat)) {
 		config.requiresEffort = true;
 	}
 	return config;
@@ -376,6 +383,13 @@ function getModelDefinedEfforts<TApi extends Api>(
 	if (spec.provider === "ollama") {
 		return OLLAMA_REASONING_EFFORTS;
 	}
+	// Qwen 3.8+ served through a local llama.cpp-style backend: the chat
+	// template's prompt-steered `reasoning_effort` kwarg accepts exactly
+	// low/medium/xhigh (and thinking cannot be turned off — the official 3.8
+	// template raises on `enable_thinking: false`, hence requiresEffort).
+	if (isOpenAICompatReasoningApi(spec.api) && isQwenTemplateReasoningEffortCompat(compat)) {
+		return QWEN38_TEMPLATE_REASONING_EFFORTS;
+	}
 	if (
 		(isOpenAICompatReasoningApi(spec.api) || (spec.api === "ollama-chat" && spec.provider === "ollama-cloud")) &&
 		isDeepseekReasoningModel(spec)
@@ -483,6 +497,12 @@ function isOpenRouterThinkingFormat(compat: CompatOf<Api>): boolean {
 function isZaiThinkingFormat(compat: CompatOf<Api>): boolean {
 	return compat !== undefined && "thinkingFormat" in compat && compat.thinkingFormat === "zai";
 }
+/** Resolved-compat gate for the Qwen 3.8+ local template `reasoning_effort` dialect. */
+function isQwenTemplateReasoningEffortCompat(compat: CompatOf<Api>): boolean {
+	return (
+		compat !== undefined && "qwenTemplateReasoningEffort" in compat && compat.qwenTemplateReasoningEffort === true
+	);
+}
 
 function inferDetectedEffortMap<TApi extends Api>(
 	spec: ModelSpec<TApi>,
@@ -796,11 +816,23 @@ export function requireSupportedEffort<TApi extends Api>(model: ApiModel<TApi>,
 	return effort;
 }
 
-/** Maps a normalized thinking effort to Google's `thinkingLevel` enum values. */
-export function mapEffortToGoogleThinkingLevel(effort: Effort): "MINIMAL" | "LOW" | "MEDIUM" | "HIGH" {
+/** Maps a normalized thinking effort to Google's `thinkingLevel` enum values.
+ * When a collapsed family routes `minimal` onto the same wire id as `low`
+ * (Antigravity Gemini 3.6/3.7 Flash), emit `LOW` — Cloud Code Assist rejects
+ * `MINIMAL` on those `-low` SKUs.
+ */
+export function mapEffortToGoogleThinkingLevel<TApi extends Api>(
+	effort: Effort,
+	model?: ApiModel<TApi>,
+): "MINIMAL" | "LOW" | "MEDIUM" | "HIGH" {
+	if (effort === Effort.Minimal) {
+		const routing = model?.thinking?.effortRouting;
+		if (routing?.[Effort.Minimal] && routing[Effort.Minimal] === routing[Effort.Low]) {
+			return "LOW";
+		}
+		return "MINIMAL";
+	}
 	switch (effort) {
-		case Effort.Minimal:
-			return "MINIMAL";
 		case Effort.Low:
 			return "LOW";
 		case Effort.Medium: