@rigelbuild/omp-catalog 18.0.3

package/src/models.json.d.ts

@@ -0,0 +1,9 @@
+import type { Api } from "./types";
+
+/** Typed declaration for the generated models.json — only the `api` field matters for type inference. */
+declare const models: {
+	[provider: string]: {
+		[modelId: string]: { readonly api: Api; [key: string]: unknown };
+	};
+};
+export default models;

package/src/models.ts

@@ -0,0 +1,108 @@
+import MODELS from "./models.json" with { type: "json" };
+import type { Api, KnownProvider, Model, TokenCost, Usage } from "./types";
+
+/**
+ * Static bundled model registry loaded from `models.json`.
+ *
+ * This module intentionally exposes compile-time defaults only.
+ * It does not include runtime discovery, stencil.so overlays, or on-disk cache state.
+ *
+ * For runtime-aware resolution, use `createModelManager()` / `resolveProviderModels()`.
+ */
+const modelRegistry = new Map<string, Map<string, Model<Api>>>();
+
+/** Return one provider's bundled models, materialized by the generator. */
+function getProviderModels(provider: string): Map<string, Model<Api>> | undefined {
+	const cachedModels = modelRegistry.get(provider);
+	if (cachedModels !== undefined) return cachedModels;
+	if (!Object.hasOwn(MODELS, provider)) return undefined;
+
+	const providerModels = new Map<string, Model<Api>>();
+	const rawModels = MODELS[provider as keyof typeof MODELS];
+	for (const id in rawModels) {
+		// models.json rows are complete Models emitted by generate-models.ts;
+		// consuming them verbatim keeps startup allocation-free.
+		providerModels.set(id, rawModels[id as keyof typeof rawModels] as unknown as Model<Api>);
+	}
+	modelRegistry.set(provider, providerModels);
+	return providerModels;
+}
+
+export type GeneratedProvider = keyof typeof MODELS;
+
+export function getBundledModel<TApi extends Api = Api>(provider: GeneratedProvider, modelId: string): Model<TApi> {
+	const providerModels = getProviderModels(provider);
+	return providerModels?.get(modelId) as Model<TApi>;
+}
+
+export function getBundledProviders(): KnownProvider[] {
+	return Object.keys(MODELS) as KnownProvider[];
+}
+
+export function getBundledModels(provider: GeneratedProvider): Model<Api>[] {
+	const models = getProviderModels(provider);
+	return models ? (Array.from(models.values()) as Model<Api>[]) : [];
+}
+function resolveTokenCost(cost: Model["cost"], promptInputTokens: number): TokenCost {
+	const longContext = cost.longContext;
+	if (!longContext) return cost;
+	return promptInputTokens > longContext.inputThreshold ? longContext : cost;
+}
+
+/** Price a prompt as fully uncached input under its active context-length tier. */
+export function calculateUncachedInputCost(cost: Model["cost"], promptInputTokens: number): number {
+	const rates = resolveTokenCost(cost, promptInputTokens);
+	return (rates.input / 1_000_000) * promptInputTokens;
+}
+
+export function calculateCost<TApi extends Api>(model: Model<TApi>, usage: Usage): Usage["cost"] {
+	const orchestration = usage.orchestration;
+	const promptInputTokens =
+		usage.input + usage.cacheRead + usage.cacheWrite + (orchestration?.input ?? 0) + (orchestration?.cacheRead ?? 0);
+	const rates = resolveTokenCost(model.cost, promptInputTokens);
+	usage.cost.input = (rates.input / 1000000) * (usage.input + (orchestration?.input ?? 0));
+	usage.cost.output = (rates.output / 1000000) * (usage.output + (orchestration?.output ?? 0));
+	usage.cost.cacheRead = (rates.cacheRead / 1000000) * (usage.cacheRead + (orchestration?.cacheRead ?? 0));
+	usage.cost.cacheWrite = cacheWriteCost(rates, usage);
+	usage.cost.total = usage.cost.input + usage.cost.output + usage.cost.cacheRead + usage.cost.cacheWrite;
+	return usage.cost;
+}
+
+/**
+ * Price cache-write tokens, honoring the TTL breakdown when the provider reports one.
+ *
+ * `rates.cacheWrite` is the 5-minute write rate (Anthropic bills 5m writes at
+ * 1.25x base input). When `usage.cttl` is present the write can mix 5m and 1h
+ * breakpoints, and 1h writes bill at 2x base input, so each component is
+ * priced at its own rate instead of the flat 5m rate. Deriving 1h from
+ * `input * 2` (Anthropic's published multiplier) is model-independent and
+ * stays correct even for legacy entries whose stored
+ * `cacheWrite` scalar drifts from 1.25x input. Providers that omit `cttl`
+ * (everyone but Anthropic) keep the flat-rate calculation.
+ *
+ * The breakdown is documented to sum to `usage.cacheWrite`, but the two are written
+ * from independent wire fields (`cache_creation` vs `cache_creation_input_tokens`),
+ * so any unattributed remainder is priced at the flat rate instead of being dropped:
+ * a partial or stale breakdown must never make write tokens free.
+ */
+function cacheWriteCost(rates: TokenCost, usage: Usage): number {
+	const rate5m = rates.cacheWrite / 1000000;
+	const cttl = usage.cttl;
+	if (!cttl) return rate5m * usage.cacheWrite;
+	const fiveMinute = cttl.ephemeral5m ?? 0;
+	const oneHour = cttl.ephemeral1h ?? 0;
+	const residual = Math.max(0, usage.cacheWrite - fiveMinute - oneHour);
+	return rate5m * (fiveMinute + residual) + ((rates.input * 2) / 1000000) * oneHour;
+}
+
+/**
+ * Check if two models are equal by comparing both their id and provider.
+ * Returns false if either model is null or undefined.
+ */
+export function modelsAreEqual<TApi extends Api>(
+	a: Model<TApi> | null | undefined,
+	b: Model<TApi> | null | undefined,
+): boolean {
+	if (!a || !b) return false;
+	return a.id === b.id && a.provider === b.provider;
+}

package/src/openai-pricing.ts

@@ -0,0 +1,29 @@
+import type { TokenCost } from "./types";
+
+/** Standard GPT-5.6 Sol rates used by the Daybreak Blue aliases. */
+export const OPENAI_GPT_56_SOL_STANDARD_COST = {
+	input: 5,
+	output: 30,
+	cacheRead: 0.5,
+	cacheWrite: 6.25,
+} as const satisfies TokenCost;
+
+/** Standard GPT-5.6 Cyber rates used by the Daybreak Red aliases. */
+export const OPENAI_GPT_56_CYBER_STANDARD_COST = {
+	input: 12.5,
+	output: 75,
+	cacheRead: 1.25,
+	cacheWrite: 15.625,
+} as const satisfies TokenCost;
+
+/** Resolve standard rates for Codex-prefixed Daybreak aliases. */
+export function resolveOpenAIDaybreakStandardCost(modelId: string): TokenCost | undefined {
+	switch (modelId) {
+		case "gpt-daybreak-blue-latest":
+			return OPENAI_GPT_56_SOL_STANDARD_COST;
+		case "gpt-daybreak-red-latest":
+			return OPENAI_GPT_56_CYBER_STANDARD_COST;
+		default:
+			return undefined;
+	}
+}

package/src/provider-models/bundled-references.ts

@@ -0,0 +1,87 @@
+import { isZeroCostXaiOAuthReference } from "../identity/reference";
+import { getBundledModels, getBundledProviders } from "../models";
+import type { Api, Model, ModelSpec } from "../types";
+
+/**
+ * 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 function toModelSpec<TApi extends Api>(model: Model<TApi>): ModelSpec<TApi> {
+	const {
+		compat: _compat,
+		compatConfig,
+		supportsComputerUse: _derivedComputerUse,
+		supportsComputerUseConfig,
+		...rest
+	} = model;
+	return {
+		...rest,
+		...(supportsComputerUseConfig !== undefined ? { supportsComputerUse: supportsComputerUseConfig } : {}),
+		compat: compatConfig,
+	} as ModelSpec<TApi>;
+}
+
+export function createBundledReferenceMap<TApi extends Api>(
+	provider: Parameters<typeof getBundledModels>[0],
+): Map<string, ModelSpec<TApi>> {
+	const references = new Map<string, ModelSpec<TApi>>();
+	for (const model of getBundledModels(provider)) {
+		references.set(model.id, toModelSpec(model as Model<TApi>));
+	}
+	return references;
+}
+
+type ProviderReferenceSource<TApi extends Api> = Map<string, ModelSpec<TApi>> | (() => Map<string, ModelSpec<TApi>>);
+
+let globalReferences: Map<string, Model<Api>> | undefined;
+
+function getGlobalReferences(): Map<string, Model<Api>> {
+	if (globalReferences) {
+		return globalReferences;
+	}
+	const references = new Map<string, Model<Api>>();
+	for (const provider of getBundledProviders()) {
+		for (const model of getBundledModels(provider as Parameters<typeof getBundledModels>[0])) {
+			const candidate = model as Model<Api>;
+			if (isZeroCostXaiOAuthReference(candidate)) {
+				continue;
+			}
+			const existing = references.get(candidate.id);
+			if (!existing) {
+				references.set(candidate.id, candidate);
+			} else if (candidate.contextWindow !== existing.contextWindow) {
+				if ((candidate.contextWindow ?? 0) > (existing.contextWindow ?? 0)) {
+					references.set(candidate.id, candidate);
+				}
+			} else if (candidate.maxTokens !== existing.maxTokens) {
+				if ((candidate.maxTokens ?? 0) > (existing.maxTokens ?? 0)) {
+					references.set(candidate.id, candidate);
+				}
+			} else if (existing.provider !== "openai" && candidate.provider === "openai") {
+				references.set(candidate.id, candidate);
+			}
+		}
+	}
+	globalReferences = references;
+	return references;
+}
+
+export function createReferenceResolver<TApi extends Api>(
+	providerReferenceSource: ProviderReferenceSource<TApi>,
+): (modelId: string) => ModelSpec<TApi> | undefined {
+	let lazyProviderReferences: Map<string, ModelSpec<TApi>> | undefined;
+	const getProviderReferences =
+		typeof providerReferenceSource === "function"
+			? () => (lazyProviderReferences ??= providerReferenceSource())
+			: () => providerReferenceSource;
+	return (modelId: string) => {
+		const providerRefs = getProviderReferences();
+		const globalRefs = getGlobalReferences();
+		const providerRef = providerRefs.get(modelId);
+		if (providerRef) return providerRef;
+		const globalRef = globalRefs.get(modelId);
+		return globalRef ? toModelSpec(globalRef as Model<TApi>) : undefined;
+	};
+}

package/src/provider-models/cache-provider-id.ts

@@ -0,0 +1,97 @@
+import { PERSONAL_GITHUB_COPILOT_BASE_URL } from "../wire/github-copilot";
+
+export interface ModelCacheProviderIdOptions {
+	apiKey?: string;
+	baseUrl?: string;
+}
+
+const CREDENTIAL_SCOPED_MODEL_CACHE_PROVIDERS: Readonly<Record<string, true>> = {
+	"opencode-go": true,
+	"opencode-zen": true,
+	"github-copilot": true,
+};
+
+/** Whether a provider's model-cache namespace requires its resolved credential. */
+export function isCredentialScopedModelCacheProvider(providerId: string): boolean {
+	return CREDENTIAL_SCOPED_MODEL_CACHE_PROVIDERS[providerId] === true;
+}
+
+export function getDefaultModelDiscoveryBaseUrl(providerId: string): string | undefined {
+	switch (providerId) {
+		case "ollama":
+			return "http://127.0.0.1:11434";
+		case "litellm":
+			return Bun.env.LITELLM_BASE_URL ?? "http://localhost:4000/v1";
+		case "opencode-go":
+			return "https://opencode.ai/zen/go/v1";
+		case "opencode-zen":
+			return "https://opencode.ai/zen/v1";
+		case "vllm":
+			return "http://127.0.0.1:8000/v1";
+		default:
+			return undefined;
+	}
+}
+
+/** Resolve an Ollama model-cache namespace scoped to the normalized discovery endpoint. */
+export function resolveOllamaModelCacheProviderId(providerId: string, baseUrl?: string): string {
+	const defaultBaseUrl = getDefaultModelDiscoveryBaseUrl("ollama")!;
+	let endpoint = defaultBaseUrl;
+	try {
+		const parsed = new URL(baseUrl ?? defaultBaseUrl);
+		const trimmedPath = parsed.pathname.replace(/\/+$/g, "");
+		const nativePath = trimmedPath.endsWith("/v1") ? trimmedPath.slice(0, -3) : trimmedPath;
+		endpoint = `${parsed.protocol}//${parsed.host}${nativePath}`;
+	} catch {
+		// Malformed URLs fall back during discovery, so share the default endpoint's cache.
+	}
+	return `${providerId}:ollama-models-v1:${Bun.hash(endpoint).toString(36)}`;
+}
+
+/** Resolve the cache namespace used by a provider's model-manager options without constructing those options. */
+export function resolveModelCacheProviderId(providerId: string, options: ModelCacheProviderIdOptions = {}): string {
+	switch (providerId) {
+		case "ollama":
+			return resolveOllamaModelCacheProviderId(providerId, options.baseUrl);
+		case "cursor":
+			// v3: max-mode Claude/Gemini rows cached before the 1M context-window
+			// discovery fix carry a stale 200k window and must be refetched.
+			return "cursor:max-mode-v3";
+		case "litellm": {
+			const baseUrl = options.baseUrl ?? getDefaultModelDiscoveryBaseUrl(providerId)!;
+			return `litellm:rich-v6:${Bun.hash(baseUrl).toString(36)}`;
+		}
+		case "opencode-go":
+		case "opencode-zen": {
+			// v3: gateway-first rows cached before stencil enrichment carry null
+			// limits and `reasoning: false`; use a fresh namespace so they refetch.
+			const configuredBaseUrl = options.baseUrl ?? getDefaultModelDiscoveryBaseUrl(providerId)!;
+			const trimmedBaseUrl = configuredBaseUrl.endsWith("/") ? configuredBaseUrl.slice(0, -1) : configuredBaseUrl;
+			const discoveryBaseUrl = trimmedBaseUrl.endsWith("/v1") ? trimmedBaseUrl : `${trimmedBaseUrl}/v1`;
+			const scope = `${options.apiKey ?? ""}\u0000${discoveryBaseUrl}`;
+			return `${providerId}:models-v3:${Bun.hash(scope).toString(36)}`;
+		}
+		case "github-copilot": {
+			// Copilot model specs bake in the plan-specific endpoint (personal vs
+			// Business/Enterprise) resolved from the credential. Discovery writes an
+			// authoritative cache, so `online-if-uncached` serves it for the full
+			// TTL without re-probing. Keying the namespace on the credential means
+			// switching `COPILOT_GITHUB_TOKEN` to a different account misses the
+			// prior endpoint's cache and re-runs discovery instead of hitting the
+			// stale host and 403ing (PR #8510 review).
+			const baseUrl = options.baseUrl ?? PERSONAL_GITHUB_COPILOT_BASE_URL;
+			const scope = `${options.apiKey ?? ""}\u0000${baseUrl}`;
+			return `github-copilot:models-v1:${Bun.hash(scope).toString(36)}`;
+		}
+		case "openrouter":
+			return "openrouter:pseudo-api";
+		case "vllm": {
+			// v2: qwen3.8 rows cached before the reasoning/template-effort upgrade
+			// carry `reasoning: false` and must be refetched.
+			const baseUrl = options.baseUrl ?? getDefaultModelDiscoveryBaseUrl(providerId)!;
+			return `vllm:models-v2:${Bun.hash(baseUrl).toString(36)}`;
+		}
+		default:
+			return providerId;
+	}
+}

package/src/provider-models/descriptor-types.ts

@@ -0,0 +1,85 @@
+import type { ModelManagerOptions } from "../model-manager";
+import type { Api, FetchImpl } from "../types";
+
+/** 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 function isCatalogDescriptor(d: ProviderDescriptor): d is CatalogProviderDescriptor {
+	return d.catalogDiscovery != null;
+}
+
+/** Whether catalog discovery may run without provider credentials. */
+export function allowsUnauthenticatedCatalogDiscovery(descriptor: CatalogProviderDescriptor): boolean {
+	return descriptor.catalogDiscovery.allowUnauthenticated ?? descriptor.allowUnauthenticated ?? false;
+}
+
+/**
+ * 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;
+}