@oh-my-pi/pi-catalog 18.2.6 → 18.2.8

package/src/build.ts

@@ -7,11 +7,11 @@
  * compat per request.
  */
 
-import { resolveModelPolicy } from "./compat/resolve";
+import { resolveDiscoveryApi, resolveModelPolicy } from "./compat/resolve";
 import type { ModelIdentity } from "./compat/types";
 import { resolveModelTokenizer } from "./model-tokenizer";
 import { materializeTimeBasedCost } from "./pricing";
-import type { Api, Model, ModelSpec } from "./types";
+import { type Api, MODEL_KINDS, type Model, type ModelSpec } from "./types";
 import { cleanModelName } from "./utils";
 
 function numberField(source: object, key: string): number | undefined {
@@ -74,6 +74,18 @@ function isInputModalities(value: unknown): value is ("text" | "image")[] {
  * only when the spec left it unset.
  */
 function applyCatalogAssignments<TApi extends Api>(model: Model<TApi>, catalog: Record<string, unknown>): void {
+	const kind = MODEL_KINDS.find(value => value === catalog.kind);
+	if (kind !== undefined) model.kind = kind;
+	const webSearch = catalog.webSearch;
+	if (
+		webSearch === "gemini" ||
+		webSearch === "anthropic" ||
+		webSearch === "codex" ||
+		webSearch === "xai" ||
+		webSearch === "openrouter"
+	) {
+		model.webSearch = webSearch;
+	}
 	const serviceTierCost = objectPayload(catalog.serviceTierCost);
 	if (serviceTierCost !== undefined) {
 		const flex = numberField(serviceTierCost, "flex");
@@ -273,6 +285,16 @@ function supportsOpenAIGAComputerUse(
 	return wireIdentity.class === "openai" && revisionAtLeast(wireIdentity, 5, 4);
 }
 
+/**
+ * Build a discovered model using the backend's catalog-selected request API.
+ * The credential-bearing provider id remains unchanged while `providerType`
+ * persists the backend policy identity across cache and config round trips.
+ */
+export function buildDiscoveredModel(spec: ModelSpec<Api>, providerType: string): Model<Api> {
+	const api = resolveDiscoveryApi(spec, providerType);
+	return buildModel({ ...spec, api, providerType });
+}
+
 /**
  * Build one model from an authored spec. Bundled models.json rows are fully
  * materialized by the generator and consumed directly (see `models.ts`), so
@@ -283,9 +305,9 @@ export function buildModel<TApi extends Api>(spec: ModelSpec<TApi>): Model<TApi>
 	const supportsComputerUseConfig = explicitComputerUseConfig(spec);
 	const model: Model<TApi> = {
 		...spec,
-		// An exact `thinking-efforts` rule upgrades a stale `reasoning: false`
-		// discovery default (see `resolveThinkingPolicy`); materialize the
-		// correction so transports and the picker see a reasoning-capable model.
+		// A reviewed `thinking-upgrade-neutral` policy can repair a stale
+		// `reasoning: false` discovery default (see `resolveThinkingPolicy`);
+		// materialize the correction for transports and the picker.
 		reasoning: spec.reasoning || policy.thinking !== undefined,
 		name: cleanModelName(spec.name),
 		identity: policy.identity,

package/src/compat/auth-ids.ts

@@ -41,6 +41,7 @@ export type AuthProviderId =
 	| "litellm"
 	| "llama.cpp"
 	| "lm-studio"
+	| "local"
 	| "meta"
 	| "minimax"
 	| "minimax-code"
@@ -76,6 +77,7 @@ export type AuthProviderId =
 	| "vercel-ai-gateway"
 	| "vllm"
 	| "wafer-serverless"
+	| "web"
 	| "xai"
 	| "xai-oauth"
 	| "xiaomi"

package/src/compat/axes.ts

@@ -10,7 +10,7 @@
  * one of the axis's declared records.
  */
 import type { Effort } from "../effort";
-import type { ThinkingControlMode } from "../types";
+import { MODEL_KINDS, type ThinkingControlMode } from "../types";
 
 /** Value shape a directive accepts (see `rules/README.md`). */
 export type AxisShape = "scalar" | "array" | "object";
@@ -290,9 +290,17 @@ export const AXES: Readonly<Record<string, AxisDef>> = {
 	"cost-patch": { key: "costPatch", set: "catalog", shape: "object" },
 	"cost-fallback": { key: "costFallback", set: "catalog", shape: "object" },
 	"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"],
+	},
 	"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" },

package/src/compat/cascade.ts

@@ -239,6 +239,30 @@ function rankCompare(a: readonly [number, number, number], b: readonly [number,
 	return a[0] - b[0] || a[1] - b[1] || a[2] - b[2];
 }
 
+function contestAxis(
+	winners: WinnerTable,
+	axis: string,
+	rank: readonly [number, number, number],
+	rule: IndexedRule,
+	target: ResolveTarget,
+): void {
+	const held = winners[axis];
+	if (held) {
+		const order = rankCompare(held.rank, rank);
+		if (order === 0) {
+			throw new AmbiguousOverlapError(
+				target.provider,
+				target.model,
+				axis,
+				held.rule.compiled.source,
+				rule.compiled.source,
+			);
+		}
+		if (order > 0) return;
+	}
+	winners[axis] = { rank, rule };
+}
+
 function contest(
 	winners: WinnerTable,
 	axes: Record<string, unknown> | undefined,
@@ -247,23 +271,7 @@ function contest(
 	target: ResolveTarget,
 ): void {
 	if (!axes) return;
-	for (const axis in axes) {
-		const held = winners[axis];
-		if (held) {
-			const order = rankCompare(held.rank, rank);
-			if (order === 0) {
-				throw new AmbiguousOverlapError(
-					target.provider,
-					target.model,
-					axis,
-					held.rule.compiled.source,
-					rule.compiled.source,
-				);
-			}
-			if (order > 0) continue;
-		}
-		winners[axis] = { rank, rule };
-	}
+	for (const axis in axes) contestAxis(winners, axis, rank, rule, target);
 }
 
 function collect(winners: WinnerTable, pick: (rule: CompiledRule) => Record<string, unknown> | undefined) {
@@ -314,8 +322,9 @@ function cloneAxes(axes: ResolvedAxes): ResolvedAxes {
 
 /**
  * Resolve wire, thinking, and catalog assignments for one structured target.
- * Exact model effort corrections can enable reasoning; absent family/revision
- * facts never satisfy selectors that require them. Returned axes are caller-owned.
+ * Exact model effort corrections and identity-scoped neutral-upgrade policies
+ * can enable reasoning; absent family/revision facts never satisfy selectors
+ * that require them. Returned axes are caller-owned.
  *
  * @throws AmbiguousOverlapError when equal-rank rules contest one axis.
  */
@@ -368,11 +377,24 @@ function resolveOverIndex(index: RuleIndex, target: ResolveTarget): ResolvedAxes
 	const ranked = rankRelevantRules(index, prepareTarget(target));
 	let reasoning = target.reasoning === true;
 	if (!reasoning) {
+		const upgrade: WinnerTable = {};
+		let hasEfforts = false;
 		for (const { rule, rank } of ranked) {
-			if (rule.hasExactEffortsRule && rank[0] === 2) {
-				reasoning = true;
-				break;
-			}
+			const thinking = rule.compiled.thinking;
+			if (thinking === undefined) continue;
+			if ("upgradeNeutral" in thinking) contestAxis(upgrade, "upgradeNeutral", rank, rule, target);
+			if ("efforts" in thinking) hasEfforts = true;
+			if (rule.hasExactEffortsRule && rank[0] === 2) reasoning = true;
+		}
+		const upgradeRule = upgrade.upgradeNeutral?.rule.compiled;
+		const identityScoped =
+			upgradeRule !== undefined &&
+			((upgradeRule.class !== undefined && upgradeRule.class !== "unknown") ||
+				upgradeRule.family !== undefined ||
+				upgradeRule.revision !== undefined ||
+				upgradeRule.models !== undefined);
+		if (identityScoped && upgradeRule?.thinking?.upgradeNeutral === true && hasEfforts) {
+			reasoning = true;
 		}
 	}
 	const wire: WinnerTable = {};

package/src/compat/provider-ids.ts

@@ -38,6 +38,7 @@ export type KnownProvider =
 	| "kimi-code"
 	| "litellm"
 	| "lm-studio"
+	| "local"
 	| "meta"
 	| "minimax"
 	| "minimax-code"
@@ -62,11 +63,13 @@ export type KnownProvider =
 	| "siliconflow-cn"
 	| "synthetic"
 	| "together"
+	| "typesafe"
 	| "umans"
 	| "venice"
 	| "vercel-ai-gateway"
 	| "vllm"
 	| "wafer-serverless"
+	| "web"
 	| "xai"
 	| "xai-oauth"
 	| "xiaomi"

package/src/compat/resolve.ts

@@ -311,6 +311,7 @@ function detectOpenAI(
 	reasoningCapable: boolean,
 ): OpenAIDetection {
 	const provider = spec.provider;
+	const backendProvider = spec.providerType ?? provider;
 	const baseUrl = spec.baseUrl;
 	const hostModel = { provider, baseUrl };
 	const isZai = modelMatchesHost(hostModel, "zai");
@@ -321,8 +322,8 @@ function detectOpenAI(
 	const isDeepseekFamily = modelMatchesHost(hostModel, "deepseekFamily") || facts.is("deepseek");
 	const isDeepseekReasoning = isDeepseekFamily && reasoningCapable;
 	const isLocalOpenAICompatBackend =
-		PROXY_OPENAI_COMPAT_PROVIDERS[provider] !== true &&
-		(LOCAL_OPENAI_COMPAT_PROVIDERS[provider] === true || hasLocalLoopbackBaseUrl(baseUrl));
+		PROXY_OPENAI_COMPAT_PROVIDERS[backendProvider] !== true &&
+		(LOCAL_OPENAI_COMPAT_PROVIDERS[backendProvider] === true || hasLocalLoopbackBaseUrl(baseUrl));
 	return {
 		facts,
 		isClinePass: provider === "cline-pass",
@@ -521,12 +522,8 @@ function detectOpenAICompat(
 		replayReasoningContent: d.isLocalOpenAICompatBackend,
 		qwenPreserveThinking:
 			(thinkingFormat === "qwen" || thinkingFormat === "qwen-chat-template") && d.isLocalOpenAICompatBackend,
-		qwenTemplateReasoningEffort:
-			(thinkingFormat === "qwen" || thinkingFormat === "qwen-chat-template") &&
-			d.isLocalOpenAICompatBackend &&
-			provider !== "ollama" &&
-			isQwen &&
-			facts.revGte("3.8"),
+		// Template effort support is a reviewed backend × model contract in KDL.
+		qwenTemplateReasoningEffort: false,
 		requiresAssistantContentForToolCalls: facts.is("kimi") || d.isDirectDeepseekReasoning,
 		cacheControlFormat:
 			(d.isClinePass && (isQwen || isAnthropicModel)) || (d.isOpenRouter && isAnthropicModel)
@@ -692,6 +689,7 @@ function resolveOpenAIResponsesPolicy(
 ): ResolvedOpenAIResponsesCompat {
 	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");
@@ -703,7 +701,8 @@ function resolveOpenAIResponsesPolicy(
 	const thinkingFormat: ResolvedOpenAISharedCompat["thinkingFormat"] = isOpenRouter ? "openrouter" : "openai";
 	const reasoningCapable = compatReasoning(spec, axes);
 	const isLocalServingBackend =
-		(PROXY_OPENAI_COMPAT_PROVIDERS[provider] !== true && LOCAL_OPENAI_COMPAT_PROVIDERS[provider] === true) ||
+		(PROXY_OPENAI_COMPAT_PROVIDERS[backendProvider] !== true &&
+			LOCAL_OPENAI_COMPAT_PROVIDERS[backendProvider] === true) ||
 		hasLocalLoopbackBaseUrl(baseUrl);
 	const isAnthropicModel = facts.is("anthropic");
 	const isDeepseekFamily = facts.is("deepseek");
@@ -1063,8 +1062,8 @@ function readRuleThinking(axes: ResolvedAxes): RuleThinking {
 
 /**
  * Compat-time reasoning capability. `axes.reasoning` also promotes targets on
- * any exact `thinking-efforts` rule (the cascade's thinking-axis gate), but
- * compat may only be repaired where the provider contract opted in with
+ * 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.
  */
@@ -1104,7 +1103,7 @@ function resolveThinkingPolicy<TApi extends Api>(
 	// reasoning (e.g. Synthetic's `none`-only off-switch): reviewed KDL must
 	// not re-expand it into an unadvertised ladder. Absent metadata is
 	// repaired only where KDL opts in with `thinking-upgrade-neutral`
-	// alongside an exact `thinking-efforts` ladder (the cascade upgrade for
+	// alongside a reviewed `thinking-efforts` ladder (the cascade upgrade for
 	// stale source capability data); otherwise the neutral default holds.
 	if (!spec.reasoning && (explicitThinking !== undefined || rule.upgradeNeutral !== true)) return undefined;
 	if (
@@ -1210,9 +1209,13 @@ function fillExplicitThinking<TApi extends Api>(
 // Entry
 // ---------------------------------------------------------------------------
 
-function buildResolveTarget<TApi extends Api>(spec: ModelSpec<TApi>, identity: ModelIdentity): ResolveTarget {
+function buildResolveTarget<TApi extends Api>(
+	spec: ModelSpec<TApi>,
+	identity: ModelIdentity,
+	providerType = spec.providerType ?? spec.provider,
+): ResolveTarget {
 	const target: ResolveTarget = {
-		provider: spec.provider,
+		provider: providerType,
 		api: spec.api,
 		class: identity.class,
 		model: spec.id,
@@ -1227,6 +1230,13 @@ function specUsesApi<TApi extends Api>(spec: ModelSpec<Api>, api: TApi): spec is
 	return spec.api === api;
 }
 
+/** Resolve the request adapter assigned to a discovery backend before materialization. */
+export function resolveDiscoveryApi(spec: ModelSpec<Api>, providerType: string): Api {
+	const identity = resolveIdentity(spec);
+	const discoveryApi = resolveCascade(buildResolveTarget(spec, identity, providerType)).catalog.discoveryApi;
+	return typeof discoveryApi === "string" ? discoveryApi : spec.api;
+}
+
 /**
  * Resolves the full policy surface for one model spec: structured identity,
  * complete compat record, thinking metadata, and catalog-data corrections.

package/src/compat/rules/README.md

@@ -50,14 +50,14 @@ class "anthropic" {
 
 Classification trims and lowercases the full model identifier. The **bare name** is the segment after its final `/`. Matcher tokens are also lowercased while parsing.
 
-| Node | Rank | Match |
-| --- | ---: | --- |
-| `exact "token"` | 4 | The whole bare name equals `token`. |
-| `bounded "token"` | 3 | The bare name equals `token`, or starts with it followed by `-`, `_`, `.`, `:`, or an ASCII digit. |
-| `namespace "token"` | 2 | A non-empty `/`-separated segment of the full identifier equals `token`. |
-| `namespace "token" bounded=#true` | 2 | Split the full identifier on `/`, `.`, and `:`; a segment must satisfy the bounded rule above. This is the only matcher property. |
-| `prefix "token"` | 1 | The bare name starts with `token`. |
-| `glob "pattern"` | 0 | An anchored `*` wildcard match over the bare name. `*` spans any substring; all non-wildcard text remains anchored in order. |
+| Node                              | Rank | Match                                                                                                                             |
+| --------------------------------- | ---: | --------------------------------------------------------------------------------------------------------------------------------- |
+| `exact "token"`                   |    4 | The whole bare name equals `token`.                                                                                               |
+| `bounded "token"`                 |    3 | The bare name equals `token`, or starts with it followed by `-`, `_`, `.`, `:`, or an ASCII digit.                                |
+| `namespace "token"`               |    2 | A non-empty `/`-separated segment of the full identifier equals `token`.                                                          |
+| `namespace "token" bounded=#true` |    2 | Split the full identifier on `/`, `.`, and `:`; a segment must satisfy the bounded rule above. This is the only matcher property. |
+| `prefix "token"`                  |    1 | The bare name starts with `token`.                                                                                                |
+| `glob "pattern"`                  |    0 | An anchored `*` wildcard match over the bare name. `*` spans any substring; all non-wildcard text remains anchored in order.      |
 
 A class match is ranked by `(matcher-kind rank, token byte length)`. The greatest tuple wins. Equal tuples from different classes are an ambiguity error; source order is not a tiebreak. If nothing matches, classification returns class `unknown` with no family or revision.
 
@@ -89,22 +89,22 @@ revision skip-bare "o1" "o3" "o4"
 
 ### Reviewed identity overrides
 
-`override` has properties only and no child block. Required string properties are `id` (stable, globally unique review ID), `model` (exact bare model identifier, compared case-insensitively), `rationale`, and `provenance`.
+`override` has properties only and no child block. Required string properties are `id` (stable, globally unique review ID), `rationale`, and `provenance`, plus exactly one selector: `model` (exact bare identifier) or `glob` (anchored `*` wildcard over the bare identifier). Both selectors compare case-insensitively; namespace prefixes before the final `/` are ignored.
 
 Optional properties are:
 
-| Property | Shape and meaning |
-| --- | --- |
-| `provider` | Exact provider key, compared case-insensitively. A matching provider-specific override wins over a provider-agnostic one. |
-| `logical` | Corrected logical model identifier. |
-| `class` | Corrected class ID; a non-empty string. |
-| `family` | Corrected product-family ID; a non-empty string. |
-| `revision` | One to three unsigned 8-bit components separated by `.` or `-`. |
-| `effort` | `off`, `minimal`, `low`, `medium`, `high`, `xhigh`, or `max`. |
-| `thinking-variant` | Boolean marker for a separately exposed thinking sibling. |
-| `expires-at-ms` | Non-negative Unix time in milliseconds. The override is inactive when the observation time is at or after this value. |
+| Property           | Shape and meaning                                                                                                         |
+| ------------------ | ------------------------------------------------------------------------------------------------------------------------- |
+| `provider`         | Exact provider key, compared case-insensitively. A matching provider-specific override wins over a provider-agnostic one. |
+| `logical`          | Corrected logical model identifier.                                                                                       |
+| `class`            | Corrected class ID; a non-empty string.                                                                                   |
+| `family`           | Corrected product-family ID; a non-empty string.                                                                          |
+| `revision`         | One to three unsigned 8-bit components separated by `.` or `-`.                                                           |
+| `effort`           | `off`, `minimal`, `low`, `medium`, `high`, `xhigh`, or `max`.                                                             |
+| `thinking-variant` | Boolean marker for a separately exposed thinking sibling.                                                                 |
+| `expires-at-ms`    | Non-negative Unix time in milliseconds. The override is inactive when the observation time is at or after this value.     |
 
-The pair `(provider, model)` must also be unique, including provider-agnostic pairs. When no observation time is supplied, an expiring override remains active.
+The tuple `(provider, selector-kind, selector)` must also be unique, including provider-agnostic selectors. Active exact overrides take precedence over every glob. Within each selector kind, provider-scoped overrides precede provider-agnostic ones; matching globs rank by non-wildcard byte count. Equal-ranked globs are an ambiguity error, never resolved by declaration order. When no observation time is supplied, an expiring override remains active.
 
 ### Suffix collapse
 
@@ -124,6 +124,7 @@ collapse {
     provider-alias "devin" "opus" "claude-opus-5"
 }
 ```
+
 `variant-family` declares one reviewed provider-scoped collapsed family: positional provider and logical id, `name=` display name, and a body of `members "a" "b" …` (wire ids in priority order), `route "<tier>" "<wire-id>"` per effort tier (`off` included), and optional `mode`, `efforts`, `default-level`, `default-member`, `retired-members`, `effort-budget "<tier>" <n>`, `requires-effort`, `suppress-when-off`, `no-thinking`, `preserve-absent-effort-routes`, and `extra-aliases`. A `{rev}` placeholder in the logical id makes the node a **template**: it is instantiated once per revision found in live ids (`gemini-{rev}-flash` matches `gemini-3.8-flash-low` → family `gemini-3.8-flash`), every wire id in the body and the `name=` carry the same placeholder, and an optional `revision=` constraint (`">=3.6"`) bounds the generations it applies to. A concrete family with the same instantiated id wins over the template. `provider-alias` maps one provider-scoped selector spelling onto a logical id without making it a family member.
 
 `thinking-suffix` accepts one non-empty suffix and no properties. `pair-token` declares bounded (possibly infix) tokens naming the thinking sibling of a live bare twin (`sonar-reasoning-pro` beside `sonar-pro`); it drives thinking-pair derivation only — never identity suffix collapse — and negated `no-`/`non-` forms never match. `effort-suffix` additionally requires `tier` with one of the effort values above, and may have `except-bare-prefix`. `routing-variant-suffix` takes one non-empty suffix followed by one or more provider IDs: a wire identifier carrying the suffix on one of those providers is a **routing variant** of its plain identifier — discovery derives base-model metadata from the plain bundled SKU while keeping the suffixed wire identifier for requests; routing variants never participate in effort collapse. `effort-lane-suffix` takes one non-empty lane suffix followed by one or more provider IDs, plus an optional `bare-prefix` gate: on a declared provider, an identifier ending in the lane suffix collapses the effort suffix wedged before the lane token while keeping the lane on the logical id. `effort-family` takes a provider, the canonical logical id, and zero or more exact aliases that fold onto it.
@@ -178,15 +179,15 @@ provider "openrouter" {
 
 ### Selectors and nesting
 
-| Selector | Form | Matching semantics |
-| --- | --- | --- |
-| `class` | `class "id" { ... }` | Exact class ID. At document root it may contain `on`, `on-api`, `family`, `revision`, and `models`. Under `provider` it may contain `family`, `revision`, and `models`. |
-| `provider` | `provider "id" { ... }` | Exact provider ID. It is root-only and may contain `class` and `models`. |
-| `on` | `on "provider-a" "provider-b" { ... }` | One or more provider IDs, combined as OR. It is allowed only under a root `class`, and may contain `family`, `revision`, and `models`. |
-| `on-api` | `on-api "adapter-a" "adapter-b" { ... }` | One or more request adapter IDs, combined as OR. It is allowed only under a root `class`, and may contain `family`, `revision`, and `models`. |
-| `family` | `family "id" { ... }` | Exact classified family ID. It may contain `revision` and `models`. A target with no family does not match. |
-| `revision` | `revision ">=2.5 <4" { ... }` | A non-empty, whitespace-separated conjunction of comparisons. It may contain `models`. A target with no revision does not match. |
-| `models` | `models "id" "vendor/*" { ... }` | One or more alternatives, combined as OR. It cannot contain another selector. `token="name"` matches an ASCII-case-insensitive token bounded by non-alphanumerics. |
+| Selector   | Form                                     | Matching semantics                                                                                                                                                      |
+| ---------- | ---------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `class`    | `class "id" { ... }`                     | Exact class ID. At document root it may contain `on`, `on-api`, `family`, `revision`, and `models`. Under `provider` it may contain `family`, `revision`, and `models`. |
+| `provider` | `provider "id" { ... }`                  | Exact provider ID. It is root-only and may contain `class` and `models`.                                                                                                |
+| `on`       | `on "provider-a" "provider-b" { ... }`   | One or more provider IDs, combined as OR. It is allowed only under a root `class`, and may contain `family`, `revision`, and `models`.                                  |
+| `on-api`   | `on-api "adapter-a" "adapter-b" { ... }` | One or more request adapter IDs, combined as OR. It is allowed only under a root `class`, and may contain `family`, `revision`, and `models`.                           |
+| `family`   | `family "id" { ... }`                    | Exact classified family ID. It may contain `revision` and `models`. A target with no family does not match.                                                             |
+| `revision` | `revision ">=2.5 <4" { ... }`            | A non-empty, whitespace-separated conjunction of comparisons. It may contain `models`. A target with no revision does not match.                                        |
+| `models`   | `models "id" "vendor/*" { ... }`         | One or more alternatives, combined as OR. It cannot contain another selector. `token="name"` matches an ASCII-case-insensitive token bounded by non-alphanumerics.      |
 
 Class, provider/`on`, `on-api`, and family selector values are compared exactly and case-sensitively to the structured resolve target. Revision operators are `>=`, `>`, `<=`, `<`, and `=`; operands have one to three dot-separated unsigned 8-bit components, omitted components zero.
 
@@ -194,6 +195,8 @@ A `models` string without `*` is an exact, case-sensitive match against the prov
 
 `priority=N` is an optional signed integer property on the block that owns axis assignments. Its default is zero. Use it only to resolve an intentional equal-specificity overlap; do not use it to encode declaration order.
 
+`buildDiscoveredModel(spec, providerType)` resolves the catalog `discovery-api` axis before materializing compatibility. It preserves the credential-bearing provider ID and records `providerType` as the backend used for provider selectors on subsequent rebuilds. Ordinary `buildModel` preserves its input API. This lets custom-named llama.cpp deployments reuse the same rules without model-specific discovery code.
+
 ### Axis vocabulary and value shapes
 
 The directive vocabulary is closed and lives in **`src/compat/axes.ts`** — one table mapping each kebab-case directive to its resolved camelCase field, namespace (`wire` / `thinking` / `catalog`), value shape, applicable compat records, and (for enums) accepted values. The compiler rejects unknown directives and out-of-vocabulary values against that table; consult it rather than a duplicated table here.
@@ -262,7 +265,7 @@ The highest-ranked matching assignment wins for that axis. Two distinct rules th
 
 ### Capability gating
 
-Wire axes are considered for every matching target. Thinking axes are considered only when the structured resolve target sets `reasoning` — except that an exact model selector declaring `thinking-efforts` upgrades the target (a reviewed correction to stale source capability metadata). Family and revision selectors never match targets missing that rank. An unmatched target resolves to empty maps; the cascade does not infer negative capabilities from absence.
+Wire axes are considered for every matching target. Thinking axes require `reasoning`, except that an exact model selector declaring `thinking-efforts` opens the gate for reviewed corrections. A winning `thinking-upgrade-neutral #true` scoped to a recognized class, family, revision, or model selector also opens it when a matching effort ladder exists; provider-wide opt-in alone does not. Materializing a neutral spec as reasoning-capable requires that opt-in and no explicit thinking vocabulary. Family and revision selectors never match targets missing that rank. An unmatched target resolves to empty maps; the cascade does not infer negative capabilities from absence.
 
 ## Runtime behavior grammar
 
@@ -399,17 +402,17 @@ Only `discovery` enrolls a provider in `generate-models.ts`; providers without i
 
 ### Seed rows
 
-A `seed` *defines* bundled rows for providers whose catalog cannot be discovered at generation time — credential-scoped rosters, unauthenticated regens, or models ahead of upstream catalogs. Every other stratum patches rows; this one authors them. Runtime model managers hand the rows to `staticModels` through `seedModels(provider)`; the generator bundles them per the seed's `bundle` policy. Values are literal — a seed never derives from another provider's row, and pricing is never borrowed.
+A `seed` _defines_ bundled rows for providers whose catalog cannot be discovered at generation time — credential-scoped rosters, unauthenticated regens, or models ahead of upstream catalogs. Every other stratum patches rows; this one authors them. Runtime model managers hand the rows to `staticModels` through `seedModels(provider)`; the generator bundles them per the seed's `bundle` policy. Values are literal — a seed never derives from another provider's row, and pricing is never borrowed.
 
 `seed` properties: `api` and `base-url` are per-row defaults (a `model` may override either with the same property names); `bundle` defaults to `always`; `precedence="seed"` is optional. `model` takes the wire id positionally, requires `name=`, and its body MUST declare `reasoning`, `input` (`"text"` and/or `"image"`), `cost` (all four per-million rates), and `limits` (`context=` / `max-tokens=`, an omitted limit is `null`); `supports-tools #true` is optional. Any other directive is an axis from the cascade vocabulary: thinking axes become the row's explicit `thinking` (then `thinking-mode` and `thinking-efforts` are both required), wire axes become its explicit `compat` and must apply to the row's API, and catalog axes are rejected because they stay rule-owned in the cascade block. Explicit `thinking`/`compat` on a seed row win over the cascade exactly as they do for any authored spec.
 
 `bundle` decides when the generator includes the rows:
 
-| Policy | Rows enter the bundle |
-| --- | --- |
-| `always` | Every regeneration. Same-id upstream/discovery rows win dedup. |
+| Policy     | Rows enter the bundle                                                     |
+| ---------- | ------------------------------------------------------------------------- |
+| `always`   | Every regeneration. Same-id upstream/discovery rows win dedup.            |
 | `fallback` | Only when the provider's authoritative catalog discovery did not succeed. |
-| `empty` | Only when no other source produced a row for the provider. |
+| `empty`    | Only when no other source produced a row for the provider.                |
 
 `precedence="seed"` prepends the rows after the previous-snapshot merge and cross-provider reference fills, so the authored row wins dedup and same-id rows on other hosts never overwrite its name or capabilities (QwenCloud Token Plan, Meta). The default `upstream` precedence appends before the snapshot merge, so the current seed — not a stale snapshot copy — is the fallback row.
 

package/src/compat/rules/auth/local.kdl

@@ -0,0 +1,4 @@
+auth "local" {
+	name "Local models"
+	allows-missing-api-key #true
+}

package/src/compat/rules/auth/typesafe.kdl

@@ -1,9 +1,6 @@
-// TypeSafe (System One judgments) is not a chat-model provider: it answers
-// typed questions (choice / yes-no / score) over JSON state via
-// `POST /v1/systemone`, consumed through `@oh-my-pi/pi-ai`'s `TypeSafeJudge`.
-// No `providers/typesafe.kdl` entry exists on purpose — it has no chat models,
-// so it never appears in the model picker; the credential alone is what the
-// judgment resolver checks.
+// TypeSafe (System One judgments) answers typed questions over JSON state via
+// `POST /v1/systemone`. Its judgment models are catalogued under the `judge`
+// kind; this auth entry supplies both live `/v1/models` discovery and requests.
 auth "typesafe" {
 	name "TypeSafe"
 	env "TYPESAFE_API_KEY"

package/src/compat/rules/auth/web.kdl

@@ -0,0 +1,4 @@
+auth "web" {
+	name "Web search engines"
+	allows-missing-api-key #true
+}

package/src/compat/rules/classes/qwen.kdl

@@ -33,11 +33,12 @@ class "qwen" {
 	}
 	// Qwen 3.8+ open-weight chat templates steer thinking depth through the
 	// `reasoning_effort` template kwarg (wire-exact low/medium/xhigh, template
-	// default xhigh) and raise on `enable_thinking: false`, so local
-	// llama.cpp-style hosts route the selected effort onto the template instead
-	// of always reasoning at xhigh. vLLM ignores top-level
-	// `enable_thinking`, so it rides the chat-template-kwargs dialect.
-	on "llama.cpp" "lm-studio" {
+	// default xhigh) and raise on `enable_thinking: false`. LM Studio routes
+	// the selected effort onto the template instead of always reasoning at
+	// xhigh; llama.cpp owns its equivalent policy in the provider rule. vLLM
+	// ignores top-level `enable_thinking`, so it rides the
+	// chat-template-kwargs dialect.
+	on "lm-studio" {
 		revision ">=3.8" {
 			supports-reasoning-effort #true
 			template-reasoning-effort #true

package/src/compat/rules/providers/anthropic.kdl

@@ -4,6 +4,7 @@ provider "anthropic" {
 	default-model "claude-opus-4-8"
 	env "ANTHROPIC_API_KEY"
 	discovery label="Anthropic"
+	web-search "anthropic"
 
 	// Curated Anthropic models that are live or limited-availability on the
 	// first-party `/v1/models` endpoint but that stencil.so has not catalogued

package/src/compat/rules/providers/deepinfra.kdl

@@ -5,4 +5,32 @@ provider "deepinfra" {
 	env "DEEPINFRA_API_KEY"
 	dynamic-models-authoritative #true
 	discovery label="DeepInfra" allow-unauthenticated=#true
+	kind-apis {
+		image "openai-images"
+		tts "openai-speech"
+	}
+
+	seed base-url="https://api.deepinfra.com/v1/openai" bundle="always" {
+		model "black-forest-labs/FLUX-2-pro" name="FLUX.2 Pro" api="openai-images" {
+			reasoning #false
+			input "text" "image"
+			cost input=0 output=0 cache-read=0 cache-write=0
+			limits
+			supports-tools #false
+		}
+		model "hexgrad/Kokoro-82M" name="Kokoro-82M" api="openai-speech" {
+			reasoning #false
+			input "text"
+			cost input=0 output=0 cache-read=0 cache-write=0
+			limits
+			supports-tools #false
+		}
+	}
+
+	models "black-forest-labs/FLUX-2-pro" {
+		kind "image"
+	}
+	models "hexgrad/Kokoro-82M" {
+		kind "tts"
+	}
 }

package/src/compat/rules/providers/google-antigravity.kdl

@@ -2,6 +2,20 @@
 
 provider "google-antigravity" {
 	default-model "gemini-3.1-pro"
+	kind-apis {
+		image "google-gemini-cli"
+	}
+	web-search "gemini"
+
+	seed api="google-gemini-cli" base-url="https://daily-cloudcode-pa.googleapis.com" bundle="always" {
+		model "gemini-3-pro-image" name="Gemini 3 Pro Image" {
+			reasoning #false
+			input "text" "image"
+			cost input=0 output=0 cache-read=0 cache-write=0
+			limits
+			supports-tools #false
+		}
+	}
 
 	class "anthropic" {
 		family "opus" {
@@ -45,6 +59,9 @@ provider "google-antigravity" {
 	models "gemini-3-pro" {
 		thinking-mode "google-level"
 	}
+	models "gemini-3-pro-image" {
+		kind "image"
+	}
 	// residue: taxonomy ranks and exact globs do not isolate these models.
 	models "gemini-3.1-flash-lite" {
 		thinking-mode "google-level"

package/src/compat/rules/providers/google.kdl

@@ -3,6 +3,10 @@
 provider "google" {
 	default-model "gemini-3.1-pro-preview"
 	env "GEMINI_API_KEY"
+	kind-apis {
+		image "google-generative-ai"
+	}
+	web-search "gemini"
 
 	class "unknown" {
 		thinking-efforts "minimal" "low" "medium" "high"
@@ -17,4 +21,9 @@ provider "google" {
 	models "gemini-2.5-computer-use-preview-10-2025" "gemini-robotics-er-1.6-preview" {
 		thinking-efforts "minimal" "low" "medium" "high"
 	}
+	// The proxy conservatively classifies tool-capable text+image output as chat;
+	// this SKU is a native image generator on the Gemini image transport.
+	models "gemini-3.1-flash-lite-image" {
+		kind "image"
+	}
 }

package/src/compat/rules/providers/llama.cpp.kdl

@@ -1,6 +1,29 @@
 // Provider-wire compat for "llama.cpp".
 
 provider "llama.cpp" {
+	supports-store #false
+	supports-developer-role #false
+	supports-reasoning-effort #false
 	// Replaces the string-only named-tool-choice provider table.
 	supports-named-tool-choice #false
+
+	class "qwen" {
+		// Responses cannot encode the template's thinking controls.
+		discovery-api "openai-completions"
+		// llama-server exposes the model's bundled chat template. Qwen templates
+		// preserve prior reasoning and accept the chat-template thinking controls.
+		thinking-upgrade-neutral #true
+		thinking-mode "effort"
+		thinking-efforts "low" "medium" "high" "max"
+		thinking-format "qwen"
+		reasoning-disable-mode "qwen-enable-thinking-false"
+		qwen-preserve-thinking #true
+
+		revision ">=3.8" {
+			supports-reasoning-effort #true
+			template-reasoning-effort #true
+			thinking-efforts "low" "medium" "xhigh"
+			thinking-requires-effort #true
+		}
+	}
 }