@rigelbuild/omp-catalog 18.0.3

package/dist/types/identity/family.d.ts

@@ -0,0 +1,239 @@
+/**
+ * Model-family id predicates: the shared vocabulary for "is this id a member
+ * of family X" checks that gate wire-level behavior across hosts (a Kimi or
+ * DeepSeek model keeps its quirks no matter which OpenAI-compatible proxy
+ * serves it). Looser per-feature heuristics (e.g. stream-markup healing)
+ * deliberately keep their own patterns — only provably-shared matchers live
+ * here.
+ */
+/** Kimi family ids in any namespace form (`moonshotai/kimi-*`, `kimi-k2.6`, `vendor/kimi.x`). */
+export declare const isKimiModelId: (modelId: string) => boolean;
+/** Kimi K2.6 specifically, including router ids that spell the version `k2p6`. */
+export declare const isKimiK26ModelId: (modelId: string) => boolean;
+/**
+ * Kimi K3 in any namespace form (`kimi-k3`, `kimi-k3.1`, `kimi-k3-turbo`,
+ * `moonshotai/kimi-k3`). K3 always reasons and drives thinking via OpenAI-style
+ * `reasoning_effort: "max"`, not the K2.x binary `thinking: { type }` block —
+ * see the moonshot discovery mapper and `buildOpenAICompat`.
+ */
+export declare const isKimiK3ModelId: (modelId: string) => boolean;
+/**
+ * Claude ids in any namespace form: bare (`claude-*`), path-namespaced
+ * (`anthropic/claude.x`), or dot-prefixed (`us.anthropic.claude-…`,
+ * `global.anthropic.claude-…`, `au.anthropic.claude-…` — Bedrock cross-region
+ * inference profiles). Necessary because {@link parseAnthropicModel} only
+ * classifies kinds enumerated in its regex, so any dotted profile whose kind
+ * (e.g. `haiku`) is not enumerated would otherwise slip past this fallback.
+ */
+export declare const isClaudeModelId: (modelId: string) => boolean;
+/** `anthropic/`-namespaced ids (aggregator catalogs like OpenRouter). */
+export declare const isAnthropicNamespacedModelId: (modelId: string) => boolean;
+/** Qwen family ids (substring match — Qwen SKUs have no stable prefix shape). */
+export declare const isQwenModelId: (modelId: string) => boolean;
+/**
+ * Open-weight Qwen 3.8+ releases (`qwen3.8-27b`, `qwen3.8-2.4t-a95b`, GGUF
+ * names like `Qwen3.8-27B-UD-Q6_K_XL`) whose chat template steers thinking
+ * depth through a `reasoning_effort` template kwarg (`low`/`medium`/`xhigh`,
+ * template default `xhigh`; thinking itself cannot be disabled). Compared
+ * component-wise so `qwen3.10` sorts after `qwen3.8`. API-only `-max` SKUs are
+ * excluded — Dashscope drives them through OpenAI-style `reasoning_effort`
+ * with curated compat. The trailing guard rejects parameter-count lookalikes
+ * (`qwen-3.8b`) without breaking `qwen3.8-27b`.
+ */
+export declare const isQwen38PlusTemplateEffortModelId: (modelId: string) => boolean;
+/** Gemma open-weights family (`gemma-3-27b-it`, `google/gemma-4-E2B-it`, `gemma2-9b`). */
+export declare const isGemmaModelId: (modelId: string) => boolean;
+/** DeepSeek family by id or display name (proxies often rename the id but keep the name). */
+export declare const isDeepseekModelIdOrName: (modelId: string) => boolean;
+/**
+ * DeepSeek V4 Flash SKU in any host/namespace form (`deepseek-v4-flash`, dated
+ * `deepseek-v4-flash-0731`, `deepseek-ai/DeepSeek-V4-Flash`). Both V4 SKUs
+ * (Flash and Pro) accept the `low` reasoning_effort tier; this predicate keeps
+ * Flash distinguishable from Pro where a host quirk splits them (e.g.
+ * OpenRouter exposes `low` on Flash but only `high` on non-Flash V4).
+ * See https://api-docs.deepseek.com/api/create-chat-completion.
+ */
+export declare const isDeepseekV4FlashModelId: (modelId: string) => boolean;
+/** Xiaomi MiMo family by id or display name. */
+export declare const isMimoModelIdOrName: (modelId: string) => boolean;
+/** StepFun Step 3.7 Flash SKU in any namespace form (`kilo/stepfun/step-3.7-flash:free`). */
+export declare const isStep37FlashModelId: (modelId: string) => boolean;
+/** Gemini family ids in any namespace form (`gemini-*`, `google/gemini-*`, `openrouter/google/gemini-…`). */
+export declare const isGeminiModelId: (modelId: string) => boolean;
+/** Grok family ids across namespace and delimiter forms (`grok-*`, `cursor-grok-*`, `xai/grok-*`). */
+export declare const isGrokModelId: (modelId: string) => boolean;
+/**
+ * Grok SKUs that expose the wire `reasoning.effort` dial. Other Grok reasoners
+ * (e.g. `grok-build`, `grok-4.20-0309-reasoning`) think natively but reject the
+ * param, so callers must omit reasoning effort for them. `grok-4.6` accepts
+ * `low`/`medium`/`high`/`xhigh` and 400s on `max`.
+ */
+export declare const isGrokReasoningEffortCapable: (modelId: string) => boolean;
+/**
+ * `grok-4.20-multi-agent*` uses `reasoning.effort` to pick agent count
+ * (`xhigh` is the 16-agent mode). Other first-party Grok effort SKUs stay on
+ * `low|medium|high` unless {@link isGrokXHighEffortCapable} (currently
+ * `grok-4.6*` plus multi-agent).
+ * https://docs.x.ai/developers/model-capabilities/text/reasoning
+ */
+export declare const isGrokMultiAgentModelId: (modelId: string) => boolean;
+/**
+ * First-party Grok SKUs whose Responses wire accepts `reasoning.effort: "xhigh"`.
+ * `grok-4.6*` documents xhigh as a reasoning depth; multi-agent uses it as
+ * 16-agent mode. `grok-4.5` / `grok-4.3` / `grok-3-mini` do not.
+ */
+export declare const isGrokXHighEffortCapable: (modelId: string) => boolean;
+/**
+ * MiniMax M2-generation family (M2, M2.1, M2.5, M2.7, including `-highspeed`/
+ * `-lightning`/`-her`/`-turbo` variants, dotless aliases like `minimax-m21`,
+ * and short `minimax/m2-…` ids on aggregator hosts). Underlying model accepts
+ * only `low|medium|high` for `reasoning_effort` and 400s on `minimal`,
+ * `xhigh`, or `none` — so hosts whose default effort map otherwise lowers
+ * `minimal` to `none` (Fireworks) or expects the full 5-tier scale must
+ * clamp instead. Excludes M1, M3, MiniMax-Text-01, music, hailuo, voice ids.
+ */
+export declare const isMinimaxM2FamilyModelId: (modelId: string) => boolean;
+/** MiniMax M3 family ids in bundled/default and aggregator namespace forms. */
+export declare const isMinimaxM3FamilyModelId: (modelId: string) => boolean;
+/**
+ * OpenAI gpt-oss family (`gpt-oss-20b`, `gpt-oss-120b`, `gpt-oss:120b`,
+ * `vendor/gpt-oss-…`). The Harmony reasoning format only accepts
+ * `low|medium|high` for `reasoning_effort` and rejects `minimal`, `xhigh`,
+ * and `none`.
+ */
+export declare const isOpenAIGptOssModelId: (modelId: string) => boolean;
+/**
+ * Meta Muse Spark ids (`muse-spark-1.1`, `muse-spark-1.2`,
+ * `muse-spark-1.2-contributor`, `meta/muse-spark-1.2`). The Responses
+ * `reasoning.effort` wire accepts `none` (thinking-off) plus
+ * `minimal`/`low`/`medium`/`high`/`xhigh`.
+ */
+export declare const isMuseSparkModelId: (modelId: string) => boolean;
+/** OpenAI model ids (gpt-*, chatgpt-*, o1/o3/o4 SKUs, codex-*, or openai/*). */
+export declare const isOpenAIModelId: (modelId: string) => boolean;
+/**
+ * OpenAI Codex models that honor `reasoning.context: "all_turns"` (full
+ * cross-turn reasoning replay). The `reasoning.context` field itself exists for
+ * the whole gpt-5/o-series family, but the `all_turns` value is only accepted
+ * from gpt-5.4 onward; earlier ids (`gpt-5.1-codex`, `gpt-5.3-codex`, and
+ * `gpt-5.3-codex-spark`) reject it with
+ * `Unsupported value: 'all_turns' is not supported with this model`. Version
+ * floor (not an allowlist) so 5.6/6.x inherit support automatically. Callers
+ * fall back to omitting `context`, letting the server default to `current_turn`.
+ */
+export declare const supportsAllTurnsReasoningContext: (modelId: string) => boolean;
+/**
+ * OpenAI Codex models that accept `reasoning.summary`. Shares the gpt-5.4 wire
+ * floor with {@link supportsAllTurnsReasoningContext}: earlier Codex ids
+ * (`gpt-5.1-codex`, `gpt-5.3-codex`, `gpt-5.3-codex-spark`) reject the field
+ * with `Unsupported parameter: 'reasoning.summary' is not supported with this
+ * model`. Callers omit `summary` for unsupported ids, letting the server skip
+ * the human-readable summary stream.
+ */
+export declare const supportsCodexReasoningSummary: (modelId: string) => boolean;
+/**
+ * OpenAI proprietary models whose serving path rejects explicit sampling
+ * parameters (`temperature`, `top_p`, `top_k`, …) with
+ * `400 Unsupported parameter: 'temperature' is not supported with this model`.
+ * Covers the o-series and the entire gpt-5+ generation — base, `mini`, `nano`,
+ * `codex*`, the `luna`/`sol`/`terra` SKUs, and the `-chat-latest` variants,
+ * since even the non-reasoning gpt-5 chat models reject sampling params (see
+ * litellm#13781). Holds regardless of which OpenAI-serving host proxies the
+ * model (official, Azure, GitHub Copilot). Version floor (not an allowlist) so
+ * 6.x inherits automatically. Issue #5606.
+ */
+export declare const isOpenAISamplingRestrictedModelId: (modelId: string) => boolean;
+/**
+ * Reasoning-capable GLM coding SKUs: glm-4.5 and up on the base / `-air` /
+ * `-turbo` lines. Excludes the vision (`…v`) shape, the non-reasoning
+ * `-flash`/`-flashx`/`-preview` variants, and pre-4.5 ids. Matching the family
+ * keeps newly-bumped integers (`glm-5.3`, `glm-6`, …) covered without a per-id
+ * allowlist.
+ */
+export declare const isReasoningGlmModelId: (modelId: string) => boolean;
+/** GLM-5.2+ coding SKUs accept `reasoning_effort` in addition to binary thinking. */
+export declare const isGlm52ReasoningEffortModelId: (modelId: string) => boolean;
+/**
+ * GLM-5.3+ coding SKUs. Unlike GLM-5.2 (whose reasoning_effort dialect is
+ * host-specific), GLM-5.3+ exposes a uniform wire-exact `low`/`high`/`max`
+ * ladder on every host, and thinking can no longer be disabled —
+ * `thinking.type` must always be `enabled`. Matching the family keeps future
+ * bumps (`glm-5.4`, `glm-6`, …) covered while excluding the vision (`…v`)
+ * shape and the non-reasoning `-flash`/`-flashx`/`-preview` variants.
+ */
+export declare const isGlm53ReasoningEffortModelId: (modelId: string) => boolean;
+/** GLM vision SKUs — the `v` that attaches to the version (`glm-4v`, `glm-4.5v`). */
+export declare const isGlmVisionModelId: (modelId: string) => boolean;
+/**
+ * Coarse vendor-lineage token for "are two models the same family?" checks
+ * (e.g. picking a cross-family reviewer). All Claude point releases share a token,
+ * Claude and GPT differ; namespace prefixes and aggregator mirrors fold onto the
+ * lineage via {@link parseKnownModel}'s `bareModelId` normalization. Opaque and
+ * comparison-only — not a stable key to persist, since the vocabulary tracks new
+ * releases. Returns `""` for ids it cannot classify; callers fall back to the provider.
+ *
+ * Vendor-only by design: a model's kind/variant (opus vs sonnet, codex vs base) is
+ * collapsed onto the single vendor token; use {@link parseKnownModel} for finer breakdowns.
+ */
+export declare const modelFamilyToken: (modelId: string) => string;
+/**
+ * True for Claude generations that support extended thinking: Sonnet/Opus 3.7+,
+ * every 4.x/5+ Opus/Sonnet, and the Fable/Mythos generation. Pre-thinking
+ * models (Claude 3.5 and older) are excluded so no thinking effort dial is
+ * fabricated for a model that rejects thinking parameters. Classifier-based, so
+ * dotted and dashed version forms both match; ids the classifier does not parse
+ * (e.g. Haiku, bare dated ids) return false.
+ */
+export declare const anthropicModelSupportsThinking: (modelId: string) => boolean;
+/**
+ * Adaptive thinking `display` is supported starting with Claude Opus 4.7+,
+ * Sonnet 5+, and the Claude Fable/Mythos 5 generation. Older adaptive-thinking
+ * models (Opus 4.6, Sonnet 4.6) reject the field. Classifier-based, so dotted
+ * and dashed version forms both match while bare dated ids
+ * (`claude-opus-4-20250514` = Opus 4.0) stay excluded.
+ */
+export declare const supportsAdaptiveThinkingDisplay: (modelId: string) => boolean;
+/**
+ * Returns true for Anthropic models with Opus 4.7+, Sonnet 5+, and Fable/Mythos 5+
+ * API restrictions:
+ * - Sampling parameters (temperature/top_p/top_k) return 400 error
+ * - Thinking content is omitted by default (needs display: "summarized")
+ */
+export declare const hasOpus47ApiRestrictions: (modelId: string) => boolean;
+/**
+ * Mid-conversation `role: "system"` messages (system instructions appended at
+ * non-first positions in the `messages` array) are supported starting with
+ * Claude Opus 4.8+, Sonnet 5+, and the Claude Fable/Mythos 5 generation.
+ * Earlier Claude models reject the role.
+ * @see https://platform.claude.com/docs/en/build-with-claude/mid-conversation-system-messages
+ */
+export declare const supportsMidConversationSystemMessages: (modelId: string) => boolean;
+/**
+ * Models that reliably follow the hashline line-anchored edit dialect
+ * (`[path#TAG]` headers plus 1-indexed anchors). Kimi, MiMo, DeepSeek V4
+ * Flash, and Step 3.7 Flash miscount anchors or drop the tag header often
+ * enough that hosts fall back to the sloppy edit format for
+ * them.
+ */
+export declare const supportsHashlineEdits: (modelId: string) => boolean;
+export declare const isAnthropicFableOrMythosModel: (modelId: string) => boolean;
+/** Thinking-variant token location inside a model id. */
+export interface ThinkingVariantToken {
+    index: number;
+    length: number;
+}
+/**
+ * Locates the first thinking-variant token (`-thinking`, `-reasoner`,
+ * `-reasoning`; trailing or infix) in a model id. The token ends at the id
+ * end or any non-alphanumeric boundary, and negated forms (`non-thinking`,
+ * `no-thinking`) never match — those name the NON-thinking SKU.
+ */
+export declare function findThinkingVariantToken(modelId: string): ThinkingVariantToken | undefined;
+/**
+ * Removes the located thinking-variant token: `kimi-k2-thinking` → `kimi-k2`,
+ * `mimo-v2-flash-thinking-original` → `mimo-v2-flash-original`,
+ * `grok-4.1-fast-reasoning` → `grok-4.1-fast`. Returns `undefined` when no
+ * token exists or nothing would remain. Callers MUST verify the result names
+ * a live model.
+ */
+export declare const stripThinkingVariantToken: (modelId: string) => string | undefined;

package/dist/types/identity/id.d.ts

@@ -0,0 +1,12 @@
+export declare function getModelLikeIdSegments(modelId: string): string[];
+export declare function getLongestModelLikeIdSegment(modelId: string): string | undefined;
+/**
+ * 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.
+ */
+export declare function getBracketStrippedModelIdCandidates(modelId: string): string[];
+export declare function stripBracketedModelIdAffixes(modelId: string): string | undefined;

package/dist/types/identity/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./bundled.js";
+export * from "./classify.js";
+export * from "./dialect.js";
+export * from "./family.js";
+export * from "./id.js";
+export * from "./markers.js";
+export * from "./priority.js";
+export * from "./reference.js";

package/dist/types/identity/markers.d.ts

@@ -0,0 +1,4 @@
+/** Marker pattern used by canonical-id resolution (`search` excluded). */
+export declare const CANONICAL_TRAILING_MARKER_PATTERN: RegExp;
+/** Marker pattern used by proxy-reference lookup (`search` included). */
+export declare const REFERENCE_TRAILING_MARKER_PATTERN: RegExp;

package/dist/types/identity/priority.d.ts

@@ -0,0 +1 @@
+export declare function buildModelProviderPriorityRank(configuredProviderOrder?: readonly string[]): Map<string, number>;

package/dist/types/identity/reference.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Proxy/reseller reference lookup: given a custom model id served through a
+ * proxy (`[Kiro] claude-opus-4-8`, `gpt-5.4:cloud`, `vendor/claude-sonnet-4-6-thinking`),
+ * find the bundled upstream model so missing pricing/capability metadata can be
+ * inherited while keeping the custom transport.
+ *
+ * Kept separate from canonical-id resolution (`./equivalence`): this lookup
+ * may strip `search`-style markers and prefers cache-pricing-complete
+ * references, both of which would be wrong for canonical coalescing.
+ */
+import type { Api, Model, ThinkingConfig } from "../types.js";
+export interface ModelReferenceIndex {
+    exact: Map<string, Model<Api>>;
+    suffixAlias: Map<string, Model<Api>>;
+}
+export declare function isZeroCostXaiOAuthReference(candidate: Model<Api>): boolean;
+/**
+ * Build a reference index from a model catalog (typically the bundled models).
+ * Pure: callers are responsible for memoizing the result.
+ */
+export declare function buildModelReferenceIndex(models: Iterable<Model<Api>>): ModelReferenceIndex;
+/**
+ * Inherit bundled reference thinking only for same-provider matches. Wire routing
+ * (`effortRouting`) is provider-specific; cross-provider inheritance can rewrite
+ * gateway ids (e.g. Portkey `@modal/GLM-5-2-FP8` → devin `glm-5-2`).
+ */
+export declare function inheritReferenceThinking(modelThinking: ThinkingConfig | undefined, reference: Pick<Model<Api>, "provider" | "thinking"> | undefined, provider: string): ThinkingConfig | undefined;
+/** Resolve a (possibly proxied/affixed) model id to its bundled upstream reference. */
+export declare function resolveModelReference(modelId: string, index: ModelReferenceIndex): Model<Api> | undefined;

package/dist/types/index.d.ts

@@ -0,0 +1,19 @@
+export * from "./compat/openai.js";
+export * from "./discovery/index.js";
+export * from "./effort.js";
+export * from "./fireworks-model-id.js";
+export * from "./identity/index.js";
+export * from "./model-cache.js";
+export * from "./model-manager.js";
+export * from "./model-thinking.js";
+export * from "./model-tokenizer.js";
+export * from "./models.js";
+export * from "./provider-models/index.js";
+export * from "./types.js";
+export * from "./utils.js";
+export * from "./variant-collapse.js";
+export * from "./wire/codex.js";
+export * from "./wire/coreweave.js";
+export * from "./wire/gemini-headers.js";
+export * from "./wire/github-copilot.js";
+export * from "./wire/image-fetchers.js";

package/dist/types/model-cache.d.ts

@@ -0,0 +1,23 @@
+import type { Api, Model, ModelSpec } from "./types.js";
+interface CacheEntry<TApi extends Api = Api> {
+    models: ModelSpec<TApi>[];
+    fresh: boolean;
+    authoritative: boolean;
+    updatedAt: number;
+    /** Model ids whose live headers were intentionally omitted from disk. */
+    headerOmittedModelIds: readonly string[];
+    /** Header-bearing model ids that cannot be rebuilt from the static source. */
+    unrestorableHeaderModelIds: readonly string[];
+    /** Whether unrestorable markers predate request-model header matching. */
+    legacyHeaderRestoreMarkers: boolean;
+    /**
+     * Hash of the static catalog slice that was merged into `models` when this
+     * row was written. `resolveProviderModels` compares against the current
+     * static fingerprint and bypasses the static+cache re-merge when they
+     * match — the cache already incorporates the same static state.
+     */
+    staticFingerprint: string;
+}
+export declare function readModelCache<TApi extends Api>(providerId: string, ttlMs: number, now: () => number, dbPath?: string): CacheEntry<TApi> | null;
+export declare function writeModelCache<TApi extends Api>(providerId: string, updatedAt: number, models: Model<TApi>[], authoritative: boolean, staticFingerprint: string, dbPath?: string, staticHeaderSources?: readonly Model<TApi>[], restorableHeaderFallback?: Record<string, string>): void;
+export {};

package/dist/types/model-manager.d.ts

@@ -0,0 +1,77 @@
+import type { Api, Model, ModelSpec, Provider } from "./types.js";
+/**
+ * Controls when dynamic endpoint models should be fetched.
+ */
+export type ModelRefreshStrategy = "online" | "offline" | "online-if-uncached";
+/**
+ * Hook for loading and mapping stencil.so fallback data into canonical model objects.
+ */
+export interface ModelsDevFallback<TApi extends Api = Api, TPayload = unknown> {
+    /** Fetches raw fallback payload (for example from stencil.so). */
+    fetch(): Promise<TPayload>;
+    /** Maps payload into provider models. */
+    map(payload: TPayload, providerId: Provider): readonly ModelSpec<TApi>[];
+}
+/**
+ * Configuration for provider model resolution.
+ */
+export interface ModelManagerOptions<TApi extends Api = Api, TModelsDevPayload = unknown> {
+    /** Provider id used for static lookup and cache namespacing. */
+    providerId: Provider;
+    /** Optional static list override. When omitted, bundled models.json is used. */
+    staticModels?: readonly ModelSpec<TApi>[];
+    /** Optional override for the cache database path. Default: <agent-dir>/models.db. */
+    cacheDbPath?: string;
+    /** Optional provider id override for cache namespacing. Defaults to providerId. */
+    cacheProviderId?: string;
+    /** Maximum cache age in milliseconds before considered stale. Default: 2h (`DEFAULT_CACHE_TTL_MS`). */
+    cacheTtlMs?: number;
+    /** When true, a successful dynamic fetch is the complete provider catalog and prunes static-only models. */
+    dynamicModelsAuthoritative?: boolean;
+    /** Cached model ids whose presence forces refresh when the static or migration-policy fingerprint changes. */
+    dropCachedModelIdsOnStaticMismatch?: readonly string[];
+    /**
+     * Trusted, provider-wide request headers that can be safely re-derived at
+     * cache-read time. The cache never persists their values. Models whose live
+     * headers matched this record at write time can survive offline reads without
+     * a bundled static source, including configured discovery providers whose
+     * bearer header comes from the current local config.
+     */
+    restorableHeaderFallback?: Record<string, string>;
+    /** Optional dynamic endpoint fetcher. */
+    fetchDynamicModels?: () => Promise<readonly ModelSpec<TApi>[] | null>;
+    /** Optional stencil.so fallback hook. */
+    modelsDev?: ModelsDevFallback<TApi, TModelsDevPayload>;
+    /** Clock override for deterministic tests. */
+    now?: () => number;
+}
+/**
+ * Resolution result.
+ *
+ * `stale` is false when the resolved catalog is authoritative for the selected provider:
+ * - a dynamic endpoint fetch succeeded in this call (an empty catalog is still
+ *   authoritative for the cycle, so downstream pruning of removed models runs),
+ * - a still-fresh authoritative cache was reused in `online-if-uncached` mode, or
+ * - the provider has no dynamic fetcher configured.
+ */
+export interface ModelResolutionResult<TApi extends Api = Api> {
+    models: Model<TApi>[];
+    stale: boolean;
+}
+/**
+ * Stateful facade over provider model resolution.
+ */
+export interface ModelManager<TApi extends Api = Api> {
+    refresh(strategy?: ModelRefreshStrategy): Promise<ModelResolutionResult<TApi>>;
+}
+/**
+ * Creates a reusable provider model manager.
+ */
+export declare function createModelManager<TApi extends Api = Api, TModelsDevPayload = unknown>(options: ModelManagerOptions<TApi, TModelsDevPayload>): ModelManager<TApi>;
+/**
+ * Resolves provider models with source precedence:
+ * static -> stencil.so -> cache -> dynamic.
+ *
+ * Later sources override earlier ones by model id.
+ */
+export declare function resolveProviderModels<TApi extends Api = Api, TModelsDevPayload = unknown>(options: ModelManagerOptions<TApi, TModelsDevPayload>, strategy?: ModelRefreshStrategy): Promise<ModelResolutionResult<TApi>>;

package/dist/types/model-thinking.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Thinking metadata: build-time derivation and runtime field-read helpers.
+ *
+ * Derivation (`resolveModelThinking`) runs exactly once per model — from
+ * `buildModel` for dynamic specs and from the catalog generator for bundled
+ * entries. Everything below the "runtime helpers" divider reads baked fields
+ * only: no id parsing, no host matching, no compat detection per request.
+ */
+import { Effort } from "./effort.js";
+import type { Api, CompatOf, Model, ModelSpec, ThinkingConfig } from "./types.js";
+/**
+ * Runtime helpers read baked metadata only, so they accept both pre-build
+ * specs and built models.
+ */
+type ApiModel<TApi extends Api = Api> = ModelSpec<TApi> | Model<TApi>;
+/**
+ * Resolve the canonical thinking metadata for a spec. Called exactly once per
+ * model by `buildModel`, after compat resolution.
+ *
+ * - Non-reasoning models never carry thinking.
+ * - Models that reason natively but reject the wire effort param
+ *   (`compat.supportsReasoningEffort: false` on openai-responses*) carry no
+ *   thinking either: `reasoning: true, thinking: undefined` IS the encoding
+ *   for "thinks, but exposes no control surface".
+ * - Explicit spec thinking (generator-baked or user-authored) owns the
+ *   capability surface (`mode`, `efforts`, `defaultLevel`); the wire facts
+ *   (`effortMap`, `supportsDisplay`) are backfilled from identity when not
+ *   explicitly set, so configs never need to know provider wire tier tables.
+ * - Sparse specs go through full inference.
+ */
+export declare function resolveModelThinking<TApi extends Api>(spec: ModelSpec<TApi>, compat: CompatOf<TApi>): ThinkingConfig | undefined;
+/** Derive thinking from identity + resolved compat, ignoring any baked value. Generator-side entry. */
+export declare function deriveThinking<TApi extends Api>(spec: ModelSpec<TApi>, compat: CompatOf<TApi>): ThinkingConfig;
+/**
+ * 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`).
+ */
+export declare function getSupportedEfforts<TApi extends Api>(model: ApiModel<TApi>): readonly Effort[];
+/**
+ * Clamps a requested thinking level against explicit model metadata.
+ *
+ * Non-reasoning models always resolve to `undefined`.
+ */
+export declare function clampThinkingLevelForModel<TApi extends Api>(model: ApiModel<TApi> | undefined, requested: Effort | undefined): Effort | undefined;
+export declare function requireSupportedEffort<TApi extends Api>(model: ApiModel<TApi>, effort: Effort): Effort;
+/** Maps a normalized thinking effort to Google's `thinkingLevel` enum values.
+ * When a collapsed family routes `minimal` onto the same wire id as `low`
+ * (Antigravity Gemini 3.6/3.7 Flash), emit `LOW` — Cloud Code Assist rejects
+ * `MINIMAL` on those `-low` SKUs.
+ */
+export declare function mapEffortToGoogleThinkingLevel<TApi extends Api>(effort: Effort, model?: ApiModel<TApi>): "MINIMAL" | "LOW" | "MEDIUM" | "HIGH";
+/**
+ * Maps a normalized thinking effort to Anthropic adaptive effort values via
+ * the model's baked `thinking.effortMap` (identity for unmapped efforts).
+ */
+export declare function mapEffortToAnthropicAdaptiveEffort<TApi extends Api>(model: ApiModel<TApi>, effort: Effort): "low" | "medium" | "high" | "xhigh" | "max" | "adaptive";
+/**
+ * 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`.
+ */
+export declare function resolveWireModelId<TApi extends Api>(model: ApiModel<TApi>, effort: Effort | undefined): string;
+/**
+ * Lowest supported effort in canonical order — the clamp target for
+ * thinking-off requests on `thinking.requiresEffort` models.
+ */
+export declare function minimumSupportedEffort<TApi extends Api>(model: ApiModel<TApi>): Effort | undefined;
+export {};

package/dist/types/model-tokenizer.d.ts

@@ -0,0 +1,8 @@
+import type { ModelTokenizer } from "./types.js";
+/**
+ * Resolve the exact locally embedded tokenizer for a canonical model id.
+ *
+ * This is catalog policy, not a runtime caller heuristic: [`buildModel`](./build.ts)
+ * materializes the result as `Model.tokenizer`; consumers read that property.
+ */
+export declare function resolveModelTokenizer(modelId: string): ModelTokenizer | undefined;

package/dist/types/models.d.ts

@@ -0,0 +1,14 @@
+import MODELS from "./models.json";
+import type { Api, KnownProvider, Model, Usage } from "./types.js";
+export type GeneratedProvider = keyof typeof MODELS;
+export declare function getBundledModel<TApi extends Api = Api>(provider: GeneratedProvider, modelId: string): Model<TApi>;
+export declare function getBundledProviders(): KnownProvider[];
+export declare function getBundledModels(provider: GeneratedProvider): Model<Api>[];
+/** Price a prompt as fully uncached input under its active context-length tier. */
+export declare function calculateUncachedInputCost(cost: Model["cost"], promptInputTokens: number): number;
+export declare function calculateCost<TApi extends Api>(model: Model<TApi>, usage: Usage): Usage["cost"];
+/**
+ * Check if two models are equal by comparing both their id and provider.
+ * Returns false if either model is null or undefined.
+ */
+export declare function modelsAreEqual<TApi extends Api>(a: Model<TApi> | null | undefined, b: Model<TApi> | null | undefined): boolean;

package/dist/types/openai-pricing.d.ts

@@ -0,0 +1,17 @@
+import type { TokenCost } from "./types.js";
+/** Standard GPT-5.6 Sol rates used by the Daybreak Blue aliases. */
+export declare const OPENAI_GPT_56_SOL_STANDARD_COST: {
+    readonly input: 5;
+    readonly output: 30;
+    readonly cacheRead: 0.5;
+    readonly cacheWrite: 6.25;
+};
+/** Standard GPT-5.6 Cyber rates used by the Daybreak Red aliases. */
+export declare const OPENAI_GPT_56_CYBER_STANDARD_COST: {
+    readonly input: 12.5;
+    readonly output: 75;
+    readonly cacheRead: 1.25;
+    readonly cacheWrite: 15.625;
+};
+/** Resolve standard rates for Codex-prefixed Daybreak aliases. */
+export declare function resolveOpenAIDaybreakStandardCost(modelId: string): TokenCost | undefined;

package/dist/types/provider-models/bundled-references.d.ts

@@ -0,0 +1,13 @@
+import { getBundledModels } from "../models.js";
+import type { Api, Model, ModelSpec } from "../types.js";
+/**
+ * Project a built `Model` back to spec stage: `compat` becomes the verbatim
+ * sparse override record (`compatConfig`), never the resolved view. Discovery
+ * mappers spread these references into the specs they hand to the model
+ * manager, which rebuilds via `buildModel`.
+ */
+export declare function toModelSpec<TApi extends Api>(model: Model<TApi>): ModelSpec<TApi>;
+export declare function createBundledReferenceMap<TApi extends Api>(provider: Parameters<typeof getBundledModels>[0]): Map<string, ModelSpec<TApi>>;
+type ProviderReferenceSource<TApi extends Api> = Map<string, ModelSpec<TApi>> | (() => Map<string, ModelSpec<TApi>>);
+export declare function createReferenceResolver<TApi extends Api>(providerReferenceSource: ProviderReferenceSource<TApi>): (modelId: string) => ModelSpec<TApi> | undefined;
+export {};

package/dist/types/provider-models/cache-provider-id.d.ts

@@ -0,0 +1,11 @@
+export interface ModelCacheProviderIdOptions {
+    apiKey?: string;
+    baseUrl?: string;
+}
+/** Whether a provider's model-cache namespace requires its resolved credential. */
+export declare function isCredentialScopedModelCacheProvider(providerId: string): boolean;
+export declare function getDefaultModelDiscoveryBaseUrl(providerId: string): string | undefined;
+/** Resolve an Ollama model-cache namespace scoped to the normalized discovery endpoint. */
+export declare function resolveOllamaModelCacheProviderId(providerId: string, baseUrl?: string): string;
+/** Resolve the cache namespace used by a provider's model-manager options without constructing those options. */
+export declare function resolveModelCacheProviderId(providerId: string, options?: ModelCacheProviderIdOptions): string;

package/dist/types/provider-models/descriptor-types.d.ts

@@ -0,0 +1,76 @@
+import type { ModelManagerOptions } from "../model-manager.js";
+import type { Api, FetchImpl } from "../types.js";
+/** Config passed to a provider's runtime model-manager factory. */
+export type ModelManagerConfig = {
+    apiKey?: string;
+    baseUrl?: string;
+    fetch?: FetchImpl;
+    /** The supplied fetch already applies provider-specific authentication. */
+    authenticated?: boolean;
+};
+/** Catalog discovery configuration for providers that support endpoint-based model listing. */
+export interface CatalogDiscoveryConfig {
+    /** Human-readable name for log messages. */
+    label: string;
+    /**
+     * Environment variables to check for API keys during catalog generation.
+     * Defaults to the entry-level `envVars` when omitted.
+     */
+    envVars?: readonly string[];
+    /** OAuth provider for credential refresh during catalog generation. */
+    oauthProvider?: string;
+    /** When true, catalog discovery proceeds even without credentials. */
+    allowUnauthenticated?: boolean;
+}
+/** Unified provider descriptor used by both runtime discovery and catalog generation. */
+export interface ProviderDescriptor {
+    providerId: string;
+    createModelManagerOptions(config: ModelManagerConfig): ModelManagerOptions<Api>;
+    /** Preferred model ID when no explicit selection is made. */
+    defaultModel: string;
+    /** When true, the runtime creates a model manager even without a valid API key (e.g. ollama). */
+    allowUnauthenticated?: boolean;
+    /** When true, successful runtime discovery replaces bundled provider models instead of merging fallback-only IDs. */
+    dynamicModelsAuthoritative?: boolean;
+    /** Catalog discovery configuration. Only providers with this field participate in generate-models.ts. */
+    catalogDiscovery?: CatalogDiscoveryConfig;
+}
+/** A provider descriptor that has catalog discovery configured. */
+export type CatalogProviderDescriptor = ProviderDescriptor & {
+    catalogDiscovery: CatalogDiscoveryConfig;
+};
+/** Type guard for descriptors with catalog discovery. */
+export declare function isCatalogDescriptor(d: ProviderDescriptor): d is CatalogProviderDescriptor;
+/** Whether catalog discovery may run without provider credentials. */
+export declare function allowsUnauthenticatedCatalogDiscovery(descriptor: CatalogProviderDescriptor): boolean;
+/**
+ * One model provider's catalog-side description. The auth half of a provider
+ * (env keys, OAuth login/refresh flows) lives in `@oh-my-pi/pi-ai`'s registry;
+ * the catalog table below is the single source of truth for ids, default
+ * models, and discovery wiring.
+ *
+ * - Every entry is a member of `KnownProvider`.
+ * - `createModelManagerOptions` present (and not `specialModelManager`) ⇒
+ *   appears in `PROVIDER_DESCRIPTORS` for runtime model discovery.
+ * - \`catalogDiscovery\` present ⇒ participates in \`generate-models.ts\`.
+ */
+export interface ProviderCatalogEntry {
+    readonly id: string;
+    /** Preferred model ID when no explicit selection is made. */
+    readonly defaultModel: string;
+    /** Environment variables consulted (in order) for the provider's runtime API-key env fallback. */
+    readonly envVars?: readonly string[];
+    /** Runtime model-manager factory. Omitted for catalog-only providers. */
+    readonly createModelManagerOptions?: (config: ModelManagerConfig) => ModelManagerOptions<Api>;
+    /** When true, the runtime creates a model manager even without a valid API key. */
+    readonly allowUnauthenticated?: boolean;
+    /** When true, successful runtime discovery replaces bundled provider models. */
+    readonly dynamicModelsAuthoritative?: boolean;
+    /** Catalog discovery configuration for generate-models.ts. */
+    readonly catalogDiscovery?: CatalogDiscoveryConfig;
+    /**
+     * Built bespoke by the coding-agent runtime (OAuth-token-driven managers);
+     * excluded from `PROVIDER_DESCRIPTORS` even though models are discoverable.
+     */
+    readonly specialModelManager?: boolean;
+}