@oh-my-pi/pi-catalog 17.1.3 → 17.1.5

package/CHANGELOG.md

@@ -2,6 +2,26 @@
 
 ## [Unreleased]
 
+## [17.1.5] - 2026-07-27
+
+### Fixed
+
+- Fixed Kimi Code (`kimi-code`) reporting `maxTokens: 32000` for every model — its `/coding/v1/models` discovery mapper and the bundled catalog applied a blanket constant, truncating `k3`/`k3-256k` output at ~4x below their real 131072 ceiling and `kimi-for-coding`/`kimi-for-coding-highspeed` below their 32768 ceiling. Output caps are now derived per family, and the model cache is invalidated so upgrades drop the stale `maxTokens: 32000` rows (including the discovery-only `k3-256k`) instead of serving them until the next network refresh ([#6711](https://github.com/can1357/oh-my-pi/issues/6711)).
+- Fixed Anthropic model discovery 404ing when the registry derived the provider base URL from a bundled model without the `/v1` suffix (`https://api.anthropic.com/models` instead of `/v1/models`), which let a stale text-only cache row shadow fresh models.dev vision metadata — surfacing as snapcompact refusing to run on `claude-opus-5`. Discovery now always targets `/v1/models` while model rows keep the provider base URL ([#6563](https://github.com/can1357/oh-my-pi/issues/6563)).
+
+## [17.1.4] - 2026-07-26
+
+### Added
+
+- Added Claude Opus 5 model entries for Amazon Bedrock: `anthropic.claude-opus-5` plus its `us.`, `eu.`, `au.`, and `global.` regional/geo IDs.
+
+### Fixed
+
+- Fixed `alibaba-token-plan` locking out China (Beijing) 百炼 Token Plan subscribers: the provider hardcoded the international Singapore endpoint, so Beijing-issued `sk-sp-` keys got `401 invalid_api_key`. The wire credential now carries an optional region base URL, and model discovery targets the credential's region ([#6682](https://github.com/can1357/oh-my-pi/issues/6682)).
+- Fixed forced `tool_choice` 400s (`tool_choice 'specified' is incompatible with thinking enabled`) on Kimi Code's Anthropic-compatible endpoint for the `kimi-for-coding`, `kimi-for-coding-highspeed`, and `k3` aliases: the Anthropic-surface compat matcher only recognised Moonshot's native `kimi-k2.7-code*` ids, so thinking-locked kimi-code models kept `supportsForcedToolChoice: true` and the forced selector was sent to a host that always thinks. These models now resolve `requiresThinkingEnabled`, keeping thinking on and downgrading forced choices to `auto`.
+- Retried empty successful provider discovery responses after the short non-authoritative interval instead of caching them for the full catalog TTL ([#6620](https://github.com/can1357/oh-my-pi/issues/6620)).
+- Fixed GitHub Copilot Claude models with no bundled catalog reference (e.g. a freshly served `claude-opus-5`) discovering with `reasoning: false`/`thinking: null` and no effort dial, and disappearing along with their synthesized `-1m` sibling on offline reads: reference-less Copilot models on the anthropic-messages proxy now derive the adaptive reasoning ladder from the model id, and the cache restores their compile-time `COPILOT_API_HEADERS` by value instead of dropping them as unrestorable ([#6664](https://github.com/can1357/oh-my-pi/issues/6664)).
+
 ## [17.1.3] - 2026-07-24
 
 ### Fixed

package/dist/types/compat/anthropic.d.ts

@@ -7,5 +7,12 @@ import type { ModelSpec, ResolvedAnthropicCompat } from "../types.js";
  * prefix check would accept lookalikes like `https://api.anthropic.com.evil.com`.
  */
 export declare function isOfficialAnthropicApiUrl(baseUrl?: string): boolean;
+/**
+ * Known non-official URLs that enforce Anthropic thinking signatures on replay.
+ *
+ * Runtime routing calls this with the effective URL because a model's resolved
+ * compat can be stale after Foundry or a provider base-URL override reroutes it.
+ */
+export declare function isAnthropicSigningProxyUrl(baseUrl?: string): boolean;
 /** Build the resolved anthropic-messages compat record for a model spec. */
 export declare function buildAnthropicCompat(spec: ModelSpec<"anthropic-messages">): ResolvedAnthropicCompat;

package/dist/types/identity/family.d.ts

@@ -119,6 +119,15 @@ export declare const isGlmVisionModelId: (modelId: string) => boolean;
  * collapsed onto the single vendor token; use {@link parseKnownModel} for finer breakdowns.
  */
 export declare const modelFamilyToken: (modelId: string) => string;
+/**
+ * True for Claude generations that support extended thinking: Sonnet/Opus 3.7+,
+ * every 4.x/5+ Opus/Sonnet, and the Fable/Mythos generation. Pre-thinking
+ * models (Claude 3.5 and older) are excluded so no thinking effort dial is
+ * fabricated for a model that rejects thinking parameters. Classifier-based, so
+ * dotted and dashed version forms both match; ids the classifier does not parse
+ * (e.g. Haiku, bare dated ids) return false.
+ */
+export declare const anthropicModelSupportsThinking: (modelId: string) => boolean;
 /**
  * Adaptive thinking `display` is supported starting with Claude Opus 4.7+,
  * Sonnet 5+, and the Claude Fable/Mythos 5 generation. Older adaptive-thinking

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

@@ -19,5 +19,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, staticHeaderSources?: readonly Model<TApi>[]): 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>): void;
 export {};

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

@@ -30,6 +30,14 @@ 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 request headers (compile-time constants, never
+     * credentials) that the cache may restore by value for any model whose live
+     * headers matched them at write time. Lets header-bearing dynamic models
+     * without a bundled static entry survive offline reads instead of being
+     * dropped as unrestorable (e.g. GitHub Copilot's User-Agent + API version).
+     */
+    restorableHeaderFallback?: Record<string, string>;
     /** Optional dynamic endpoint fetcher. */
     fetchDynamicModels?: () => Promise<readonly ModelSpec<TApi>[] | null>;
     /** Optional models.dev fallback hook. */
@@ -41,7 +49,8 @@ export interface ModelManagerOptions<TApi extends Api = Api, TModelsDevPayload =
  * Resolution result.
  *
  * `stale` is false when the resolved catalog is authoritative for the selected provider:
- * - dynamic endpoint data was fetched in this call,
+ * - a dynamic endpoint fetch succeeded in this call (an empty catalog is still
+ *   authoritative for the cycle, so downstream pruning of removed models runs),
  * - a still-fresh authoritative cache was reused in `online-if-uncached` mode, or
  * - the provider has no dynamic fetcher configured.
  */

package/dist/types/provider-models/bundled-references.d.ts

@@ -8,4 +8,6 @@ import type { Api, Model, ModelSpec } from "../types.js";
  */
 export declare function toModelSpec<TApi extends Api>(model: Model<TApi>): ModelSpec<TApi>;
 export declare function createBundledReferenceMap<TApi extends Api>(provider: Parameters<typeof getBundledModels>[0]): Map<string, ModelSpec<TApi>>;
-export declare function createReferenceResolver<TApi extends Api>(providerRefs: Map<string, ModelSpec<TApi>>): (modelId: string) => ModelSpec<TApi> | undefined;
+type ProviderReferenceSource<TApi extends Api> = Map<string, ModelSpec<TApi>> | (() => Map<string, ModelSpec<TApi>>);
+export declare function createReferenceResolver<TApi extends Api>(providerReferenceSource: ProviderReferenceSource<TApi>): (modelId: string) => ModelSpec<TApi> | undefined;
+export {};

package/dist/types/provider-models/cache-provider-id.d.ts

@@ -0,0 +1,7 @@
+export interface ModelCacheProviderIdOptions {
+    apiKey?: string;
+    baseUrl?: string;
+}
+export declare function getDefaultModelDiscoveryBaseUrl(providerId: string): string | undefined;
+/** Resolve the cache namespace used by a provider's model-manager options without constructing those options. */
+export declare function resolveModelCacheProviderId(providerId: string, options?: ModelCacheProviderIdOptions): string;

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

@@ -1,3 +1,4 @@
+export * from "./cache-provider-id.js";
 export * from "./descriptor-types.js";
 export * from "./descriptors.js";
 export * from "./google.js";

package/dist/types/provider-models/openai-compat.d.ts

@@ -1,6 +1,7 @@
 import type { ModelManagerOptions } from "../model-manager.js";
 import { getBundledModels } from "../models.js";
 import type { Api, FetchImpl, ModelSpec, Provider } from "../types.js";
+import { ALIBABA_TOKEN_PLAN_BASE_URL } from "../wire/alibaba-token-plan.js";
 export interface ModelsDevModel {
     id?: string;
     name?: string;
@@ -299,7 +300,7 @@ export interface AlibabaCodingPlanModelManagerConfig {
     fetch?: FetchImpl;
 }
 export declare function alibabaCodingPlanModelManagerOptions(config?: AlibabaCodingPlanModelManagerConfig): ModelManagerOptions<"openai-completions">;
-export declare const ALIBABA_TOKEN_PLAN_BASE_URL = "https://token-plan.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1";
+export { ALIBABA_TOKEN_PLAN_BASE_URL };
 export declare const ALIBABA_TOKEN_PLAN_STATIC_MODELS: readonly ModelSpec<"openai-completions">[];
 export interface AlibabaTokenPlanModelManagerConfig {
     apiKey?: string;
@@ -318,6 +319,22 @@ export interface KimiCodeModelManagerConfig {
     baseUrl?: string;
     fetch?: FetchImpl;
 }
+/**
+ * Kimi Code output ceilings by model family. The `/coding/v1/models` discovery
+ * envelope carries no output-limit field, so the mapper supplies the documented
+ * per-family caps instead of a blanket constant. Values match models.dev's
+ * `kimi-for-coding` and `moonshotai` kimi-k3 entries. See #6711.
+ */
+export declare const KIMI_CODE_K3_MAX_TOKENS = 131072;
+export declare const KIMI_CODE_FOR_CODING_MAX_TOKENS = 32768;
+/** Fallback output cap for Kimi Code families without a documented ceiling (legacy K2 discovery rows). */
+export declare const KIMI_CODE_DEFAULT_MAX_TOKENS = 32000;
+/**
+ * Resolve a Kimi Code model's output ceiling from its id: `k3` / `k3-256k` ->
+ * 131072, `kimi-for-coding[-highspeed]` -> 32768, everything else -> `fallback`.
+ */
+export declare function kimiCodeMaxTokens(modelId: string, fallback?: number): number;
+export declare function kimiCodeMaxTokens(modelId: string, fallback: number | null): number | null;
 export declare function kimiCodeModelManagerOptions(config?: KimiCodeModelManagerConfig): ModelManagerOptions<"openai-completions">;
 /** Native LM Studio metadata keyed by model id from `/api/v0/models`. */
 export interface LmStudioNativeModelMetadata {
@@ -506,4 +523,3 @@ export interface ModelsDevProviderDescriptor {
 export declare function mapModelsDevToModels(data: Record<string, unknown>, descriptors: readonly ModelsDevProviderDescriptor[]): ModelSpec<Api>[];
 /** All provider descriptors for models.dev data mapping in generate-models.ts. */
 export declare const MODELS_DEV_PROVIDER_DESCRIPTORS: readonly ModelsDevProviderDescriptor[];
-export {};

package/dist/types/types.d.ts

@@ -432,6 +432,20 @@ export interface AnthropicCompat {
      * blocks instead of normal `tool_use` calls.
      */
     escapeBuiltinToolNames?: boolean;
+    /**
+     * The configured endpoint enforces Anthropic's signature protocol on
+     * replayed thinking blocks — either the official API itself or a proxy
+     * that forwards to it (GitHub Copilot, ZenMux, Cloudflare AI Gateway's
+     * `/anthropic` route, Google Vertex's `publishers/anthropic/…`).
+     * Downstream transforms strip stale cross-model thinking signatures on
+     * these endpoints so the signing proxy doesn't 400 with
+     * `Invalid signature in thinking block` (#4297), and adaptive-thinking
+     * models keep the interleaved-thinking beta on them (#6717). Known hosts
+     * are auto-detected from provider id and baseUrl; set this to mark an
+     * opaque signing proxy the URL list can't recognize. Superset of
+     * {@link ResolvedAnthropicCompat.officialEndpoint}.
+     */
+    signingEndpoint?: boolean;
 }
 /**
  * Compatibility settings for Bedrock Converse prompt caching. Cache pricing is
@@ -597,17 +611,6 @@ export type ResolvedAnthropicCompat = Required<AnthropicCompat> & {
      * env headers, and cache-TTL shaping without per-request URL parsing.
      */
     officialEndpoint: boolean;
-    /**
-     * The configured endpoint enforces Anthropic's signature protocol on
-     * replayed thinking blocks — either the official API itself or a proxy
-     * that forwards to it (GitHub Copilot, ZenMux, Cloudflare AI Gateway's
-     * `/anthropic` route, Google Vertex's `publishers/anthropic/…`).
-     * Downstream transforms strip stale cross-model thinking signatures on
-     * these endpoints so the signing proxy doesn't 400 with
-     * `Invalid signature in thinking block` (#4297). Superset of
-     * {@link officialEndpoint}.
-     */
-    signingEndpoint: boolean;
 };
 /**
  * Compatibility settings for the devin-agent (Codeium Cascade) API. Cascade
@@ -686,6 +689,8 @@ export interface Model<TApi extends Api = Api> {
     supportsTools?: boolean;
     /** Whether this model accepts the GA OpenAI Responses `{ type: "computer" }` native tool. */
     supportsComputerUse?: boolean;
+    /** Verbatim explicit computer-use support from the spec; undefined when `buildModel` inferred the runtime value. */
+    supportsComputerUseConfig?: boolean;
     /** GitLab Duo Workflow root namespace selected during catalog discovery. */
     gitlabDuoWorkflowRootNamespaceId?: string;
     /** Cursor `max_mode` request flag returned by `GetUsableModels` for premium models that require max mode. */
@@ -770,7 +775,7 @@ export interface Model<TApi extends Api = Api> {
  * vocabulary of `buildModel`. Identical to `Model` except `compat` carries the
  * sparse override shape and nothing is resolved yet.
  */
-export interface ModelSpec<TApi extends Api = Api> extends Omit<Model<TApi>, "compat" | "compatConfig"> {
+export interface ModelSpec<TApi extends Api = Api> extends Omit<Model<TApi>, "compat" | "compatConfig" | "supportsComputerUseConfig"> {
     /** Sparse compatibility overrides; resolved into `Model.compat` by `buildModel`. */
     compat?: CompatConfigOf<TApi>;
 }

package/dist/types/wire/alibaba-token-plan.d.ts

@@ -1,6 +1,22 @@
+/**
+ * International (Singapore) Token Plan endpoint. Default region; keys issued by
+ * the international product authenticate only here.
+ */
+export declare const ALIBABA_TOKEN_PLAN_BASE_URL = "https://token-plan.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1";
+/**
+ * China (Beijing) Token Plan endpoint (百炼 Token Plan). Keys are region-locked:
+ * a Beijing-issued key is rejected by the international endpoint with
+ * `invalid_api_key`, and vice versa (#6682).
+ */
+export declare const ALIBABA_TOKEN_PLAN_CN_BASE_URL = "https://token-plan.cn-beijing.maas.aliyuncs.com/compatible-mode/v1";
 export interface AlibabaTokenPlanCredential {
     token: string;
     cookie?: string;
+    /**
+     * Region base URL the key authenticates against. Absent means the default
+     * international endpoint ({@link ALIBABA_TOKEN_PLAN_BASE_URL}).
+     */
+    baseUrl?: string;
 }
 export declare function parseAlibabaTokenPlanCredential(value: string): AlibabaTokenPlanCredential | null;
-export declare function serializeAlibabaTokenPlanCredential(token: string, cookie: string): string;
+export declare function serializeAlibabaTokenPlanCredential(token: string, cookie: string, baseUrl?: string): string;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-catalog",
-	"version": "17.1.3",
+	"version": "17.1.5",
 	"description": "Model catalog for omp: bundled model database, provider discovery descriptors, model identity, classification, and equivalence",
 	"homepage": "https://omp.sh",
 	"author": "Can Boluk",
@@ -34,12 +34,12 @@
 	},
 	"dependencies": {
 		"@bufbuild/protobuf": "^2.12.1",
-		"@oh-my-pi/pi-utils": "17.1.3",
+		"@oh-my-pi/pi-utils": "17.1.5",
 		"arktype": "2.2.3",
 		"zod": "^4"
 	},
 	"devDependencies": {
-		"@oh-my-pi/pi-ai": "17.1.3",
+		"@oh-my-pi/pi-ai": "17.1.5",
 		"@types/bun": "^1.3.14"
 	},
 	"engines": {

package/src/build.ts

@@ -20,28 +20,53 @@ import { cleanModelName } from "./utils";
 
 const OPENAI_GA_COMPUTER_MODEL_RE = /^gpt-5\.(?:[4-9]|[1-9]\d)(?:[.-]|$)/i;
 
-function supportsOpenAIGAComputerUse(spec: ModelSpec<Api>): boolean {
-	if (spec.supportsComputerUse !== undefined) return spec.supportsComputerUse;
-	if (
-		spec.api !== "openai-responses" &&
-		spec.api !== "openai-codex-responses" &&
-		spec.api !== "azure-openai-responses"
-	) {
+function isDirectOpenAIResponsesEndpoint(spec: ModelSpec<Api>): boolean {
+	if (spec.api === "openai-responses") {
+		if (spec.provider !== "openai") return false;
+		if (!spec.baseUrl) return true;
+		try {
+			const url = new URL(spec.baseUrl);
+			return url.protocol === "https:" && url.hostname === "api.openai.com";
+		} catch {
+			return false;
+		}
+	}
+	if (spec.api !== "azure-openai-responses" || (spec.provider !== "azure" && spec.provider !== "azure-openai")) {
 		return false;
 	}
-	if (spec.api !== "azure-openai-responses" && spec.provider !== "openai" && spec.provider !== "openai-codex") {
+	if (!spec.baseUrl) return true;
+	try {
+		const url = new URL(spec.baseUrl);
+		return (
+			url.protocol === "https:" &&
+			(url.hostname.endsWith(".openai.azure.com") || url.hostname === "models.inference.ai.azure.com")
+		);
+	} catch {
 		return false;
 	}
+}
+
+function explicitComputerUseConfig(spec: ModelSpec<Api>): boolean | undefined {
+	return "supportsComputerUseConfig" in spec
+		? (spec as Model<Api>).supportsComputerUseConfig
+		: spec.supportsComputerUse;
+}
+
+function supportsOpenAIGAComputerUse(spec: ModelSpec<Api>, explicitSupport: boolean | undefined): boolean {
+	if (explicitSupport !== undefined) return explicitSupport;
+	if (!isDirectOpenAIResponsesEndpoint(spec)) return false;
 	return OPENAI_GA_COMPUTER_MODEL_RE.test(spec.requestModelId ?? spec.id);
 }
 
 export function buildModel<TApi extends Api>(spec: ModelSpec<TApi>): Model<TApi> {
 	const compat = buildCompat(spec) as CompatOf<TApi>;
+	const supportsComputerUseConfig = explicitComputerUseConfig(spec);
 	return {
 		...spec,
 		name: cleanModelName(spec.name),
 		thinking: resolveModelThinking(spec, compat),
-		supportsComputerUse: supportsOpenAIGAComputerUse(spec),
+		supportsComputerUse: supportsOpenAIGAComputerUse(spec, supportsComputerUseConfig),
+		supportsComputerUseConfig,
 		compat,
 		compatConfig: spec.compat,
 	} as Model<TApi>;

package/src/compat/anthropic.ts

@@ -4,10 +4,11 @@
  * defaults come from provider ids, strict host checks, and model-id
  * classification, with explicit spec overrides assigned on top.
  */
-import { modelMatchesHost } from "../hosts";
+import { hostMatchesUrl, modelMatchesHost } from "../hosts";
 import {
 	hasOpus47ApiRestrictions,
 	isAnthropicFableOrMythosModel,
+	isKimiK3ModelId,
 	supportsMidConversationSystemMessages,
 } from "../identity/family";
 import type { ModelSpec, ResolvedAnthropicCompat } from "../types";
@@ -28,12 +29,25 @@ export function isOfficialAnthropicApiUrl(baseUrl?: string): boolean {
 	return lower === OFFICIAL_ANTHROPIC_URL || lower.startsWith(`${OFFICIAL_ANTHROPIC_URL}/`);
 }
 
-/** Mirrors `compat/openai.ts`; native-only host gating is the caller's responsibility. */
+/**
+ * Kimi models whose native endpoints (api.kimi.com, api.moonshot.ai) keep
+ * thinking enabled server-side no matter what the request carries: they
+ * reject disabled thinking (#3852) AND reject forced tool_choice
+ * (`tool_choice 'specified' is incompatible with thinking enabled`), so compat
+ * must keep thinking on and downgrade forced choices to `auto`. Covers the
+ * K2.7 Code family — public id, its Highspeed variant, and the kimi-code
+ * `kimi-for-coding[-highspeed]` aliases — plus K3 (`kimi-k3`, bare `k3` on
+ * kimi-code). Broader than the `compat/openai.ts` mirror: the OpenAI surface
+ * has its own per-dialect policies (K3 forced-choice guard, explicit disable
+ * shapes), while this surface has no working way to force a tool.
+ * Native-only host gating is the caller's responsibility.
+ */
 const KIMI_K27_CODE_MODEL_PATTERN = /(?:^|\/)kimi[-._]?k2(?:[._-]?|p)7[-._]?code(?:[-._]?highspeed)?$/i;
 
-function matchesKimiK27CodeFamily(spec: ModelSpec<"anthropic-messages">): boolean {
+function matchesKimiMandatoryThinkingModel(spec: ModelSpec<"anthropic-messages">): boolean {
 	if (KIMI_K27_CODE_MODEL_PATTERN.test(spec.id)) return true;
-	return spec.id === "kimi-for-coding" && /k2\.?7 code/i.test(spec.name ?? "");
+	if (spec.id === "kimi-for-coding" || spec.id === "kimi-for-coding-highspeed") return true;
+	return isKimiK3ModelId(spec.id) || spec.id === "k3";
 }
 
 const CLOUDFLARE_ANTHROPIC_GATEWAY_URL_MARKER = /gateway\.ai\.cloudflare\.com\/.+\/anthropic(?:\/|$)/i;
@@ -82,6 +96,23 @@ function isAzureAnthropicRoute(baseUrl?: string): boolean {
 	return baseUrl !== undefined && AZURE_ANTHROPIC_URL_MARKER.test(baseUrl);
 }
 
+/**
+ * Known non-official URLs that enforce Anthropic thinking signatures on replay.
+ *
+ * Runtime routing calls this with the effective URL because a model's resolved
+ * compat can be stale after Foundry or a provider base-URL override reroutes it.
+ */
+export function isAnthropicSigningProxyUrl(baseUrl?: string): boolean {
+	return (
+		hostMatchesUrl(baseUrl, "githubCopilot") ||
+		hostMatchesUrl(baseUrl, "zenmux") ||
+		isCloudflareAnthropicGateway(baseUrl) ||
+		isVertexAnthropicRoute(baseUrl) ||
+		isBedrockAnthropicRoute(baseUrl) ||
+		isAzureAnthropicRoute(baseUrl)
+	);
+}
+
 /** Build the resolved anthropic-messages compat record for a model spec. */
 export function buildAnthropicCompat(spec: ModelSpec<"anthropic-messages">): ResolvedAnthropicCompat {
 	const baseUrl = spec.baseUrl;
@@ -98,12 +129,9 @@ export function buildAnthropicCompat(spec: ModelSpec<"anthropic-messages">): Res
 	// signature-enforcing Anthropic — same failure class as GitHub Copilot #2851
 	// (issue #4192).
 	const isZenmux = modelMatchesHost(spec, "zenmux");
-	const requiresThinkingEnabled = modelMatchesHost(spec, "moonshotNative") && matchesKimiK27CodeFamily(spec);
-	const isVertex = isVertexAnthropicRoute(baseUrl);
-	const isBedrock = isBedrockAnthropicRoute(baseUrl);
+	const requiresThinkingEnabled = modelMatchesHost(spec, "moonshotNative") && matchesKimiMandatoryThinkingModel(spec);
 	const isAzure = isAzureAnthropicRoute(baseUrl);
-	const signingEndpoint =
-		official || isCopilot || isZenmux || isCloudflareAnthropicGateway(baseUrl) || isVertex || isBedrock || isAzure;
+	const signingEndpoint = official || isCopilot || isZenmux || isAnthropicSigningProxyUrl(baseUrl);
 	const compat: ResolvedAnthropicCompat = {
 		officialEndpoint: official,
 		signingEndpoint,

package/src/compat/bedrock.ts

@@ -42,6 +42,15 @@ const EXPLICIT_CHECKPOINTS_4096_1H: ResolvedBedrockCompat = {
 	promptCacheMaximumCheckpoints: 4,
 };
 
+// AWS モデルカード: 512 トークン、最大 4 個のキャッシュチェックポイント、5 分と 1 時間の TTL。
+// https://docs.aws.amazon.com/bedrock/latest/userguide/model-card-anthropic-claude-opus-5.html
+const EXPLICIT_CHECKPOINTS_512_1H: ResolvedBedrockCompat = {
+	promptCacheMode: "explicit",
+	supportsLongPromptCacheRetention: true,
+	promptCacheMinimumTokens: 512,
+	promptCacheMaximumCheckpoints: 4,
+};
+
 /**
  * Explicit Nova cache points complement Bedrock's automatic prefix caching:
  * AWS recommends them for consistent cache hits and input-cost savings. Keep
@@ -82,6 +91,9 @@ function detectedBedrockCompat(modelId: string): ResolvedBedrockCompat {
 	) {
 		return EXPLICIT_CHECKPOINTS_4096_1H;
 	}
+	if (id.includes("anthropic.claude-opus-5")) {
+		return EXPLICIT_CHECKPOINTS_512_1H;
+	}
 	if (id.includes("anthropic.claude-opus-4-6")) {
 		return EXPLICIT_CHECKPOINTS_4096_5M;
 	}

package/src/identity/family.ts

@@ -261,6 +261,19 @@ export const modelFamilyToken = memo((modelId: string): string => {
 	return "";
 });
 
+/**
+ * True for Claude generations that support extended thinking: Sonnet/Opus 3.7+,
+ * every 4.x/5+ Opus/Sonnet, and the Fable/Mythos generation. Pre-thinking
+ * models (Claude 3.5 and older) are excluded so no thinking effort dial is
+ * fabricated for a model that rejects thinking parameters. Classifier-based, so
+ * dotted and dashed version forms both match; ids the classifier does not parse
+ * (e.g. Haiku, bare dated ids) return false.
+ */
+export const anthropicModelSupportsThinking = memo((modelId: string): boolean => {
+	const parsed = parseAnthropicModel(bareModelId(modelId));
+	return parsed !== null && semverGte(parsed.version, "3.7");
+});
+
 /**
  * Adaptive thinking `display` is supported starting with Claude Opus 4.7+,
  * Sonnet 5+, and the Claude Fable/Mythos 5 generation. Older adaptive-thinking

package/src/model-cache.ts

@@ -9,9 +9,11 @@ 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. Request headers are
 // intentionally omitted: arbitrary provider-defined header names can carry
-// credentials. v10 deletes rows that may contain persisted headers and records
-// which model ids lost headers and which cannot be rebuilt from static inputs,
-// so the manager can restore the safe subset or refetch dynamic-only headers;
+// credentials. v12 invalidates Kimi Code rows carrying the blanket
+// maxTokens: 32000 that predate per-family output caps (k3/k3-256k -> 131072,
+// kimi-for-coding[-highspeed] -> 32768, #6711); v11 invalidates rows that may
+// persist derived computer-use
+// headers and records which model ids lost headers or cannot be rebuilt.
 // v9 invalidated Kimi Code rows predating live effort and protocol metadata;
 // v8 invalidated Codex discovery rows predating provider-native V2 compaction
 // metadata; v7 invalidated rows predating the Antigravity Gemini budget-mode
@@ -20,7 +22,7 @@ import type { Api, Model, ModelSpec } from "./types";
 // 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 = 10;
+const CACHE_SCHEMA_VERSION = 12;
 const HEADER_RESTORE_VERSION = 1;
 
 interface CacheRow {
@@ -204,8 +206,8 @@ function hasModelHeaders(model: Model<Api>): boolean {
  * headers and reject/refetch dynamic-only cached models that need live headers.
  */
 function toCachedModelSpec<TApi extends Api>(model: Model<TApi>): ModelSpec<TApi> {
-	const { headers: _headers, compatConfig, ...rest } = model;
-	return { ...rest, compat: compatConfig };
+	const { headers: _headers, compatConfig, supportsComputerUseConfig, ...rest } = model;
+	return { ...rest, supportsComputerUse: supportsComputerUseConfig, compat: compatConfig };
 }
 
 /** Whether two in-memory header records are byte-for-byte equivalent. */
@@ -228,6 +230,7 @@ export function writeModelCache<TApi extends Api>(
 	staticFingerprint: string,
 	dbPath?: string,
 	staticHeaderSources: readonly Model<TApi>[] = [],
+	restorableHeaderFallback?: Record<string, string>,
 ): void {
 	try {
 		withModelCacheDb(dbPath, db => {
@@ -244,7 +247,14 @@ export function writeModelCache<TApi extends Api>(
 					// unrestorable and dropped on the next offline read (#6037, #6284).
 					const staticHeaderSource =
 						staticById.get(model.id) ?? (model.requestModelId ? staticById.get(model.requestModelId) : undefined);
-					if (!headersEqual(model.headers, staticHeaderSource?.headers)) {
+					// A model with no static source is still restorable when its live
+					// headers equal the provider's trusted constant (a compile-time,
+					// non-credential value the reader can reattach by value). This keeps
+					// reference-less Copilot models (e.g. claude-opus-5) alive offline.
+					const matchesStatic = staticHeaderSource
+						? headersEqual(model.headers, staticHeaderSource.headers)
+						: headersEqual(model.headers, restorableHeaderFallback);
+					if (!matchesStatic) {
 						unrestorableHeaderModelIds.push(model.id);
 					}
 				}