@linxiraos/pi-catalog 1.1.7 → 1.1.9

package/src/compat/axes.ts

@@ -0,0 +1,301 @@
+/**
+ * The closed compat-axis vocabulary: every KDL cascade directive, the resolved
+ * camelCase field it assigns, its value shape, and — for wire axes — the
+ * compat records it applies to.
+ *
+ * Single source of truth shared by the compile-time rule compiler
+ * (`scripts/compat-compiler`) and the runtime engine (`./resolve`). The
+ * compiler rejects any directive absent from this table; the runtime assigns
+ * a wire axis onto a model's compat record only when the model's API maps to
+ * one of the axis's declared records.
+ */
+import type { Effort } from "../effort";
+import type { ThinkingControlMode } from "../types";
+
+/** Value shape a directive accepts (see `rules/README.md`). */
+export type AxisShape = "scalar" | "array" | "object";
+
+/** Axis namespace: request-wire compat, thinking control surface, or catalog metadata. */
+export type AxisSet = "wire" | "thinking" | "catalog";
+
+/** Resolved compat record families a wire axis may be assigned onto. */
+export type CompatRecordName = "openai" | "openai-responses" | "anthropic" | "bedrock" | "devin" | "google";
+
+/** One axis definition: resolved key, namespace, shape, and applicability. */
+export interface AxisDef {
+	/** Resolved camelCase field the directive assigns. */
+	key: string;
+	set: AxisSet;
+	shape: AxisShape;
+	/** Wire axes only: records this key exists on. */
+	records?: readonly CompatRecordName[];
+	/** Closed value vocabulary for string scalars / string arrays. */
+	values?: readonly string[];
+	/**
+	 * Object axes only: payload child names are literal wire JSON keys copied
+	 * verbatim (`extra-body`). Default object payloads author kebab-case names
+	 * that compile to camelCase resolved keys.
+	 */
+	verbatimKeys?: true;
+}
+
+const OAI = ["openai", "openai-responses"] as const;
+const EFFORTS = ["minimal", "low", "medium", "high", "xhigh", "max"] as const;
+
+/** Effort tiers accepted by taxonomy collapse/override vocabulary (`Effort` ∪ `"off"`). */
+export const EFFORT_TIERS: readonly string[] = [...EFFORTS, "off"];
+
+/**
+ * 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.
+ */
+export const DELEGATION_BIASES = ["eager", "restrained", "gated"] as const;
+const THINKING_MODES = [
+	"effort",
+	"budget",
+	"google-level",
+	"anthropic-adaptive",
+	"anthropic-budget-effort",
+] as const satisfies readonly ThinkingControlMode[];
+
+/** Narrow a KDL string to an effort tier (`Effort` ∪ `"off"`). */
+export function isEffortTier(value: string): value is Effort | "off" {
+	return EFFORT_TIERS.includes(value);
+}
+
+/** Narrow a KDL string to a thinking control mode. */
+export function isThinkingMode(value: string): value is ThinkingControlMode {
+	return (THINKING_MODES as readonly string[]).includes(value);
+}
+
+function wire(
+	key: string,
+	records: readonly CompatRecordName[],
+	shape: AxisShape = "scalar",
+	values?: readonly string[],
+): AxisDef {
+	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.
+ */
+export const AXES: Readonly<Record<string, AxisDef>> = {
+	// ── wire: OpenAI-compatible surfaces (chat completions + Responses) ──
+	"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", ["openai"]),
+	"disable-reasoning-on-forced-tool-choice": wire("disableReasoningOnForcedToolChoice", OAI),
+	"disable-reasoning-on-tool-choice": wire("disableReasoningOnToolChoice", OAI),
+	"drop-thinking-when-reasoning-effort": wire("dropThinkingWhenReasoningEffort", ["openai"]),
+	"empty-length-finish-is-context-error": wire("emptyLengthFinishIsContextError", OAI),
+	"extra-body": { ...wire("extraBody", ["openai"], "object"), verbatimKeys: true },
+	"filter-reasoning-history": wire("filterReasoningHistory", OAI),
+	"include-encrypted-reasoning": wire("includeEncryptedReasoning", OAI),
+	"kimi-api-format": wire("kimiApiFormat", ["openai"], "scalar", ["openai", "anthropic"]),
+	"max-tokens-field": wire("maxTokensField", ["openai"], "scalar", ["max_completion_tokens", "max_tokens"]),
+	"native-kimi-k3-reasoning": wire("nativeKimiK3Reasoning", ["openai"]),
+	"omit-reasoning-effort": wire("omitReasoningEffort", OAI),
+	"prompt-cache-breakpoint-ttl": wire("promptCacheBreakpointTtl", OAI, "scalar", ["30m"]),
+	"prompt-cache-session-header": wire("promptCacheSessionHeader", OAI, "scalar", ["x-grok-conv-id"]),
+	"qwen-preserve-thinking": wire("qwenPreserveThinking", ["openai"]),
+	"reject-root-object-union": wire("rejectRootObjectUnion", OAI),
+	"retry-without-strict-on-grammar-error": wire("retryWithoutStrictOnGrammarError", OAI),
+	"reasoning-content-field": wire("reasoningContentField", OAI, "scalar", [
+		"reasoning_content",
+		"reasoning",
+		"reasoning_text",
+	]),
+	"reasoning-deltas-may-be-cumulative": wire("reasoningDeltasMayBeCumulative", OAI),
+	"reasoning-disable-mode": wire("reasoningDisableMode", OAI, "scalar", [
+		"omit",
+		"lowest-effort",
+		"none-effort",
+		"openrouter-enabled-false",
+		"cline-enabled-false",
+		"venice-disable-thinking",
+		"zai-thinking-disabled",
+		"qwen-enable-thinking-false",
+		"qwen-template-false",
+		"chat-template-thinking-false",
+	]),
+	"reasoning-effort-map": wire("reasoningEffortMap", OAI, "object"),
+	"replay-reasoning-content": wire("replayReasoningContent", ["openai"]),
+	"requires-assistant-after-tool-result": wire("requiresAssistantAfterToolResult", ["openai"]),
+	"requires-assistant-content-for-tool-calls": wire("requiresAssistantContentForToolCalls", OAI),
+	"requires-mistral-tool-ids": wire("requiresMistralToolIds", ["openai"]),
+	"requires-reasoning-content-for-all-assistant-turns": wire("requiresReasoningContentForAllAssistantTurns", OAI),
+	"requires-reasoning-content-for-tool-calls": wire("requiresReasoningContentForToolCalls", OAI),
+	"requires-thinking-as-text": wire("requiresThinkingAsText", ["openai"]),
+	"requires-tool-result-name": wire("requiresToolResultName", ["openai"]),
+	"strict-responses-pairing": wire("strictResponsesPairing", ["openai-responses"]),
+	"requires-reasoning-off-juice-instruction": wire("requiresReasoningOffJuiceInstruction", ["openai-responses"]),
+	"supports-all-turns-reasoning-context": wire("supportsAllTurnsReasoningContext", ["openai-responses"]),
+	"supports-configuration-update": wire("supportsConfigurationUpdate", ["openai-responses"]),
+	"strip-deepseek-special-tokens": wire("stripDeepseekSpecialTokens", OAI),
+	"stream-markup-healing-pattern": wire("streamMarkupHealingPattern", OAI, "scalar", [
+		"kimi",
+		"dsml",
+		"qwen",
+		"thinking",
+		"harmony",
+	]),
+	"supports-developer-role": wire("supportsDeveloperRole", OAI),
+	"supports-image-detail-original": wire("supportsImageDetailOriginal", ["openai-responses"]),
+	"supports-long-prompt-cache-retention": wire("supportsLongPromptCacheRetention", [...OAI, "bedrock"]),
+	"supports-multiple-system-messages": wire("supportsMultipleSystemMessages", ["openai"]),
+	"supports-named-tool-choice": wire("supportsNamedToolChoice", OAI),
+	"supports-obfuscation-opt-out": wire("supportsObfuscationOptOut", ["openai-responses"]),
+	"harmony-leak-mitigation": wire("harmonyLeakMitigation", ["openai-responses"]),
+	"supports-penalty-and-stop-params": wire("supportsPenaltyAndStopParams", OAI),
+	"supports-prompt-cache-breakpoints": wire("supportsPromptCacheBreakpoints", OAI),
+	"supports-prompt-cache-key": wire("supportsPromptCacheKey", ["openai"]),
+	"supports-reasoning-effort": wire("supportsReasoningEffort", OAI),
+	"supports-reasoning-params": wire("supportsReasoningParams", OAI),
+	"supports-reasoning-summary": wire("supportsReasoningSummary", ["openai-responses"]),
+	"supports-store": wire("supportsStore", ["openai"]),
+	"supports-strict-mode": wire("supportsStrictMode", OAI),
+	"supports-tool-choice": wire("supportsToolChoice", OAI),
+	"supports-usage-in-streaming": wire("supportsUsageInStreaming", ["openai"]),
+	"template-reasoning-effort": wire("qwenTemplateReasoningEffort", ["openai"]),
+	"thinking-format": wire("thinkingFormat", OAI, "scalar", [
+		"openai",
+		"openrouter",
+		"zai",
+		"kimi",
+		"qwen",
+		"qwen-chat-template",
+		"chat-template",
+	]),
+	"thinking-keep": wire("thinkingKeep", ["openai"]),
+	"tool-schema-flavor": wire("toolSchemaFlavor", OAI, "scalar", ["moonshot-mfjs", "grammar", "none"]),
+	"tool-strict-mode": wire("toolStrictMode", ["openai"], "scalar", ["all_strict", "none", "mixed"]),
+	"uses-openai-tool-call-id-limit": wire("usesOpenAIToolCallIdLimit", OAI),
+	"when-thinking": wire("whenThinking", ["openai"], "object"),
+	"wire-model-id-mode": wire("wireModelIdMode", OAI, "scalar", [
+		"raw",
+		"cline-pass",
+		"firepass",
+		"fireworks",
+		"openrouter",
+	]),
+	"zai-reasoning-effort-dialect": wire("zaiReasoningEffortDialect", ["openai"]),
+
+	// ── wire: anthropic-messages ──
+	"allow-anthropic-header-overrides": wire("allowAnthropicHeaderOverrides", ["anthropic"]),
+	"disable-adaptive-thinking": wire("disableAdaptiveThinking", ["anthropic"]),
+	"disable-strict-tools": wire("disableStrictTools", ["anthropic"]),
+	"escape-builtin-tool-names": wire("escapeBuiltinToolNames", ["anthropic"]),
+	"inject-claude-code-instruction": wire("injectClaudeCodeInstruction", ["anthropic"]),
+	"official-endpoint": wire("officialEndpoint", ["anthropic", "openai-responses"]),
+	"replay-unsigned-thinking": wire("replayUnsignedThinking", ["anthropic"]),
+	"requires-thinking-enabled": wire("requiresThinkingEnabled", ["anthropic"]),
+	"requires-tool-result-id": wire("requiresToolResultId", ["anthropic"]),
+	"signing-endpoint": wire("signingEndpoint", ["anthropic"]),
+	"supports-context-management": wire("supportsContextManagement", ["anthropic"]),
+	"supports-output-effort": wire("supportsOutputEffort", ["anthropic"]),
+	"supports-eager-tool-input-streaming": wire("supportsEagerToolInputStreaming", ["anthropic"]),
+	"supports-long-cache-retention": wire("supportsLongCacheRetention", ["anthropic"]),
+	"supports-mid-conversation-system": wire("supportsMidConversationSystem", ["anthropic"]),
+	"supports-mid-conversation-tool-changes": wire("supportsMidConversationToolChanges", ["anthropic"]),
+	"supports-per-message-effort": wire("supportsPerMessageEffort", ["anthropic"]),
+	"supports-thinking-binding-controls": wire("supportsThinkingBindingControls", ["anthropic"]),
+	"supports-turn-scoped-system": wire("supportsTurnScopedSystem", ["anthropic"]),
+
+	// ── wire: bedrock-converse-stream ──
+	"prompt-cache-maximum-checkpoints": wire("promptCacheMaximumCheckpoints", ["bedrock"]),
+	"prompt-cache-minimum-tokens": wire("promptCacheMinimumTokens", ["bedrock"]),
+	"prompt-cache-mode": wire("promptCacheMode", ["bedrock"], "scalar", ["none", "automatic", "explicit"]),
+
+	// ── wire: devin-agent ──
+	"model-router": wire("modelRouter", ["devin"]),
+	"supports-parallel-tool-calls": wire("supportsParallelToolCalls", ["devin"]),
+	"trust-explicit-thinking-only": wire("trustExplicitThinkingOnly", ["devin"]),
+
+	// ── wire: google APIs ──
+	"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"]),
+
+	// ── wire: shared across surfaces ──
+	"stream-first-event-timeout-ms": wire("streamFirstEventTimeoutMs", [...OAI, "google"]),
+	"stream-idle-timeout-ms": wire("streamIdleTimeoutMs", [...OAI, "anthropic", "bedrock", "google"]),
+	"strip-image-input": wire("stripImageInput", [...OAI, "anthropic", "google"]),
+	"supports-forced-tool-choice": wire("supportsForcedToolChoice", [...OAI, "anthropic"]),
+	"supports-sampling-params": wire("supportsSamplingParams", [...OAI, "anthropic"]),
+	"thinking-loop-guard": wire("thinkingLoopGuard", [...OAI, "anthropic", "google"], "scalar", [
+		"gemini",
+		"deepseek",
+		"xai",
+	]),
+
+	// ── thinking control surface ──
+	"thinking-default-level": { key: "defaultLevel", set: "thinking", shape: "scalar", values: EFFORTS },
+	"thinking-effort-budgets": { key: "effortBudgets", set: "thinking", shape: "object" },
+	"thinking-effort-map": { key: "effortMap", set: "thinking", shape: "object" },
+	"thinking-efforts": { key: "efforts", set: "thinking", shape: "array", values: EFFORTS },
+	"thinking-mode": {
+		key: "mode",
+		set: "thinking",
+		shape: "scalar",
+		values: THINKING_MODES,
+	},
+	"thinking-requires-effort": { key: "requiresEffort", set: "thinking", shape: "scalar" },
+	"thinking-prefix-binding": { key: "prefixBinding", set: "thinking", shape: "scalar" },
+	"thinking-suppress-when-off": { key: "suppressWhenOff", set: "thinking", shape: "scalar" },
+	"thinking-supports-display": { key: "supportsDisplay", set: "thinking", shape: "scalar" },
+
+	// ── catalog metadata ──
+	"apply-patch-tool-type": {
+		key: "applyPatchToolType",
+		set: "catalog",
+		shape: "scalar",
+		values: ["freeform", "function"],
+	},
+	"context-promotion-target": { key: "contextPromotionTarget", set: "catalog", shape: "scalar" },
+	"context-window-floor": { key: "contextWindowFloor", set: "catalog", shape: "scalar" },
+	"cost-patch": { key: "costPatch", set: "catalog", shape: "object" },
+	"delegation-bias": { key: "delegationBias", set: "catalog", shape: "scalar", values: DELEGATION_BIASES },
+	"edit-revision": { key: "editRevision", set: "catalog", shape: "scalar" },
+	"input-modalities": { key: "inputModalities", set: "catalog", shape: "array", values: ["text", "image"] },
+	"limits-patch": { key: "limitsPatch", set: "catalog", shape: "object" },
+	"long-context-cost": { key: "longContext", set: "catalog", shape: "object" },
+	"long-usage-limit-fallback": { key: "longUsageLimitFallback", set: "catalog", shape: "scalar" },
+	"requires-cursor-tool-schema-projection": {
+		key: "requiresCursorToolSchemaProjection",
+		set: "catalog",
+		shape: "scalar",
+	},
+	priority: { key: "priority", set: "catalog", shape: "scalar" },
+	"service-tier-cost": { key: "serviceTierCost", set: "catalog", shape: "object" },
+};
+
+/** Records applicable to each API family; used by `resolve.ts` when applying wire axes. */
+export const API_COMPAT_RECORDS: Readonly<Record<string, readonly CompatRecordName[]>> = {
+	"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"],
+};

package/src/compat/behavior.ts

@@ -0,0 +1,207 @@
+/**
+ * Typed accessors over the compiled runtime-behavior vocabulary
+ * (`rules/runtime/behavior.kdl`): provider/model heuristics that run before
+ * or outside exact bundled-model lookup — responses routing, API routing,
+ * quota tiers, plan requirements, model limits, roster exclusions, hosted
+ * defaults, and pricing peers.
+ */
+import { globMatch } from "./cascade";
+import rules from "./rules.json";
+import type { CompiledMatchList } from "./types";
+
+const behavior = rules.behavior;
+
+function matchesList(match: CompiledMatchList, model: string, modelLower: string): boolean {
+	if (match.exact?.some(candidate => candidate === model)) return true;
+	if (match.prefix?.some(prefix => model.startsWith(prefix))) return true;
+	if (match.substring?.some(sub => model.includes(sub))) return true;
+	if (match.token !== undefined) {
+		const parts = modelLower.split(/[^a-z0-9]+/);
+		if (match.token.some(token => parts.includes(token))) return true;
+	}
+	if (match.glob?.some(pattern => globMatch(pattern, modelLower))) return true;
+	return false;
+}
+
+/**
+ * Conservative heuristic for a normalized, lowercase discovered model id with
+ * no exact bundled record: whether it likely rides the OpenAI Responses API.
+ */
+export function isLikelyOpenAIResponsesId(model: string): boolean {
+	const rule = behavior.openaiResponsesHeuristic;
+	if (!rule) return false;
+	if (rule.excludePrefixes.some(prefix => model.startsWith(prefix))) return false;
+	if (rule.excludeSubstrings.some(sub => model.includes(sub))) return false;
+	return rule.includePrefixes.some(prefix => model.startsWith(prefix));
+}
+
+/**
+ * Additional catalog-declared operations for a discovered provider/model pair
+ * (e.g. `generate_image`), augmenting provider discovery metadata.
+ */
+export function modelOperationOverrides(provider: string, model: string): readonly string[] {
+	const lower = model.toLowerCase();
+	const out: string[] = [];
+	for (const rule of behavior.modelOperations) {
+		if (rule.provider !== provider || !matchesList(rule.models, lower, lower)) continue;
+		for (const operation of rule.operations) {
+			if (!out.includes(operation)) out.push(operation);
+		}
+	}
+	return out;
+}
+
+/**
+ * Splits a Cursor effort-suffixed OpenAI sibling id into its base id and
+ * declared effort tier. The family gate requires the declared marker
+ * (`gpt-`) followed immediately by an ASCII digit; matching stays
+ * case-sensitive to preserve Cursor wire-id behavior.
+ */
+export function cursorEffortSuffix(model: string): { base: string; tier: string } | undefined {
+	const rule = behavior.cursorEffort;
+	if (!rule) return undefined;
+	for (const tier of rule.tiers) {
+		if (!model.endsWith(tier)) continue;
+		const prefix = model.slice(0, model.length - tier.length);
+		if (!prefix.endsWith("-")) continue;
+		const base = prefix.slice(0, -1);
+		let family = false;
+		let index = base.indexOf(rule.familyMarker);
+		while (index !== -1) {
+			const next = base.charCodeAt(index + rule.familyMarker.length);
+			if (next >= 48 && next <= 57) {
+				family = true;
+				break;
+			}
+			index = base.indexOf(rule.familyMarker, index + 1);
+		}
+		if (!family) return undefined;
+		return { base, tier };
+	}
+	return undefined;
+}
+
+/** Fixed Cursor `requestedModel` parameters declared for an exact wire model. */
+export function cursorModelParameters(model: string): readonly { id: string; value: string }[] {
+	return behavior.cursorParameters.filter(parameter => parameter.model === model);
+}
+
+/**
+ * The catalog-declared quota scope or display tier for a provider model id.
+ * Exact authored memberships win; provider-authored substring fallbacks
+ * preserve quota semantics for newly discovered ids.
+ */
+export function quotaTierFor(provider: string, model: string): string | undefined {
+	const rule = behavior.quotaTiers.find(candidate => candidate.provider === provider);
+	if (!rule) return undefined;
+	for (const tier of rule.tiers) {
+		if (tier.models.includes(model)) return tier.label;
+	}
+	for (const fallback of rule.fallbacks) {
+		if (model.includes(fallback.substring)) return fallback.label;
+	}
+	return undefined;
+}
+
+/** Whether a provider has catalog-authored model quota scopes. */
+export function hasQuotaTierPolicy(provider: string): boolean {
+	return behavior.quotaTiers.some(rule => rule.provider === provider);
+}
+
+/** The provider-default wire model for a model-less hosted operation. */
+export function hostedDefaultModel(provider: string): string | undefined {
+	return behavior.hostedDefaults.find(entry => entry.provider === provider)?.model;
+}
+
+/** One resolved API route for a provider model id. */
+export interface ApiRouteMatch {
+	/** Transport API the id rides. */
+	api: string;
+	/** Wire id after prefix stripping, when the route declares `strip-prefix`. */
+	requestModelId?: string;
+}
+
+/**
+ * Resolves the declared API route for a provider model id. Routes match in
+ * declaration order; a `strip-prefix` route with a prefix matcher strips the
+ * matched prefix off the wire id. Falls back to the node's `default` API.
+ */
+export function apiRouteFor(provider: string, model: string): ApiRouteMatch | undefined {
+	const table = behavior.apiRoutes.find(candidate => candidate.provider === provider);
+	if (!table) return undefined;
+	const lower = model.toLowerCase();
+	for (const route of table.routes) {
+		if (!matchesList(route.match, model, lower)) continue;
+		const out: ApiRouteMatch = { api: route.api };
+		if (route.stripPrefix) {
+			const prefix = route.match.prefix?.find(candidate => model.startsWith(candidate));
+			if (prefix) out.requestModelId = model.slice(prefix.length);
+		}
+		return out;
+	}
+	return table.default !== undefined ? { api: table.default } : undefined;
+}
+
+/** Exact model ids named by a provider's api-routes rules (cache-migration drop lists). */
+export function apiRouteExactModelIds(provider: string): string[] {
+	const table = behavior.apiRoutes.find(candidate => candidate.provider === provider);
+	if (!table) return [];
+	const ids: string[] = [];
+	for (const route of table.routes) {
+		for (const id of route.match.exact ?? []) {
+			if (!ids.includes(id)) ids.push(id);
+		}
+	}
+	return ids;
+}
+
+/** Declared context-window / max-token pins for a provider model id. */
+export function modelLimitsFor(provider: string, model: string): { context?: number; maxTokens?: number } | undefined {
+	for (const table of behavior.modelLimits) {
+		if (table.provider !== provider) continue;
+		const limit = table.limits.find(entry => entry.model === model);
+		if (limit) {
+			const out: { context?: number; maxTokens?: number } = {};
+			if (limit.context !== undefined) out.context = limit.context;
+			if (limit.maxTokens !== undefined) out.maxTokens = limit.maxTokens;
+			return out;
+		}
+	}
+	return undefined;
+}
+
+/** Whether a provider roster entry is a declared non-chat/unsupported SKU. */
+export function isExcludedModel(provider: string, model: string): boolean {
+	const lower = model.toLowerCase();
+	return behavior.excludeModels.some(rule => rule.provider === provider && matchesList(rule.match, lower, lower));
+}
+
+/**
+ * Whether a provider is retired: its entire roster is excluded from the
+ * generated bundle and must never be resurrected from the previous snapshot.
+ */
+export function isRetiredProvider(provider: string): boolean {
+	return behavior.retiredProviders.includes(provider);
+}
+
+/** The declared subscription tier required to use a provider model id, if any. */
+export function planRequirementFor(provider: string, model: string): string | undefined {
+	const rule = behavior.planRequirements.find(candidate => candidate.provider === provider);
+	if (!rule) return undefined;
+	const lower = model.toLowerCase();
+	for (const tier of rule.tiers) {
+		if (matchesList(tier.match, model, lower)) return tier.tier;
+	}
+	return undefined;
+}
+
+/** Cross-provider pricing-peer resolution for one provider model id. */
+export function pricingPeerFor(
+	provider: string,
+	model: string,
+): { peers: readonly string[]; peerId: string } | undefined {
+	const rule = behavior.pricingPeers.find(candidate => candidate.provider === provider);
+	if (!rule) return undefined;
+	const alias = rule.aliases.find(candidate => candidate.model === model);
+	return { peers: rule.peers, peerId: alias?.peerId ?? model };
+}