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

package/lib/id-EJwVLDHE.mjs

@@ -0,0 +1,2548 @@
+import { installBunShim as __installBunShim } from "./bun-shim.mjs";
+__installBunShim();
+import { c as compareRevision, h as isRecord, n as hasModelScopedEffortsRule, r as resolveCascade, u as parseRevision } from "./cascade-BWjRTD1q.mjs";
+import "./utils-DrDwmNtu.mjs";
+import { l as classifyModel, p as stripThinkingVariantSuffix } from "./pricing-DusBEhwm.mjs";
+//#region node_modules/.pnpm/@oh-my-pi+pi-catalog@18.12.6/node_modules/@oh-my-pi/pi-catalog/src/effort.ts
+/** User-facing thinking levels, ordered least to most intensive. */
+let Effort = /* @__PURE__ */ function(Effort) {
+	Effort["Minimal"] = "minimal";
+	Effort["Low"] = "low";
+	Effort["Medium"] = "medium";
+	Effort["High"] = "high";
+	Effort["XHigh"] = "xhigh";
+	Effort["Max"] = "max";
+	return Effort;
+}({});
+const THINKING_EFFORTS = [
+	"minimal",
+	"low",
+	"medium",
+	"high",
+	"xhigh",
+	"max"
+];
+//#endregion
+//#region node_modules/.pnpm/@oh-my-pi+pi-catalog@18.12.6/node_modules/@oh-my-pi/pi-catalog/src/hosts.ts
+const KNOWN_HOSTS = {
+	openai: {
+		providers: ["openai"],
+		urlMarkers: ["api.openai.com"]
+	},
+	/** URL-only: a Codex provider rerouted through a proxy does not imply the subscription backend's capabilities. */
+	openaiCodex: { urlMarkers: ["chatgpt.com/backend-api", "chat.openai.com/backend-api"] },
+	azureOpenAI: {
+		providers: ["azure"],
+		urlMarkers: [
+			".openai.azure.com",
+			"azure.com/openai",
+			"models.inference.ai.azure.com"
+		]
+	},
+	openrouter: {
+		providers: ["openrouter"],
+		urlMarkers: ["openrouter.ai"]
+	},
+	vercelAIGateway: {
+		providers: ["vercel-ai-gateway"],
+		urlMarkers: ["ai-gateway.vercel.sh"]
+	},
+	githubCopilot: {
+		providers: ["github-copilot"],
+		urlMarkers: ["githubcopilot.com", "copilot-api."]
+	},
+	anthropic: {
+		providers: ["anthropic"],
+		urlMarkers: ["api.anthropic.com"]
+	},
+	/** DeepSeek's first-party API only — gates direct-API quirks (max_tokens field, thinking extraBody). */
+	deepseekDirect: {
+		providers: ["deepseek"],
+		urlMarkers: ["api.deepseek.com"]
+	},
+	/** Any DeepSeek-operated host (first-party API, web-chat fronts). Wider than `deepseekDirect` on purpose. */
+	deepseekFamily: {
+		providers: ["deepseek"],
+		urlMarkers: ["deepseek.com"]
+	},
+	cerebras: {
+		providers: ["cerebras"],
+		urlMarkers: ["cerebras.ai"]
+	},
+	zai: {
+		providers: ["zai"],
+		urlMarkers: ["api.z.ai"]
+	},
+	zhipu: {
+		providers: ["zhipu-coding-plan"],
+		urlMarkers: ["open.bigmodel.cn"]
+	},
+	kilo: {
+		providers: ["kilo"],
+		urlMarkers: ["api.kilo.ai"]
+	},
+	alibabaDashscope: {
+		providers: ["alibaba-coding-plan", "alibaba-token-plan"],
+		urlMarkers: ["dashscope", "token-plan."]
+	},
+	umans: {
+		providers: ["umans"],
+		urlMarkers: ["api.code.umans.ai"]
+	},
+	xiaomi: {
+		providers: ["xiaomi"],
+		providerPrefixes: ["xiaomi-token-plan-"],
+		urlMarkers: ["xiaomimimo.com"]
+	},
+	xai: {
+		providers: ["xai", "xai-oauth"],
+		urlMarkers: ["api.x.ai"]
+	},
+	mistral: {
+		providers: ["mistral"],
+		urlMarkers: ["mistral.ai"]
+	},
+	together: {
+		providers: ["together"],
+		urlMarkers: ["api.together.xyz"]
+	},
+	baseten: {
+		providers: ["baseten"],
+		urlMarkers: ["baseten.co"]
+	},
+	/** URL-only on purpose: the `fireworks`/`firepass` providers route per-model and not every model is Fireworks-shaped. */
+	fireworks: { urlMarkers: ["fireworks.ai"] },
+	groq: {
+		providers: ["groq"],
+		urlMarkers: ["api.groq.com"]
+	},
+	minimax: {
+		providers: [
+			"minimax",
+			"minimax-code",
+			"minimax-code-cn"
+		],
+		urlMarkers: ["api.minimax.io", "api.minimaxi.com"]
+	},
+	qwenPortal: {
+		providers: ["qwen-portal"],
+		urlMarkers: ["portal.qwen.ai"]
+	},
+	/** NVIDIA NIM (`integrate.api.nvidia.com`). Qwen NIM endpoints take `chat_template_kwargs.enable_thinking`, never top-level `enable_thinking`. */
+	nvidia: {
+		providers: ["nvidia"],
+		urlMarkers: ["integrate.api.nvidia.com"]
+	},
+	/** Venice AI (`api.venice.ai`). OpenAI-compatible; drives reasoning via top-level `reasoning_effort` (and `venice_parameters.disable_thinking`), and rejects DashScope's top-level `enable_thinking` with a 400 (`additionalProperties: false` request schema). */
+	venice: {
+		providers: ["venice"],
+		urlMarkers: ["api.venice.ai"]
+	},
+	moonshotNative: {
+		providers: ["moonshot", "kimi-code"],
+		urlMarkers: ["api.moonshot.ai", "api.kimi.com"]
+	},
+	/** Google AI Studio's OpenAI-compatible shim (`/v1beta/openai`) — a subset of chat-completions; rejects `store` with a 400. Native Gemini uses `google-generative-ai` api instead. */
+	googleAistudio: {
+		providers: [],
+		urlMarkers: ["generativelanguage.googleapis.com"]
+	},
+	opencode: {
+		providers: ["opencode-go", "opencode-zen"],
+		urlMarkers: ["opencode.ai"]
+	},
+	/** ZenMux's Anthropic-compatible proxy (`zenmux.ai/api/anthropic`) forwards to signature-enforcing Anthropic. */
+	zenmux: {
+		providers: ["zenmux"],
+		urlMarkers: ["zenmux.ai"]
+	},
+	chutes: { urlMarkers: ["chutes.ai"] }
+};
+const MAX_URL_HOST_MATCHES = 512;
+const urlHostMatches = /* @__PURE__ */ new Map();
+function getUrlHostMatches(baseUrl) {
+	let matches = urlHostMatches.get(baseUrl);
+	if (matches !== void 0) return matches;
+	if (urlHostMatches.size === MAX_URL_HOST_MATCHES) urlHostMatches.clear();
+	matches = /* @__PURE__ */ new Map();
+	urlHostMatches.set(baseUrl, matches);
+	return matches;
+}
+/** URL-only host check (for call sites that have no provider id, e.g. raw env config). */
+function hostMatchesUrl(baseUrl, host) {
+	if (!baseUrl) return false;
+	const matches = getUrlHostMatches(baseUrl);
+	const cached = matches.get(host);
+	if (cached !== void 0) return cached;
+	const spec = KNOWN_HOSTS[host];
+	for (const marker of spec.urlMarkers) if (includesAsciiCaseInsensitive(baseUrl, marker)) {
+		matches.set(host, true);
+		return true;
+	}
+	matches.set(host, false);
+	return false;
+}
+/** Provider-or-URL host check — the canonical `provider === id || baseUrl.includes(marker)` idiom. */
+function modelMatchesHost(model, host) {
+	const spec = KNOWN_HOSTS[host];
+	if (spec.providers) {
+		for (const provider of spec.providers) if (model.provider === provider) return true;
+	}
+	if (spec.providerPrefixes) {
+		for (const prefix of spec.providerPrefixes) if (model.provider.startsWith(prefix)) return true;
+	}
+	return hostMatchesUrl(model.baseUrl, host);
+}
+function includesAsciiCaseInsensitive(value, lowerNeedle) {
+	const needleLength = lowerNeedle.length;
+	const end = value.length - needleLength;
+	for (let start = 0; start <= end; start++) {
+		let offset = 0;
+		for (; offset < needleLength; offset++) if ((value.charCodeAt(start + offset) | 32) !== lowerNeedle.charCodeAt(offset)) break;
+		if (offset === needleLength) return true;
+	}
+	return false;
+}
+/**
+* Hostname for a Vertex AI GenerateContent / rawPredict / OpenAI-compat
+* request for the given location.
+*
+* - `global` → global endpoint (`aiplatform.googleapis.com`)
+* - `eu` / `us` multi-regions → REP endpoints (`aiplatform.{eu|us}.rep.googleapis.com`)
+* - every other location → regional (`{location}-aiplatform.googleapis.com`)
+*
+* Multi-region codes do NOT follow the regional `{location}-aiplatform` pattern;
+* interpolating them that way yields hosts like `eu-aiplatform.googleapis.com`
+* that 404.
+*/
+function resolveVertexEndpointHost(location) {
+	if (location === "global") return "aiplatform.googleapis.com";
+	if (location === "eu" || location === "us") return `aiplatform.${location}.rep.googleapis.com`;
+	return `${location}-aiplatform.googleapis.com`;
+}
+/** Vertex AI Anthropic raw-predict endpoints (`:streamRawPredict` / `:rawPredict`). */
+function isVertexRawPredictUrl(baseUrl) {
+	return baseUrl.includes(":streamRawPredict") || baseUrl.includes(":rawPredict");
+}
+const BEDROCK_PUBLIC_HOST = /^(?:(?<runtime>bedrock-runtime(?:-fips)?)\.[a-z0-9-]+\.amazonaws\.com|bedrock-mantle\.(?:[a-z0-9-]+|\{region\})\.api\.aws)$/;
+const BEDROCK_PRIVATELINK_HOST = /^vpce-[a-z0-9-]+\.(?:(?<runtime>bedrock-runtime(?:-fips)?)|bedrock-mantle)\.[a-z0-9-]+\.vpce\.amazonaws\.com$/;
+function hasPathPrefix(pathname, prefix) {
+	return pathname === prefix || pathname.startsWith(`${prefix}/`);
+}
+/**
+* Amazon Bedrock API route on a bedrock-runtime or bedrock-mantle endpoint
+* (public, FIPS, or PrivateLink hostname):
+* - `anthropic`: the Anthropic Messages API under `/anthropic`.
+* - `openai`: the OpenAI-compatible APIs under `/openai`, plus Mantle's
+*   documented `/v1` base (`https://bedrock-mantle.<region>.api.aws/v1`).
+* - `runtime`: the bedrock-runtime origin itself, where Converse and
+*   InvokeModel live under `/model/<id>/…`.
+*
+* Hostnames are parsed strictly so proxies that embed these hosts in a path
+* do not match.
+*/
+function isBedrockRouteUrl(baseUrl, route) {
+	if (!baseUrl) return false;
+	let url;
+	try {
+		url = new URL(baseUrl);
+	} catch {
+		return false;
+	}
+	if (url.protocol !== "https:") return false;
+	const host = BEDROCK_PUBLIC_HOST.exec(url.hostname) ?? BEDROCK_PRIVATELINK_HOST.exec(url.hostname);
+	if (!host) return false;
+	const isMantle = host.groups?.runtime === void 0;
+	if (route === "runtime") return !isMantle && url.pathname === "/";
+	if (route === "anthropic") return hasPathPrefix(url.pathname, "/anthropic");
+	return hasPathPrefix(url.pathname, "/openai") || isMantle && hasPathPrefix(url.pathname, "/v1");
+}
+//#endregion
+//#region node_modules/.pnpm/@oh-my-pi+pi-catalog@18.12.6/node_modules/@oh-my-pi/pi-catalog/src/model-thinking.ts
+/**
+* Returns the supported thinking efforts declared on the model metadata.
+* Empty for non-reasoning models and for reasoning models without a
+* controllable effort surface (`thinking: undefined`).
+*/
+function getSupportedEfforts(model) {
+	if (!model.reasoning) return [];
+	return model.thinking?.efforts ?? [];
+}
+/**
+* Neutral view of a model whose thinking ladder is unverified: `reasoning: false`
+* and no ladder. Re-entering policy resolution starts from it (the ladder is
+* derived output, not authored input), and requests without an effort send it so
+* no reasoning or disable fields reach an upstream that may reject them.
+*/
+function withoutUnverifiedThinking(model) {
+	if (!model.thinking?.unverified) return model;
+	const { thinking: _derived, ...rest } = model;
+	return {
+		...rest,
+		reasoning: false
+	};
+}
+function requireSupportedEffort(model, effort) {
+	if (!model.reasoning) throw new Error(`Model ${model.provider}/${model.id} does not support thinking`);
+	const levels = getSupportedEfforts(model);
+	if (!levels.includes(effort)) throw new Error(`Thinking effort ${effort} is not supported by ${model.provider}/${model.id}. Supported efforts: ${levels.join(", ")}`);
+	return effort;
+}
+/**
+* Maps a normalized thinking effort to Anthropic adaptive effort values via
+* the model's baked `thinking.effortMap` (identity for unmapped efforts).
+*
+* The Anthropic adaptive wire vocabulary has no `minimal` tier (valid values:
+* `low`, `medium`, `high`, `xhigh`, `max`); a model ladder that exposes
+* `minimal` — custom `anthropic-messages` providers do, unlike the built-in
+* Claude ladders — would otherwise serialize `output_config.effort: "minimal"`
+* and 400 (`level "minimal" not supported`). Clamp it to the lowest real tier,
+* mirroring {@link mapEffortToGoogleThinkingLevel}'s `minimal` handling.
+*/
+function mapEffortToAnthropicAdaptiveEffort(model, effort) {
+	const supported = requireSupportedEffort(model, effort);
+	const mapped = model.thinking?.effortMap?.[supported] ?? supported;
+	if (mapped === "minimal") return "low";
+	return mapped;
+}
+/**
+* Resolves the upstream wire model id for a request at the given effort
+* (`undefined` = thinking off). Collapsed effort-tier variants route through
+* `thinking.effortRouting`; everything else falls back to
+* `requestModelId ?? id`.
+*/
+function resolveWireModelId(model, effort) {
+	return model.thinking?.effortRouting?.[effort ?? "off"] ?? model.requestModelId ?? model.id;
+}
+//#endregion
+//#region node_modules/.pnpm/@oh-my-pi+pi-catalog@18.12.6/node_modules/@oh-my-pi/pi-catalog/src/wire/codex.ts
+/**
+* Constants for OpenAI Codex (ChatGPT OAuth) backend
+*/
+const CODEX_BASE_URL = "https://chatgpt.com/backend-api";
+const OFFICIAL_CODEX_URL = new URL(CODEX_BASE_URL);
+/** Strict official-Codex endpoint check; exact origin or a path boundary after {@link CODEX_BASE_URL}. */
+function isOfficialCodexApiUrl(baseUrl) {
+	if (!baseUrl) return true;
+	try {
+		const candidate = new URL(baseUrl);
+		const candidatePath = candidate.pathname.replace(/\/+$/, "");
+		return candidate.origin === OFFICIAL_CODEX_URL.origin && (candidatePath === OFFICIAL_CODEX_URL.pathname || candidatePath.startsWith(`${OFFICIAL_CODEX_URL.pathname}/`));
+	} catch {
+		return false;
+	}
+}
+/**
+* Pinned OpenAI Codex client version (corresponds to @openai/codex package version).
+* Updated from npm by `bun run check-spoofed-versions --update`.
+*
+* The backend version-gates model availability against this value on both
+* `/models?client_version=` and `/responses`, independently of a model's
+* declared `minimal_client_version`: GPT-6.1 Sol declares 0.153.0 yet is
+* omitted from `/models` at 0.155.1 and listed at 0.159.0. An older pin
+* silently hides newer SKUs from discovery.
+*/
+const CODEX_CLIENT_VERSION = "0.159.0";
+const OPENAI_HEADERS = {
+	BETA: "OpenAI-Beta",
+	/** Codex feature-negotiation header; values identify opt-in wire protocols. */
+	CODEX_BETA_FEATURES: "x-codex-beta-features",
+	ACCOUNT_ID: "chatgpt-account-id",
+	ORIGINATOR: "originator",
+	VERSION: "version",
+	SESSION_ID: "session_id",
+	CONVERSATION_ID: "conversation_id",
+	SCOPED_SESSION_ID: "session-id",
+	THREAD_ID: "thread-id",
+	INSTALLATION_ID: "x-codex-installation-id",
+	WINDOW_ID: "x-codex-window-id",
+	TURN_METADATA: "x-codex-turn-metadata",
+	PARENT_THREAD_ID: "x-codex-parent-thread-id",
+	SUBAGENT: "x-openai-subagent",
+	/** Responses Lite transport marker (codex-rs `add_responses_lite_header`); value is always `"true"`. */
+	RESPONSES_LITE: "x-openai-internal-codex-responses-lite",
+	/** DeviceCheck attestation envelope (codex-rs `X_OAI_ATTESTATION_HEADER`); sent on ChatGPT-OAuth requests. */
+	ATTESTATION: "x-oai-attestation",
+	/** Client-declared data residency for region-pinned enterprise workspaces. */
+	RESIDENCY: "x-openai-internal-codex-residency",
+	/**
+	* Model routing hint (codex-rs `X_CODEX_ROUTING_HINT_HEADER`): `model=<slug>`
+	* or `model=<slug>;tier=<service_tier>`; sent on every ChatGPT-OAuth
+	* Responses, compaction, and WebSocket handshake request. Built by
+	* {@link codexRoutingHint}.
+	*/
+	ROUTING_HINT: "x-codex-routing-hint"
+};
+const OPENAI_HEADER_VALUES = {
+	BETA_RESPONSES: "responses=experimental",
+	BETA_RESPONSES_WEBSOCKETS_V2: "responses_websockets=2026-02-06",
+	REMOTE_COMPACTION_V2: "remote_compaction_v2",
+	ORIGINATOR_CODEX: "omp"
+};
+const JWT_CLAIM_PATH = "https://api.openai.com/auth";
+/**
+* Build the `x-codex-routing-hint` value for a request (codex-rs
+* `build_routing_hint_header`): the requested model slug plus the explicit
+* service tier when one is set. Callers set it only on ChatGPT-OAuth requests
+* to the Codex backend; API-key OpenAI traffic never carries it.
+*/
+function codexRoutingHint(model, serviceTier) {
+	return serviceTier ? `model=${model};tier=${serviceTier}` : `model=${model}`;
+}
+/**
+* Extract account ID from a Codex JWT access token.
+* Returns undefined if the token is not a valid Codex JWT.
+*/
+function getCodexAccountId(accessToken) {
+	try {
+		const parts = accessToken.split(".");
+		if (parts.length !== 3) return void 0;
+		const decoded = Buffer.from(parts[1] ?? "", "base64").toString("utf-8");
+		return JSON.parse(decoded)["https://api.openai.com/auth"]?.chatgpt_account_id ?? void 0;
+	} catch {
+		return;
+	}
+}
+/** Residency claim value of an account that is not region-pinned. */
+const CODEX_UNCONSTRAINED_RESIDENCY = "no_constraint";
+/**
+* Extract the account's data residency from a Codex JWT access token.
+*
+* Enterprise ChatGPT workspaces can be pinned to a region. Such a workspace
+* rejects a Codex request whose egress does not match it — HTTP 401
+* `Workspace is not authorized in this region.` — unless the client declares
+* the residency itself. The token already carries it, so no configuration is
+* needed: `chatgpt_data_residency` is the authoritative claim, with
+* `chatgpt_compute_residency` as the fallback for tokens that only carry that.
+*
+* Returns undefined for a non-JWT token, or for the (common) accounts that are
+* not region-pinned: their claims omit residency or carry the
+* {@link CODEX_UNCONSTRAINED_RESIDENCY} sentinel. The backend answers 404 to a
+* declared `no_constraint`, and codex-rs never sends it.
+*/
+function getCodexResidency(accessToken) {
+	try {
+		const parts = accessToken.split(".");
+		if (parts.length !== 3) return void 0;
+		const decoded = Buffer.from(parts[1] ?? "", "base64").toString("utf-8");
+		const auth = JSON.parse(decoded)[JWT_CLAIM_PATH];
+		for (const claim of [auth?.chatgpt_data_residency, auth?.chatgpt_compute_residency]) {
+			if (typeof claim !== "string") continue;
+			const residency = claim.trim();
+			if (residency.length === 0) continue;
+			return residency.toLowerCase() === CODEX_UNCONSTRAINED_RESIDENCY ? void 0 : residency;
+		}
+		return;
+	} catch {
+		return;
+	}
+}
+/**
+* Adds the token's workspace residency to Codex request headers without
+* replacing a caller-supplied value.
+*/
+function applyCodexResidencyHeader(headers, accessToken) {
+	const headerName = OPENAI_HEADERS.RESIDENCY;
+	if (headers instanceof Headers) {
+		if (headers.has(headerName)) return;
+		const residency = getCodexResidency(accessToken);
+		if (residency) headers.set(headerName, residency);
+		return;
+	}
+	for (const configuredName in headers) if (configuredName.toLowerCase() === headerName) return;
+	const residency = getCodexResidency(accessToken);
+	if (residency) headers[headerName] = residency;
+}
+//#endregion
+//#region node_modules/.pnpm/@oh-my-pi+pi-catalog@18.12.6/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;
+/**
+* Amazon Bedrock's Anthropic Messages API: the `/anthropic` path on the
+* bedrock-runtime or bedrock-mantle endpoint. It rejects the tool `strict`
+* field and enforces Anthropic signatures on replay.
+*/
+function isBedrockAnthropicRoute(baseUrl) {
+	return isBedrockRouteUrl(baseUrl, "anthropic");
+}
+/**
+* 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)) || isBedrockAnthropicRoute(baseUrl) || isAzureAnthropicRoute(baseUrl);
+}
+//#endregion
+//#region node_modules/.pnpm/@oh-my-pi+pi-catalog@18.12.6/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.12.6/node_modules/@oh-my-pi/pi-catalog/src/types.ts
+/** Catalog kinds used to isolate role-specific runners from session chat models. */
+const MODEL_KINDS = [
+	"chat",
+	"tiny",
+	"image",
+	"tts",
+	"stt",
+	"search",
+	"judge",
+	"embedding",
+	"rerank",
+	"video"
+];
+/** Kinds a provider maps to a runner transport through `kind-apis` in its KDL; discovery drops rows of these kinds when the provider declares no API. */
+const KIND_API_KINDS = [
+	"image",
+	"tts",
+	"stt",
+	"embedding",
+	"rerank",
+	"video"
+];
+new Map(Object.entries({
+	"web-search": "search",
+	typesafe: "judge",
+	"openrouter-decisions": "judge",
+	"openai-decisions": "judge",
+	"workers-ai-systemone": "judge",
+	"openai-images": "image",
+	"openrouter-images": "image",
+	"xai-tts": "tts",
+	"openai-speech": "tts",
+	"openai-embeddings": "embedding",
+	"openrouter-rerank": "rerank",
+	"openrouter-video": "video",
+	"openai-transcriptions": "stt"
+}));
+//#endregion
+//#region node_modules/.pnpm/@oh-my-pi+pi-catalog@18.12.6/node_modules/@oh-my-pi/pi-catalog/src/wire/factory-droid.ts
+/**
+* Factory Droid wire constants shared by catalog discovery, the pi-ai
+* provider, OAuth login and account usage: client identity, upstream/region
+* vocabulary, API hosts and the account-scoped model-cache namespace.
+*/
+/**
+* Client version reported to Factory's API. When bumping it, recapture the
+* native request corpus with `packages/ai/scripts/capture-factory-droid-native.ts`
+* against the matching CLI binary and make `factory-droid-native-parity.test.ts` pass.
+*/
+const FACTORY_DROID_CLIENT_VERSION = "0.237.0";
+/** Wire protocols the Factory proxy multiplexes; `api-routes provider="factory-droid"` picks one per model. */
+const FACTORY_DROID_WIRES = [
+	"openai-completions",
+	"openai-responses",
+	"anthropic-messages",
+	"google-generate"
+];
+/**
+* Upstream routers the proxy dispatches to, sent as the `x-api-provider`
+* header. The KDL compiler validates the rotation and region axes against it.
+*/
+const FACTORY_DROID_UPSTREAMS = [
+	"fireworks",
+	"baseten",
+	"mistral",
+	"anthropic",
+	"azure_anthropic",
+	"vertex_anthropic",
+	"bedrock_anthropic",
+	"openai",
+	"azure_openai",
+	"bedrock_openai",
+	"google",
+	"xai",
+	"snowflake",
+	"databricks"
+];
+/** Inference region for an account: explicit scope wins, else EU residency infers EU, else global. */
+function resolveFactoryDroidInferenceRegion(scope) {
+	return scope.inferenceRegion ?? (scope.region === "eu" ? "eu" : "global");
+}
+/** Factory API host per residency region; EU accounts are served from the EU region. */
+function factoryDroidApiBaseUrl(region) {
+	return region === "eu" ? "https://api.eu.factory.ai" : "https://api.factory.ai";
+}
+/** Per-wire base URL for an account region; the stream layer appends the path suffix. */
+function factoryDroidWireBaseUrl(wire, region) {
+	const host = factoryDroidApiBaseUrl(region);
+	switch (wire) {
+		case "openai-completions":
+		case "openai-responses": return `${host}/api/llm/o/v1`;
+		case "anthropic-messages": return `${host}/api/llm/a`;
+		case "google-generate": return `${host}/api/llm/g/v1`;
+	}
+}
+/**
+* Client identity headers shared by discovery, usage and inference requests.
+* Callers add their own auth, `Accept`, routing and SDK headers.
+*/
+function factoryDroidClientHeaders(orgId) {
+	return {
+		"X-Client-Version": FACTORY_DROID_CLIENT_VERSION,
+		"X-Factory-Client": "cli",
+		...orgId ? { "X-Factory-Org-Id": orgId } : {}
+	};
+}
+/** Model-cache namespace for a Factory credential and its account scope. */
+function factoryDroidModelCacheProviderId(options) {
+	const token = options.apiKey ?? "";
+	let credentialScope = `bearer\u0000${token}`;
+	const parts = token.split(".");
+	if (parts.length === 3 && parts.every(Boolean)) try {
+		const claims = JSON.parse(Buffer.from(parts[1], "base64url").toString("utf8"));
+		if (isRecord(claims) && !Array.isArray(claims) && typeof claims.external_org_id === "string" && claims.external_org_id.trim() && typeof claims.sub === "string" && claims.sub.trim()) credentialScope = `account\u0000${claims.external_org_id}\u0000${claims.sub}`;
+	} catch {}
+	const region = options.region === "eu" ? "eu" : "global";
+	const scope = `${credentialScope}\u0000${options.orgId ?? ""}\u0000${region}\u0000${options.inferenceRegion ?? region}`;
+	return `factory-droid:models-v4:${Bun.hash(scope).toString(36)}`;
+}
+//#endregion
+//#region node_modules/.pnpm/@oh-my-pi+pi-catalog@18.12.6/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 = {
+	"completions-reasoning-mode": wire("completionsReasoningMode", ["request"], "scalar", [
+		"none",
+		"effort",
+		"opt-in",
+		"forced-on"
+	]),
+	"completions-reasoning-history": wire("completionsReasoningHistory", ["request"], "scalar", [
+		"omit",
+		"preserved",
+		"interleaved"
+	]),
+	"anthropic-thinking": wire("anthropicThinking", ["request"], "scalar", [
+		"adaptive",
+		"adaptive-summarized",
+		"budget-interleaved",
+		"budget-effort"
+	]),
+	"anthropic-tool-streaming-beta": wire("anthropicToolStreamingBeta", ["request"]),
+	"openai-platform-header": wire("openaiPlatformHeader", ["request"]),
+	"responses-cache-retention": wire("responsesCacheRetention", ["request"]),
+	"responses-verbosity": wire("responsesVerbosity", ["request"], "scalar", ["low"]),
+	"responses-service-tier": wire("responsesServiceTier", ["request"], "scalar", ["priority"]),
+	"responses-parallel-tool-calls": wire("responsesParallelToolCalls", ["request"]),
+	"responses-safety-identifier": wire("responsesSafetyIdentifier", ["request"]),
+	"responses-tool-choice-auto": wire("responsesToolChoiceAuto", ["request"]),
+	"routing-session-lock": wire("routingSessionLock", ["request"]),
+	"google-thinking": wire("googleThinking", ["request"], "scalar", ["level", "level-medium"]),
+	"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),
+	"disable-reasoning-with-tools": wire("disableReasoningWithTools", ["openai"]),
+	"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"]),
+	"mistral-reasoning-content-parts": wire("mistralReasoningContentParts", ["openai"]),
+	"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),
+	"session-header": wire("sessionHeader", OAI, "scalar", ["x-litellm-session-id"]),
+	"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"]),
+	"synthetic-reasoning-content-fallback": wire("syntheticReasoningContentFallback", ["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"]),
+	"connection-bound-native-history": wire("connectionBoundNativeHistory", ["openai-responses"]),
+	"stateful-responses": wire("statefulResponses", ["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"]),
+	"supports-steering": wire("supportsSteering", ["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"]),
+	"store-responses": wire("storeResponses", ["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"]),
+	"bedrock-messages-api": wire("bedrockMessagesApi", ["anthropic"]),
+	"allow-anthropic-header-overrides": wire("allowAnthropicHeaderOverrides", ["anthropic"]),
+	"disable-adaptive-thinking": wire("disableAdaptiveThinking", ["anthropic"]),
+	"disable-strict-tools": wire("disableStrictTools", ["anthropic"]),
+	"between-tools-effort": wire("betweenToolsEffort", ["anthropic"], "scalar", [
+		"low",
+		"medium",
+		"high"
+	]),
+	"disabled-thinking": wire("disabledThinking", ["anthropic", "bedrock"], "scalar", [
+		"omit",
+		"disabled",
+		"adaptive",
+		"between-tools"
+	]),
+	"effort-beta": wire("effortBeta", ["anthropic"]),
+	"escape-builtin-tool-names": wire("escapeBuiltinToolNames", ["anthropic"]),
+	"fast-mode": wire("fastMode", ["anthropic"]),
+	"first-party-provider": wire("firstPartyProvider", ["anthropic"]),
+	"honors-claude-code-beta-kill-switch": wire("honorsClaudeCodeBetaKillSwitch", ["anthropic"]),
+	"inject-claude-code-instruction": wire("injectClaudeCodeInstruction", ["anthropic"]),
+	"max-image-dimension": wire("maxImageDimension", ["anthropic", "google"]),
+	"max-image-payload-bytes": wire("maxImagePayloadBytes", ["anthropic", "google"]),
+	"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"]),
+	"strip-thinking-history": wire("stripThinkingHistory", [
+		"openai",
+		"anthropic",
+		"ollama"
+	]),
+	"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-server-compaction": wire("supportsServerCompaction", ["anthropic", "bedrock"]),
+	"supports-between-tools-thinking": wire("supportsBetweenToolsThinking", ["anthropic"]),
+	"supports-thinking-binding-controls": wire("supportsThinkingBindingControls", ["anthropic", "bedrock"]),
+	"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", [...OAI, "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"]),
+	/**
+	* Whether this wire may revise text it has already streamed: bytes
+	* reclassified out of the visible channel (a leaned-on thinking opener),
+	* carved into a tool call, reordered by content-block index, or replaced
+	* wholesale by an authoritative final payload. Unassigned means the wire
+	* only appends, so the transcript may retire finished lines into native
+	* scrollback while the turn is still streaming (see
+	* `AssistantMessageComponent`). Declare `possible` only with a citable
+	* mechanism: the renderer also verifies published rows every frame and stops
+	* retiring the block on the first mismatch, so this axis decides where
+	* mid-stream retirement is attempted, not whether it is safe.
+	*/
+	"stream-revision": wire("streamRevision", [...OAI, "bedrock"], "scalar", ["none", "possible"]),
+	"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",
+		"bedrock"
+	]),
+	"supports-sampling-params": wire("supportsSamplingParams", [
+		...OAI,
+		"anthropic",
+		"bedrock",
+		"devin",
+		"google"
+	]),
+	"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,
+		emptyArray: true
+	},
+	"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"
+	},
+	/** Unclassified neutral ids here are capability-unknown: offer the ladder as opt-in. */
+	"thinking-unverified": {
+		key: "unverified",
+		set: "thinking",
+		shape: "scalar"
+	},
+	"apply-patch-tool-type": {
+		key: "applyPatchToolType",
+		set: "catalog",
+		shape: "scalar",
+		values: ["freeform", "function"]
+	},
+	"requires-native-tools": {
+		key: "requiresNativeTools",
+		set: "catalog",
+		shape: "scalar",
+		values: [true, false]
+	},
+	"tool-schemas-in-context": {
+		key: "toolSchemasInContext",
+		set: "catalog",
+		shape: "scalar",
+		values: [true, false]
+	},
+	"requires-tool-free-history-for-tool-opt-out": {
+		key: "requiresToolFreeHistoryForToolOptOut",
+		set: "catalog",
+		shape: "scalar",
+		values: [true, false]
+	},
+	/** Replayed tool calls must satisfy the target wire's declaration charset and length. */
+	"tool-call-name-charset": {
+		key: "toolCallNameCharset",
+		set: "catalog",
+		shape: "scalar",
+		values: ["ascii", "google"]
+	},
+	"tool-call-name-max-length": {
+		key: "toolCallNameMaxLength",
+		set: "catalog",
+		shape: "scalar"
+	},
+	"preserves-max-output-tokens": {
+		key: "preservesMaxOutputTokens",
+		set: "catalog",
+		shape: "scalar",
+		values: [true, false]
+	},
+	"omit-max-output-tokens": {
+		key: "omitMaxOutputTokens",
+		set: "catalog",
+		shape: "scalar",
+		values: [true, false]
+	},
+	/**
+	* The host accepts a prompt plus `max_tokens` beyond the context window and
+	* ends generation at the window (Anthropic `model_context_window_exceeded`)
+	* instead of rejecting the request, so callers must not lower the output cap
+	* to fit the window.
+	*/
+	"stops-output-at-context-window": {
+		key: "stopsOutputAtContextWindow",
+		set: "catalog",
+		shape: "scalar",
+		values: [true, false]
+	},
+	/**
+	* The model's input classifier refuses requests that reproduce assistant
+	* reasoning as quoted text (`reasoning_extraction`), so reasoning must not
+	* be replayed as text into its input: compaction archives, summarizer
+	* transcripts and demoted interrupted turns leave it out. Declared per class
+	* in `classes/*.kdl`.
+	*/
+	"classifier-cot-extraction": {
+		key: "classifierCotExtraction",
+		set: "catalog",
+		shape: "scalar",
+		values: [true, false]
+	},
+	"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"
+	},
+	"context-window-authoritative": {
+		key: "contextWindowAuthoritative",
+		set: "catalog",
+		shape: "scalar",
+		values: [true, false]
+	},
+	/**
+	* The model's long-context price tier does not bound its runtime context
+	* window: with extended context off, the window is not capped at the
+	* tier's input threshold (subscription hosts carrying API-equivalent tier
+	* prices, or a model served at its full window). Explicit user context
+	* overrides still apply.
+	*/
+	"long-context-window-uncapped": {
+		key: "longContextWindowUncapped",
+		set: "catalog",
+		shape: "scalar",
+		values: [true, false]
+	},
+	"cost-patch": {
+		key: "costPatch",
+		set: "catalog",
+		shape: "object"
+	},
+	"cost-fallback": {
+		key: "costFallback",
+		set: "catalog",
+		shape: "object"
+	},
+	/**
+	* The host bills cache-hit input tokens at the full input rate (no cache
+	* discount), so the built row's `cacheRead` tracks its live `input` price.
+	*/
+	"cache-read-at-input-rate": {
+		key: "cacheReadAtInputRate",
+		set: "catalog",
+		shape: "scalar",
+		values: [true, false]
+	},
+	/**
+	* The host bills cache writes at this multiple of the row's live `input`
+	* price, for hosts whose discovery reports cache-write tokens but no
+	* cache-write rate. It replaces any `cacheWrite` the row carries, including
+	* a `cost-patch`/`cost-fallback` value and an absolute long-context tier's
+	* `cacheWrite` (rebased on the tier's `input`).
+	*/
+	"cache-write-rate": {
+		key: "cacheWriteRate",
+		set: "catalog",
+		shape: "scalar"
+	},
+	/**
+	* How the model line bills a replayed signed thinking block as input:
+	* `output` bills the reasoning its signature carries, at the size the turn
+	* billed as output, and not the signature's bytes. Unassigned: estimated
+	* from the signature's bytes. Read through `./thinking-replay`.
+	*/
+	"thinking-replay-tokens": {
+		key: "thinkingReplayTokens",
+		set: "catalog",
+		shape: "scalar",
+		values: ["output", "signature"]
+	},
+	"delegation-bias": {
+		key: "delegationBias",
+		set: "catalog",
+		shape: "scalar",
+		values: DELEGATION_BIASES
+	},
+	"discovery-api": {
+		key: "discoveryApi",
+		set: "catalog",
+		shape: "scalar"
+	},
+	"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"]
+	},
+	kind: {
+		key: "kind",
+		set: "catalog",
+		shape: "scalar",
+		values: MODEL_KINDS
+	},
+	"web-search": {
+		key: "webSearch",
+		set: "catalog",
+		shape: "scalar",
+		values: [
+			"gemini",
+			"anthropic",
+			"codex",
+			"xai",
+			"openrouter",
+			"openai"
+		]
+	},
+	"web-search-model": {
+		key: "webSearchModel",
+		set: "catalog",
+		shape: "scalar"
+	},
+	"hosted-image": {
+		key: "hostedImage",
+		set: "catalog",
+		shape: "scalar",
+		values: [true, false]
+	},
+	/** How the model line bills an input image; shape and formulas in `./image-tokenization`. */
+	"image-tokenization": {
+		key: "imageTokenization",
+		set: "catalog",
+		shape: "object"
+	},
+	/**
+	* Most images one request may carry, documents included where the host
+	* counts them. Unassigned: unknown host, held to a conservative floor.
+	*/
+	"image-count-budget": {
+		key: "imageCountBudget",
+		set: "catalog",
+		shape: "scalar"
+	},
+	/**
+	* Replaces `image-count-budget` while the request reaches the official
+	* endpoint (pi-ai `reachesBudgetedHost`): a limit measured or documented
+	* for the host's own endpoint, which a custom `baseUrl` or an
+	* `ANTHROPIC_BASE_URL`/`FOUNDRY_BASE_URL` reroute (proxy, gateway) need not share.
+	*/
+	"official-image-count-budget": {
+		key: "officialImageCountBudget",
+		set: "catalog",
+		shape: "scalar"
+	},
+	/**
+	* Opt-in: the reader may get a fresh `read` result as snapcompact frames
+	* (`snapcompact.toolResults`), because it edits as exactly from frames as
+	* from text. Unassigned: `read` results stay text, since a reader that
+	* misreads indentation in frames makes inexact edits.
+	*/
+	"snapcompact-image-reads": {
+		key: "snapcompactImageReads",
+		set: "catalog",
+		shape: "scalar",
+		values: [true, false]
+	},
+	"image-model": {
+		key: "imageModel",
+		set: "catalog",
+		shape: "scalar"
+	},
+	/** Longest image edge the host passes to the model: it downscales larger images to fit first. */
+	"image-max-edge": {
+		key: "imageMaxEdge",
+		set: "catalog",
+		shape: "scalar"
+	},
+	"inline-image-byte-budget": {
+		key: "inlineImageByteBudget",
+		set: "catalog",
+		shape: "scalar"
+	},
+	/**
+	* Largest request body the host accepts. Where set, the inline-image byte clamp keeps the newest user message's
+	* and newest tool result's images past `inline-image-byte-budget` while they alone fit this limit.
+	*/
+	"request-body-byte-limit": {
+		key: "requestBodyByteLimit",
+		set: "catalog",
+		shape: "scalar"
+	},
+	/**
+	* Opt-in: the host budgets above apply whenever the request reaches the provider's own catalog endpoint
+	* (`endpoint-hosts`, or an unset `baseUrl`), for a hosted gateway whose compat names no official endpoint.
+	* Unassigned: they apply only on the official endpoint (pi-ai `reachesOfficialEndpoint`).
+	*/
+	"catalog-endpoint-budgets": {
+		key: "catalogEndpointBudgets",
+		set: "catalog",
+		shape: "scalar",
+		values: [true, false]
+	},
+	/**
+	* Supported formats and size bounds for judgment-request images; `mime-types`
+	* is comma-separated because object payloads have no array shape.
+	*/
+	"judgment-image-input": {
+		key: "judgmentImageInput",
+		set: "catalog",
+		shape: "object"
+	},
+	/**
+	* `Content-Encoding`s the host decodes on request bodies, most preferred
+	* first. Applied only while the request reaches the provider's own endpoint
+	* (see `endpoint-hosts`), so a proxy or rerouted endpoint never receives
+	* bytes it cannot read. Unassigned: bodies are sent uncompressed.
+	*/
+	"request-encodings": {
+		key: "requestEncodings",
+		set: "catalog",
+		shape: "array",
+		values: ["zstd", "gzip"]
+	},
+	/**
+	* HTTPS hostnames the provider itself serves besides its bundled base URL's
+	* host — per-account endpoints such as Copilot's plan hosts. Together with
+	* that host they define the provider's own endpoint, which tells first-party
+	* traffic from a custom gateway that reuses the provider id.
+	*/
+	"endpoint-hosts": {
+		key: "endpointHosts",
+		set: "catalog",
+		shape: "array"
+	},
+	/**
+	* Pattern of the JSON 400/415 error body the host returns when it cannot
+	* decode a compressed request body. Unassigned: every JSON 400/415 is a
+	* possible rejection and is re-checked with an uncompressed resend. Either
+	* way, a 400/403/415 whose body is not JSON (presumed a proxy's answer, not
+	* the host's) is re-checked too.
+	*/
+	"request-encoding-rejection": {
+		key: "requestEncodingRejection",
+		set: "catalog",
+		shape: "scalar"
+	},
+	/**
+	* Most questions one System One judgment request may carry; the judge
+	* splits larger requests. Unassigned: the endpoint takes any batch size.
+	*/
+	"judgment-questions-max": {
+		key: "judgmentQuestionsMax",
+		set: "catalog",
+		shape: "scalar"
+	},
+	"limits-patch": {
+		key: "limitsPatch",
+		set: "catalog",
+		shape: "object"
+	},
+	/** Seeds `maxTokens` only when the row reports none; applied after `limits-patch`. */
+	"max-tokens-fallback": {
+		key: "maxTokensFallback",
+		set: "catalog",
+		shape: "scalar"
+	},
+	/** Most output tokens the host serves: a larger reported `maxTokens` is lowered to it; an unknown one stays unknown. */
+	"max-tokens-ceiling": {
+		key: "maxTokensCeiling",
+		set: "catalog",
+		shape: "scalar"
+	},
+	"long-context-cost": {
+		key: "longContext",
+		set: "catalog",
+		shape: "object"
+	},
+	"prompt-cache": {
+		key: "promptCache",
+		set: "catalog",
+		shape: "object"
+	},
+	"task-sibling-prompt-cache": {
+		key: "taskSiblingPromptCache",
+		set: "catalog",
+		shape: "scalar",
+		values: [true, false]
+	},
+	/**
+	* Prompt-cache lookback in block positions: how far back from a cache
+	* breakpoint the provider looks for an earlier request's cache entry.
+	* Unassigned: no known lookback bound.
+	*/
+	"prompt-cache-lookback": {
+		key: "promptCacheLookback",
+		set: "catalog",
+		shape: "scalar"
+	},
+	/**
+	* The provider's own endpoint keeps prompt-cache entries indefinitely
+	* (logged-in Codex subscriptions): an idle gap never cools the prefix, so
+	* rewriting it while idle only discards a warm cache. Read through
+	* `compat/prompt-cache-persistent.ts`. Unassigned: entries expire.
+	*/
+	"prompt-cache-persistent": {
+		key: "promptCachePersistent",
+		set: "catalog",
+		shape: "scalar",
+		values: [true, false]
+	},
+	"long-usage-limit-fallback": {
+		key: "longUsageLimitFallback",
+		set: "catalog",
+		shape: "scalar"
+	},
+	"max-context-window": {
+		key: "maxContextWindow",
+		set: "catalog",
+		shape: "scalar"
+	},
+	/**
+	* Every host of the model returns its full plaintext trace wherever the
+	* wire does not mark reasoning as a summary (`ThinkingContent.summary ===
+	* false` vouches for nothing more), and its identity (class + family +
+	* revision) pins one set of weights, so a turn's reasoning may replay
+	* natively on another host serving the same model. Marked summaries never
+	* carry; do not declare it where a host serves summaries unmarked.
+	* Declared per family in `classes/*.kdl`; a host whose reasoning must not be
+	* carried in or out sets `#false` in its `providers/*.kdl`. Read through
+	* `compat/reasoning-carry.ts`.
+	*/
+	"portable-reasoning": {
+		key: "portableReasoning",
+		set: "catalog",
+		shape: "scalar",
+		values: [true, false]
+	},
+	"pricing-status": {
+		key: "pricingStatus",
+		set: "catalog",
+		shape: "scalar",
+		values: [
+			"free",
+			"included",
+			"variable",
+			"unknown"
+		]
+	},
+	"requires-cursor-tool-schema-projection": {
+		key: "requiresCursorToolSchemaProjection",
+		set: "catalog",
+		shape: "scalar"
+	},
+	"requires-tool-result-image-hoisting": {
+		key: "requiresToolResultImageHoisting",
+		set: "catalog",
+		shape: "scalar"
+	},
+	"supports-assistant-prefill": {
+		key: "supportsAssistantPrefill",
+		set: "catalog",
+		shape: "scalar"
+	},
+	/**
+	* Ordered Anthropic model ids forwarded as the server-side `fallbacks`
+	* chain when the user opts in. Each must appear in the requested model's
+	* `allowed_fallback_models` (GET /v1/models/{id}); anything else is a 400.
+	*/
+	"server-side-fallback-models": {
+		key: "serverSideFallbackModels",
+		set: "catalog",
+		shape: "array"
+	},
+	/**
+	* Anthropic model ids a refusal's `fallback_credit_token` may be redeemed
+	* on (the refused model's permitted fallback targets). Unordered; a retry
+	* on any other model cannot redeem the credit.
+	*/
+	"fallback-credit-targets": {
+		key: "fallbackCreditTargets",
+		set: "catalog",
+		shape: "array"
+	},
+	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"
+	},
+	/** Ordered upstream rotation; the first entry is the default `x-api-provider`. */
+	"upstream-rotation": {
+		key: "upstreamRotation",
+		set: "catalog",
+		shape: "array",
+		values: FACTORY_DROID_UPSTREAMS
+	},
+	/**
+	* Upstreams eligible to serve one inference region. The provider-wide rule
+	* is the upstream serving table; a model rule replaces it (the native
+	* region override), and a bare directive means the region never serves it.
+	*/
+	"region-upstreams-global": {
+		key: "regionUpstreamsGlobal",
+		set: "catalog",
+		shape: "array",
+		values: FACTORY_DROID_UPSTREAMS,
+		emptyArray: true
+	},
+	"region-upstreams-us": {
+		key: "regionUpstreamsUs",
+		set: "catalog",
+		shape: "array",
+		values: FACTORY_DROID_UPSTREAMS,
+		emptyArray: true
+	},
+	"region-upstreams-eu": {
+		key: "regionUpstreamsEu",
+		set: "catalog",
+		shape: "array",
+		values: FACTORY_DROID_UPSTREAMS,
+		emptyArray: true
+	},
+	/** EU inference limits (`context-window`, `max-tokens`) where the region narrows the default. */
+	"region-limits-eu": {
+		key: "regionLimitsEu",
+		set: "catalog",
+		shape: "object"
+	},
+	/**
+	* Subscription credit rates: `input` is the per-token credit weight shown
+	* as the model's multiplier; `output` and `cache-read` multiply it.
+	*/
+	"credit-rates": {
+		key: "creditRates",
+		set: "catalog",
+		shape: "object"
+	},
+	/**
+	* List price borrowed from a bundled catalog row: provider id, then the
+	* row id when it differs from the model's own. Absent means no list price.
+	*/
+	"list-price-from": {
+		key: "listPriceFrom",
+		set: "catalog",
+		shape: "array"
+	},
+	/** Provider family whose live routing defaults apply to the model. */
+	"routing-family": {
+		key: "routingFamily",
+		set: "catalog",
+		shape: "scalar",
+		values: [
+			"anthropic",
+			"openai",
+			"google",
+			"factory",
+			"xai"
+		]
+	},
+	/** Other ids organization policy may use for the model. */
+	"policy-aliases": {
+		key: "policyAliases",
+		set: "catalog",
+		shape: "array"
+	},
+	/**
+	* Account gates: `feature-flag` must be on to list the model,
+	* `deprecation-flag` hides it once on, `requires-explicit-opt-in` hides it
+	* without an org policy, and `base-variant` marks a fast tier of that model.
+	*/
+	entitlement: {
+		key: "entitlement",
+		set: "catalog",
+		shape: "object"
+	},
+	/** The native default when the caller picks no effort is thinking off. */
+	"default-reasoning-off": {
+		key: "defaultReasoningOff",
+		set: "catalog",
+		shape: "scalar",
+		values: [true, false]
+	}
+};
+/** Records applicable to each API family; used by `resolve.ts` when applying wire axes. */
+const API_COMPAT_RECORDS = {
+	"ollama-chat": ["ollama"],
+	"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.12.6/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.
+*/
+const REQUEST_AXIS_KEYS = Object.values(AXES).filter((axis) => axis.records?.includes("request")).map((axis) => axis.key);
+function resolveRequestPolicy(axes) {
+	const policy = {};
+	for (const key of REQUEST_AXIS_KEYS) if (key in axes.wire) policy[key] = axes.wire[key];
+	return policy;
+}
+/** 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; Haiku ≥ 5.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");
+		if (this.family("haiku")) return this.revGte("5.5");
+		return false;
+	}
+};
+/**
+* The id a spec resolves identity and rules under: its own, unless that names
+* no model and the row sends a model that does on the wire. A Devin Fusion
+* pairing runs only its lead, so the lead's reviewed rules (cache-write rate,
+* long-context tier) apply to it at build time.
+*/
+function policyModelId(spec) {
+	const wireId = spec.requestModelId;
+	if (wireId === void 0 || wireId === spec.id) return spec.id;
+	if (classifyModel(spec.provider, spec.id).class !== "unknown") return spec.id;
+	return classifyModel(spec.provider, wireId).class === "unknown" ? spec.id : wireId;
+}
+function resolveIdentity(spec) {
+	return classifyModel(spec.provider, policyModelId(spec));
+}
+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)) 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(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();
+		if (hostname.endsWith(".")) hostname = hostname.slice(0, -1);
+	} 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, reasoningCapable) {
+	const provider = spec.provider;
+	const backendProvider = spec.providerType ?? 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")) && reasoningCapable;
+	const isLocalOpenAICompatBackend = PROXY_OPENAI_COMPAT_PROVIDERS[backendProvider] !== true && (LOCAL_OPENAI_COMPAT_PROVIDERS[backendProvider] === true || hasLocalLoopbackBaseUrl(baseUrl));
+	return {
+		facts,
+		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, reasoningCapable) {
+	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 : reasoningCapable && facts.is("kimi") && (facts.family("k3") || facts.family("k2.7-code")) && hostMatchesUrl(baseUrl, "moonshotNative") ? 3e5 : reasoningCapable && 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),
+		trustExplicitThinkingOnly: void 0,
+		supportsReasoningParams: true,
+		supportsSamplingParams: true,
+		supportsPenaltyAndStopParams: !(isGrok && reasoningCapable),
+		reasoningEffortMap: {},
+		supportsUsageInStreaming: !isCerebrasHost,
+		alwaysSendMaxTokens: facts.is("kimi"),
+		disableReasoningOnForcedToolChoice: facts.is("kimi") && !isMoonshotKimiK3 || isAnthropicModel,
+		disableReasoningOnToolChoice: isDeepseekFamily && reasoningCapable && !d.isOpenRouter,
+		disableReasoningWithTools: false,
+		supportsToolChoice: !d.isDirectDeepseekReasoning,
+		supportsForcedToolChoice: !d.requiresEnabledThinking && !(d.isOpenCodeHost && d.isDeepseekReasoning),
+		supportsNamedToolChoice: true,
+		maxTokensField: useMaxTokens ? "max_tokens" : "max_completion_tokens",
+		requiresToolResultName: isMistral,
+		requiresAssistantAfterToolResult: isMistral,
+		requiresThinkingAsText: isMistral,
+		requiresMistralToolIds: isMistral,
+		thinkingFormat,
+		kimiApiFormat: void 0,
+		reasoningDisableMode: d.isVenice ? "venice-disable-thinking" : resolveReasoningDisableMode(thinkingFormat),
+		omitReasoningEffort: false,
+		includeEncryptedReasoning: true,
+		filterReasoningHistory: d.isOpenRouter && isAnthropicModel,
+		thinkingKeep: usesMoonshotKimiPreservedThinking ? "all" : void 0,
+		reasoningContentField: "reasoning_content",
+		mistralReasoningContentParts: void 0,
+		requiresReasoningContentForToolCalls: facts.is("kimi") && !d.isOpenCodeProvider || isDeepseekFamily && reasoningCapable || d.isXiaomiMimo || d.isOpenRouter && reasoningCapable,
+		requiresReasoningContentForAllAssistantTurns: (isDeepseekFamily && reasoningCapable || d.isXiaomiMimo) && !d.isOpenRouter,
+		allowsSyntheticReasoningContentForToolCalls: (!isDeepseekFamily || !reasoningCapable) && !d.isXiaomiMimo,
+		syntheticReasoningContentFallback: void 0,
+		replayReasoningContent: d.isLocalOpenAICompatBackend,
+		qwenPreserveThinking: (thinkingFormat === "qwen" || thinkingFormat === "qwen-chat-template") && d.isLocalOpenAICompatBackend,
+		qwenTemplateReasoningEffort: false,
+		requiresAssistantContentForToolCalls: facts.is("kimi") || d.isDirectDeepseekReasoning,
+		cacheControlFormat: 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: false,
+		stripThinkingHistory: void 0,
+		officialEndpoint: isOfficialOpenAIEndpoint(spec.provider, baseUrl) || void 0,
+		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: d.isLocalOpenAICompatBackend,
+		stripImageInput: false,
+		thinkingLoopGuard: void 0,
+		rejectRootObjectUnion: false,
+		retryWithoutStrictOnGrammarError: false,
+		supportsPromptCacheKey: false
+	};
+}
+/**
+* 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. DSML is DeepSeek's own tool-call grammar, so
+* every host serving a DeepSeek model gets it — gateways, local backends, and
+* custom providers alike.
+*/
+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")) 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.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 = compatReasoning(spec, axes) ? objectPayload(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 reasoningCapable = compatReasoning(spec, axes);
+	const d = detectOpenAI(spec, facts, reasoningCapable);
+	const compat = detectOpenAICompat(spec, d, reasoningCapable);
+	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 backendProvider = spec.providerType ?? 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 = compatReasoning(spec, axes);
+	const isLocalServingBackend = PROXY_OPENAI_COMPAT_PROVIDERS[backendProvider] !== true && LOCAL_OPENAI_COMPAT_PROVIDERS[backendProvider] === 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,
+		trustExplicitThinkingOnly: void 0,
+		supportsLongPromptCacheRetention: isOpenAIUrl,
+		supportsPromptCacheBreakpoints,
+		promptCacheBreakpointTtl: supportsPromptCacheBreakpoints ? "30m" : void 0,
+		strictResponsesPairing: hostMatchesUrl(baseUrl, "azureOpenAI"),
+		supportsImageDetailOriginal: isOpenAIUrl || hostMatchesUrl(baseUrl, "azureOpenAI") || isAzure && !baseUrl || hostMatchesUrl(baseUrl, "openaiCodex"),
+		supportsReasoningSummary: !isXaiHost,
+		statefulResponses: void 0,
+		supportsAllTurnsReasoningContext: false,
+		supportsConfigurationUpdate: false,
+		supportsSteering: false,
+		requiresReasoningOffJuiceInstruction: false,
+		stripImageInput: false,
+		thinkingLoopGuard: void 0,
+		reasoningEffortMap: {},
+		supportsReasoningParams: true,
+		supportsSamplingParams: true,
+		supportsPenaltyAndStopParams: !isXaiHost,
+		thinkingFormat,
+		reasoningDisableMode: resolveReasoningDisableMode(thinkingFormat),
+		omitReasoningEffort: false,
+		includeEncryptedReasoning: true,
+		filterReasoningHistory: isOpenRouter && isAnthropicModel,
+		disableReasoningOnForcedToolChoice: facts.is("kimi"),
+		disableReasoningOnToolChoice: isDeepseekFamily && reasoningCapable && !isOpenRouter,
+		disableReasoningWithTools: false,
+		supportsToolChoice: true,
+		supportsForcedToolChoice: true,
+		supportsNamedToolChoice: true,
+		reasoningContentField: "reasoning_content",
+		requiresReasoningContentForToolCalls: (facts.is("kimi") || isDeepseekFamily && reasoningCapable || isOpenRouter && reasoningCapable) && reasoningCapable,
+		requiresReasoningContentForAllAssistantTurns: isDeepseekFamily && reasoningCapable && !isOpenRouter,
+		allowsSyntheticReasoningContentForToolCalls: !isDeepseekFamily || !reasoningCapable,
+		syntheticReasoningContentFallback: void 0,
+		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: PROXY_OPENAI_COMPAT_PROVIDERS[backendProvider] !== true && (LOCAL_OPENAI_COMPAT_PROVIDERS[backendProvider] === true || hasLocalLoopbackBaseUrl(baseUrl)),
+		supportsObfuscationOptOut: isOpenAIUrl || provider === "openai",
+		storeResponses: false,
+		connectionBoundNativeHistory: false,
+		officialEndpoint: isOfficialOpenAIEndpoint(provider, baseUrl) || api === "openai-codex-responses" && isOfficialCodexApiUrl(baseUrl),
+		harmonyLeakMitigation: false,
+		rejectRootObjectUnion: false,
+		retryWithoutStrictOnGrammarError: false,
+		cacheControlFormat: isOpenRouter && isAnthropicModel ? "anthropic" : void 0,
+		stripDeepseekSpecialTokens: false,
+		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,
+		storeResponses: compat.storeResponses,
+		connectionBoundNativeHistory: compat.connectionBoundNativeHistory,
+		supportsAllTurnsReasoningContext: compat.supportsAllTurnsReasoningContext,
+		supportsConfigurationUpdate: compat.supportsConfigurationUpdate,
+		supportsSteering: compat.supportsSteering,
+		officialEndpoint: compat.officialEndpoint,
+		harmonyLeakMitigation: compat.harmonyLeakMitigation,
+		cacheControlFormat: compat.cacheControlFormat,
+		requiresReasoningOffJuiceInstruction: compat.requiresReasoningOffJuiceInstruction,
+		supportsReasoningSummary: compat.supportsReasoningSummary,
+		statefulResponses: compat.statefulResponses,
+		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 bedrockMessagesApi = isBedrockAnthropicRoute(baseUrl);
+	const rejectsStrictTools = isAzureAnthropicRoute(baseUrl) || bedrockMessagesApi;
+	const signingEndpoint = official || isCopilot || isZenmux || isAnthropicSigningProxyUrl(baseUrl);
+	const compat = {
+		officialEndpoint: official,
+		signingEndpoint,
+		supportsContextManagement: true,
+		supportsServerCompaction: false,
+		firstPartyProvider: false,
+		honorsClaudeCodeBetaKillSwitch: false,
+		supportsOutputEffort: true,
+		disableStrictTools: rejectsStrictTools,
+		bedrockMessagesApi: bedrockMessagesApi || void 0,
+		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,
+		supportsBetweenToolsThinking: false,
+		supportsForcedToolChoice: !requiresThinkingEnabled && !facts.family("fable", "mythos"),
+		supportsSamplingParams: true,
+		requiresToolResultId: false,
+		requiresThinkingEnabled,
+		replayUnsignedThinking: !signingEndpoint && (compatReasoning(spec, axes) || modelMatchesHost(spec, "deepseekFamily")),
+		escapeBuiltinToolNames: false,
+		injectClaudeCodeInstruction: true,
+		stripImageInput: false,
+		maxImageDimension: void 0,
+		maxImagePayloadBytes: void 0,
+		thinkingLoopGuard: void 0,
+		stripThinkingHistory: void 0,
+		fastMode: 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",
+		supportsServerCompaction: false,
+		supportsLongPromptCacheRetention: false,
+		promptCacheMinimumTokens: 0,
+		promptCacheMaximumCheckpoints: 0,
+		supportsForcedToolChoice: true,
+		supportsThinkingBindingControls: true
+	};
+	compat.streamIdleTimeoutMs = compatReasoning(spec, axes) ? BEDROCK_REASONING_STREAM_IDLE_TIMEOUT_MS : void 0;
+	applyWireAxes(compat, axes.wire, "bedrock-converse-stream");
+	applyCompatOverrides(compat, spec.compat);
+	return compat;
+}
+function resolveOllamaPolicy(spec, axes) {
+	const compat = { stripThinkingHistory: false };
+	applyWireAxes(compat, axes.wire, "ollama-chat");
+	applyCompatOverrides(compat, spec.compat);
+	return compat;
+}
+function resolveDevinPolicy(spec, axes) {
+	const compat = {
+		trustExplicitThinkingOnly: false,
+		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,
+		maxImageDimension: void 0,
+		maxImagePayloadBytes: void 0
+	};
+	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;
+}
+/**
+* URL-keyed Fireworks effort remap: covers custom provider ids pointed at the
+* Fireworks host, which the `fireworks`/`firepass` `thinking-effort-map`
+* rules cannot match. Rule and configured maps override it.
+*/
+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 "budget";
+		case "anthropic-messages":
+			if (facts.is("anthropic")) {
+				if (facts.revGte(facts.family("haiku") ? "5.5" : "4.6")) 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;
+	if (typeof raw.unverified === "boolean") out.unverified = raw.unverified;
+	return out;
+}
+/**
+* Compat-time reasoning capability. `axes.reasoning` also promotes targets on
+* reviewed effort corrections (the cascade's thinking-axis gate), but compat
+* may only be repaired where the matching contract opted in with
+* `thinking-upgrade-neutral`; everywhere else a spec that reports no reasoning
+* stays the authoritative capability surface.
+*/
+function compatReasoning(spec, axes) {
+	if (spec.reasoning) return true;
+	return axes.reasoning && readRuleThinking(axes).upgradeNeutral === true;
+}
+/** 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;
+	const unverified = !compatReasoning(spec, axes);
+	if (unverified && (explicitThinking !== void 0 || facts.identity.class !== "unknown" || rule.unverified !== true)) 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;
+	if (rule.efforts?.length === 0) return void 0;
+	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`);
+	const effortMap = mergeEffortMap(spec, rule.effortMap, compat, config.efforts);
+	if (effortMap !== void 0) config.effortMap = effortMap;
+	if (unverified) {
+		config.unverified = true;
+		return config;
+	}
+	if (rule.defaultLevel !== void 0) config.defaultLevel = rule.defaultLevel;
+	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;
+	const needsEffortBudgets = thinking.effortBudgets === void 0 && rule.effortBudgets !== void 0;
+	if (effortMap === void 0 && !needsDisplay && !needsRequiresEffort && !needsDefaultLevel && !needsPrefixBinding && !needsEffortBudgets) 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;
+	if (needsEffortBudgets) filled.effortBudgets = rule.effortBudgets;
+	return filled;
+}
+function buildResolveTarget(spec, identity, providerType = spec.providerType ?? spec.provider) {
+	const target = {
+		provider: providerType,
+		api: spec.api,
+		class: identity.class,
+		model: policyModelId(spec),
+		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;
+}
+/**
+* Catalog-data axis assignments for one model spec — the `catalog` field of
+* {@link resolveModelPolicy} without resolving the compat and thinking
+* policies, which dominate its cost on catalog-wide scans.
+*/
+function resolveCatalogAxes(spec) {
+	return resolveCascade(buildResolveTarget(spec, resolveIdentity(spec))).catalog;
+}
+function resolveModelPolicy(input, route) {
+	const spec = withoutUnverifiedThinking(input);
+	const identity = resolveIdentity(spec);
+	const facts = new IdentityFacts(identity);
+	const target = buildResolveTarget(spec, identity);
+	target.upstream = route?.upstream;
+	const axes = resolveCascade(target);
+	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, "ollama-chat")) compat = resolveOllamaPolicy(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,
+		request: resolveRequestPolicy(axes)
+	};
+}
+/**
+* Whether reviewed rules know THIS model's effort ladder, as opposed to it
+* inheriting a provider-wide default or {@link resolveThinkingPolicy} falling
+* through to the neutral wire ladder.
+*
+* Discovery uses this to tell "omp knows this model's tiers" apart from "omp
+* is guessing them", so catalog-published tiers can correct the guess without
+* ever overriding reviewed knowledge.
+*/
+function hasModelScopedEffortLadder(spec) {
+	return hasModelScopedEffortsRule(buildResolveTarget(spec, resolveIdentity(spec)));
+}
+//#endregion
+//#region node_modules/.pnpm/@oh-my-pi+pi-catalog@18.12.6/node_modules/@oh-my-pi/pi-catalog/src/identity/id.ts
+const LEADING_BRACKETED_AFFIX_PATTERN = /^(?:\s*(?:\[|【)[^\]】]+(?:\]|】)\s*)+/u;
+const TRAILING_BRACKETED_AFFIX_PATTERN = /(?:\s*(?:\[|【)[^\]】]+(?:\]|】)\s*)+$/u;
+/** Strip a provider namespace prefix (`openai/gpt-5.4` → `gpt-5.4`). */
+const bareModelIdCache = /* @__PURE__ */ new Map();
+function bareModelId(modelId) {
+	const cached = bareModelIdCache.get(modelId);
+	if (cached !== void 0) return cached;
+	const separator = modelId.lastIndexOf("/");
+	const result = separator === -1 ? modelId : modelId.slice(separator + 1);
+	bareModelIdCache.set(modelId, result);
+	return result;
+}
+const MODEL_ID_SEGMENT_PATTERN = /[a-z0-9.:-]+/g;
+const MODEL_FAMILY_PREFIX_PATTERN = /^(claude|gemini|gpt|grok|glm|qwen|deepseek|kimi|mimo|doubao|ernie|gpt-oss|gemma|minimax|step|command|jamba|llama|o[1345])/i;
+function normalizeModelIdWhitespace(value) {
+	return value.trim().replace(/\s+/g, " ");
+}
+/** Ordering for model-like segments: longest first, ties broken lexicographically. */
+function compareSegmentPreference(left, right) {
+	return left.length !== right.length ? right.length - left.length : left.localeCompare(right);
+}
+function getModelLikeIdSegments(modelId) {
+	const matches = normalizeModelIdWhitespace(modelId).toLowerCase().match(MODEL_ID_SEGMENT_PATTERN);
+	if (!matches) return [];
+	const segments = /* @__PURE__ */ new Set();
+	for (const segment of matches) if (MODEL_FAMILY_PREFIX_PATTERN.test(segment) && /\d/.test(segment)) segments.add(segment);
+	return [...segments].sort(compareSegmentPreference);
+}
+function getLongestModelLikeIdSegment(modelId) {
+	const matches = normalizeModelIdWhitespace(modelId).toLowerCase().match(MODEL_ID_SEGMENT_PATTERN);
+	if (!matches) return void 0;
+	let best;
+	for (const segment of matches) if (MODEL_FAMILY_PREFIX_PATTERN.test(segment) && /\d/.test(segment) && (best === void 0 || compareSegmentPreference(segment, best) < 0)) best = segment;
+	return best;
+}
+function hasBracketAffixMarker(value) {
+	for (let index = 0; index < value.length; index++) {
+		const code = value.charCodeAt(index);
+		if (code === 91 || code === 93 || code === 12304 || code === 12305) return true;
+	}
+	return false;
+}
+/**
+* Strip reseller / wrapper tags that are injected as bracketed affixes around an
+* upstream model id, e.g.
+*   "[Kiro] claude-opus-4-8"                -> "claude-opus-4-8"
+*   "[gcli转] gemini-3.1-pro-preview [假流]" -> "gemini-3.1-pro-preview"
+*
+* Candidates are returned most-stripped first: both ends, then leading-only, then trailing-only.
+*/
+function getBracketStrippedModelIdCandidates(modelId) {
+	if (!hasBracketAffixMarker(modelId)) return [];
+	const normalized = normalizeModelIdWhitespace(modelId);
+	if (!normalized) return [];
+	const strippedLeading = normalized.replace(LEADING_BRACKETED_AFFIX_PATTERN, "");
+	const withoutLeading = normalizeModelIdWhitespace(strippedLeading);
+	const withoutTrailing = normalizeModelIdWhitespace(normalized.replace(TRAILING_BRACKETED_AFFIX_PATTERN, ""));
+	const withoutBoth = normalizeModelIdWhitespace(strippedLeading.replace(TRAILING_BRACKETED_AFFIX_PATTERN, ""));
+	const candidates = /* @__PURE__ */ new Set();
+	for (const candidate of [
+		withoutBoth,
+		withoutLeading,
+		withoutTrailing
+	]) if (candidate && candidate !== normalized) candidates.add(candidate);
+	return [...candidates];
+}
+//#endregion
+export { withoutUnverifiedThinking as A, applyCodexResidencyHeader as C, mapEffortToAnthropicAdaptiveEffort as D, getSupportedEfforts as E, resolveVertexEndpointHost as F, Effort as I, THINKING_EFFORTS as L, isBedrockRouteUrl as M, isVertexRawPredictUrl as N, requireSupportedEffort as O, modelMatchesHost as P, OPENAI_HEADER_VALUES as S, getCodexAccountId as T, isBedrockAnthropicRoute as _, hasModelScopedEffortLadder as a, CODEX_CLIENT_VERSION as b, FACTORY_DROID_WIRES as c, factoryDroidModelCacheProviderId as d, factoryDroidWireBaseUrl as f, isAnthropicSigningProxyUrl as g, MODEL_KINDS as h, getModelLikeIdSegments as i, hostMatchesUrl as j, resolveWireModelId as k, factoryDroidApiBaseUrl as l, KIND_API_KINDS as m, getBracketStrippedModelIdCandidates as n, resolveCatalogAxes as o, resolveFactoryDroidInferenceRegion as p, getLongestModelLikeIdSegment as r, resolveModelPolicy as s, bareModelId as t, factoryDroidClientHeaders as u, isOfficialAnthropicApiUrl as v, codexRoutingHint as w, OPENAI_HEADERS as x, CODEX_BASE_URL as y };