@xiaoso/dsh-tool-plus 0.1.6 → 0.1.7-beta.1

package/lib/collapse-DOR8sOGf.mjs

@@ -0,0 +1,2304 @@
+import { installBunShim as __installBunShim } from "./bun-shim.mjs";
+__installBunShim();
+import { n as isRecord } from "./type-guards-CttAANEx.mjs";
+import { c as resolveCascade, d as compareRevision, f as parseRevision, i as collapseVocabulary, m as revisionSatisfies, n as classifyModel, o as stripThinkingVariantSuffix, p as parseRevisionConstraint, r as collapseVariantId } from "./taxonomy-DSIM99rS.mjs";
+import { t as cleanModelName } from "./utils-DeWqNWV8.mjs";
+import { n as THINKING_EFFORTS } from "./effort-BdtQMN-_.mjs";
+import { t as bareModelId } from "./id-AL5obQzR.mjs";
+import { r as modelMatchesHost, t as hostMatchesUrl } from "./hosts-00rjRzUD.mjs";
+//#region node_modules/.pnpm/@oh-my-pi+pi-catalog@18.1.17/node_modules/@oh-my-pi/pi-catalog/src/compat/anthropic.ts
+/**
+* Anthropic endpoint-shape predicates: which URLs are the official first-party
+* API, and which non-official hosts enforce Anthropic's thinking-signature
+* protocol on replay. Compat resolution (`./resolve`) and runtime routing in
+* pi-ai both consume these; URL matching is the one detection surface that
+* stays in code.
+*/
+const OFFICIAL_ANTHROPIC_URL = "https://api.anthropic.com";
+/**
+* Official first-party Anthropic API. A missing baseUrl is official on purpose:
+* request dispatch falls back to `https://api.anthropic.com`. This is the one
+* auth-sensitive host check — OAuth credentials are attached based on it — so
+* it requires the exact origin or a path boundary (`/`) after it; a bare
+* prefix check would accept lookalikes like `https://api.anthropic.com.evil.com`.
+*/
+function isOfficialAnthropicApiUrl(baseUrl) {
+	if (!baseUrl) return true;
+	const lower = baseUrl.toLowerCase();
+	return lower === OFFICIAL_ANTHROPIC_URL || lower.startsWith(`${OFFICIAL_ANTHROPIC_URL}/`);
+}
+const CLOUDFLARE_ANTHROPIC_GATEWAY_URL_MARKER = /gateway\.ai\.cloudflare\.com\/.+\/anthropic(?:\/|$)/i;
+const VERTEX_ANTHROPIC_URL_MARKER = /aiplatform\.googleapis\.com\/.+\/publishers\/anthropic\//i;
+const BEDROCK_ANTHROPIC_URL_MARKER = /(?:^|\/\/|\.)bedrock-runtime\.[a-z0-9-]+\.amazonaws\.com/i;
+const AZURE_ANTHROPIC_URL_MARKER = /(?:^|\/\/|\.)[a-z0-9-]+\.(?:inference|services)\.ai\.azure\.com/i;
+/**
+* Azure AI Inference / Foundry Anthropic route
+* (`<resource>.inference.ai.azure.com`, `<resource>.services.ai.azure.com`).
+* Fronts Claude behind Azure identity and enforces Anthropic signatures on
+* replay; it also rejects the top-level `strict` tool field.
+*/
+function isAzureAnthropicRoute(baseUrl) {
+	return baseUrl !== void 0 && AZURE_ANTHROPIC_URL_MARKER.test(baseUrl);
+}
+/**
+* Known non-official URLs that enforce Anthropic thinking signatures on replay
+* (GitHub Copilot, ZenMux, Cloudflare AI Gateway `/anthropic`, Google Vertex
+* `publishers/anthropic`, AWS Bedrock, Azure Foundry).
+*
+* 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.
+*/
+function isAnthropicSigningProxyUrl(baseUrl) {
+	return hostMatchesUrl(baseUrl, "githubCopilot") || hostMatchesUrl(baseUrl, "zenmux") || baseUrl !== void 0 && (CLOUDFLARE_ANTHROPIC_GATEWAY_URL_MARKER.test(baseUrl) || VERTEX_ANTHROPIC_URL_MARKER.test(baseUrl) || BEDROCK_ANTHROPIC_URL_MARKER.test(baseUrl)) || isAzureAnthropicRoute(baseUrl);
+}
+//#endregion
+//#region node_modules/.pnpm/@oh-my-pi+pi-catalog@18.1.17/node_modules/@oh-my-pi/pi-catalog/src/compat/apply.ts
+/**
+* Assign defined override values onto a freshly-built resolved compat record,
+* in place. Keys the record doesn't declare are ignored (loosely-typed config
+* may carry junk). `buildModel` is the only intended caller — the record being
+* mutated is the single per-model allocation; nothing here runs per request.
+*/
+function applyCompatOverrides(compat, overrides) {
+	if (!overrides) return;
+	for (const key in overrides) {
+		const value = overrides[key];
+		if (value !== void 0 && key in compat) compat[key] = value;
+	}
+}
+//#endregion
+//#region node_modules/.pnpm/@oh-my-pi+pi-catalog@18.1.17/node_modules/@oh-my-pi/pi-catalog/src/compat/axes.ts
+const OAI = ["openai", "openai-responses"];
+const EFFORTS = [
+	"minimal",
+	"low",
+	"medium",
+	"high",
+	"xhigh",
+	"max"
+];
+[...EFFORTS];
+/**
+* How hard agent prompts push subagent delegation for a model lineage
+* (`delegation-bias` axis). `eager` is the unassigned default: the prompt
+* actively pushes fan-out. `restrained` keeps fan-out for genuinely parallel
+* slices but forbids reflexive scouts and single-agent babysitting. `gated`
+* forbids subagents unless the user or a skill asks.
+*/
+const DELEGATION_BIASES = [
+	"eager",
+	"restrained",
+	"gated"
+];
+const THINKING_MODES = [
+	"effort",
+	"budget",
+	"google-level",
+	"anthropic-adaptive",
+	"anthropic-budget-effort"
+];
+function wire(key, records, shape = "scalar", values) {
+	return {
+		key,
+		set: "wire",
+		shape,
+		records,
+		values
+	};
+}
+/**
+* KDL directive → axis definition. Keys are the kebab-case directive
+* spellings accepted inside `classes/*.kdl` and `providers/*.kdl` rule
+* blocks.
+*/
+const AXES = {
+	"allows-synthetic-reasoning-content-for-tool-calls": wire("allowsSyntheticReasoningContentForToolCalls", OAI),
+	"always-send-max-tokens": wire("alwaysSendMaxTokens", OAI),
+	"cache-control-format": wire("cacheControlFormat", OAI, "scalar", ["anthropic"]),
+	"clamp-output-to-model-max": wire("clampOutputToModelMax", OAI),
+	"disable-reasoning-on-forced-tool-choice": wire("disableReasoningOnForcedToolChoice", OAI),
+	"disable-reasoning-on-tool-choice": wire("disableReasoningOnToolChoice", OAI),
+	"drop-thinking-when-reasoning-effort": wire("dropThinkingWhenReasoningEffort", ["openai"]),
+	"empty-length-finish-is-context-error": wire("emptyLengthFinishIsContextError", OAI),
+	"extra-body": {
+		...wire("extraBody", ["openai"], "object"),
+		verbatimKeys: true
+	},
+	"filter-reasoning-history": wire("filterReasoningHistory", OAI),
+	"include-encrypted-reasoning": wire("includeEncryptedReasoning", OAI),
+	"kimi-api-format": wire("kimiApiFormat", ["openai"], "scalar", ["openai", "anthropic"]),
+	"max-tokens-field": wire("maxTokensField", ["openai"], "scalar", ["max_completion_tokens", "max_tokens"]),
+	"native-kimi-k3-reasoning": wire("nativeKimiK3Reasoning", ["openai"]),
+	"omit-reasoning-effort": wire("omitReasoningEffort", OAI),
+	"prompt-cache-breakpoint-ttl": wire("promptCacheBreakpointTtl", OAI, "scalar", ["30m"]),
+	"prompt-cache-session-header": wire("promptCacheSessionHeader", OAI, "scalar", ["x-grok-conv-id"]),
+	"qwen-preserve-thinking": wire("qwenPreserveThinking", ["openai"]),
+	"reject-root-object-union": wire("rejectRootObjectUnion", OAI),
+	"retry-without-strict-on-grammar-error": wire("retryWithoutStrictOnGrammarError", OAI),
+	"reasoning-content-field": wire("reasoningContentField", OAI, "scalar", [
+		"reasoning_content",
+		"reasoning",
+		"reasoning_text"
+	]),
+	"reasoning-deltas-may-be-cumulative": wire("reasoningDeltasMayBeCumulative", OAI),
+	"reasoning-disable-mode": wire("reasoningDisableMode", OAI, "scalar", [
+		"omit",
+		"lowest-effort",
+		"none-effort",
+		"openrouter-enabled-false",
+		"cline-enabled-false",
+		"venice-disable-thinking",
+		"zai-thinking-disabled",
+		"qwen-enable-thinking-false",
+		"qwen-template-false",
+		"chat-template-thinking-false"
+	]),
+	"reasoning-effort-map": wire("reasoningEffortMap", OAI, "object"),
+	"replay-reasoning-content": wire("replayReasoningContent", ["openai"]),
+	"requires-assistant-after-tool-result": wire("requiresAssistantAfterToolResult", ["openai"]),
+	"requires-assistant-content-for-tool-calls": wire("requiresAssistantContentForToolCalls", OAI),
+	"requires-mistral-tool-ids": wire("requiresMistralToolIds", ["openai"]),
+	"requires-reasoning-content-for-all-assistant-turns": wire("requiresReasoningContentForAllAssistantTurns", OAI),
+	"requires-reasoning-content-for-tool-calls": wire("requiresReasoningContentForToolCalls", OAI),
+	"requires-thinking-as-text": wire("requiresThinkingAsText", ["openai"]),
+	"requires-tool-result-name": wire("requiresToolResultName", ["openai"]),
+	"strict-responses-pairing": wire("strictResponsesPairing", ["openai-responses"]),
+	"requires-reasoning-off-juice-instruction": wire("requiresReasoningOffJuiceInstruction", ["openai-responses"]),
+	"supports-all-turns-reasoning-context": wire("supportsAllTurnsReasoningContext", ["openai-responses"]),
+	"supports-configuration-update": wire("supportsConfigurationUpdate", ["openai-responses"]),
+	"strip-deepseek-special-tokens": wire("stripDeepseekSpecialTokens", OAI),
+	"stream-markup-healing-pattern": wire("streamMarkupHealingPattern", OAI, "scalar", [
+		"kimi",
+		"dsml",
+		"qwen",
+		"thinking",
+		"harmony"
+	]),
+	"supports-developer-role": wire("supportsDeveloperRole", OAI),
+	"supports-image-detail-original": wire("supportsImageDetailOriginal", ["openai-responses"]),
+	"supports-long-prompt-cache-retention": wire("supportsLongPromptCacheRetention", [...OAI, "bedrock"]),
+	"supports-multiple-system-messages": wire("supportsMultipleSystemMessages", ["openai"]),
+	"supports-named-tool-choice": wire("supportsNamedToolChoice", OAI),
+	"supports-obfuscation-opt-out": wire("supportsObfuscationOptOut", ["openai-responses"]),
+	"harmony-leak-mitigation": wire("harmonyLeakMitigation", ["openai-responses"]),
+	"supports-penalty-and-stop-params": wire("supportsPenaltyAndStopParams", OAI),
+	"supports-prompt-cache-breakpoints": wire("supportsPromptCacheBreakpoints", OAI),
+	"supports-prompt-cache-key": wire("supportsPromptCacheKey", ["openai"]),
+	"supports-reasoning-effort": wire("supportsReasoningEffort", OAI),
+	"supports-reasoning-params": wire("supportsReasoningParams", OAI),
+	"supports-reasoning-summary": wire("supportsReasoningSummary", ["openai-responses"]),
+	"supports-store": wire("supportsStore", ["openai"]),
+	"supports-strict-mode": wire("supportsStrictMode", OAI),
+	"supports-tool-choice": wire("supportsToolChoice", OAI),
+	"supports-usage-in-streaming": wire("supportsUsageInStreaming", ["openai"]),
+	"template-reasoning-effort": wire("qwenTemplateReasoningEffort", ["openai"]),
+	"thinking-format": wire("thinkingFormat", OAI, "scalar", [
+		"openai",
+		"openrouter",
+		"zai",
+		"kimi",
+		"qwen",
+		"qwen-chat-template",
+		"chat-template"
+	]),
+	"thinking-keep": wire("thinkingKeep", ["openai"]),
+	"tool-schema-flavor": wire("toolSchemaFlavor", OAI, "scalar", [
+		"moonshot-mfjs",
+		"grammar",
+		"none"
+	]),
+	"tool-strict-mode": wire("toolStrictMode", ["openai"], "scalar", [
+		"all_strict",
+		"none",
+		"mixed"
+	]),
+	"uses-openai-tool-call-id-limit": wire("usesOpenAIToolCallIdLimit", OAI),
+	"when-thinking": wire("whenThinking", ["openai"], "object"),
+	"wire-model-id-mode": wire("wireModelIdMode", OAI, "scalar", [
+		"raw",
+		"cline-pass",
+		"firepass",
+		"fireworks",
+		"openrouter"
+	]),
+	"zai-reasoning-effort-dialect": wire("zaiReasoningEffortDialect", ["openai"]),
+	"allow-anthropic-header-overrides": wire("allowAnthropicHeaderOverrides", ["anthropic"]),
+	"disable-adaptive-thinking": wire("disableAdaptiveThinking", ["anthropic"]),
+	"disable-strict-tools": wire("disableStrictTools", ["anthropic"]),
+	"escape-builtin-tool-names": wire("escapeBuiltinToolNames", ["anthropic"]),
+	"inject-claude-code-instruction": wire("injectClaudeCodeInstruction", ["anthropic"]),
+	"official-endpoint": wire("officialEndpoint", ["anthropic", "openai-responses"]),
+	"replay-unsigned-thinking": wire("replayUnsignedThinking", ["anthropic"]),
+	"requires-thinking-enabled": wire("requiresThinkingEnabled", ["anthropic"]),
+	"requires-tool-result-id": wire("requiresToolResultId", ["anthropic"]),
+	"signing-endpoint": wire("signingEndpoint", ["anthropic"]),
+	"supports-context-management": wire("supportsContextManagement", ["anthropic"]),
+	"supports-output-effort": wire("supportsOutputEffort", ["anthropic"]),
+	"supports-eager-tool-input-streaming": wire("supportsEagerToolInputStreaming", ["anthropic"]),
+	"supports-long-cache-retention": wire("supportsLongCacheRetention", ["anthropic"]),
+	"supports-mid-conversation-system": wire("supportsMidConversationSystem", ["anthropic"]),
+	"supports-mid-conversation-tool-changes": wire("supportsMidConversationToolChanges", ["anthropic"]),
+	"supports-per-message-effort": wire("supportsPerMessageEffort", ["anthropic"]),
+	"supports-thinking-binding-controls": wire("supportsThinkingBindingControls", ["anthropic"]),
+	"supports-turn-scoped-system": wire("supportsTurnScopedSystem", ["anthropic"]),
+	"prompt-cache-maximum-checkpoints": wire("promptCacheMaximumCheckpoints", ["bedrock"]),
+	"prompt-cache-minimum-tokens": wire("promptCacheMinimumTokens", ["bedrock"]),
+	"prompt-cache-mode": wire("promptCacheMode", ["bedrock"], "scalar", [
+		"none",
+		"automatic",
+		"explicit"
+	]),
+	"model-router": wire("modelRouter", ["devin"]),
+	"supports-parallel-tool-calls": wire("supportsParallelToolCalls", ["devin"]),
+	"trust-explicit-thinking-only": wire("trustExplicitThinkingOnly", ["devin"]),
+	"antigravity-claude-tool-mode": wire("antigravityClaudeToolMode", ["google"]),
+	"antigravity-usage-label": wire("antigravityUsageLabel", ["google"]),
+	"cca-legacy-parameters-schema": wire("ccaLegacyParametersSchema", ["google"]),
+	"claude-thinking-beta-header": wire("claudeThinkingBetaHeader", ["google"]),
+	"drop-unsigned-thinking": wire("dropUnsignedThinking", ["google"]),
+	"flash-stream-leak-workaround": wire("flashStreamLeakWorkaround", ["google"]),
+	"multimodal-function-response": wire("multimodalFunctionResponse", ["google"]),
+	"requires-skip-thought-signature": wire("requiresSkipThoughtSignature", ["google"]),
+	"requires-skip-thought-signature-on-first-function-call": wire("requiresSkipThoughtSignatureOnFirstFunctionCall", ["google"]),
+	"supports-function-part-id": wire("supportsFunctionPartId", ["google"]),
+	"stream-first-event-timeout-ms": wire("streamFirstEventTimeoutMs", [...OAI, "google"]),
+	"stream-idle-timeout-ms": wire("streamIdleTimeoutMs", [
+		...OAI,
+		"anthropic",
+		"bedrock",
+		"google"
+	]),
+	"strip-image-input": wire("stripImageInput", [
+		...OAI,
+		"anthropic",
+		"google"
+	]),
+	"supports-forced-tool-choice": wire("supportsForcedToolChoice", [...OAI, "anthropic"]),
+	"supports-sampling-params": wire("supportsSamplingParams", [...OAI, "anthropic"]),
+	"thinking-loop-guard": wire("thinkingLoopGuard", [
+		...OAI,
+		"anthropic",
+		"google"
+	], "scalar", [
+		"gemini",
+		"deepseek",
+		"xai"
+	]),
+	"thinking-default-level": {
+		key: "defaultLevel",
+		set: "thinking",
+		shape: "scalar",
+		values: EFFORTS
+	},
+	"thinking-effort-budgets": {
+		key: "effortBudgets",
+		set: "thinking",
+		shape: "object"
+	},
+	"thinking-effort-map": {
+		key: "effortMap",
+		set: "thinking",
+		shape: "object"
+	},
+	"thinking-efforts": {
+		key: "efforts",
+		set: "thinking",
+		shape: "array",
+		values: EFFORTS
+	},
+	"thinking-mode": {
+		key: "mode",
+		set: "thinking",
+		shape: "scalar",
+		values: THINKING_MODES
+	},
+	"thinking-requires-effort": {
+		key: "requiresEffort",
+		set: "thinking",
+		shape: "scalar"
+	},
+	"thinking-prefix-binding": {
+		key: "prefixBinding",
+		set: "thinking",
+		shape: "scalar"
+	},
+	"thinking-suppress-when-off": {
+		key: "suppressWhenOff",
+		set: "thinking",
+		shape: "scalar"
+	},
+	"thinking-supports-display": {
+		key: "supportsDisplay",
+		set: "thinking",
+		shape: "scalar"
+	},
+	"thinking-upgrade-neutral": {
+		key: "upgradeNeutral",
+		set: "thinking",
+		shape: "scalar"
+	},
+	"apply-patch-tool-type": {
+		key: "applyPatchToolType",
+		set: "catalog",
+		shape: "scalar",
+		values: ["freeform", "function"]
+	},
+	"clamp-context-override": {
+		key: "clampContextOverride",
+		set: "catalog",
+		shape: "scalar"
+	},
+	"context-promotion-target": {
+		key: "contextPromotionTarget",
+		set: "catalog",
+		shape: "scalar"
+	},
+	"context-window-floor": {
+		key: "contextWindowFloor",
+		set: "catalog",
+		shape: "scalar"
+	},
+	"cost-patch": {
+		key: "costPatch",
+		set: "catalog",
+		shape: "object"
+	},
+	"delegation-bias": {
+		key: "delegationBias",
+		set: "catalog",
+		shape: "scalar",
+		values: DELEGATION_BIASES
+	},
+	"edit-prompt-variant": {
+		key: "editPromptVariant",
+		set: "catalog",
+		shape: "scalar",
+		values: ["full", "compact"]
+	},
+	"edit-revision": {
+		key: "editRevision",
+		set: "catalog",
+		shape: "scalar"
+	},
+	"input-modalities": {
+		key: "inputModalities",
+		set: "catalog",
+		shape: "array",
+		values: ["text", "image"]
+	},
+	"limits-patch": {
+		key: "limitsPatch",
+		set: "catalog",
+		shape: "object"
+	},
+	"long-context-cost": {
+		key: "longContext",
+		set: "catalog",
+		shape: "object"
+	},
+	"long-usage-limit-fallback": {
+		key: "longUsageLimitFallback",
+		set: "catalog",
+		shape: "scalar"
+	},
+	"max-context-window": {
+		key: "maxContextWindow",
+		set: "catalog",
+		shape: "scalar"
+	},
+	"requires-cursor-tool-schema-projection": {
+		key: "requiresCursorToolSchemaProjection",
+		set: "catalog",
+		shape: "scalar"
+	},
+	priority: {
+		key: "priority",
+		set: "catalog",
+		shape: "scalar"
+	},
+	"service-tier-cost": {
+		key: "serviceTierCost",
+		set: "catalog",
+		shape: "object"
+	},
+	"time-based-cost": {
+		key: "timeBased",
+		set: "catalog",
+		shape: "object"
+	}
+};
+/** Records applicable to each API family; used by `resolve.ts` when applying wire axes. */
+const API_COMPAT_RECORDS = {
+	"openai-completions": ["openai"],
+	openrouter: ["openai", "openai-responses"],
+	"openai-responses": ["openai-responses"],
+	"azure-openai-responses": ["openai-responses"],
+	"openai-codex-responses": ["openai-responses"],
+	"anthropic-messages": ["anthropic"],
+	"bedrock-converse-stream": ["bedrock"],
+	"devin-agent": ["devin"],
+	"google-generative-ai": ["google"],
+	"google-vertex": ["google"],
+	"google-gemini-cli": ["google"]
+};
+//#endregion
+//#region node_modules/.pnpm/@oh-my-pi+pi-catalog@18.1.17/node_modules/@oh-my-pi/pi-catalog/src/compat/resolve.ts
+/**
+* `resolveModelPolicy` — the single model-policy resolver. Layering, later
+* layers win:
+*
+*   1. unconditional per-API compat defaults;
+*   2. host-derived flags: URL/provider detection via `hosts.ts`, including
+*      compound host×identity branches (keyed on {@link ModelIdentity} fields,
+*      never on model-name matching);
+*   3. compat-cascade axes compiled from `rules/` (pure identity- and
+*      provider-keyed policy lives there, not here);
+*   4. spec-authored sparse overrides (`applyCompatOverrides`), then the
+*      spec-undefined fixups the legacy builders applied.
+*
+* Thinking metadata resolves after compat: explicit spec thinking wins,
+* cascade thinking axes drive the ladder/mode/wire facts, and identity-generic
+* fallbacks cover unmatched targets.
+*/
+/** Structured identity plus revision comparison helpers. */
+var IdentityFacts = class {
+	identity;
+	revision;
+	constructor(identity) {
+		this.identity = identity;
+		this.revision = identity.revision === void 0 ? void 0 : parseRevision(identity.revision);
+	}
+	is(cls) {
+		return this.identity.class === cls;
+	}
+	family(...families) {
+		return this.identity.family !== void 0 && families.includes(this.identity.family);
+	}
+	revGte(min) {
+		if (!this.revision) return false;
+		const bound = parseRevision(min);
+		return bound !== void 0 && compareRevision(this.revision, bound) >= 0;
+	}
+	revMajor() {
+		return this.revision?.[0];
+	}
+	/** Kimi K2.7-Code / K3 lines whose native hosts mandate enabled thinking. */
+	get kimiMandatoryThinking() {
+		return this.is("kimi") && this.family("k2.7-code", "k3");
+	}
+	/** Adaptive-thinking Claude generation floor (Opus ≥ min; Sonnet/Fable/Mythos ≥ 5). */
+	anthropicAdaptiveGenAtLeast(opusMin) {
+		if (!this.is("anthropic")) return false;
+		if (this.family("opus")) return this.revGte(opusMin);
+		if (this.family("sonnet", "fable", "mythos")) return this.revGte("5");
+		return false;
+	}
+};
+function resolveIdentity(spec) {
+	return classifyModel(spec.provider, spec.id);
+}
+let keyRecords;
+function getKeyRecords() {
+	if (!keyRecords) {
+		keyRecords = {};
+		for (const directive in AXES) {
+			const axis = AXES[directive];
+			if (axis.set === "wire" && axis.records) keyRecords[axis.key] = { records: axis.records };
+		}
+	}
+	return keyRecords;
+}
+/**
+* Assigns resolved wire axes onto a freshly-detected compat record. An axis
+* lands only when the model's API maps to one of the axis's declared records
+* — the axes table is the single applicability authority, so optional keys
+* absent from the detected baseline still land.
+*/
+function applyWireAxes(compat, wire, api) {
+	const records = API_COMPAT_RECORDS[api];
+	if (!records) return;
+	const info = getKeyRecords();
+	for (const key in wire) {
+		if (!info[key]?.records.some((record) => records.includes(record))) continue;
+		Reflect.set(compat, key, wire[key]);
+	}
+}
+/**
+* Preserves legacy per-key merge semantics for map-valued effort remaps: a
+* cascade-provided `reasoningEffortMap` is the detected base and sparse spec
+* overrides overlay it key by key (spec keys win, unseen keys survive).
+*/
+function overlayEffortMapAxis(compat, axes, specCompat) {
+	const axisMap = effortRecord(axes.wire.reasoningEffortMap);
+	if (axisMap && specCompat?.reasoningEffortMap) compat.reasoningEffortMap = {
+		...axisMap,
+		...specCompat.reasoningEffortMap
+	};
+}
+function effortList(value) {
+	if (!Array.isArray(value) || value.length === 0) return void 0;
+	const out = [];
+	for (const entry of value) {
+		const effort = THINKING_EFFORTS.find((candidate) => candidate === entry);
+		if (effort === void 0) return void 0;
+		out.push(effort);
+	}
+	return out;
+}
+function effortValue(value) {
+	return THINKING_EFFORTS.find((candidate) => candidate === value);
+}
+function objectPayload$1(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+}
+function effortRecord(value) {
+	if (typeof value !== "object" || value === null) return void 0;
+	const out = {};
+	let any = false;
+	for (const key in value) {
+		const effort = effortValue(key);
+		const mapped = Reflect.get(value, key);
+		if (effort === void 0 || typeof mapped !== "string") continue;
+		out[effort] = mapped;
+		any = true;
+	}
+	return any ? out : void 0;
+}
+function effortNumberRecord(value) {
+	if (typeof value !== "object" || value === null) return void 0;
+	const out = {};
+	let any = false;
+	for (const key in value) {
+		const effort = effortValue(key);
+		const mapped = Reflect.get(value, key);
+		if (effort === void 0 || typeof mapped !== "number") continue;
+		out[effort] = mapped;
+		any = true;
+	}
+	return any ? out : void 0;
+}
+function thinkingMode(value) {
+	switch (value) {
+		case "effort":
+		case "budget":
+		case "google-level":
+		case "anthropic-adaptive":
+		case "anthropic-budget-effort": return value;
+		default: return;
+	}
+}
+const GLM_CODING_PLAN_STREAM_IDLE_TIMEOUT_MS = 6e5;
+const LOCAL_OPENAI_COMPAT_STREAM_IDLE_TIMEOUT_MS = 3e5;
+const LOCAL_OPENAI_COMPAT_PROVIDERS = {
+	"llama.cpp": true,
+	"lm-studio": true,
+	vllm: true,
+	ollama: true
+};
+const PROXY_OPENAI_COMPAT_PROVIDERS = { litellm: true };
+function hasLocalLoopbackBaseUrl(baseUrl) {
+	if (!baseUrl) return false;
+	let hostname;
+	try {
+		hostname = new URL(baseUrl).hostname.toLowerCase();
+	} catch {
+		return false;
+	}
+	if (hostname === "localhost" || hostname === "127.0.0.1" || hostname === "0.0.0.0" || hostname === "::1" || hostname === "[::1]") return true;
+	if (hostname.startsWith("10.")) return true;
+	if (hostname.startsWith("192.168.")) return true;
+	if (/^172\.(1[6-9]|2[0-9]|3[01])\./.test(hostname)) return true;
+	if (hostname.endsWith(".local")) return true;
+	return false;
+}
+function resolveReasoningDisableMode(thinkingFormat) {
+	switch (thinkingFormat) {
+		case "openrouter": return "openrouter-enabled-false";
+		case "zai":
+		case "kimi": return "zai-thinking-disabled";
+		case "qwen": return "qwen-enable-thinking-false";
+		case "qwen-chat-template": return "qwen-template-false";
+		case "chat-template": return "chat-template-thinking-false";
+		default: return "lowest-effort";
+	}
+}
+/** Strict official-OpenAI check: provider id `openai` and an `api.openai.com` host. */
+function isOfficialOpenAIEndpoint(provider, baseUrl) {
+	if (provider !== "openai") return false;
+	if (!baseUrl) return true;
+	try {
+		return new URL(baseUrl).hostname === "api.openai.com";
+	} catch {
+		return false;
+	}
+}
+function detectOpenAI(spec, facts) {
+	const provider = spec.provider;
+	const baseUrl = spec.baseUrl;
+	const hostModel = {
+		provider,
+		baseUrl
+	};
+	const isZai = modelMatchesHost(hostModel, "zai");
+	const isZhipu = modelMatchesHost(hostModel, "zhipu");
+	const isMoonshotNative = modelMatchesHost(hostModel, "moonshotNative");
+	const isXiaomiHost = modelMatchesHost(hostModel, "xiaomi");
+	const isDirectDeepseekApi = modelMatchesHost(hostModel, "deepseekDirect");
+	const isDeepseekReasoning = (modelMatchesHost(hostModel, "deepseekFamily") || facts.is("deepseek")) && Boolean(spec.reasoning);
+	const isLocalOpenAICompatBackend = PROXY_OPENAI_COMPAT_PROVIDERS[provider] !== true && (LOCAL_OPENAI_COMPAT_PROVIDERS[provider] === true || hasLocalLoopbackBaseUrl(baseUrl));
+	return {
+		facts,
+		isClinePass: provider === "cline-pass",
+		isZai,
+		isZhipu,
+		isMoonshotNative,
+		isOpenCodeHost: modelMatchesHost(hostModel, "opencode"),
+		isOpenCodeProvider: provider === "opencode-go" || provider === "opencode-zen",
+		isDirectDeepseekApi,
+		isDeepseekReasoning,
+		isDirectDeepseekReasoning: isDirectDeepseekApi && isDeepseekReasoning,
+		isVenice: modelMatchesHost(hostModel, "venice"),
+		requiresEnabledThinking: isMoonshotNative && facts.is("kimi") && facts.family("k2.7-code"),
+		isXiaomiMimo: isXiaomiHost && facts.is("mimo"),
+		isLocalOpenAICompatBackend,
+		isLocalServingBackend: isLocalOpenAICompatBackend || hasLocalLoopbackBaseUrl(baseUrl),
+		isOpenRouter: modelMatchesHost(hostModel, "openrouter")
+	};
+}
+/**
+* Detected chat-completions baseline. Pure identity policy (Kimi max-token
+* behavior, DeepSeek reasoning-content contracts, Qwen dialects, sampling
+* restrictions, effort maps, markup healers, …) is rule-owned and absent
+* here; compound host×identity branches remain, keyed on identity fields.
+*/
+function detectOpenAICompat(spec, d) {
+	const provider = spec.provider;
+	const baseUrl = spec.baseUrl;
+	const hostModel = {
+		provider,
+		baseUrl
+	};
+	const facts = d.facts;
+	const isCerebras = modelMatchesHost(hostModel, "cerebras");
+	const isCerebrasHost = hostMatchesUrl(baseUrl, "cerebras");
+	const isKilo = modelMatchesHost(hostModel, "kilo");
+	const isAlibaba = modelMatchesHost(hostModel, "alibabaDashscope");
+	const isXiaomiHost = modelMatchesHost(hostModel, "xiaomi");
+	const isGrok = modelMatchesHost(hostModel, "xai");
+	const isMistral = modelMatchesHost(hostModel, "mistral");
+	const isGoogleAistudioOpenAI = hostMatchesUrl(baseUrl, "googleAistudio");
+	const isOpenAIHost = modelMatchesHost(hostModel, "openai");
+	const isAzureHost = modelMatchesHost(hostModel, "azureOpenAI");
+	const isVercelGateway = modelMatchesHost(hostModel, "vercelAIGateway");
+	const isTogether = modelMatchesHost(hostModel, "together");
+	const isFireworks = hostMatchesUrl(baseUrl, "fireworks");
+	const isGroqHost = modelMatchesHost(hostModel, "groq");
+	const isMiniMaxHost = modelMatchesHost(hostModel, "minimax");
+	const isQwenPortal = modelMatchesHost(hostModel, "qwenPortal");
+	const isMoonshotKimi = facts.is("kimi") && d.isMoonshotNative;
+	const isMoonshotKimiK3 = isMoonshotKimi && facts.family("k3");
+	const usesMoonshotKimiPreservedThinking = isMoonshotKimi && facts.family("k2.6");
+	const isAnthropicModel = modelMatchesHost(hostModel, "anthropic") || facts.is("anthropic");
+	const isQwen = facts.is("qwen");
+	const isDeepseekFamily = modelMatchesHost(hostModel, "deepseekFamily") || facts.is("deepseek");
+	const supportsZaiReasoningEffort = (d.isZai || d.isZhipu) && facts.is("glm") && facts.revGte("5.2");
+	const isNonStandard = isCerebras || isGrok || isMistral || isGoogleAistudioOpenAI || hostMatchesUrl(baseUrl, "chutes") || hostMatchesUrl(baseUrl, "deepseekFamily") || isFireworks || isAlibaba || d.isZai || d.isZhipu || isKilo || isQwen || isXiaomiHost || d.isMoonshotNative || d.isOpenCodeHost;
+	const useMaxTokens = isMistral || d.isMoonshotNative || d.isZai || d.isZhipu || hostMatchesUrl(baseUrl, "chutes") || isFireworks || d.isDirectDeepseekApi;
+	const supportsPromptCacheBreakpoints = isOfficialOpenAIEndpoint(provider, baseUrl) && facts.is("openai") && facts.revGte("5.6");
+	const supportsMultipleSystemMessagesDefault = !isMiniMaxHost && !isAlibaba && !isQwenPortal && !isQwen && (isOpenAIHost || isAzureHost || d.isOpenRouter || isCerebras || isTogether || isFireworks || isGroqHost || isDeepseekFamily || isMistral || isGrok || d.isZai || d.isZhipu || provider === "github-copilot" || provider === "zenmux");
+	const streamIdleTimeoutMs = facts.is("glm") && facts.revGte("5") && !facts.family("vision") && (hostMatchesUrl(baseUrl, "zai") || hostMatchesUrl(baseUrl, "zhipu") || hostMatchesUrl(baseUrl, "opencode")) ? GLM_CODING_PLAN_STREAM_IDLE_TIMEOUT_MS : facts.is("mimo") && hostMatchesUrl(baseUrl, "xiaomi") ? 3e5 : spec.reasoning && facts.is("kimi") && (facts.family("k3") || facts.family("k2.7-code")) && hostMatchesUrl(baseUrl, "moonshotNative") ? 3e5 : spec.reasoning && facts.is("deepseek") && hostMatchesUrl(baseUrl, "deepseekDirect") ? 3e5 : d.isLocalServingBackend ? LOCAL_OPENAI_COMPAT_STREAM_IDLE_TIMEOUT_MS : void 0;
+	const wireModelIdMode = hostMatchesUrl(baseUrl, "openrouter") ? "openrouter" : "raw";
+	const thinkingFormat = facts.is("kimi") && !facts.family("k3") && hostMatchesUrl(baseUrl, "moonshotNative") || hostMatchesUrl(baseUrl, "zai") || hostMatchesUrl(baseUrl, "zhipu") || facts.is("mimo") && hostMatchesUrl(baseUrl, "xiaomi") ? "zai" : hostMatchesUrl(baseUrl, "openrouter") ? "openrouter" : isQwen && hostMatchesUrl(baseUrl, "nvidia") ? "qwen-chat-template" : isQwen && (isFireworks || hostMatchesUrl(baseUrl, "venice")) ? "openai" : hostMatchesUrl(baseUrl, "alibabaDashscope") || isQwen ? "qwen" : "openai";
+	return {
+		supportsStore: !isNonStandard,
+		supportsDeveloperRole: isOpenAIHost || isAzureHost,
+		supportsMultipleSystemMessages: supportsMultipleSystemMessagesDefault,
+		supportsReasoningEffort: !isGrok && !d.isXiaomiMimo && (!(d.isZai || d.isZhipu) || supportsZaiReasoningEffort),
+		supportsReasoningParams: provider !== "github-copilot",
+		supportsSamplingParams: !(facts.is("openai") && (facts.family("o-series") || facts.revGte("5"))),
+		supportsPenaltyAndStopParams: !(isGrok && Boolean(spec.reasoning)),
+		reasoningEffortMap: {},
+		supportsUsageInStreaming: !isCerebrasHost,
+		alwaysSendMaxTokens: facts.is("kimi"),
+		disableReasoningOnForcedToolChoice: !d.isClinePass && (facts.is("kimi") && !isMoonshotKimiK3 || isAnthropicModel),
+		disableReasoningOnToolChoice: !d.isClinePass && isDeepseekFamily && Boolean(spec.reasoning) && !d.isOpenRouter,
+		supportsToolChoice: d.isClinePass || !d.isDirectDeepseekReasoning,
+		supportsForcedToolChoice: !d.requiresEnabledThinking && !(d.isOpenCodeHost && d.isDeepseekReasoning) && !(d.isClinePass && isQwen),
+		supportsNamedToolChoice: true,
+		maxTokensField: useMaxTokens ? "max_tokens" : "max_completion_tokens",
+		requiresToolResultName: isMistral,
+		requiresAssistantAfterToolResult: isMistral,
+		requiresThinkingAsText: isMistral,
+		requiresMistralToolIds: isMistral,
+		thinkingFormat,
+		kimiApiFormat: void 0,
+		reasoningDisableMode: d.isClinePass ? "cline-enabled-false" : d.isVenice ? "venice-disable-thinking" : resolveReasoningDisableMode(thinkingFormat),
+		omitReasoningEffort: false,
+		includeEncryptedReasoning: true,
+		filterReasoningHistory: d.isOpenRouter && isAnthropicModel,
+		thinkingKeep: usesMoonshotKimiPreservedThinking ? "all" : void 0,
+		reasoningContentField: d.isClinePass ? "reasoning" : "reasoning_content",
+		requiresReasoningContentForToolCalls: facts.is("kimi") && !d.isOpenCodeProvider || isDeepseekFamily && Boolean(spec.reasoning) || d.isXiaomiMimo || d.isOpenRouter && Boolean(spec.reasoning),
+		requiresReasoningContentForAllAssistantTurns: (isDeepseekFamily && Boolean(spec.reasoning) || d.isXiaomiMimo) && !d.isOpenRouter,
+		allowsSyntheticReasoningContentForToolCalls: (!isDeepseekFamily || !spec.reasoning) && !d.isXiaomiMimo,
+		replayReasoningContent: d.isLocalOpenAICompatBackend,
+		qwenPreserveThinking: (thinkingFormat === "qwen" || thinkingFormat === "qwen-chat-template") && d.isLocalOpenAICompatBackend,
+		qwenTemplateReasoningEffort: (thinkingFormat === "qwen" || thinkingFormat === "qwen-chat-template") && d.isLocalOpenAICompatBackend && provider !== "ollama" && isQwen && facts.revGte("3.8"),
+		requiresAssistantContentForToolCalls: facts.is("kimi") || d.isDirectDeepseekReasoning,
+		cacheControlFormat: d.isClinePass && (isQwen || isAnthropicModel) || d.isOpenRouter && isAnthropicModel ? "anthropic" : void 0,
+		supportsPromptCacheBreakpoints,
+		promptCacheBreakpointTtl: supportsPromptCacheBreakpoints ? "30m" : void 0,
+		openRouterRouting: void 0,
+		vercelGatewayRouting: void 0,
+		isOpenRouterHost: d.isOpenRouter,
+		wireModelIdMode,
+		isVercelGatewayHost: isVercelGateway,
+		supportsStrictMode: hostMatchesUrl(baseUrl, "openai") || hostMatchesUrl(baseUrl, "azureOpenAI") || hostMatchesUrl(baseUrl, "cerebras") || hostMatchesUrl(baseUrl, "together") || hostMatchesUrl(baseUrl, "openrouter") || hostMatchesUrl(baseUrl, "deepseekFamily"),
+		extraBody: void 0,
+		toolStrictMode: isCerebrasHost ? "all_strict" : "mixed",
+		toolSchemaFlavor: d.isMoonshotNative || facts.is("kimi") ? "moonshot-mfjs" : d.isLocalOpenAICompatBackend ? "grammar" : void 0,
+		streamFirstEventTimeoutMs: d.isLocalServingBackend ? 0 : void 0,
+		streamIdleTimeoutMs,
+		stripDeepseekSpecialTokens: facts.is("deepseek") && (provider === "nvidia" || provider === "deepseek"),
+		streamMarkupHealingPattern: detectStreamMarkupHealing(spec.provider, facts, baseUrl),
+		reasoningDeltasMayBeCumulative: false,
+		emptyLengthFinishIsContextError: false,
+		usesOpenAIToolCallIdLimit: false,
+		promptCacheSessionHeader: hostMatchesUrl(baseUrl, "xai") ? "x-grok-conv-id" : void 0,
+		dropThinkingWhenReasoningEffort: false,
+		nativeKimiK3Reasoning: false,
+		zaiReasoningEffortDialect: false,
+		clampOutputToModelMax: false,
+		stripImageInput: false,
+		thinkingLoopGuard: void 0,
+		rejectRootObjectUnion: false,
+		retryWithoutStrictOnGrammarError: false,
+		supportsPromptCacheKey: false
+	};
+}
+const DSML_HEALING_PROVIDERS = {
+	ollama: true,
+	"ollama-cloud": true,
+	nvidia: true,
+	deepseek: true,
+	fireworks: true,
+	nanogpt: true,
+	"opencode-go": true,
+	openrouter: true
+};
+/**
+* Default leaked-markup healer. Kimi/DeepSeek dedicated grammars are keyed on
+* identity class; official OpenAI heals nothing; everything else defaults to
+* the generic `thinking` healer.
+*/
+function detectStreamMarkupHealing(provider, facts, baseUrl) {
+	const isKimiK2 = facts.is("kimi") && facts.identity.family?.startsWith("k2") === true;
+	if (provider === "kimi-code" || provider === "moonshot" || isKimiK2) return "kimi";
+	if (facts.is("deepseek") && DSML_HEALING_PROVIDERS[provider] === true) return "dsml";
+	if (isOfficialOpenAIEndpoint(provider, baseUrl)) return void 0;
+	return "thinking";
+}
+function fixupOpenAICompat(spec, compat, d, axes) {
+	const deepseekThinking = compat.extraBody?.thinking;
+	if (d.isDirectDeepseekReasoning && typeof deepseekThinking === "object" && deepseekThinking !== null && "type" in deepseekThinking && deepseekThinking.type === "enabled") {
+		const extraBody = { ...compat.extraBody };
+		delete extraBody.thinking;
+		compat.extraBody = Object.keys(extraBody).length > 0 ? extraBody : void 0;
+	}
+	if (spec.compat?.reasoningDisableMode === void 0 && !("reasoningDisableMode" in axes.wire)) compat.reasoningDisableMode = d.isClinePass ? "cline-enabled-false" : d.requiresEnabledThinking ? "omit" : d.isDirectDeepseekReasoning ? "zai-thinking-disabled" : d.isVenice ? "venice-disable-thinking" : resolveReasoningDisableMode(compat.thinkingFormat);
+	if (spec.compat?.omitReasoningEffort === void 0 && !("omitReasoningEffort" in axes.wire) && !compat.supportsReasoningEffort) compat.omitReasoningEffort = true;
+	const axisWhenThinking = spec.reasoning ? objectPayload$1(axes.wire.whenThinking) : void 0;
+	const whenThinkingPolicy = spec.compat?.whenThinking ?? axisWhenThinking ?? (d.isDirectDeepseekReasoning ? { extraBody: {
+		...compat.extraBody,
+		thinking: { type: "enabled" }
+	} } : void 0);
+	if (whenThinkingPolicy) {
+		const variant = {
+			...compat,
+			whenThinking: void 0
+		};
+		applyCompatOverrides(variant, whenThinkingPolicy);
+		if (Reflect.get(whenThinkingPolicy, "reasoningDisableMode") === void 0) variant.reasoningDisableMode = d.isVenice ? "venice-disable-thinking" : resolveReasoningDisableMode(variant.thinkingFormat);
+		if (Reflect.get(whenThinkingPolicy, "omitReasoningEffort") === void 0 && !variant.supportsReasoningEffort) variant.omitReasoningEffort = true;
+		compat.whenThinking = variant;
+	} else compat.whenThinking = void 0;
+}
+function resolveOpenAICompletionsPolicy(spec, facts, axes) {
+	const d = detectOpenAI(spec, facts);
+	const compat = detectOpenAICompat(spec, d);
+	applyWireAxes(compat, axes.wire, "openai-completions");
+	applyCompatOverrides(compat, spec.compat);
+	overlayEffortMapAxis(compat, axes, spec.compat);
+	fixupOpenAICompat(spec, compat, d, axes);
+	return compat;
+}
+/** Detected Responses-API baseline (ported from `buildOpenAIResponsesCompat`). */
+function resolveOpenAIResponsesPolicy(spec, facts, axes, api) {
+	const baseUrl = spec.baseUrl ?? "";
+	const provider = spec.provider;
+	const hostModel = {
+		provider,
+		baseUrl
+	};
+	const isAzure = modelMatchesHost(hostModel, "azureOpenAI");
+	const isOpenRouter = modelMatchesHost(hostModel, "openrouter");
+	const isOpenAIUrl = hostMatchesUrl(baseUrl, "openai");
+	const isVercelGateway = modelMatchesHost(hostModel, "vercelAIGateway");
+	const isXaiHost = modelMatchesHost(hostModel, "xai");
+	const supportsPromptCacheBreakpoints = isOfficialOpenAIEndpoint(provider, baseUrl) && facts.is("openai") && facts.revGte("5.6");
+	const thinkingFormat = isOpenRouter ? "openrouter" : "openai";
+	const reasoningCapable = Boolean(spec.reasoning);
+	const isLocalServingBackend = PROXY_OPENAI_COMPAT_PROVIDERS[provider] !== true && LOCAL_OPENAI_COMPAT_PROVIDERS[provider] === true || hasLocalLoopbackBaseUrl(baseUrl);
+	const isAnthropicModel = facts.is("anthropic");
+	const isDeepseekFamily = facts.is("deepseek");
+	const compat = {
+		supportsDeveloperRole: isAzure || isOpenAIUrl || hostMatchesUrl(baseUrl, "githubCopilot"),
+		supportsStrictMode: isAzure || hostMatchesUrl(baseUrl, "openai") || hostMatchesUrl(baseUrl, "azureOpenAI") || hostMatchesUrl(baseUrl, "cerebras") || hostMatchesUrl(baseUrl, "together") || hostMatchesUrl(baseUrl, "openrouter") || hostMatchesUrl(baseUrl, "deepseekFamily"),
+		supportsReasoningEffort: !isXaiHost,
+		supportsLongPromptCacheRetention: isOpenAIUrl,
+		supportsPromptCacheBreakpoints,
+		promptCacheBreakpointTtl: supportsPromptCacheBreakpoints ? "30m" : void 0,
+		strictResponsesPairing: isAzure || provider === "github-copilot",
+		supportsImageDetailOriginal: !isXaiHost && !modelMatchesHost(hostModel, "githubCopilot"),
+		supportsReasoningSummary: !isXaiHost,
+		supportsAllTurnsReasoningContext: false,
+		supportsConfigurationUpdate: false,
+		requiresReasoningOffJuiceInstruction: false,
+		stripImageInput: false,
+		thinkingLoopGuard: void 0,
+		reasoningEffortMap: {},
+		supportsReasoningParams: true,
+		supportsSamplingParams: !(facts.is("openai") && (facts.family("o-series") || facts.revGte("5"))),
+		supportsPenaltyAndStopParams: !isXaiHost,
+		thinkingFormat,
+		reasoningDisableMode: resolveReasoningDisableMode(thinkingFormat),
+		omitReasoningEffort: false,
+		includeEncryptedReasoning: true,
+		filterReasoningHistory: isOpenRouter && isAnthropicModel,
+		disableReasoningOnForcedToolChoice: facts.is("kimi"),
+		disableReasoningOnToolChoice: isDeepseekFamily && reasoningCapable && !isOpenRouter,
+		supportsToolChoice: true,
+		supportsForcedToolChoice: provider !== "opencode-go" && provider !== "opencode-zen",
+		supportsNamedToolChoice: true,
+		reasoningContentField: "reasoning_content",
+		requiresReasoningContentForToolCalls: (facts.is("kimi") || isDeepseekFamily && reasoningCapable || isOpenRouter && reasoningCapable) && reasoningCapable,
+		requiresReasoningContentForAllAssistantTurns: isDeepseekFamily && reasoningCapable && !isOpenRouter,
+		allowsSyntheticReasoningContentForToolCalls: !isDeepseekFamily || !reasoningCapable,
+		replayReasoningContent: false,
+		qwenPreserveThinking: false,
+		qwenTemplateReasoningEffort: false,
+		requiresThinkingAsText: false,
+		requiresMistralToolIds: false,
+		requiresToolResultName: false,
+		requiresAssistantAfterToolResult: false,
+		requiresAssistantContentForToolCalls: facts.is("kimi"),
+		openRouterRouting: void 0,
+		vercelGatewayRouting: void 0,
+		isOpenRouterHost: isOpenRouter,
+		isVercelGatewayHost: isVercelGateway,
+		wireModelIdMode: isOpenRouter ? "openrouter" : "raw",
+		toolSchemaFlavor: facts.is("kimi") ? "moonshot-mfjs" : void 0,
+		alwaysSendMaxTokens: facts.is("kimi"),
+		clampOutputToModelMax: false,
+		supportsObfuscationOptOut: isOpenAIUrl || provider === "openai",
+		officialEndpoint: isOfficialOpenAIEndpoint(provider, baseUrl),
+		harmonyLeakMitigation: false,
+		rejectRootObjectUnion: false,
+		retryWithoutStrictOnGrammarError: false,
+		cacheControlFormat: isOpenRouter && isAnthropicModel ? "anthropic" : void 0,
+		stripDeepseekSpecialTokens: facts.is("deepseek") && (provider === "nvidia" || provider === "deepseek"),
+		streamMarkupHealingPattern: detectStreamMarkupHealing(provider, facts, baseUrl),
+		reasoningDeltasMayBeCumulative: false,
+		emptyLengthFinishIsContextError: false,
+		usesOpenAIToolCallIdLimit: false,
+		promptCacheSessionHeader: hostMatchesUrl(baseUrl, "xai") ? "x-grok-conv-id" : void 0,
+		streamFirstEventTimeoutMs: isLocalServingBackend ? 0 : spec.compat?.streamFirstEventTimeoutMs,
+		streamIdleTimeoutMs: isLocalServingBackend ? LOCAL_OPENAI_COMPAT_STREAM_IDLE_TIMEOUT_MS : spec.compat?.streamIdleTimeoutMs
+	};
+	applyWireAxes(compat, axes.wire, api);
+	applyCompatOverrides(compat, spec.compat);
+	overlayEffortMapAxis(compat, axes, spec.compat);
+	if (isXaiHost && "reasoningEffortMap" in axes.wire) {
+		const canonical = effortRecord(axes.wire.reasoningEffortMap) ?? {};
+		compat.reasoningEffortMap = {
+			...compat.reasoningEffortMap,
+			...canonical
+		};
+		for (const key of ["xhigh", "max"]) if (!(key in canonical)) delete compat.reasoningEffortMap[key];
+	}
+	if (spec.compat?.reasoningDisableMode === void 0 && !("reasoningDisableMode" in axes.wire)) compat.reasoningDisableMode = resolveReasoningDisableMode(compat.thinkingFormat);
+	if (spec.compat?.omitReasoningEffort === void 0 && !("omitReasoningEffort" in axes.wire) && !compat.supportsReasoningEffort) compat.omitReasoningEffort = true;
+	if (provider === "xai-oauth" && axes.wire.supportsReasoningEffort === true && spec.compat?.supportsReasoningEffort !== false) {
+		compat.supportsReasoningEffort = true;
+		compat.omitReasoningEffort = false;
+	}
+	return compat;
+}
+function pickResponsesOnly(compat) {
+	return {
+		supportsLongPromptCacheRetention: compat.supportsLongPromptCacheRetention,
+		strictResponsesPairing: compat.strictResponsesPairing,
+		supportsImageDetailOriginal: compat.supportsImageDetailOriginal,
+		supportsObfuscationOptOut: compat.supportsObfuscationOptOut,
+		supportsAllTurnsReasoningContext: compat.supportsAllTurnsReasoningContext,
+		supportsConfigurationUpdate: compat.supportsConfigurationUpdate,
+		officialEndpoint: compat.officialEndpoint,
+		harmonyLeakMitigation: compat.harmonyLeakMitigation,
+		cacheControlFormat: compat.cacheControlFormat,
+		requiresReasoningOffJuiceInstruction: compat.requiresReasoningOffJuiceInstruction,
+		supportsReasoningSummary: compat.supportsReasoningSummary,
+		isVercelGatewayHost: compat.isVercelGatewayHost
+	};
+}
+function resolveAnthropicPolicy(spec, facts, axes) {
+	const baseUrl = spec.baseUrl;
+	const official = isOfficialAnthropicApiUrl(baseUrl);
+	const isCopilot = modelMatchesHost(spec, "githubCopilot");
+	const isZenmux = modelMatchesHost(spec, "zenmux");
+	const requiresThinkingEnabled = modelMatchesHost(spec, "moonshotNative") && facts.kimiMandatoryThinking;
+	const isAzure = isAzureAnthropicRoute(baseUrl);
+	const signingEndpoint = official || isCopilot || isZenmux || isAnthropicSigningProxyUrl(baseUrl);
+	const compat = {
+		officialEndpoint: official,
+		signingEndpoint,
+		supportsContextManagement: true,
+		supportsOutputEffort: true,
+		disableStrictTools: isAzure,
+		disableAdaptiveThinking: false,
+		allowAnthropicHeaderOverrides: false,
+		supportsEagerToolInputStreaming: official,
+		supportsLongCacheRetention: official,
+		supportsMidConversationSystem: official && !facts.family("sonnet") && facts.anthropicAdaptiveGenAtLeast("4.8"),
+		supportsTurnScopedSystem: false,
+		supportsMidConversationToolChanges: false,
+		supportsPerMessageEffort: false,
+		supportsThinkingBindingControls: false,
+		supportsForcedToolChoice: !requiresThinkingEnabled && !facts.family("fable", "mythos"),
+		supportsSamplingParams: !facts.anthropicAdaptiveGenAtLeast("4.7"),
+		requiresToolResultId: false,
+		requiresThinkingEnabled,
+		replayUnsignedThinking: !signingEndpoint && (Boolean(spec.reasoning) || modelMatchesHost(spec, "deepseekFamily")),
+		escapeBuiltinToolNames: false,
+		injectClaudeCodeInstruction: true,
+		stripImageInput: false,
+		thinkingLoopGuard: void 0,
+		streamIdleTimeoutMs: spec.compat?.streamIdleTimeoutMs
+	};
+	applyWireAxes(compat, axes.wire, "anthropic-messages");
+	applyCompatOverrides(compat, spec.compat);
+	return compat;
+}
+const BEDROCK_REASONING_STREAM_IDLE_TIMEOUT_MS = 6e5;
+function resolveBedrockPolicy(spec, axes) {
+	const compat = {
+		promptCacheMode: "none",
+		supportsLongPromptCacheRetention: false,
+		promptCacheMinimumTokens: 0,
+		promptCacheMaximumCheckpoints: 0
+	};
+	compat.streamIdleTimeoutMs = spec.reasoning ? BEDROCK_REASONING_STREAM_IDLE_TIMEOUT_MS : void 0;
+	applyWireAxes(compat, axes.wire, "bedrock-converse-stream");
+	applyCompatOverrides(compat, spec.compat);
+	return compat;
+}
+function resolveDevinPolicy(spec, axes) {
+	const compat = {
+		trustExplicitThinkingOnly: true,
+		modelRouter: false,
+		supportsParallelToolCalls: false
+	};
+	applyWireAxes(compat, axes.wire, "devin-agent");
+	applyCompatOverrides(compat, spec.compat);
+	return compat;
+}
+function resolveGooglePolicy(spec, axes) {
+	const compat = {
+		supportsFunctionPartId: false,
+		requiresSkipThoughtSignature: false,
+		requiresSkipThoughtSignatureOnFirstFunctionCall: false,
+		dropUnsignedThinking: false,
+		ccaLegacyParametersSchema: false,
+		multimodalFunctionResponse: false,
+		flashStreamLeakWorkaround: false,
+		claudeThinkingBetaHeader: false,
+		antigravityClaudeToolMode: false,
+		stripImageInput: false
+	};
+	applyWireAxes(compat, axes.wire, spec.api);
+	applyCompatOverrides(compat, spec.compat);
+	return compat;
+}
+const DEFAULT_REASONING_EFFORTS = [
+	"minimal",
+	"low",
+	"medium",
+	"high"
+];
+const DEFAULT_REASONING_EFFORTS_WITH_XHIGH = [...DEFAULT_REASONING_EFFORTS, "xhigh"];
+function omitsWireReasoningEffort(api, compat) {
+	if (api !== "openai-responses" && api !== "openai-codex-responses" && api !== "azure-openai-responses") return false;
+	return compat !== void 0 && "supportsReasoningEffort" in compat && compat.supportsReasoningEffort === false;
+}
+function readCompatEffortMap(compat) {
+	if (compat === void 0 || !("reasoningEffortMap" in compat)) return void 0;
+	const map = compat.reasoningEffortMap;
+	return map && Object.keys(map).length > 0 ? map : void 0;
+}
+/** Host-quirk effort remaps detected outside the rules (URL/API compounds). */
+const FIREWORKS_THINKING_EFFORT_MAP = { ["minimal"]: "none" };
+/** Identity/API-derived default control mode; `thinking-mode` rules override. */
+function defaultThinkingMode(spec, facts) {
+	switch (spec.api) {
+		case "google-generative-ai":
+		case "google-gemini-cli":
+		case "google-vertex": return facts.is("gemini") && facts.revMajor() === 3 ? "google-level" : "budget";
+		case "anthropic-messages":
+			if (facts.is("minimax") && facts.family("m2", "m3")) return "anthropic-adaptive";
+			if (facts.is("glm") && facts.revGte("5.2") && (spec.provider === "umans" || spec.provider === "zai")) return "anthropic-budget-effort";
+			if (facts.is("anthropic")) {
+				if (facts.revGte("4.6") && !facts.family("haiku")) return "anthropic-adaptive";
+				if (facts.family("opus") && facts.revGte("4.5")) return "anthropic-budget-effort";
+			}
+			return "budget";
+		case "bedrock-converse-stream":
+			if (facts.is("anthropic")) {
+				if (facts.anthropicAdaptiveGenAtLeast("4.6")) return "anthropic-adaptive";
+				if (facts.family("opus") && facts.revGte("4.5")) return "anthropic-budget-effort";
+			}
+			if (facts.is("openai")) return "effort";
+			return "budget";
+		default: return "effort";
+	}
+}
+/** API/compat-generic fallback ladder for targets no rule covered. */
+function fallbackEfforts(spec, compat) {
+	if (spec.api === "anthropic-messages") return DEFAULT_REASONING_EFFORTS_WITH_XHIGH;
+	if (spec.api === "bedrock-converse-stream") return DEFAULT_REASONING_EFFORTS;
+	if ((spec.api === "openai-completions" || spec.api === "openrouter") && compat !== void 0 && "thinkingFormat" in compat) {
+		if (compat.thinkingFormat === "openai" && compat.supportsReasoningEffort) return DEFAULT_REASONING_EFFORTS_WITH_XHIGH;
+		return DEFAULT_REASONING_EFFORTS;
+	}
+	if (spec.api === "openai-responses" || spec.api === "openai-codex-responses" || spec.api === "azure-openai-responses") return DEFAULT_REASONING_EFFORTS_WITH_XHIGH;
+	return DEFAULT_REASONING_EFFORTS;
+}
+function filterEffortMap(map, efforts) {
+	let filtered;
+	for (const effort of efforts) {
+		const mapped = map[effort];
+		if (mapped === void 0) continue;
+		filtered ??= {};
+		filtered[effort] = mapped;
+	}
+	return filtered;
+}
+function readRuleThinking(axes) {
+	const raw = axes.thinking;
+	const out = {};
+	const mode = thinkingMode(raw.mode);
+	if (mode !== void 0) out.mode = mode;
+	const efforts = effortList(raw.efforts);
+	if (efforts !== void 0) out.efforts = efforts;
+	const defaultLevel = effortValue(raw.defaultLevel);
+	if (defaultLevel !== void 0) out.defaultLevel = defaultLevel;
+	const effortMap = effortRecord(raw.effortMap);
+	if (effortMap !== void 0) out.effortMap = effortMap;
+	const effortBudgets = effortNumberRecord(raw.effortBudgets);
+	if (effortBudgets !== void 0) out.effortBudgets = effortBudgets;
+	if (typeof raw.requiresEffort === "boolean") out.requiresEffort = raw.requiresEffort;
+	if (typeof raw.suppressWhenOff === "boolean") out.suppressWhenOff = raw.suppressWhenOff;
+	if (typeof raw.supportsDisplay === "boolean") out.supportsDisplay = raw.supportsDisplay;
+	if (typeof raw.prefixBinding === "boolean") out.prefixBinding = raw.prefixBinding;
+	if (typeof raw.upgradeNeutral === "boolean") out.upgradeNeutral = raw.upgradeNeutral;
+	return out;
+}
+/** Identity-derived `requiresEffort` default (mandatory-reasoning lineages). */
+function impliesMandatoryReasoning(facts, modelId) {
+	if (facts.identity.thinkingVariant) return true;
+	if (stripThinkingVariantSuffix(modelId) !== void 0) return true;
+	return false;
+}
+function isQwenTemplateReasoningEffortCompat(compat) {
+	return compat !== void 0 && "qwenTemplateReasoningEffort" in compat && compat.qwenTemplateReasoningEffort === true;
+}
+function resolveThinkingPolicy(spec, facts, axes, compat) {
+	const rule = readRuleThinking(axes);
+	const explicitThinking = spec.thinking !== void 0 && Array.isArray(spec.thinking.efforts) && spec.thinking.efforts.length > 0 ? spec.thinking : void 0;
+	if (!spec.reasoning && (explicitThinking !== void 0 || rule.upgradeNeutral !== true)) return void 0;
+	if (spec.provider === "cline-pass" && compat !== void 0 && "supportsReasoningEffort" in compat && compat.supportsReasoningEffort === false) return;
+	if (omitsWireReasoningEffort(spec.api, compat)) return void 0;
+	if (explicitThinking !== void 0) return fillExplicitThinking(spec, facts, compat, explicitThinking, rule);
+	if (compat !== void 0 && "trustExplicitThinkingOnly" in compat && compat.trustExplicitThinkingOnly === true) return;
+	const config = {
+		mode: rule.mode ?? defaultThinkingMode(spec, facts),
+		efforts: rule.efforts ?? fallbackEfforts(spec, compat)
+	};
+	if (config.efforts.length === 0) throw new Error(`Model ${spec.provider}/${spec.id} resolved to an empty thinking range`);
+	if (rule.defaultLevel !== void 0) config.defaultLevel = rule.defaultLevel;
+	const effortMap = mergeEffortMap(spec, rule.effortMap, compat, config.efforts);
+	if (effortMap !== void 0) config.effortMap = effortMap;
+	if (rule.effortBudgets !== void 0) config.effortBudgets = rule.effortBudgets;
+	if (rule.supportsDisplay ?? defaultSupportsDisplay(spec, facts)) config.supportsDisplay = true;
+	if (rule.prefixBinding) config.prefixBinding = true;
+	if (rule.requiresEffort ?? (impliesMandatoryReasoning(facts, spec.id) || isQwenTemplateReasoningEffortCompat(compat))) config.requiresEffort = true;
+	if (rule.suppressWhenOff) config.suppressWhenOff = true;
+	return config;
+}
+/**
+* Displayable-thinking default: an api-conditioned lineage fact (Anthropic
+* wire dialects streaming adaptive Claude 4.7+ thinking) that KDL cannot
+* express — cascade selectors have no api dimension. `thinking-supports-display`
+* rules override per deployment.
+*/
+function defaultSupportsDisplay(spec, facts) {
+	return (spec.api === "anthropic-messages" || spec.api === "bedrock-converse-stream") && facts.anthropicAdaptiveGenAtLeast("4.7");
+}
+function mergeEffortMap(spec, ruleMap, compat, efforts) {
+	const detected = (spec.api === "openai-completions" || spec.api === "openrouter") && modelMatchesHost({
+		provider: spec.provider,
+		baseUrl: spec.baseUrl ?? ""
+	}, "fireworks") ? FIREWORKS_THINKING_EFFORT_MAP : void 0;
+	const configured = readCompatEffortMap(compat);
+	if (detected === void 0 && ruleMap === void 0 && configured === void 0) return void 0;
+	return filterEffortMap({
+		...detected,
+		...ruleMap,
+		...configured
+	}, efforts);
+}
+/**
+* Backfill missing wire/default fields onto explicit thinking metadata.
+* Explicit spec thinking is layer 4 of the resolution order: its ladder and
+* every explicitly-set field always win; only absent fields are filled from
+* the rules and identity-derived defaults.
+*/
+function fillExplicitThinking(spec, facts, compat, thinking, rule) {
+	const effortMap = thinking.effortMap === void 0 ? mergeEffortMap(spec, rule.effortMap, compat, thinking.efforts) : void 0;
+	const needsDisplay = thinking.supportsDisplay === void 0 && (rule.supportsDisplay ?? defaultSupportsDisplay(spec, facts));
+	const needsRequiresEffort = thinking.requiresEffort === void 0 && (rule.requiresEffort ?? (impliesMandatoryReasoning(facts, spec.id) || isQwenTemplateReasoningEffortCompat(compat)));
+	const needsDefaultLevel = thinking.defaultLevel === void 0 && rule.defaultLevel !== void 0;
+	const needsPrefixBinding = thinking.prefixBinding === void 0 && rule.prefixBinding === true;
+	if (effortMap === void 0 && !needsDisplay && !needsRequiresEffort && !needsDefaultLevel && !needsPrefixBinding) return thinking;
+	const filled = { ...thinking };
+	if (effortMap !== void 0) filled.effortMap = effortMap;
+	if (needsDisplay) filled.supportsDisplay = true;
+	if (needsDefaultLevel && rule.defaultLevel !== void 0) filled.defaultLevel = rule.defaultLevel;
+	if (needsRequiresEffort) filled.requiresEffort = true;
+	if (needsPrefixBinding) filled.prefixBinding = true;
+	return filled;
+}
+function buildResolveTarget(spec, identity) {
+	const target = {
+		provider: spec.provider,
+		api: spec.api,
+		class: identity.class,
+		model: spec.id,
+		reasoning: Boolean(spec.reasoning)
+	};
+	if (identity.family !== void 0) target.family = identity.family;
+	if (identity.revision !== void 0) target.revision = identity.revision;
+	return target;
+}
+function specUsesApi(spec, api) {
+	return spec.api === api;
+}
+function resolveModelPolicy(spec) {
+	const identity = resolveIdentity(spec);
+	const facts = new IdentityFacts(identity);
+	const axes = resolveCascade(buildResolveTarget(spec, identity));
+	let compat;
+	if (specUsesApi(spec, "openrouter")) {
+		const chat = resolveOpenAICompletionsPolicy(spec, facts, axes);
+		const responses = resolveOpenAIResponsesPolicy(spec, facts, axes, "openrouter");
+		compat = {
+			...chat,
+			...pickResponsesOnly(responses)
+		};
+	} else if (specUsesApi(spec, "openai-completions")) compat = resolveOpenAICompletionsPolicy(spec, facts, axes);
+	else if (specUsesApi(spec, "openai-responses") || specUsesApi(spec, "azure-openai-responses") || specUsesApi(spec, "openai-codex-responses")) compat = resolveOpenAIResponsesPolicy(spec, facts, axes, spec.api);
+	else if (specUsesApi(spec, "anthropic-messages")) compat = resolveAnthropicPolicy(spec, facts, axes);
+	else if (specUsesApi(spec, "bedrock-converse-stream")) compat = resolveBedrockPolicy(spec, axes);
+	else if (specUsesApi(spec, "devin-agent")) compat = resolveDevinPolicy(spec, axes);
+	else if (specUsesApi(spec, "google-generative-ai") || specUsesApi(spec, "google-vertex") || specUsesApi(spec, "google-gemini-cli")) compat = resolveGooglePolicy(spec, axes);
+	else compat = void 0;
+	return {
+		identity,
+		compat,
+		thinking: resolveThinkingPolicy(spec, facts, axes, compat),
+		catalog: axes.catalog
+	};
+}
+//#endregion
+//#region node_modules/.pnpm/@oh-my-pi+pi-catalog@18.1.17/node_modules/@oh-my-pi/pi-catalog/src/model-tokenizer.ts
+const MAX_TOKENIZER_CACHE_ENTRIES = 2048;
+const modelTokenizerCache = /* @__PURE__ */ new Map();
+function revisionAtLeast$1(revision, floor) {
+	if (revision === void 0) return false;
+	const parsedRevision = parseRevision(revision);
+	const parsedFloor = parseRevision(floor);
+	return parsedRevision !== void 0 && parsedFloor !== void 0 && compareRevision(parsedRevision, parsedFloor) >= 0;
+}
+function claudeTokenizer(identity) {
+	if (identity.class !== "anthropic") return void 0;
+	if (identity.family === "opus") {
+		if (revisionAtLeast$1(identity.revision, "5")) return "claude-v5";
+		if (revisionAtLeast$1(identity.revision, "4.7")) return "claude-v47";
+		return "claude-v3";
+	}
+	if (identity.family === "sonnet" || identity.family === "fable" || identity.family === "mythos") return revisionAtLeast$1(identity.revision, "5") ? "claude-v5-sonnet" : "claude-v3";
+	return "claude-v3";
+}
+function qwenTokenizer(identity) {
+	return identity.class === "qwen" && revisionAtLeast$1(identity.revision, "3.5") ? "qwen3" : void 0;
+}
+function deepSeekTokenizer(identity) {
+	return identity.class === "deepseek" ? "deepseek-v3" : void 0;
+}
+function kimiTokenizer(identity) {
+	return identity.class === "kimi" ? "kimi-k2" : void 0;
+}
+function glmTokenizer(identity) {
+	return identity.class === "glm" && revisionAtLeast$1(identity.revision, "5") ? "glm5" : void 0;
+}
+/**
+* Resolve the exact locally embedded tokenizer for a canonical model id.
+*
+* This is catalog policy, not a runtime caller heuristic: [`buildModel`](./build.ts)
+* materializes the result as `Model.tokenizer`; consumers read that property.
+*/
+function resolveModelTokenizer(modelId) {
+	const cached = modelTokenizerCache.get(modelId);
+	if (cached !== void 0) return cached ?? void 0;
+	const identity = classifyModel("", bareModelId(modelId), { lenient: true });
+	const tokenizer = claudeTokenizer(identity) ?? qwenTokenizer(identity) ?? deepSeekTokenizer(identity) ?? kimiTokenizer(identity) ?? glmTokenizer(identity);
+	if (modelTokenizerCache.size === MAX_TOKENIZER_CACHE_ENTRIES) modelTokenizerCache.clear();
+	modelTokenizerCache.set(modelId, tokenizer ?? null);
+	return tokenizer;
+}
+//#endregion
+//#region node_modules/.pnpm/@oh-my-pi+pi-catalog@18.1.17/node_modules/@oh-my-pi/pi-catalog/src/pricing.ts
+function nonnegative(value) {
+	return typeof value === "number" && Number.isFinite(value) && value >= 0;
+}
+function isRates(value) {
+	return isRecord(value) && nonnegative(value.input) && nonnegative(value.output) && nonnegative(value.cacheRead) && nonnegative(value.cacheWrite);
+}
+function isLongContext(value) {
+	return isRecord(value) && isRates(value) && typeof value.inputThreshold === "number" && Number.isFinite(value.inputThreshold) && value.inputThreshold > 0 && (value.inputThresholdInclusive === void 0 || typeof value.inputThresholdInclusive === "boolean");
+}
+function isPeakWindow(value) {
+	return isRecord(value) && Array.isArray(value.weekdays) && value.weekdays.length > 0 && value.weekdays.every((day) => Number.isInteger(day) && day >= 0 && day <= 6) && new Set(value.weekdays).size === value.weekdays.length && typeof value.startMinute === "number" && Number.isInteger(value.startMinute) && typeof value.endMinute === "number" && Number.isInteger(value.endMinute) && value.startMinute >= 0 && value.endMinute <= 1440 && value.startMinute < value.endMinute;
+}
+function isEffectiveRate(value) {
+	return isRecord(value) && isRates(value) && typeof value.effectiveFrom === "number" && Number.isSafeInteger(value.effectiveFrom) && Math.abs(value.effectiveFrom) <= 864e13 && (value.longContext === void 0 || isLongContext(value.longContext));
+}
+/** Validate serialized schedules before admitting cached model rows. */
+function isTimeBasedCost(value) {
+	if (!isRecord(value) || !nonnegative(value.offPeakMultiplier) || !Array.isArray(value.peakWindows) || !value.peakWindows.every(isPeakWindow)) return false;
+	if (value.effectiveRates === void 0) return true;
+	if (!Array.isArray(value.effectiveRates) || !value.effectiveRates.every(isEffectiveRate)) return false;
+	const dates = /* @__PURE__ */ new Set();
+	for (const rate of value.effectiveRates) {
+		if (dates.has(rate.effectiveFrom)) return false;
+		dates.add(rate.effectiveFrom);
+	}
+	return true;
+}
+function payload(value, keys, field) {
+	if (!isRecord(value) || Object.keys(value).some((key) => !keys.includes(key))) throw new Error(`Invalid time-based-cost ${field}`);
+	return value;
+}
+function namedEntries(value, field) {
+	if (!isRecord(value)) throw new Error(`Invalid time-based-cost ${field}: expected named objects`);
+	return Object.values(value);
+}
+/** KDL object children are named records; normalize them once while constructing the model. */
+function materializeTimeBasedCost(value) {
+	const source = payload(value, [
+		"offPeakMultiplier",
+		"peakWindows",
+		"effectiveRates"
+	], "schedule");
+	const peakWindows = namedEntries(source.peakWindows, "peak-windows").map((entry) => {
+		const window = payload(entry, [
+			"weekdays",
+			"startMinute",
+			"endMinute"
+		], "peak-window");
+		if (typeof window.weekdays !== "string" || !/^[0-6](,[0-6])*$/.test(window.weekdays)) throw new Error("Invalid time-based-cost weekdays: expected comma-separated UTC weekday numbers");
+		return {
+			...window,
+			weekdays: window.weekdays.split(",").map(Number)
+		};
+	});
+	const effectiveRates = source.effectiveRates === void 0 ? void 0 : namedEntries(source.effectiveRates, "effective-rates").map((entry) => {
+		const rate = payload(entry, [
+			"effectiveFrom",
+			"input",
+			"output",
+			"cacheRead",
+			"cacheWrite",
+			"longContext"
+		], "effective-rate");
+		const date = rate.effectiveFrom;
+		if (typeof date !== "string" || !/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d{3})?Z$/.test(date)) throw new Error("Invalid time-based-cost effective-from: expected an ISO UTC timestamp");
+		const effectiveFrom = Date.parse(date);
+		if (!Number.isFinite(effectiveFrom) || new Date(effectiveFrom).toISOString() !== (date.includes(".") ? date : date.replace("Z", ".000Z"))) throw new Error("Invalid time-based-cost effective-from: invalid UTC date");
+		if (rate.longContext !== void 0) payload(rate.longContext, [
+			"inputThreshold",
+			"inputThresholdInclusive",
+			"input",
+			"output",
+			"cacheRead",
+			"cacheWrite"
+		], "long-context");
+		return {
+			...rate,
+			effectiveFrom
+		};
+	});
+	const schedule = {
+		offPeakMultiplier: source.offPeakMultiplier,
+		peakWindows,
+		...effectiveRates && { effectiveRates }
+	};
+	if (!isTimeBasedCost(schedule)) throw new Error("Invalid time-based-cost schedule: invalid windows, rates, or multiplier");
+	return schedule;
+}
+//#endregion
+//#region node_modules/.pnpm/@oh-my-pi+pi-catalog@18.1.17/node_modules/@oh-my-pi/pi-catalog/src/build.ts
+/**
+* The single Model constructor. Resolution runs through the compat engine
+* (`compat/resolve`): identity classification, cascade-rule axes, host
+* detection, and spec overrides materialize exactly once per spec.
+*
+* Request handlers read fields — they never detect, parse ids, or allocate
+* compat per request.
+*/
+function numberField(source, key) {
+	const value = Reflect.get(source, key);
+	return typeof value === "number" ? value : void 0;
+}
+/** Narrow an unknown compiled-axis payload to an object payload. */
+function objectPayload(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+}
+/** Narrow a compiled `input-modalities` axis value to the model input union. */
+function isInputModalities(value) {
+	return Array.isArray(value) && value.every((entry) => entry === "text" || entry === "image");
+}
+/**
+* Applies resolved catalog-data axes onto the model: reviewed metadata
+* corrections (`cost-patch`, `limits-patch`, `long-context-cost`,
+* `context-window-floor`) overwrite upstream values; selection metadata
+* (`priority`, `apply-patch-tool-type`, `service-tier-cost`,
+* `requires-cursor-tool-schema-projection`) is rule-owned;
+* `context-promotion-target` fills only when the spec left it unset.
+*/
+function applyCatalogAssignments(model, catalog) {
+	const serviceTierCost = objectPayload(catalog.serviceTierCost);
+	if (serviceTierCost !== void 0) {
+		const flex = numberField(serviceTierCost, "flex");
+		const priorityTier = numberField(serviceTierCost, "priority");
+		model.serviceTierCost = {
+			...flex !== void 0 && { flex },
+			...priorityTier !== void 0 && { priority: priorityTier }
+		};
+	}
+	const priority = catalog.priority;
+	if (typeof priority === "number") model.priority = priority;
+	const applyPatchToolType = catalog.applyPatchToolType;
+	if (applyPatchToolType === "freeform" || applyPatchToolType === "function") model.applyPatchToolType = applyPatchToolType;
+	const editPromptVariant = catalog.editPromptVariant;
+	if (editPromptVariant === "full" || editPromptVariant === "compact") model.editPromptVariant = editPromptVariant;
+	if (catalog.requiresCursorToolSchemaProjection === true) model.requiresCursorToolSchemaProjection = true;
+	else delete model.requiresCursorToolSchemaProjection;
+	const contextPromotionTarget = catalog.contextPromotionTarget;
+	if (typeof contextPromotionTarget === "string" && model.contextPromotionTarget === void 0) model.contextPromotionTarget = contextPromotionTarget;
+}
+/**
+* Applies reviewed catalog-data value corrections (`cost-patch`,
+* `limits-patch`, `long-context-cost`, `context-window-floor`,
+* `input-modalities`) onto an upstream-sourced spec. Applied by
+* `buildModel` to every upstream-sourced spec; user-authored overrides are
+* recomposed after building by the override applicators, so explicit user
+* limits and pricing still win.
+*/
+function applyCatalogCorrections(model, catalog) {
+	const longContext = objectPayload(catalog.longContext);
+	if (longContext !== void 0) {
+		const inputThreshold = numberField(longContext, "inputThreshold");
+		const inclusive = Reflect.get(longContext, "inputThresholdInclusive") === true;
+		const multiplier = numberField(longContext, "multiplier");
+		const input = numberField(longContext, "input");
+		const output = numberField(longContext, "output");
+		const cacheRead = numberField(longContext, "cacheRead");
+		const cacheWrite = numberField(longContext, "cacheWrite");
+		const base = model.cost;
+		const hasTokenPrice = base.input !== 0 || base.output !== 0 || base.cacheRead !== 0 || base.cacheWrite !== 0;
+		if (inputThreshold !== void 0 && multiplier !== void 0 && hasTokenPrice) model.cost = {
+			...base,
+			longContext: {
+				inputThreshold,
+				...inclusive && { inputThresholdInclusive: true },
+				input: base.input * multiplier,
+				output: base.output * multiplier,
+				cacheRead: base.cacheRead * multiplier,
+				cacheWrite: base.cacheWrite * multiplier
+			}
+		};
+		else if (inputThreshold !== void 0 && input !== void 0 && output !== void 0 && cacheRead !== void 0 && cacheWrite !== void 0) model.cost = {
+			...model.cost,
+			longContext: {
+				inputThreshold,
+				input,
+				output,
+				cacheRead,
+				cacheWrite
+			}
+		};
+	}
+	const patch = objectPayload(catalog.costPatch);
+	if (patch !== void 0) {
+		model.cost = { ...model.cost };
+		const input = numberField(patch, "input");
+		if (input !== void 0) model.cost.input = input;
+		const output = numberField(patch, "output");
+		if (output !== void 0) model.cost.output = output;
+		const cacheRead = numberField(patch, "cacheRead");
+		if (cacheRead !== void 0) model.cost.cacheRead = cacheRead;
+		const cacheWrite = numberField(patch, "cacheWrite");
+		if (cacheWrite !== void 0) model.cost.cacheWrite = cacheWrite;
+	}
+	if (catalog.timeBased !== void 0) model.cost = {
+		...model.cost,
+		timeBased: materializeTimeBasedCost(catalog.timeBased)
+	};
+	const limitsPatch = objectPayload(catalog.limitsPatch);
+	if (limitsPatch !== void 0) {
+		const contextWindow = numberField(limitsPatch, "contextWindow");
+		if (contextWindow !== void 0) model.contextWindow = contextWindow;
+		const maxTokens = numberField(limitsPatch, "maxTokens");
+		if (maxTokens !== void 0) model.maxTokens = maxTokens;
+	}
+	const contextWindowFloor = catalog.contextWindowFloor;
+	if (typeof contextWindowFloor === "number") model.contextWindow = Math.max(model.contextWindow ?? 0, contextWindowFloor);
+	const inputModalities = catalog.inputModalities;
+	if (isInputModalities(inputModalities)) model.input = inputModalities;
+}
+/**
+* Direct first-party OpenAI Responses endpoints (api.openai.com, Azure OpenAI
+* deployments). Gates GA computer-use detection; identity supplies the model
+* generation.
+*/
+function isDirectOpenAIResponsesEndpoint(spec) {
+	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.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) {
+	if (!("supportsComputerUseConfig" in spec)) return spec.supportsComputerUse;
+	const value = Reflect.get(spec, "supportsComputerUseConfig");
+	return typeof value === "boolean" ? value : void 0;
+}
+function revisionAtLeast(identity, major, minor) {
+	if (identity.revision === void 0) return false;
+	const [revMajor = 0, revMinor = 0] = identity.revision.split(".").map(Number);
+	return revMajor > major || revMajor === major && revMinor >= minor;
+}
+function supportsOpenAIGAComputerUse(spec, identity, explicitSupport) {
+	if (explicitSupport !== void 0) return explicitSupport;
+	if (!isDirectOpenAIResponsesEndpoint(spec)) return false;
+	const wireIdentity = spec.requestModelId === void 0 ? identity : resolveModelPolicy({
+		...spec,
+		id: spec.requestModelId
+	}).identity;
+	return wireIdentity.class === "openai" && revisionAtLeast(wireIdentity, 5, 4);
+}
+/**
+* Build one model from an authored spec. Bundled models.json rows are fully
+* materialized by the generator and consumed directly (see `models.ts`), so
+* this only runs for discovered/custom/override specs.
+*/
+function buildModel(spec) {
+	const policy = resolveModelPolicy(spec);
+	const supportsComputerUseConfig = explicitComputerUseConfig(spec);
+	const model = {
+		...spec,
+		reasoning: spec.reasoning || policy.thinking !== void 0,
+		name: cleanModelName(spec.name),
+		identity: policy.identity,
+		requiresGlyphTokenization: policy.identity.class === "anthropic",
+		tokenizer: spec.tokenizer ?? resolveModelTokenizer(spec.requestModelId ?? spec.id),
+		thinking: policy.thinking,
+		supportsComputerUse: supportsOpenAIGAComputerUse(spec, policy.identity, supportsComputerUseConfig),
+		supportsComputerUseConfig,
+		compat: policy.compat,
+		compatConfig: spec.compat
+	};
+	applyCatalogAssignments(model, policy.catalog);
+	applyCatalogCorrections(model, policy.catalog);
+	return model;
+}
+//#endregion
+//#region node_modules/.pnpm/@oh-my-pi+pi-catalog@18.1.17/node_modules/@oh-my-pi/pi-catalog/src/compat/types.ts
+/**
+* Revision placeholder in a templated `variant-family` (`gemini-{rev}-flash`).
+* A family whose id carries it is instantiated once per live revision that
+* discovery advertises, so new generations of a lineage collapse without a
+* new reviewed entry.
+*/
+const REVISION_PLACEHOLDER = "{rev}";
+//#endregion
+//#region node_modules/.pnpm/@oh-my-pi+pi-catalog@18.1.17/node_modules/@oh-my-pi/pi-catalog/src/compat/collapse.ts
+const VARIANT_ROUTING_KEYS = ["off", ...THINKING_EFFORTS];
+const DEFAULT_PAIR_EFFORTS = [
+	"minimal",
+	"low",
+	"medium",
+	"high"
+];
+/**
+* Build one effort-tier family from a tier→wire-id map: routing keeps only the
+* listed efforts, `members` dedupes the targets in tier order, and thinking is
+* `mode: "effort"` (mandatory when the family has no `off` route). Shared by the
+* Devin and Cursor tables, whose per-effort siblings follow the same shape.
+*/
+function tierFamily(id, name, routes, efforts, defaultMember) {
+	const routing = {};
+	if (routes.off) routing.off = routes.off;
+	for (const effort of efforts) switch (effort) {
+		case "minimal":
+			if (routes.minimal) routing[effort] = routes.minimal;
+			break;
+		case "low":
+			if (routes.low) routing[effort] = routes.low;
+			break;
+		case "medium":
+			if (routes.medium) routing[effort] = routes.medium;
+			break;
+		case "high":
+			if (routes.high) routing[effort] = routes.high;
+			break;
+		case "xhigh":
+			if (routes.xhigh) routing[effort] = routes.xhigh;
+			break;
+		case "max": if (routes.max) routing[effort] = routes.max;
+	}
+	return {
+		id,
+		name,
+		members: [
+			routes.off,
+			routes.minimal,
+			routes.low,
+			routes.medium,
+			routes.high,
+			routes.xhigh,
+			routes.max
+		].filter((member, index, items) => typeof member === "string" && items.indexOf(member) === index),
+		routing,
+		thinking: {
+			mode: "effort",
+			efforts,
+			...routes.off ? void 0 : { requiresEffort: true }
+		},
+		...defaultMember !== void 0 ? { defaultMember } : void 0
+	};
+}
+/** One reviewed family from the compiled collapse vocabulary → runtime shape. */
+function compiledFamily(compiled) {
+	const family = {
+		id: compiled.id,
+		name: compiled.name,
+		members: compiled.members,
+		routing: compiled.routing
+	};
+	if (compiled.defaultMember !== void 0) family.defaultMember = compiled.defaultMember;
+	if (compiled.retiredMembers?.length) family.retiredMembers = compiled.retiredMembers;
+	if (!compiled.noThinking && compiled.mode !== void 0) family.thinking = {
+		mode: compiled.mode,
+		efforts: compiled.efforts ?? [],
+		...compiled.effortBudgets !== void 0 && { effortBudgets: compiled.effortBudgets },
+		...compiled.defaultLevel !== void 0 && { defaultLevel: compiled.defaultLevel },
+		...compiled.requiresEffort === true && { requiresEffort: true }
+	};
+	if (compiled.suppressWhenOff) family.suppressWhenOff = true;
+	if (compiled.preserveAbsentEffortRoutes) family.preserveAbsentEffortRoutes = true;
+	if (compiled.extraAliases?.length) family.extraAliases = compiled.extraAliases;
+	return family;
+}
+const REVISION_CAPTURE = String.raw`(\d+(?:\.\d+){0,2})`;
+/** One compiled `{rev}` family → runtime template with its id matcher. */
+function compiledTemplate(compiled) {
+	const family = compiledFamily(compiled);
+	const alternatives = [
+		family.id,
+		...family.members,
+		...family.extraAliases ?? []
+	].map((id) => id.split(REVISION_PLACEHOLDER).map((part) => part.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join(REVISION_CAPTURE));
+	const template = {
+		family,
+		pattern: new RegExp(`^(?:${alternatives.join("|")})$`, "i")
+	};
+	if (compiled.revision !== void 0) {
+		const terms = parseRevisionConstraint(compiled.revision);
+		if (terms !== void 0) template.revision = terms;
+	}
+	return template;
+}
+/** Substitute the placeholder throughout one templated family. */
+function instantiateTemplate(template, rev) {
+	if (template.revision !== void 0) {
+		const parsed = parseRevision(rev);
+		if (parsed === void 0 || !revisionSatisfies(parsed, template.revision)) return void 0;
+	}
+	const fill = (id) => id.replaceAll(REVISION_PLACEHOLDER, rev);
+	const source = template.family;
+	const routing = {};
+	for (const effort of VARIANT_ROUTING_KEYS) {
+		const target = source.routing[effort];
+		if (target !== void 0) routing[effort] = fill(target);
+	}
+	const family = {
+		...source,
+		id: fill(source.id),
+		name: fill(source.name),
+		members: source.members.map(fill),
+		routing
+	};
+	if (source.defaultMember !== void 0) family.defaultMember = fill(source.defaultMember);
+	if (source.retiredMembers !== void 0) family.retiredMembers = source.retiredMembers.map(fill);
+	if (source.extraAliases !== void 0) family.extraAliases = source.extraAliases.map(fill);
+	return family;
+}
+/**
+* The family a template yields for `id` (logical id, member, or alias), or
+* undefined when no template matches or the revision is out of range.
+*/
+function templateFamilyFor(templates, id) {
+	for (const template of templates) {
+		const match = template.pattern.exec(id);
+		if (match === null) continue;
+		let rev;
+		for (let group = 1; group < match.length && rev === void 0; group++) rev = match[group];
+		if (rev === void 0) continue;
+		const family = instantiateTemplate(template, rev);
+		if (family !== void 0) return family;
+	}
+}
+/**
+* Concrete families for every revision present in `ids`, one per
+* instantiated id, skipping ids a concrete family in `table` already owns.
+*/
+function instantiateTemplates(table, ids) {
+	const templates = table.templates;
+	if (templates === void 0 || templates.length === 0) return [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const family of table.families) seen.add(family.id);
+	const out = [];
+	for (const id of ids) {
+		const family = templateFamilyFor(templates, id);
+		if (family === void 0 || seen.has(family.id)) continue;
+		seen.add(family.id);
+		out.push(family);
+	}
+	return out;
+}
+/** Provider id → reviewed collapse table, built once from the compiled vocabulary. */
+function buildCompiledTables() {
+	const { variantFamilies, providerAliases } = collapseVocabulary();
+	const tables = {};
+	for (const compiled of variantFamilies) {
+		const table = tables[compiled.provider] ??= { families: [] };
+		if (compiled.id.includes("{rev}")) (table.templates ??= []).push(compiledTemplate(compiled));
+		else table.families.push(compiledFamily(compiled));
+	}
+	for (const [provider, aliases] of Object.entries(providerAliases)) {
+		tables[provider] ??= { families: [] };
+		tables[provider].providerAliases = aliases;
+	}
+	return tables;
+}
+const CURSOR_TIER_ID_PATTERN = /^(.+?)-(extra-high|none|minimal|low|medium|high|xhigh|max)(-fast)?$/;
+const CURSOR_TIER_BASE_PATTERN = /-(extra-high|none|minimal|low|medium|high|xhigh|max)$/;
+const CURSOR_THINKING_TOKEN_PATTERN = /(^|-)thinking($|-)/;
+const CURSOR_TIER_BY_TOKEN = {
+	none: "none",
+	minimal: "minimal",
+	low: "low",
+	medium: "medium",
+	high: "high",
+	"extra-high": "xhigh",
+	xhigh: "xhigh",
+	max: "max"
+};
+/** Whether an existing logical row already routes every live member in `members`. */
+function collapsedCursorLogicalMatches(spec, members) {
+	const routing = spec.thinking?.effortRouting;
+	if (!routing) return false;
+	for (const member of members) {
+		if (spec.requestModelId === member.spec.id) continue;
+		let matched = false;
+		for (const effort of VARIANT_ROUTING_KEYS) if (routing[effort] === member.spec.id) {
+			matched = true;
+			break;
+		}
+		if (!matched) return false;
+	}
+	return true;
+}
+/**
+* Derive safe Cursor per-effort families from live wire ids. A family is
+* intentionally left expanded when its base is an independent live SKU, any
+* member already has a thinking ladder, member metadata differs, or a tier
+* token is also part of a product name.
+*/
+function deriveCursorEffortFamilies(specs) {
+	const byId = /* @__PURE__ */ new Map();
+	const groups = /* @__PURE__ */ new Map();
+	const candidateBases = /* @__PURE__ */ new Set();
+	for (const spec of specs) {
+		if (!byId.has(spec.id)) byId.set(spec.id, spec);
+		const match = CURSOR_TIER_ID_PATTERN.exec(spec.id);
+		if (!match) continue;
+		const baseId = match[1];
+		const tier = CURSOR_TIER_BY_TOKEN[match[2] ?? ""];
+		const fast = match[3] !== void 0;
+		if (!baseId || !tier) continue;
+		const member = {
+			baseId,
+			fast,
+			spec,
+			tier
+		};
+		const key = `${baseId}\0${fast ? "fast" : "standard"}`;
+		const group = groups.get(key);
+		if (group) group.push(member);
+		else groups.set(key, [member]);
+		candidateBases.add(baseId);
+	}
+	const unsafeBases = /* @__PURE__ */ new Set();
+	for (const group of groups.values()) {
+		const first = group[0];
+		if (!first) continue;
+		const { baseId } = first;
+		const standardGroup = groups.get(`${baseId}\0standard`) ?? [];
+		const standardBase = byId.get(baseId);
+		const laneBase = byId.get(`${baseId}${first.fast ? "-fast" : ""}`);
+		const independentStandardBase = standardBase !== void 0 && !collapsedCursorLogicalMatches(standardBase, standardGroup);
+		const independentLaneBase = laneBase !== void 0 && !collapsedCursorLogicalMatches(laneBase, group);
+		if (independentStandardBase || independentLaneBase || new Set(group.map((member) => member.tier)).size !== group.length || CURSOR_TIER_BASE_PATTERN.test(baseId) || CURSOR_THINKING_TOKEN_PATTERN.test(baseId) || candidateBases.has(`${baseId}-thinking`) || byId.has(`${baseId}-thinking`) || byId.has(`${baseId}-thinking-fast`) || byId.has(`${baseId}-fast-thinking`) || group.some((member) => member.spec.thinking !== void 0 || member.spec.requestModelId !== void 0) || group.some((member) => candidateBases.has(`${baseId}-${member.tier}`))) unsafeBases.add(baseId);
+	}
+	const families = [];
+	for (const group of groups.values()) {
+		const first = group[0];
+		if (!first || group.length < 2 || unsafeBases.has(first.baseId)) continue;
+		if (group.some((member) => member.spec.api !== first.spec.api || member.spec.baseUrl !== first.spec.baseUrl || member.spec.contextWindow !== first.spec.contextWindow || member.spec.maxTokens !== first.spec.maxTokens || member.spec.cursorMaxMode !== first.spec.cursorMaxMode || !Bun.deepEquals(member.spec.cost, first.spec.cost) || !Bun.deepEquals(member.spec.compat, first.spec.compat))) continue;
+		const routes = {};
+		for (const member of group) if (member.tier === "none") routes.off = member.spec.id;
+		else routes[member.tier] = member.spec.id;
+		const efforts = THINKING_EFFORTS.filter((effort) => routes[effort] !== void 0);
+		if (efforts.length === 0) continue;
+		const strippedName = first.spec.name.replace(/\s+(extra-high|none|minimal|low|medium|high|xhigh|max)(\s+fast)?$/i, "").trim();
+		const baseName = strippedName === first.spec.id ? first.baseId : strippedName || first.baseId;
+		const suffix = first.fast ? "-fast" : "";
+		families.push(tierFamily(`${first.baseId}${suffix}`, `${baseName}${first.fast ? " Fast" : ""}`, routes, efforts));
+	}
+	return families;
+}
+/** Provider id → reviewed collapse table. The CCA providers diverge on thinking transport. */
+const REVIEWED_COLLAPSE_TABLES = buildCompiledTables();
+/**
+* Return the reviewed collapse table compiled for `provider`, when declared.
+* Discovery uses this accessor to preserve injectable table seams.
+*/
+function reviewedCollapseTable(provider) {
+	return REVIEWED_COLLAPSE_TABLES[provider] ?? REVIEWED_COLLAPSE_TABLES[provider.toLowerCase()];
+}
+/**
+* The global automatic rule: derive an `X` + `X-thinking` family for every
+* pair where both ids are live in `specs` (trailing or infix token). Gates:
+* - both members share the same `api`,
+* - known pricing must match — all-zero cost rows count as unknown
+*   (aggregators routinely ship them), but twins that BOTH carry real,
+*   differing prices are distinct SKUs and never merge,
+* - ids claimed by the provider's reviewed table are skipped (curation wins).
+* The capability surface prefers the thinking member's metadata, then the
+* bare member's, then the canonical deriver (aggregators often ship
+* `reasoning: false` and no thinking config on the twin), then a budget
+* default. `off` routes to the bare id; every supported effort routes to the
+* thinking id.
+*/
+function deriveThinkingPairFamilies(specs, table, provider) {
+	const byId = /* @__PURE__ */ new Map();
+	for (const spec of specs) if (!byId.has(spec.id)) byId.set(spec.id, spec);
+	const claimed = table ? getAliasIndex(table) : void 0;
+	const families = [];
+	for (const spec of specs) {
+		const collapsed = provider === void 0 ? void 0 : collapseVariantId(provider, spec.id);
+		const baseId = collapsed?.thinkingVariant ? collapsed.logicalId : stripThinkingVariantSuffix(spec.id);
+		if (baseId === void 0 || baseId === spec.id) continue;
+		const base = byId.get(baseId);
+		if (!base) continue;
+		if (claimed && (claimed.resolve(spec.id) !== void 0 || claimed.resolve(baseId) !== void 0 || claimed.isFamily(spec.id) || claimed.isFamily(baseId))) continue;
+		if (spec.api !== base.api) continue;
+		const specPriced = spec.cost.input !== 0 || spec.cost.output !== 0;
+		const basePriced = base.cost.input !== 0 || base.cost.output !== 0;
+		if (specPriced && basePriced && (spec.cost.input !== base.cost.input || spec.cost.output !== base.cost.output || spec.cost.cacheRead !== base.cost.cacheRead || spec.cost.cacheWrite !== base.cost.cacheWrite)) continue;
+		const surface = derivePairThinkingSurface(spec, base);
+		const routing = { off: base.id };
+		for (const effort of surface.efforts) routing[effort] = spec.id;
+		families.push({
+			id: base.id,
+			name: base.name,
+			members: [base.id, spec.id],
+			routing,
+			thinking: surface
+		});
+	}
+	return families;
+}
+function derivePairThinkingSurface(thinkingSpec, baseSpec) {
+	const baked = thinkingSpec.thinking ?? baseSpec.thinking;
+	if (baked && baked.efforts.length > 0) {
+		const { effortRouting: _routing, suppressWhenOff: _suppress, requiresEffort: _required, ...surface } = baked;
+		return surface;
+	}
+	const { compat: _compat, ...policySpec } = thinkingSpec;
+	const derived = resolveModelPolicy({
+		...policySpec,
+		reasoning: true,
+		thinking: void 0
+	}).thinking;
+	if (derived && derived.efforts.length > 0) {
+		const { effortRouting: _dRouting, suppressWhenOff: _dSuppress, requiresEffort: _dRequired, ...surface } = derived;
+		return surface;
+	}
+	return {
+		mode: "budget",
+		efforts: DEFAULT_PAIR_EFFORTS
+	};
+}
+/**
+* Re-point a stale collapsed spec whose `requestModelId` or routing still
+* targets a retired wire id. Collapsed snapshots (bundled catalog, cache
+* rows, previous-generation fallbacks) pass through collapsing untouched, so
+* a reviewed-table routing fix would otherwise never reach them. Only retired
+* targets are rewritten — presence-filtered routing decisions from live
+* discovery stay authoritative for everything else. Per retired entry the
+* table's route for that effort wins, then the off/first-live-member wire id,
+* then the route is dropped (falls back to `requestModelId ?? id`). Returns
+* `spec` by reference when nothing targets a retired id.
+*/
+function reconcileRetiredRouting(spec, family, retired) {
+	const currentThinking = spec.thinking;
+	const routing = currentThinking?.effortRouting;
+	const requestRetired = spec.requestModelId !== void 0 && retired.has(spec.requestModelId);
+	let routingRetired = false;
+	if (routing !== void 0) for (const key of VARIANT_ROUTING_KEYS) {
+		const target = routing[key];
+		if (target !== void 0 && retired.has(target)) {
+			routingRetired = true;
+			break;
+		}
+	}
+	if (!requestRetired && !routingRetired) return spec;
+	const offTarget = family.routing.off;
+	const fallbackWireId = offTarget !== void 0 && !retired.has(offTarget) ? offTarget : family.members.find((id) => !retired.has(id));
+	const next = { ...spec };
+	if (routingRetired && routing !== void 0 && currentThinking !== void 0) {
+		const nextRouting = {};
+		for (const effortKey of VARIANT_ROUTING_KEYS) {
+			const target = routing[effortKey];
+			if (target === void 0) continue;
+			if (!retired.has(target)) {
+				nextRouting[effortKey] = target;
+				continue;
+			}
+			const tableTarget = family.routing[effortKey];
+			if (tableTarget !== void 0 && !retired.has(tableTarget)) nextRouting[effortKey] = tableTarget;
+			else if (fallbackWireId !== void 0) nextRouting[effortKey] = fallbackWireId;
+		}
+		next.thinking = {
+			...currentThinking,
+			effortRouting: nextRouting
+		};
+	}
+	if (requestRetired) {
+		if (fallbackWireId !== void 0 && fallbackWireId !== spec.id) next.requestModelId = fallbackWireId;
+		else delete next.requestModelId;
+	}
+	return next;
+}
+/**
+* Refresh a collapsed snapshot's thinking surface in place. Bundled catalog and
+* prev-generation snapshots freeze a family's transport, budgets, and routing;
+* discovery emits the canonical id but the exact-id merge never overwrites a
+* stale `family.id` row (e.g. `gemini-3.1-pro`) nor a recycled `extraAliases`
+* row (e.g. `gemini-3-flash`). This re-applies the reviewed-table family's thinking,
+* routing, and default wire id while keeping the spec id (load-bearing for exact
+* selectors and bundled lookups). Returns `spec` by reference when unchanged.
+*/
+function refreshCollapsedThinking(spec, family, retired) {
+	const familyThinking = family.thinking;
+	if (!spec.reasoning || familyThinking?.effortBudgets === void 0) return spec;
+	const routing = {};
+	let hasRouting = false;
+	for (const effortKey of VARIANT_ROUTING_KEYS) {
+		const target = family.routing[effortKey];
+		if (target !== void 0 && !retired?.has(target)) {
+			routing[effortKey] = target;
+			hasRouting = true;
+		}
+	}
+	const thinking = { ...familyThinking };
+	if (hasRouting) thinking.effortRouting = routing;
+	if (family.suppressWhenOff) thinking.suppressWhenOff = true;
+	const offTarget = family.routing.off;
+	const requestModelId = offTarget !== void 0 && !retired?.has(offTarget) && offTarget !== spec.id ? offTarget : spec.requestModelId;
+	if (Bun.deepEquals(thinking, spec.thinking) && requestModelId === spec.requestModelId) return spec;
+	return {
+		...spec,
+		thinking,
+		...requestModelId !== void 0 ? { requestModelId } : {}
+	};
+}
+/**
+* Re-point a collapsed snapshot's default wire id to the family's declared
+* {@link EffortVariantFamily.defaultMember} when the snapshot still advertises a
+* different default. Bundled catalog and cache rows freeze `requestModelId` from
+* before a family gained a preferred default (Cursor Grok 4.5/4.6 → `-medium`),
+* and neither the existing-collapsed pass-through nor `refreshCollapsedThinking`
+* (scoped to `effortBudgets` families) would otherwise correct them — leaving an
+* effort-less request clamped to the refused `-low` tier (issue #9478). Only
+* re-points when the target is a live route in the snapshot's own
+* `effortRouting`. Returns `spec` by reference when unchanged.
+*/
+function reconcileDefaultMember(spec, family, presentMembers) {
+	const defaultMember = family.defaultMember;
+	if (defaultMember === void 0 || defaultMember === spec.id) return spec;
+	const target = presentMembers === void 0 || presentMembers.has(defaultMember) ? defaultMember : family.members.find((id) => presentMembers.has(id));
+	if (target === void 0 || spec.requestModelId === target) return spec;
+	const routing = spec.thinking?.effortRouting;
+	if (routing === void 0) return spec;
+	for (const key of VARIANT_ROUTING_KEYS) if (routing[key] === target) return {
+		...spec,
+		requestModelId: target
+	};
+	return spec;
+}
+/**
+* Collapse every family in `table` found in `specs`. Non-member specs pass
+* through verbatim (by reference), order preserved; the collapsed spec
+* replaces the first occurrence of its family.
+*/
+function collapseWithTable(specs, table) {
+	const byId = /* @__PURE__ */ new Map();
+	for (const spec of specs) if (!byId.has(spec.id)) byId.set(spec.id, spec);
+	/** family id → spec to emit at the family's first occurrence. */
+	const replacement = /* @__PURE__ */ new Map();
+	/** spec ids that belong to a touched family (members + logical id). */
+	const familyIdBySpecId = /* @__PURE__ */ new Map();
+	const instantiated = instantiateTemplates(table, byId.keys());
+	const families = instantiated.length === 0 ? table.families : [...table.families, ...instantiated];
+	for (const family of families) {
+		const retired = family.retiredMembers !== void 0 && family.retiredMembers.length > 0 ? new Set(family.retiredMembers) : void 0;
+		const existing = byId.get(family.id);
+		const existingCollapsed = existing !== void 0 && (existing.requestModelId !== void 0 || existing.thinking?.effortRouting !== void 0);
+		const reconciled = existing !== void 0 && existingCollapsed && retired !== void 0 ? reconcileRetiredRouting(existing, family, retired) : existing;
+		const rawPresent = family.members.filter((id) => byId.has(id) && !(id === family.id && existingCollapsed));
+		if (rawPresent.length === 0) {
+			const refreshed = existing !== void 0 && existingCollapsed ? reconcileDefaultMember(refreshCollapsedThinking(reconciled ?? existing, family, retired), family) : reconciled;
+			if (refreshed !== void 0 && refreshed !== existing) {
+				familyIdBySpecId.set(family.id, family.id);
+				replacement.set(family.id, refreshed);
+			}
+			continue;
+		}
+		for (const id of rawPresent) familyIdBySpecId.set(id, family.id);
+		if (existing) familyIdBySpecId.set(family.id, family.id);
+		if (existingCollapsed && reconciled !== void 0) {
+			replacement.set(family.id, reconcileDefaultMember(reconciled, family, new Set(rawPresent)));
+			continue;
+		}
+		const memberSpecs = [];
+		for (const id of rawPresent) {
+			const member = byId.get(id);
+			if (member !== void 0) memberSpecs.push(member);
+		}
+		const firstMember = memberSpecs[0];
+		if (firstMember === void 0) continue;
+		const presentSet = new Set(rawPresent);
+		const routing = {};
+		let hasRouting = false;
+		let hasEffortRoute = false;
+		let usedAbsentEffortRoute = false;
+		for (const effort of VARIANT_ROUTING_KEYS) {
+			const target = family.routing[effort];
+			const targetPresent = target !== void 0 && presentSet.has(target);
+			const preserveAbsentEffort = target !== void 0 && effort !== "off" && family.preserveAbsentEffortRoutes === true;
+			if (target !== void 0 && (targetPresent || preserveAbsentEffort) && !retired?.has(target)) {
+				routing[effort] = target;
+				hasRouting = true;
+				if (effort !== "off") hasEffortRoute = true;
+				if (!targetPresent && effort !== "off") usedAbsentEffortRoute = true;
+			}
+		}
+		const reasoning = memberSpecs.some((spec) => spec.reasoning) || hasEffortRoute;
+		const familyThinking = family.thinking;
+		const thinking = familyThinking ? { ...familyThinking } : void 0;
+		if (thinking !== void 0) {
+			if (hasRouting) thinking.effortRouting = routing;
+			if (family.suppressWhenOff) thinking.suppressWhenOff = true;
+		}
+		const input = [];
+		if (memberSpecs.some((spec) => spec.input.includes("text"))) input.push("text");
+		if (memberSpecs.some((spec) => spec.input.includes("image"))) input.push("image");
+		const collapsed = {
+			...firstMember,
+			id: family.id,
+			name: family.name,
+			reasoning,
+			input,
+			contextWindow: maxOrNull(memberSpecs.map((spec) => spec.contextWindow)),
+			maxTokens: maxOrNull(memberSpecs.map((spec) => spec.maxTokens))
+		};
+		const defaultWireId = (family.defaultMember !== void 0 && presentSet.has(family.defaultMember) && !retired?.has(family.defaultMember) ? family.defaultMember : void 0) ?? rawPresent.find((id) => !retired?.has(id)) ?? rawPresent[0];
+		if (defaultWireId === void 0) continue;
+		if (defaultWireId === family.id) {
+			if (usedAbsentEffortRoute) collapsed.requestModelId = defaultWireId;
+			else delete collapsed.requestModelId;
+		} else collapsed.requestModelId = defaultWireId;
+		if (reasoning && thinking !== void 0) collapsed.thinking = thinking;
+		else delete collapsed.thinking;
+		replacement.set(family.id, collapsed);
+	}
+	for (const family of table.families) {
+		if (family.extraAliases === void 0) continue;
+		const retired = family.retiredMembers !== void 0 && family.retiredMembers.length > 0 ? new Set(family.retiredMembers) : void 0;
+		for (const alias of family.extraAliases) {
+			if (alias === family.id || familyIdBySpecId.has(alias)) continue;
+			const aliasSpec = byId.get(alias);
+			if (aliasSpec === void 0) continue;
+			const refreshed = refreshCollapsedThinking(aliasSpec, family, retired);
+			if (refreshed !== aliasSpec) {
+				familyIdBySpecId.set(alias, alias);
+				replacement.set(alias, refreshed);
+			}
+		}
+	}
+	if (replacement.size === 0) return [...specs];
+	const emitted = /* @__PURE__ */ new Set();
+	const out = [];
+	for (const spec of specs) {
+		const familyId = familyIdBySpecId.get(spec.id);
+		if (familyId === void 0) {
+			out.push(spec);
+			continue;
+		}
+		if (emitted.has(familyId)) continue;
+		emitted.add(familyId);
+		const familySpec = replacement.get(familyId);
+		if (familySpec !== void 0) out.push(familySpec);
+	}
+	return out;
+}
+/**
+* Re-key model-to-model configuration after collapse removes a referenced
+* member id. Qualified targets keep their provider; bare targets remain bare.
+*/
+function retargetCollapsedModelReferences(specs) {
+	const liveIdsByProvider = /* @__PURE__ */ new Map();
+	for (const spec of specs) {
+		const provider = spec.provider.toLowerCase();
+		let liveIds = liveIdsByProvider.get(provider);
+		if (!liveIds) {
+			liveIds = /* @__PURE__ */ new Set();
+			liveIdsByProvider.set(provider, liveIds);
+		}
+		liveIds.add(spec.id.toLowerCase());
+	}
+	for (let index = 0; index < specs.length; index++) {
+		const spec = specs[index];
+		if (!spec) continue;
+		const contextPromotionTarget = resolveCollapsedModelReference(spec.contextPromotionTarget, spec.provider, liveIdsByProvider);
+		const compactionModel = resolveCollapsedModelReference(spec.compactionModel, spec.provider, liveIdsByProvider);
+		if (contextPromotionTarget === spec.contextPromotionTarget && compactionModel === spec.compactionModel) continue;
+		specs[index] = {
+			...spec,
+			contextPromotionTarget,
+			compactionModel
+		};
+	}
+}
+function resolveCollapsedModelReference(target, currentProvider, liveIdsByProvider) {
+	if (target === void 0) return void 0;
+	const separator = target.indexOf("/");
+	const provider = separator >= 0 ? target.slice(0, separator) : currentProvider;
+	const providerId = provider.toLowerCase();
+	const normalizedModelId = (separator >= 0 ? target.slice(separator + 1) : target).trim().toLowerCase();
+	const liveIds = liveIdsByProvider.get(providerId);
+	if (liveIds?.has(normalizedModelId)) return target;
+	const alias = resolveRegisteredVariantAlias(provider, normalizedModelId);
+	if (alias === void 0 || !liveIds?.has(alias.toLowerCase())) return target;
+	return separator >= 0 ? `${provider}/${alias}` : alias;
+}
+/**
+* Collapse a full mixed-provider list: per provider, the compiled reviewed table, Cursor's
+* conservative live effort-sibling rule, and the automatic `X`/`X-thinking`
+* pair rule. Used by the catalog generator; the runtime equivalent lives at
+* the model-manager merge point. Output is regrouped by provider — callers
+* re-sort.
+*/
+function collapseVariants(specs, opts) {
+	if (opts?.table !== void 0) return collapseWithTable(specs, opts.table);
+	const byProvider = /* @__PURE__ */ new Map();
+	for (const spec of specs) {
+		const slice = byProvider.get(spec.provider);
+		if (slice) slice.push(spec);
+		else byProvider.set(spec.provider, [spec]);
+	}
+	const out = [];
+	for (const [provider, slice] of byProvider) {
+		const table = reviewedCollapseTable(provider);
+		let result = table ? collapseWithTable(slice, table) : slice;
+		if (provider === "cursor") {
+			const cursorDerived = deriveCursorEffortFamilies(result);
+			if (cursorDerived.length > 0) result = collapseWithTable(result, { families: cursorDerived });
+		}
+		const derived = deriveThinkingPairFamilies(result, table, provider);
+		if (derived.length > 0) result = collapseWithTable(result, { families: derived });
+		registerCollapsedVariantAliases(provider, result);
+		out.push(...result);
+	}
+	retargetCollapsedModelReferences(out);
+	return out;
+}
+/**
+* Alias index over a collapse table (or the live families observed at
+* runtime). Templated families are materialized on first lookup of any id
+* they match, so a revision discovery has never advertised still resolves.
+*/
+var VariantAliasIndex = class {
+	/** lowercased retired id → replacement model id. */
+	#forward = /* @__PURE__ */ new Map();
+	/**
+	* lowercased provider-scoped alias → replacement model id. Kept apart from
+	* `#forward` so bare-id and reverse lookups never see it.
+	*/
+	providerScoped = /* @__PURE__ */ new Map();
+	/** replacement model id → retired ids that resolve to it. */
+	#reverse = /* @__PURE__ */ new Map();
+	/** Collapsed logical ids declared by the table or observed at runtime. */
+	#familyIds = /* @__PURE__ */ new Set();
+	#templates;
+	constructor(templates = []) {
+		this.#templates = templates;
+	}
+	/** Register `from` → `to`; false when `from` is already claimed. */
+	add(from, to) {
+		if (from === to || this.#forward.has(from.toLowerCase())) return false;
+		this.#forward.set(from.toLowerCase(), to);
+		const sources = this.#reverse.get(to);
+		if (sources) sources.push(from);
+		else this.#reverse.set(to, [from]);
+		return true;
+	}
+	/** Register a family: its logical id plus every member and extra alias. */
+	addFamily(family) {
+		this.#familyIds.add(family.id);
+		for (const member of family.members) this.add(member, family.id);
+		for (const alias of family.extraAliases ?? []) this.add(alias, family.id);
+	}
+	markFamily(id) {
+		this.#familyIds.add(id);
+	}
+	/** Replacement model id for a retired/member id (case-insensitive). */
+	resolve(id) {
+		const lower = id.toLowerCase();
+		this.#learn(lower);
+		return this.#forward.get(lower);
+	}
+	/** Whether `id` is a collapsed logical id of this index. */
+	isFamily(id) {
+		this.#learn(id);
+		return this.#familyIds.has(id);
+	}
+	/** Retired ids that resolve to logical `id`. */
+	sourcesOf(id) {
+		this.#learn(id);
+		return this.#reverse.get(id);
+	}
+	/** Materialize the template family that owns `id`, once. */
+	#learn(id) {
+		if (this.#templates.length === 0) return;
+		const family = templateFamilyFor(this.#templates, id);
+		if (family === void 0 || this.#familyIds.has(family.id)) return;
+		this.addFamily(family);
+	}
+};
+const dynamicAliasIndexes = /* @__PURE__ */ new Map();
+const kAliasIndex = Symbol("compat-collapse.aliasIndex");
+/**
+* Persist aliases embedded in collapsed routing so generated catalog rows and
+* newly discovered families expose the same selector migrations as reviewed tables.
+*/
+function registerCollapsedVariantAliases(provider, specs) {
+	const providerId = provider.toLowerCase();
+	let index = dynamicAliasIndexes.get(providerId);
+	for (const spec of specs) {
+		const routing = spec.thinking?.effortRouting;
+		if (!routing) continue;
+		let registered = false;
+		for (const effort of VARIANT_ROUTING_KEYS) {
+			const source = routing[effort];
+			if (!source || source === spec.id) continue;
+			index ??= new VariantAliasIndex();
+			registered = index.add(source, spec.id) || registered;
+		}
+		if (spec.requestModelId && spec.requestModelId !== spec.id) {
+			index ??= new VariantAliasIndex();
+			registered = index.add(spec.requestModelId, spec.id) || registered;
+		}
+		if (registered) index?.markFamily(spec.id);
+	}
+	if (index) dynamicAliasIndexes.set(providerId, index);
+}
+function resolveRegisteredVariantAlias(provider, normalizedModelId) {
+	const providerId = provider.toLowerCase();
+	const table = reviewedCollapseTable(provider) ?? reviewedCollapseTable(providerId);
+	return (table ? getAliasIndex(table).resolve(normalizedModelId) : void 0) ?? dynamicAliasIndexes.get(providerId)?.resolve(normalizedModelId);
+}
+function getAliasIndex(table) {
+	const cached = Reflect.get(table, kAliasIndex);
+	if (cached instanceof VariantAliasIndex) return cached;
+	const index = new VariantAliasIndex(table.templates);
+	for (const family of table.families) index.addFamily(family);
+	for (const alias in table.providerAliases) {
+		const target = table.providerAliases[alias];
+		if (target !== void 0 && alias !== target) index.providerScoped.set(alias.toLowerCase(), target);
+	}
+	Reflect.set(table, kAliasIndex, index);
+	return index;
+}
+function maxOrNull(values) {
+	const known = values.filter((v) => v != null);
+	return known.length ? Math.max(...known) : null;
+}
+//#endregion
+export { isOfficialAnthropicApiUrl as a, isAnthropicSigningProxyUrl as i, buildModel as n, resolveModelPolicy as r, collapseVariants as t };