@xiaoso/dsh-tool-plus 0.1.16 → 0.1.17-beta.0

package/lib/collapse-CkMNRNr7.mjs

@@ -1,2304 +0,0 @@
-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-I4I8azHN.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 };