jeopi-catalog 16.5.1 → 16.5.6

package/CHANGELOG.md

@@ -2,6 +2,23 @@
 
 ## [Unreleased]
 
+## [16.5.6] - 2026-10-01
+
+### Fixed
+
+- Exclude all model request headers from the SQLite model cache and invalidate pre-fix cache rows with SQLite secure deletion enabled. Restore headers only from matching current static models or trusted provider/configuration sources; models with unreconstructible dynamic headers require fresh discovery and are not returned as authenticated offline fallbacks. Adapted from oh-my-pi's header omission, restoration, and Copilot variant fixes.
+
+## [16.5.5] - 2026-09-30
+
+### Fixed
+
+- Refresh OpenAI account model lists with current OpenAI metadata from models.dev, including GPT-6 and GPT-6.1, dated snapshots, and fine-tunes; exclude audio, image, and specialized models unsupported by the coding agent.
+- Replace stale OpenAI and Codex model lists after successful discovery and isolate cached lists by endpoint and credentials.
+
+### Added
+
+- Support scoped catalog regeneration with repeatable `gen:models --provider <provider-id>` options.
+
 ## [16.4.3] - 2026-07-22
 
 ### Fixed

package/dist/types/discovery/codex.d.ts

@@ -1,3 +1,4 @@
+import type { FetchImpl } from "jeopi-utils";
 import type { ModelSpec } from "../types";
 /**
  * Fetch options for OpenAI Codex model discovery.
@@ -18,9 +19,9 @@ export interface CodexModelDiscoveryOptions {
     /** Abort signal for network request cancellation. */
     signal?: AbortSignal;
     /** Optional fetch implementation override for tests. */
-    fetchFn?: typeof fetch;
+    fetchFn?: FetchImpl;
     /** Optional registry fetch implementation override for client version lookup. */
-    registryFetchFn?: typeof fetch;
+    registryFetchFn?: FetchImpl;
 }
 /**
  * Normalized Codex discovery response.

package/dist/types/model-cache.d.ts

@@ -4,6 +4,10 @@ interface CacheEntry<TApi extends Api = Api> {
     fresh: boolean;
     authoritative: boolean;
     updatedAt: number;
+    /** Model ids whose request headers were omitted from disk. */
+    headerOmittedModelIds: readonly string[];
+    /** Model ids whose headers did not match a trusted local source. */
+    unrestorableHeaderModelIds: readonly string[];
     /**
      * Hash of the static catalog slice that was merged into `models` when this
      * row was written. `resolveProviderModels` compares against the current
@@ -13,5 +17,5 @@ interface CacheEntry<TApi extends Api = Api> {
     staticFingerprint: string;
 }
 export declare function readModelCache<TApi extends Api>(providerId: string, ttlMs: number, now: () => number, dbPath?: string): CacheEntry<TApi> | null;
-export declare function writeModelCache<TApi extends Api>(providerId: string, updatedAt: number, models: Model<TApi>[], authoritative: boolean, staticFingerprint: string, dbPath?: string): void;
+export declare function writeModelCache<TApi extends Api>(providerId: string, updatedAt: number, models: Model<TApi>[], authoritative: boolean, staticFingerprint: string, dbPath?: string, staticHeaderSources?: readonly Model<TApi>[], restorableHeaderFallback?: Record<string, string>, restoreCachedHeaders?: (model: Model<Api>) => Record<string, string> | undefined): void;
 export {};

package/dist/types/model-manager.d.ts

@@ -30,6 +30,17 @@ export interface ModelManagerOptions<TApi extends Api = Api, TModelsDevPayload =
     dynamicModelsAuthoritative?: boolean;
     /** Cached model ids to ignore when the cache was written against a different static catalog fingerprint. */
     dropCachedModelIdsOnStaticMismatch?: readonly string[];
+    /** Trusted provider-wide headers restored locally, never persisted. */
+    restorableHeaderFallback?: Record<string, string>;
+    /**
+     * Reconstruct the complete header set from authoritative local configuration.
+     * Takes `Model<Api>` (not `Model<TApi>`): the parameter position is
+     * contravariant, so binding it to `TApi` would make `ModelManagerOptions<TApi>`
+     * invariant in `TApi` and break narrow-to-`ModelManagerOptions<Api>` assignment
+     * at every per-provider descriptor factory. Implementations needing identity
+     * use `model.id` / `model.requestModelId`, both present regardless of `api`.
+     */
+    restoreCachedHeaders?: (model: Model<Api>) => Record<string, string> | undefined;
     /** Optional dynamic endpoint fetcher. */
     fetchDynamicModels?: () => Promise<readonly ModelSpec<TApi>[] | null>;
     /** Optional models.dev fallback hook. */
@@ -59,6 +70,11 @@ export interface ModelManager<TApi extends Api = Api> {
  * Creates a reusable provider model manager.
  */
 export declare function createModelManager<TApi extends Api = Api, TModelsDevPayload = unknown>(options: ModelManagerOptions<TApi, TModelsDevPayload>): ModelManager<TApi>;
+/** Restore omitted headers only from trusted local sources; unresolved models must not be used. */
+export declare function restoreCachedModelHeaders<TApi extends Api>(cachedModels: readonly ModelSpec<TApi>[], staticModels: readonly Model<TApi>[], headerOmittedModelIds: readonly string[], unrestorableHeaderModelIds: readonly string[], restorableHeaderFallback?: Record<string, string>, restoreCachedHeaders?: (model: Model<Api>) => Record<string, string> | undefined): {
+    models: Model<TApi>[];
+    unresolvedModelIds: ReadonlySet<string>;
+};
 /**
  * Resolves provider models with source precedence:
  * static -> models.dev -> cache -> dynamic.

package/dist/types/provider-models/special.d.ts

@@ -5,6 +5,8 @@ export interface OpenAICodexModelManagerConfig {
     accessToken?: string;
     accountId?: string;
     clientVersion?: string;
+    baseUrl?: string;
+    fetch?: FetchImpl;
 }
 export declare function openaiCodexModelManagerOptions(config?: OpenAICodexModelManagerConfig): ModelManagerOptions<"openai-codex-responses">;
 export interface CursorModelManagerConfig {

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "jeopi-catalog",
-	"version": "16.5.1",
+	"version": "16.5.6",
 	"description": "Model catalog for jeopi: bundled model database, provider discovery descriptors, model identity, classification, and equivalence",
 	"homepage": "https://github.com/akillness/jeopi",
 	"author": "Can Boluk",
@@ -34,12 +34,12 @@
 	},
 	"dependencies": {
 		"@bufbuild/protobuf": "^2.12.0",
-		"jeopi-utils": "16.5.1",
+		"jeopi-utils": "16.5.6",
 		"arktype": "2.2.3",
 		"zod": "^4"
 	},
 	"devDependencies": {
-		"jeopi-ai": "16.5.1",
+		"jeopi-ai": "16.5.6",
 		"@types/bun": "^1.3.14"
 	},
 	"engines": {

package/src/discovery/codex.ts

@@ -62,9 +62,9 @@ export interface CodexModelDiscoveryOptions {
 	/** Abort signal for network request cancellation. */
 	signal?: AbortSignal;
 	/** Optional fetch implementation override for tests. */
-	fetchFn?: typeof fetch;
+	fetchFn?: FetchImpl;
 	/** Optional registry fetch implementation override for client version lookup. */
-	registryFetchFn?: typeof fetch;
+	registryFetchFn?: FetchImpl;
 }
 
 /**

package/src/model-cache.ts

@@ -6,16 +6,10 @@ import { Database } from "bun:sqlite";
 import { getModelDbPath } from "jeopi-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. v8 invalidates Codex
-// discovery rows predating provider-native V2 compaction metadata; v7
-// invalidated 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 invalidated 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 = 8;
+// Rows persist sparse ModelSpec metadata, never request headers: arbitrary
+// provider-defined header names may carry credentials. v9 records restoration
+// provenance and invalidates older rows, including v8 credential-bearing rows.
+const CACHE_SCHEMA_VERSION = 9;
 
 interface CacheRow {
 	provider_id: string;
@@ -24,6 +18,8 @@ interface CacheRow {
 	authoritative: number;
 	static_fingerprint: string;
 	models: string;
+	header_omitted_model_ids: string;
+	unrestorable_header_model_ids: string;
 }
 
 interface TableInfoRow {
@@ -35,6 +31,10 @@ interface CacheEntry<TApi extends Api = Api> {
 	fresh: boolean;
 	authoritative: boolean;
 	updatedAt: number;
+	/** Model ids whose request headers were omitted from disk. */
+	headerOmittedModelIds: readonly string[];
+	/** Model ids whose headers did not match a trusted local source. */
+	unrestorableHeaderModelIds: readonly string[];
 	/**
 	 * Hash of the static catalog slice that was merged into `models` when this
 	 * row was written. `resolveProviderModels` compares against the current
@@ -52,6 +52,8 @@ function openDb(resolvedPath: string): Database {
 	// Install the busy handler BEFORE any lock-taking statement. See
 	// https://github.com/can1357/oh-my-pi/issues/2421.
 	db.run("PRAGMA busy_timeout = 3000");
+	// Scrub deleted legacy credential-bearing cells rather than retaining them in free pages.
+	db.run("PRAGMA secure_delete = ON");
 	db.run("PRAGMA journal_mode = WAL");
 	db.run(`
 		CREATE TABLE IF NOT EXISTS model_cache (
@@ -60,6 +62,8 @@ function openDb(resolvedPath: string): Database {
 			updated_at INTEGER NOT NULL,
 			authoritative INTEGER NOT NULL DEFAULT 0,
 			static_fingerprint TEXT NOT NULL DEFAULT '',
+			header_omitted_model_ids TEXT NOT NULL DEFAULT '[]',
+			unrestorable_header_model_ids TEXT NOT NULL DEFAULT '[]',
 			models TEXT NOT NULL
 		)
 	`);
@@ -98,6 +102,12 @@ function migrateCacheSchema(db: Database): void {
 		if (!columns.some(column => column.name === "static_fingerprint")) {
 			db.run("ALTER TABLE model_cache ADD COLUMN static_fingerprint TEXT NOT NULL DEFAULT ''");
 		}
+		if (!columns.some(column => column.name === "header_omitted_model_ids")) {
+			db.run("ALTER TABLE model_cache ADD COLUMN header_omitted_model_ids TEXT NOT NULL DEFAULT '[]'");
+		}
+		if (!columns.some(column => column.name === "unrestorable_header_model_ids")) {
+			db.run("ALTER TABLE model_cache ADD COLUMN unrestorable_header_model_ids TEXT NOT NULL DEFAULT '[]'");
+		}
 	} finally {
 		stmt.finalize();
 	}
@@ -124,6 +134,15 @@ export function readModelCache<TApi extends Api>(
 					return null;
 				}
 				const models = JSON.parse(row.models) as ModelSpec<TApi>[];
+				const headerOmittedModelIds: unknown = JSON.parse(row.header_omitted_model_ids);
+				const unrestorableHeaderModelIds: unknown = JSON.parse(row.unrestorable_header_model_ids);
+				if (
+					!Array.isArray(headerOmittedModelIds) ||
+					!headerOmittedModelIds.every(id => typeof id === "string") ||
+					!Array.isArray(unrestorableHeaderModelIds) ||
+					!unrestorableHeaderModelIds.every(id => typeof id === "string")
+				)
+					return null;
 				const ageMs = now() - row.updated_at;
 				const fresh = Number.isFinite(ageMs) && ageMs >= 0 && ageMs <= ttlMs;
 				return {
@@ -131,6 +150,8 @@ export function readModelCache<TApi extends Api>(
 					fresh,
 					authoritative: row.authoritative === 1,
 					updatedAt: row.updated_at,
+					headerOmittedModelIds,
+					unrestorableHeaderModelIds,
 					staticFingerprint: row.static_fingerprint ?? "",
 				};
 			} finally {
@@ -142,6 +163,14 @@ export function readModelCache<TApi extends Api>(
 	}
 }
 
+function headersEqual(left: Record<string, string>, right: Record<string, string> | undefined): boolean {
+	if (!right) return false;
+	return (
+		Object.keys(left).length === Object.keys(right).length &&
+		Object.keys(left).every(key => Object.hasOwn(right, key) && left[key] === right[key])
+	);
+}
+
 export function writeModelCache<TApi extends Api>(
 	providerId: string,
 	updatedAt: number,
@@ -149,19 +178,44 @@ export function writeModelCache<TApi extends Api>(
 	authoritative: boolean,
 	staticFingerprint: string,
 	dbPath?: string,
+	staticHeaderSources: readonly Model<TApi>[] = [],
+	restorableHeaderFallback?: Record<string, string>,
+	restoreCachedHeaders?: (model: Model<Api>) => Record<string, string> | undefined,
 ): void {
 	try {
 		withModelCacheDb(dbPath, db => {
+			const headerOmittedModelIds: string[] = [];
+			const unrestorableHeaderModelIds: string[] = [];
+			const staticById = new Map(staticHeaderSources.map(model => [model.id, model]));
+			const cachedModels = models.map(model => {
+				const { headers, compatConfig, ...metadata } = model;
+				if (headers && Object.keys(headers).length > 0) {
+					headerOmittedModelIds.push(model.id);
+					const source =
+						staticById.get(model.id) ?? (model.requestModelId ? staticById.get(model.requestModelId) : undefined);
+					if (
+						!headersEqual(headers, source?.headers ?? restorableHeaderFallback) &&
+						!headersEqual(headers, restoreCachedHeaders?.({ ...model, headers: undefined }))
+					) {
+						unrestorableHeaderModelIds.push(model.id);
+					}
+				}
+				return { ...metadata, compat: compatConfig };
+			});
 			db.run(
-				`INSERT OR REPLACE INTO model_cache (provider_id, version, updated_at, authoritative, static_fingerprint, models)
-				 VALUES (?, ?, ?, ?, ?, ?)`,
+				`INSERT OR REPLACE INTO model_cache (
+					provider_id, version, updated_at, authoritative, static_fingerprint,
+					header_omitted_model_ids, unrestorable_header_model_ids, models
+				) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
 				[
 					providerId,
 					CACHE_SCHEMA_VERSION,
 					updatedAt,
 					authoritative ? 1 : 0,
 					staticFingerprint,
-					JSON.stringify(models.map(model => ({ ...model, compat: model.compatConfig, compatConfig: undefined }))),
+					JSON.stringify(headerOmittedModelIds),
+					JSON.stringify(unrestorableHeaderModelIds),
+					JSON.stringify(cachedModels),
 				],
 			);
 		});

package/src/model-manager.ts

@@ -41,6 +41,17 @@ export interface ModelManagerOptions<TApi extends Api = Api, TModelsDevPayload =
 	dynamicModelsAuthoritative?: boolean;
 	/** Cached model ids to ignore when the cache was written against a different static catalog fingerprint. */
 	dropCachedModelIdsOnStaticMismatch?: readonly string[];
+	/** Trusted provider-wide headers restored locally, never persisted. */
+	restorableHeaderFallback?: Record<string, string>;
+	/**
+	 * Reconstruct the complete header set from authoritative local configuration.
+	 * Takes `Model<Api>` (not `Model<TApi>`): the parameter position is
+	 * contravariant, so binding it to `TApi` would make `ModelManagerOptions<TApi>`
+	 * invariant in `TApi` and break narrow-to-`ModelManagerOptions<Api>` assignment
+	 * at every per-provider descriptor factory. Implementations needing identity
+	 * use `model.id` / `model.requestModelId`, both present regardless of `api`.
+	 */
+	restoreCachedHeaders?: (model: Model<Api>) => Record<string, string> | undefined;
 	/** Optional dynamic endpoint fetcher. */
 	fetchDynamicModels?: () => Promise<readonly ModelSpec<TApi>[] | null>;
 	/** Optional models.dev fallback hook. */
@@ -101,6 +112,37 @@ function passModelList<TApi extends Api>(value: unknown): Model<TApi>[] {
 	return out;
 }
 
+/** Restore omitted headers only from trusted local sources; unresolved models must not be used. */
+export function restoreCachedModelHeaders<TApi extends Api>(
+	cachedModels: readonly ModelSpec<TApi>[],
+	staticModels: readonly Model<TApi>[],
+	headerOmittedModelIds: readonly string[],
+	unrestorableHeaderModelIds: readonly string[],
+	restorableHeaderFallback?: Record<string, string>,
+	restoreCachedHeaders?: (model: Model<Api>) => Record<string, string> | undefined,
+): { models: Model<TApi>[]; unresolvedModelIds: ReadonlySet<string> } {
+	const models = passModelList<TApi>(cachedModels);
+	const unresolvedModelIds = new Set<string>();
+	if (headerOmittedModelIds.length === 0) return { models, unresolvedModelIds };
+	const omittedIds = new Set(headerOmittedModelIds);
+	const unrestorableIds = new Set(unrestorableHeaderModelIds);
+	const staticById = new Map(staticModels.map(model => [model.id, model]));
+	const restored = models.map(model => {
+		if (!omittedIds.has(model.id)) return model;
+		const source =
+			staticById.get(model.id) ?? (model.requestModelId ? staticById.get(model.requestModelId) : undefined);
+		const headers = unrestorableIds.has(model.id)
+			? undefined
+			: (source?.headers ?? restorableHeaderFallback ?? restoreCachedHeaders?.(model));
+		if (!headers) {
+			unresolvedModelIds.add(model.id);
+			return model;
+		}
+		return { ...model, headers };
+	});
+	return { models: restored, unresolvedModelIds };
+}
+
 /**
  * Resolves provider models with source precedence:
  * static -> models.dev -> cache -> dynamic.
@@ -119,10 +161,21 @@ export async function resolveProviderModels<TApi extends Api = Api, TModelsDevPa
 		? passModelList<TApi>(options.staticModels)
 		: (getBundledModels(options.providerId as GeneratedProvider) as Model<TApi>[]);
 	const cache = readModelCache<TApi>(cacheProviderId, ttlMs, now, dbPath);
+	const restoredCache = restoreCachedModelHeaders(
+		cache?.models ?? [],
+		staticModels,
+		cache?.headerOmittedModelIds ?? [],
+		cache?.unrestorableHeaderModelIds ?? [],
+		options.restorableHeaderFallback,
+		options.restoreCachedHeaders,
+	);
+	const usableCachedModels = restoredCache.models.filter(model => !restoredCache.unresolvedModelIds.has(model.id));
+	const cacheHasUnresolvedHeaders = restoredCache.unresolvedModelIds.size > 0;
 	const dynamicModelsAuthoritative = options.dynamicModelsAuthoritative ?? false;
 	const staticFingerprint = fingerprintStatic(staticModels, dynamicModelsAuthoritative);
 	const cacheFingerprintMatches = cache?.staticFingerprint === staticFingerprint && staticFingerprint.length > 0;
-	const hasUsableFreshCache = (cache?.fresh ?? false) && (!dynamicModelsAuthoritative || cacheFingerprintMatches);
+	const hasUsableFreshCache =
+		(cache?.fresh ?? false) && !cacheHasUnresolvedHeaders && (!dynamicModelsAuthoritative || cacheFingerprintMatches);
 	const dynamicFetcher = options.fetchDynamicModels;
 	const hasDynamicFetcher = typeof dynamicFetcher === "function";
 	const hasAuthoritativeCache = ((cache?.authoritative ?? false) && hasUsableFreshCache) || !hasDynamicFetcher;
@@ -139,8 +192,14 @@ export async function resolveProviderModels<TApi extends Api = Api, TModelsDevPa
 	// was merged in last time, the cache row IS the authoritative merge result.
 	// Re-running `mergeDynamicModels(static, cache)` would just rebuild the same
 	// objects (~800ms in the steady-state cold-start profile for `omp -p hi`).
-	if (!shouldFetchFromNetwork && cache?.fresh && hasAuthoritativeCache && cacheFingerprintMatches) {
-		return { models: collapseBuiltModelVariants(passModelList<TApi>(cache.models)), stale: false };
+	if (
+		!shouldFetchFromNetwork &&
+		cache?.fresh &&
+		hasAuthoritativeCache &&
+		cacheFingerprintMatches &&
+		!cacheHasUnresolvedHeaders
+	) {
+		return { models: collapseBuiltModelVariants(restoredCache.models), stale: false };
 	}
 
 	const [fetchedModelsDevModels, fetchedDynamicModels] = shouldFetchFromNetwork
@@ -153,7 +212,7 @@ export async function resolveProviderModels<TApi extends Api = Api, TModelsDevPa
 	const cacheModels = dynamicFetchSucceeded
 		? []
 		: prepareCacheModelsForStaticMismatch(
-				normalizeModelList<TApi>(cache?.models ?? []),
+				usableCachedModels,
 				staticModels,
 				cacheFingerprintMatches,
 				options.dropCachedModelIdsOnStaticMismatch,
@@ -162,7 +221,10 @@ export async function resolveProviderModels<TApi extends Api = Api, TModelsDevPa
 	const mergedWithCache = mergeDynamicModels(mergeModelSources(staticModels, modelsDevModels), cacheModels);
 	const mergedModels = mergeDynamicModels(mergedWithCache, dynamicModels);
 	const models = collapseBuiltModelVariants(
-		dynamicModelsAuthoritative && dynamicFetchSucceeded ? retainModelIds(mergedModels, dynamicModels) : mergedModels,
+		(dynamicModelsAuthoritative && dynamicFetchSucceeded
+			? retainModelIds(mergedModels, dynamicModels)
+			: mergedModels
+		).filter(model => dynamicFetchSucceeded || !restoredCache.unresolvedModelIds.has(model.id)),
 	);
 	const dynamicAuthoritative = !hasDynamicFetcher || dynamicFetchSucceeded || shouldUseFreshCacheAsAuthoritative;
 	if (shouldFetchFromNetwork) {
@@ -178,11 +240,25 @@ export async function resolveProviderModels<TApi extends Api = Api, TModelsDevPa
 				true,
 				staticFingerprint,
 				dbPath,
+				staticModels,
+				options.restorableHeaderFallback,
+				options.restoreCachedHeaders,
 			);
 		} else {
 			// Dynamic fetch failed — update cache with a non-authoritative snapshot so
 			// stale state remains visible while retry backoff still applies.
 			const latestCache = readModelCache<TApi>(cacheProviderId, ttlMs, now, dbPath);
+			const latestRestoredCache = restoreCachedModelHeaders(
+				latestCache?.models ?? cache?.models ?? [],
+				staticModels,
+				latestCache?.headerOmittedModelIds ?? cache?.headerOmittedModelIds ?? [],
+				latestCache?.unrestorableHeaderModelIds ?? cache?.unrestorableHeaderModelIds ?? [],
+				options.restorableHeaderFallback,
+				options.restoreCachedHeaders,
+			);
+			// Dropping unresolved rows would also erase the evidence that a same-id
+			// static model lacks required headers. Keep that provenance until discovery succeeds.
+			if (latestRestoredCache.unresolvedModelIds.size > 0) return { models, stale: true };
 			writeModelCache(
 				cacheProviderId,
 				now(),
@@ -190,16 +266,19 @@ export async function resolveProviderModels<TApi extends Api = Api, TModelsDevPa
 					mergeDynamicModels(
 						mergeModelSources(staticModels, modelsDevModels),
 						prepareCacheModelsForStaticMismatch(
-							normalizeModelList<TApi>(latestCache?.models ?? cache?.models ?? []),
+							latestRestoredCache.models.filter(model => !latestRestoredCache.unresolvedModelIds.has(model.id)),
 							staticModels,
 							cacheFingerprintMatches,
 							options.dropCachedModelIdsOnStaticMismatch,
 						),
-					),
+					).filter(model => !latestRestoredCache.unresolvedModelIds.has(model.id)),
 				),
 				false,
 				staticFingerprint,
 				dbPath,
+				staticModels,
+				options.restorableHeaderFallback,
+				options.restoreCachedHeaders,
 			);
 		}
 	}

package/src/model-thinking.ts

@@ -513,6 +513,9 @@ function impliesMandatoryReasoning(parsed: ParsedModel, modelId: string): boolea
 	}
 	if (isMinimaxM2FamilyModelId(modelId)) return true;
 	if (OPENAI_O_SERIES_RE.test(bareModelId(modelId))) return true;
+	// These GPT-6 models reject "none"; Sol/Luna 6.0 still accept it.
+	const canonicalOpenAIId = bareModelId(modelId).replace(/^ft:/, "").split(":")[0];
+	if (/^gpt-(?:6-astra|6\.1-sol)(?:$|-)/i.test(canonicalOpenAIId)) return true;
 	return findThinkingVariantToken(modelId) !== undefined;
 }