@rigelbuild/omp-catalog 18.0.3

package/dist/types/utils.d.ts

@@ -0,0 +1,20 @@
+import { type FetchImpl } from "@rigelbuild/omp-utils";
+export { isRecord } from "@rigelbuild/omp-utils";
+/**
+ * Fetch implementation for catalog discovery probes: the caller's override
+ * when given, otherwise global fetch wrapped for `NODE_EXTRA_CA_CERTS`.
+ */
+export declare function discoveryFetch(override?: FetchImpl): FetchImpl;
+export declare function toNumber(value: unknown): number | undefined;
+export declare function toPositiveNumber(value: unknown, fallback: number): number;
+export declare function toPositiveNumber(value: unknown, fallback: number | null): number | null;
+/** Positive finite number, or `null` when the value is missing/non-positive. */
+export declare function toPositiveNumberOrNull(value: unknown): number | null;
+export declare function toBoolean(value: unknown): boolean | undefined;
+export declare function isAnthropicOAuthToken(key: string): boolean;
+/**
+ * Normalize a model display name: drop the gateway author prefix and
+ * model-extrinsic decorations. Returns the input verbatim when nothing
+ * matches (or when stripping would leave an empty name).
+ */
+export declare function cleanModelName(name: string): string;

package/dist/types/variant-collapse.d.ts

@@ -0,0 +1,137 @@
+import { Effort } from "./effort.js";
+import type { Api, Model, ModelSpec, Provider, ThinkingConfig } from "./types.js";
+/**
+ * Structural bound for collapse inputs: both raw `ModelSpec`s and built
+ * `Model`s qualify. (`Model.compat` is the resolved record, not the sparse
+ * config, so the two are not mutually assignable — collapsing never touches
+ * `compat`.)
+ */
+export type VariantSpecLike = Omit<ModelSpec<Api>, "compat"> & {
+    compat?: unknown;
+};
+/** One collapsed family: logical id + member wire ids + per-effort routing. */
+export interface EffortVariantFamily {
+    /** Collapsed logical id (may equal a member id — e.g. bare/thinking pairs). */
+    id: string;
+    /** Final display name, no tier marker. */
+    name: string;
+    /**
+     * Member wire ids in priority order. The first member present in the input
+     * becomes the collapsed spec's default wire id (`requestModelId`; omitted
+     * when it equals the logical id).
+     */
+    members: readonly string[];
+    /**
+     * Wire ids upstream no longer serves (e.g. a deployment killed while
+     * discovery still advertises it). Fresh collapsing never routes to them,
+     * and stale collapsed snapshots (bundled catalog, cache rows,
+     * previous-generation fallbacks) get routing/`requestModelId` entries that
+     * target them re-pointed through `routing`. Keep retired ids in `members`
+     * so the raw upstream spec is still consumed and aliased.
+     */
+    retiredMembers?: readonly string[];
+    /**
+     * Per-effort upstream wire id; `"off"` applies when thinking is disabled.
+     * Entries whose target member is absent from the input are dropped — those
+     * efforts fall back to `requestModelId ?? id`.
+     */
+    routing: Readonly<Partial<Record<Effort | "off", string>>>;
+    /** Explicit capability surface for the collapsed spec — no inference. */
+    thinking: Readonly<Omit<ThinkingConfig, "effortRouting" | "suppressWhenOff">>;
+    /** Thinking-off requests must explicitly suppress thinking on the wire. */
+    suppressWhenOff?: boolean;
+    /**
+     * Preserve non-off effort routes even when discovery omits the backing member.
+     * Used for Cloud Code Assist `X`/`X-thinking` pairs where upstream accepts
+     * the `-thinking` wire id but the model-list endpoint may advertise only the
+     * bare id.
+     */
+    preserveAbsentEffortRoutes?: boolean;
+    /** Retired/recycled selector ids that alias to this family without being members. */
+    extraAliases?: readonly string[];
+}
+export interface VariantCollapseTable {
+    families: readonly EffortVariantFamily[];
+}
+/** `google-antigravity` Gemini families, using each generation's native transport. */
+export declare const ANTIGRAVITY_VARIANT_COLLAPSE_TABLE: VariantCollapseTable;
+/** `google-gemini-cli` Gemini families on the official CLI's level transport. */
+export declare const GEMINI_CLI_VARIANT_COLLAPSE_TABLE: VariantCollapseTable;
+export declare const DEVIN_VARIANT_COLLAPSE_TABLE: VariantCollapseTable;
+/** `cursor` per-effort sibling families collapsed per service-tier lane: Grok 4.5/4.6 plus GPT-5.6 Luna/Sol/Terra. */
+export declare const CURSOR_VARIANT_COLLAPSE_TABLE: VariantCollapseTable;
+/** Provider id → hand collapse table. The CCA providers diverge on thinking transport. */
+export declare const VARIANT_COLLAPSE_TABLES: Readonly<Record<string, VariantCollapseTable>>;
+/**
+ * The global automatic rule: derive an `X` + `X-thinking` family for every
+ * pair where both ids are live in `specs` (trailing or infix token). Gates:
+ * - both members share the same `api`,
+ * - known pricing must match — all-zero cost rows count as unknown
+ *   (aggregators routinely ship them), but twins that BOTH carry real,
+ *   differing prices are distinct SKUs and never merge,
+ * - ids claimed by the provider's hand `table` are skipped (curation wins).
+ * The capability surface prefers the thinking member's metadata, then the
+ * bare member's, then the canonical deriver (aggregators often ship
+ * `reasoning: false` and no thinking config on the twin), then a budget
+ * default. `off` routes to the bare id; every supported effort routes to the
+ * thinking id.
+ */
+export declare function deriveThinkingPairFamilies<TSpec extends VariantSpecLike>(specs: readonly TSpec[], table?: VariantCollapseTable): EffortVariantFamily[];
+/**
+ * True when `spec` is the output of collapsing rather than a raw upstream
+ * member. `thinking.effortRouting` is written only by collapsing; the
+ * `requestModelId` arm is scoped to the provider's hand-table family ids so
+ * unrelated carriers (GitHub Copilot `-1m` context variants) never match.
+ */
+export declare function isVariantCollapsedSpec(spec: VariantSpecLike): boolean;
+/**
+ * Collapse every family in `table` found in `specs`. Non-member specs pass
+ * through verbatim (by reference), order preserved; the collapsed spec
+ * replaces the first occurrence of its family.
+ */
+export declare function collapseEffortVariants<TSpec extends VariantSpecLike>(specs: readonly TSpec[], table: VariantCollapseTable): TSpec[];
+/**
+ * Collapse a full mixed-provider list: per provider, the hand table, Cursor's
+ * conservative live effort-sibling rule, and the automatic `X`/`X-thinking`
+ * pair rule. Used by the catalog generator; the runtime equivalent lives at
+ * the model-manager merge point. Output is regrouped by provider — callers
+ * re-sort.
+ */
+export declare function collapseEffortVariantsAcrossProviders<TSpec extends VariantSpecLike>(specs: readonly TSpec[]): TSpec[];
+/**
+ * Runtime entry point for already-built `Model` lists (the model-manager
+ * merge point, coding-agent registry custom providers): collapses hand
+ * tables plus derived pairs, then re-runs `buildModel` on freshly created
+ * logical specs so thinking wire defaults stay resolved. Untouched entries
+ * pass through by reference.
+ */
+export declare function collapseBuiltModelVariants<TApi extends Api>(models: readonly Model<TApi>[]): Model<TApi>[];
+/**
+ * Resolve a retired effort-tier variant id (collapsed member, recycled id) to
+ * its replacement model id for `provider` via hand-table or registered live
+ * aliases. Returns `undefined` when the id is not a known alias; derived
+ * `X-thinking` members also resolve through `stripThinkingVariantToken`.
+ * Callers must try an exact model lookup first — a live model always wins over
+ * an alias.
+ */
+export declare function resolveVariantAlias(provider: Provider, modelId: string): string | undefined;
+/** Bare-id alias hit: replacement id plus the providers declaring it. */
+export interface BareVariantAliasHit {
+    id: string;
+    /** Providers declaring the alias — candidates from these win ties. */
+    providers: readonly Provider[];
+}
+/**
+ * Provider-agnostic alias lookup for bare-id selectors. Returns the declaring
+ * providers so callers can prefer their models when the replacement id exists
+ * on unrelated providers too (e.g. a retired Cursor tier id must not resolve
+ * to `openai/gpt-5.4`).
+ */
+export declare function resolveBareVariantAlias(modelId: string): BareVariantAliasHit | undefined;
+/**
+ * Reverse alias lookup: the retired ids that resolve to `modelId` for
+ * `provider` via hand-table or registered live aliases. Used to re-key config
+ * keyed by raw member ids (models.yml `modelOverrides`, suppressed selectors)
+ * onto the collapsed model.
+ */
+export declare function getVariantAliasSources(provider: Provider, modelId: string): readonly string[];

package/dist/types/wire/alibaba-token-plan.d.ts

@@ -0,0 +1,22 @@
+/**
+ * International (Singapore) Token Plan endpoint. Default region; keys issued by
+ * the international product authenticate only here.
+ */
+export declare const ALIBABA_TOKEN_PLAN_BASE_URL = "https://token-plan.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1";
+/**
+ * China (Beijing) Token Plan endpoint (百炼 Token Plan). Keys are region-locked:
+ * a Beijing-issued key is rejected by the international endpoint with
+ * `invalid_api_key`, and vice versa (#6682).
+ */
+export declare const ALIBABA_TOKEN_PLAN_CN_BASE_URL = "https://token-plan.cn-beijing.maas.aliyuncs.com/compatible-mode/v1";
+export interface AlibabaTokenPlanCredential {
+    token: string;
+    cookie?: string;
+    /**
+     * Region base URL the key authenticates against. Absent means the default
+     * international endpoint ({@link ALIBABA_TOKEN_PLAN_BASE_URL}).
+     */
+    baseUrl?: string;
+}
+export declare function parseAlibabaTokenPlanCredential(value: string): AlibabaTokenPlanCredential | null;
+export declare function serializeAlibabaTokenPlanCredential(token: string, cookie: string, baseUrl?: string): string;

package/dist/types/wire/codex.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Constants for OpenAI Codex (ChatGPT OAuth) backend
+ */
+export declare const CODEX_BASE_URL = "https://chatgpt.com/backend-api";
+/**
+ * Pinned OpenAI Codex client version (corresponds to @openai/codex package version).
+ */
+export declare const CODEX_CLIENT_VERSION = "0.144.1";
+export declare const OPENAI_HEADERS: {
+    readonly BETA: "OpenAI-Beta";
+    /** Codex feature-negotiation header; values identify opt-in wire protocols. */
+    readonly CODEX_BETA_FEATURES: "x-codex-beta-features";
+    readonly ACCOUNT_ID: "chatgpt-account-id";
+    readonly ORIGINATOR: "originator";
+    readonly VERSION: "version";
+    readonly SESSION_ID: "session_id";
+    readonly CONVERSATION_ID: "conversation_id";
+    readonly SCOPED_SESSION_ID: "session-id";
+    readonly THREAD_ID: "thread-id";
+    readonly INSTALLATION_ID: "x-codex-installation-id";
+    readonly WINDOW_ID: "x-codex-window-id";
+    readonly TURN_METADATA: "x-codex-turn-metadata";
+    readonly PARENT_THREAD_ID: "x-codex-parent-thread-id";
+    readonly SUBAGENT: "x-openai-subagent";
+    /** Responses Lite transport marker (codex-rs `add_responses_lite_header`); value is always `"true"`. */
+    readonly RESPONSES_LITE: "x-openai-internal-codex-responses-lite";
+    /** DeviceCheck attestation envelope (codex-rs `X_OAI_ATTESTATION_HEADER`); sent on ChatGPT-OAuth requests. */
+    readonly ATTESTATION: "x-oai-attestation";
+    /** Client-declared data residency for region-pinned enterprise workspaces. */
+    readonly RESIDENCY: "x-openai-internal-codex-residency";
+};
+export declare const OPENAI_HEADER_VALUES: {
+    readonly BETA_RESPONSES: "responses=experimental";
+    readonly BETA_RESPONSES_WEBSOCKETS_V2: "responses_websockets=2026-02-06";
+    readonly REMOTE_COMPACTION_V2: "remote_compaction_v2";
+    readonly ORIGINATOR_CODEX: "pi";
+};
+export declare const URL_PATHS: {
+    readonly RESPONSES: "/responses";
+    readonly CODEX_RESPONSES: "/codex/responses";
+};
+export declare const JWT_CLAIM_PATH: "https://api.openai.com/auth";
+/**
+ * Extract account ID from a Codex JWT access token.
+ * Returns undefined if the token is not a valid Codex JWT.
+ */
+export declare function getCodexAccountId(accessToken: string): string | undefined;
+/**
+ * Extract the account's data residency from a Codex JWT access token.
+ *
+ * Enterprise ChatGPT workspaces can be pinned to a region. Such a workspace
+ * rejects a Codex request whose egress does not match it — HTTP 401
+ * `Workspace is not authorized in this region.` — unless the client declares
+ * the residency itself. The token already carries it, so no configuration is
+ * needed: `chatgpt_data_residency` is the authoritative claim, with
+ * `chatgpt_compute_residency` as the fallback for tokens that only carry that.
+ *
+ * Returns undefined for a non-JWT token, or for the (common) accounts whose
+ * claims omit residency entirely — those workspaces are not region-pinned.
+ */
+export declare function getCodexResidency(accessToken: string): string | undefined;
+/**
+ * Adds the token's workspace residency to Codex request headers without
+ * replacing a caller-supplied value.
+ */
+export declare function applyCodexResidencyHeader(headers: Headers | Record<string, string>, accessToken: string): void;

package/dist/types/wire/coreweave.d.ts

@@ -0,0 +1,12 @@
+export declare const COREWEAVE_PROJECT_HEADER: "OpenAI-Project";
+export interface CoreWeaveProjectEnv {
+    [key: string]: string | undefined;
+    COREWEAVE_PROJECT?: string;
+    WANDB_INFERENCE_PROJECT?: string;
+    WANDB_ENTITY?: string;
+    WANDB_PROJECT?: string;
+}
+export declare function resolveCoreWeaveProject(env: CoreWeaveProjectEnv): string | undefined;
+export declare function coreWeaveProjectHeaders(env: CoreWeaveProjectEnv): Record<string, string> | undefined;
+export declare function hasCoreWeaveProjectHeader(headers: Record<string, string>): boolean;
+export declare function removeBlankCoreWeaveProjectHeaders(headers: Record<string, string>): void;

package/dist/types/wire/gemini-headers.d.ts

@@ -0,0 +1,62 @@
+import type { FetchImpl } from "@rigelbuild/omp-utils";
+/**
+ * Build a User-Agent string that identifies as Gemini CLI to unlock higher rate limits.
+ * Uses the same format as the official Gemini CLI (v0.35+):
+ * GeminiCLI/VERSION/MODEL (PLATFORM; ARCH; SURFACE)
+ */
+export declare function getGeminiCliUserAgent(modelId?: string): string;
+export declare const getGeminiCliHeaders: (modelId?: string) => {
+    "User-Agent": string;
+    "Client-Metadata": string;
+};
+/**
+ * Antigravity / Cloud Code Assist user agent. Lives in its own file so discovery
+ * and usage code can read it without pulling the heavy google-gemini-cli provider
+ * (and its @google/genai → google-auth-library dependency chain) into the startup
+ * parse graph.
+ *
+ * Format captured from the real 2.8.0 `antigravity/hub` client:
+ * `antigravity/hub/2.8.0 (aidev_client; os_type=darwin; arch=arm64; cl=963137146)`.
+ * The backend gates newer models (e.g. gemini-3.7-flash) on the client version,
+ * so the version tracks the latest Antigravity release via the update manifest
+ * (see {@link ensureAntigravityVersion}) with `DEFAULT_ANTIGRAVITY_VERSION` as
+ * the offline fallback. os_type/arch are pinned to the darwin/arm64 reference
+ * client the version and manifest are captured from, independent of the host
+ * platform. Overrides: PI_AI_ANTIGRAVITY_VERSION / _CL / _OS / _ARCH.
+ */
+export declare const DEFAULT_ANTIGRAVITY_VERSION = "2.8.0";
+/** Current Antigravity client version: env override → manifest-discovered → pinned fallback. */
+export declare function getAntigravityVersion(): string;
+/**
+ * Extracts the client version from an electron-builder update manifest.
+ * Returns null when no well-formed `version:` line is present.
+ */
+export declare function parseAntigravityManifestVersion(yamlText: string): string | null;
+/**
+ * Resolves the latest Antigravity release from the official update manifest.
+ * Success is cached for the process lifetime; failures are silent (the pinned
+ * fallback stays valid) and clear the in-flight cache so a later call retries.
+ * Skipped entirely when PI_AI_ANTIGRAVITY_VERSION is set.
+ */
+export declare function ensureAntigravityVersion(fetcher?: FetchImpl, signal?: AbortSignal): Promise<void>;
+/** Antigravity `User-Agent` header value; rebuilt when the discovered version changes. */
+export declare function getAntigravityUserAgent(): string;
+/**
+ * Per-wire-id Antigravity Cloud Code Assist request constants, captured from the
+ * real `antigravity/hub` client against `daily-cloudcode-pa`. `modelEnum` is the
+ * opaque `labels.model_enum` token the client tags each request with — optional
+ * because Anthropic-backed wire ids (e.g. `claude-sonnet-4-6`,
+ * `claude-opus-4-6-thinking`) are accepted without one; the label is purely
+ * telemetry. `maxOutputTokens` is the fixed `generationConfig.maxOutputTokens`
+ * the backend enforces regardless of the thinking budget (Claude caps at
+ * 64000, Gemini accepts the discovered cap). Keyed by the routed upstream wire
+ * id (post effort-routing), not the collapsed logical id. Checkpoint-only ids
+ * (e.g. `gemini-3.1-flash-lite`) are intentionally absent — this provider only
+ * emits agent requests.
+ */
+export interface AntigravityModelWireProfile {
+    modelEnum?: string;
+    maxOutputTokens: number;
+}
+export declare const ANTIGRAVITY_MODEL_WIRE_PROFILES: Readonly<Record<string, AntigravityModelWireProfile>>;
+export declare function getAntigravityModelWireProfile(wireModelId: string): AntigravityModelWireProfile | undefined;

package/dist/types/wire/github-copilot.d.ts

@@ -0,0 +1,47 @@
+import type { FetchImpl } from "../types.js";
+/**
+ * GitHub Copilot wire metadata: API-key envelope parsing and endpoint
+ * derivation shared by catalog discovery and the pi-ai OAuth flow. The device
+ * login / token refresh flow lives in `@oh-my-pi/pi-ai`'s registry.
+ */
+export declare const COPILOT_USER_AGENT: "opencode/1.3.15";
+export declare const OPENCODE_HEADERS: {
+    readonly "User-Agent": "opencode/1.3.15";
+};
+/**
+ * Copilot API version sent on `api.githubcopilot.com` requests (`/models`,
+ * chat endpoints). Newer versions unlock tiered context metadata: `/models`
+ * reports the full long-context window in `capabilities.limits` plus per-tier
+ * boundaries/prices under `billing.token_prices.{default,long_context}`.
+ * Without it the endpoint serves default-tier limits only (e.g. 264k instead
+ * of 1M for Claude Opus). Never send this to `api.github.com` REST endpoints —
+ * they validate `X-GitHub-Api-Version` against the REST version vocabulary.
+ */
+export declare const COPILOT_API_VERSION: "2026-06-01";
+/** Headers for `api.githubcopilot.com` (capi) requests: discovery, chat, policy. */
+export declare const COPILOT_API_HEADERS: {
+    readonly "User-Agent": "opencode/1.3.15";
+    readonly "X-GitHub-Api-Version": "2026-06-01";
+};
+export type ParsedGitHubCopilotApiKey = {
+    accessToken: string;
+    enterpriseUrl?: string;
+    apiEndpoint?: string;
+};
+export declare function isPublicGitHubHost(host: string): boolean;
+/** Canonical personal-Copilot API host. */
+export declare const PERSONAL_GITHUB_COPILOT_BASE_URL: "https://api.githubcopilot.com";
+/** `true` when the resolved base URL is the canonical personal-Copilot host. */
+export declare function isPersonalGitHubCopilotBaseUrl(baseUrl: string | undefined): boolean;
+export declare function normalizeGitHubCopilotEnterpriseDomain(input: string | undefined): string | undefined;
+export declare function normalizeGitHubCopilotApiEndpoint(input: string | undefined): string | undefined;
+/**
+ * Resolve the plan-specific Copilot API endpoint advertised for a GitHub token.
+ * Login and raw environment-token discovery share this best-effort probe. Pass
+ * a `signal` to bound it against the same discovery deadline as `/models`; a
+ * stalled probe otherwise blocks discovery indefinitely.
+ */
+export declare function discoverGitHubCopilotApiEndpoint(token: string, fetchImpl: FetchImpl, signal?: AbortSignal): Promise<string | undefined>;
+export declare function parseGitHubCopilotApiKey(apiKeyRaw: string): ParsedGitHubCopilotApiKey;
+export declare function normalizeDomain(input: string): string | null;
+export declare function getGitHubCopilotBaseUrl(enterpriseDomain?: string): string;

package/dist/types/wire/image-fetchers.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Identification of provider-side image fetchers.
+ *
+ * A request may carry an image either inline (base64) or as a URL. With a URL,
+ * the provider's backend performs its own server-side GET against that URL, so
+ * a local blob server sees an inbound request from vendor infrastructure rather
+ * than from the client. This module names those fetchers, letting a blob server
+ * attribute an inbound GET to the vendor that issued it — which is how a caller
+ * learns where a request actually landed when a router sits between them and
+ * the model.
+ *
+ * NOT an authentication mechanism. Every value here is a request header chosen
+ * by the caller and is trivially forged. Authorize blob reads with an
+ * unguessable URL (single-use capability token, short TTL) and treat a fetcher
+ * match as attribution/telemetry only.
+ *
+ * Each entry was captured from a live fetch triggered by handing that vendor's
+ * API a URL-sourced image.
+ */
+/** Vendor whose infrastructure performed an inbound fetch. */
+export type ImageFetcherVendor = "openai" | "anthropic" | "xai" | "google";
+/** Registry key for a known fetcher. */
+export type ImageFetcherId = "openai-file-downloader" | "anthropic-claude-user" | "anthropic-claude-user-preview" | "xai-image-api-fetch" | "google";
+/** Request signature of one provider-side fetcher. */
+export interface ImageFetcherIdentity {
+    vendor: ImageFetcherVendor;
+    /** Human-readable name for logs and UI. */
+    label: string;
+    /**
+     * `User-Agent` contract: an exact string for fetchers that send a fixed
+     * value, or a pattern for those embedding a client version.
+     */
+    userAgent: string | RegExp;
+    /**
+     * Vendor-proprietary headers observed alongside the agent, used to
+     * corroborate a `User-Agent` claim. Generic infrastructure headers
+     * (`traceparent`, `x-cloud-trace-context`) are deliberately excluded: they
+     * are emitted by unrelated infrastructure and corroborate nothing. Empty
+     * means the agent string is the only available signal, so
+     * {@link ImageFetcherMatch.corroborated} can never be true for that entry.
+     */
+    markerHeaders: readonly string[];
+    /** API surface the capture came from. */
+    observedVia: string;
+    /** Operational caveats a blob server should account for. */
+    note?: string;
+}
+/**
+ * Known provider-side fetchers.
+ *
+ * Agent contracts do not overlap — exact strings never collide with the
+ * versioned patterns — so lookup order carries no meaning.
+ */
+export declare const IMAGE_FETCHERS: Readonly<Record<ImageFetcherId, ImageFetcherIdentity>>;
+/** Attribution outcome for one inbound request. */
+export interface ImageFetcherMatch {
+    id: ImageFetcherId;
+    identity: ImageFetcherIdentity;
+    /**
+     * Whether every proprietary marker header for the matched identity is
+     * present. Always false for identities declaring no markers — absence of
+     * corroboration is not evidence against the match.
+     */
+    corroborated: boolean;
+}
+/** Inbound header bag, as exposed by either `fetch` or a Node-style server. */
+export type InboundHeaders = Headers | Readonly<Record<string, string | readonly string[] | undefined>>;
+/**
+ * Attribute an inbound blob request to a known provider-side fetcher, or
+ * `null` when the agent matches none.
+ *
+ * Matches on `User-Agent` alone and reports marker-header corroboration
+ * separately; callers MUST NOT treat either as proof of origin. Gate access on
+ * the unguessable URL.
+ */
+export declare function identifyImageFetcher(headers: InboundHeaders): ImageFetcherMatch | null;

package/package.json

@@ -0,0 +1,102 @@
+{
+	"type": "module",
+	"name": "@rigelbuild/omp-catalog",
+	"version": "18.0.3",
+	"description": "Model catalog for omp: bundled model database, provider discovery descriptors, model identity, classification, and equivalence",
+	"homepage": "https://omp.sh",
+	"author": "Stencil Labs, Inc.",
+	"license": "MIT",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/can1357/oh-my-pi.git",
+		"directory": "packages/catalog"
+	},
+	"bugs": {
+		"url": "https://github.com/can1357/oh-my-pi/issues"
+	},
+	"keywords": [
+		"ai",
+		"llm",
+		"models",
+		"catalog",
+		"discovery"
+	],
+	"main": "./src/index.ts",
+	"types": "./dist/types/index.d.ts",
+	"scripts": {
+		"check": "biome check . && bun run check:types",
+		"check:types": "tsgo -p tsconfig.json --noEmit",
+		"lint": "biome lint .",
+		"test": "bun test --parallel",
+		"fix": "biome check --write --unsafe .",
+		"fmt": "biome format --write .",
+		"gen:models": "bun scripts/generate-models.ts",
+		"gen:proto": "bun scripts/generate-protocols.ts"
+	},
+	"dependencies": {
+		"@rigelbuild/omp-omptype": "18.0.3",
+		"@rigelbuild/omp-utils": "18.0.3"
+	},
+	"devDependencies": {
+		"@rigelbuild/omp-ai": "18.0.3",
+		"@types/bun": "^1.3.14"
+	},
+	"engines": {
+		"bun": ">=1.3.14"
+	},
+	"files": [
+		"src",
+		"README.md",
+		"CHANGELOG.md",
+		"LICENSE",
+		"THIRD-PARTY-NOTICES.txt",
+		"dist/types"
+	],
+	"exports": {
+		".": {
+			"types": "./dist/types/index.d.ts",
+			"import": "./src/index.ts"
+		},
+		"./models.json": {
+			"types": "./dist/types/models.json.d.d.ts",
+			"import": "./src/models.json"
+		},
+		"./provider-models": {
+			"types": "./dist/types/provider-models/index.d.ts",
+			"import": "./src/provider-models/index.ts"
+		},
+		"./provider-models/*": {
+			"types": "./dist/types/provider-models/*.d.ts",
+			"import": "./src/provider-models/*.ts"
+		},
+		"./discovery": {
+			"types": "./dist/types/discovery/index.d.ts",
+			"import": "./src/discovery/index.ts"
+		},
+		"./discovery/*": {
+			"types": "./dist/types/discovery/*.d.ts",
+			"import": "./src/discovery/*.ts"
+		},
+		"./identity": {
+			"types": "./dist/types/identity/index.d.ts",
+			"import": "./src/identity/index.ts"
+		},
+		"./identity/*": {
+			"types": "./dist/types/identity/*.d.ts",
+			"import": "./src/identity/*.ts"
+		},
+		"./wire/*": {
+			"types": "./dist/types/wire/*.d.ts",
+			"import": "./src/wire/*.ts"
+		},
+		"./compat/*": {
+			"types": "./dist/types/compat/*.d.ts",
+			"import": "./src/compat/*.ts"
+		},
+		"./*": {
+			"types": "./dist/types/*.d.ts",
+			"import": "./src/*.ts"
+		},
+		"./*.js": "./src/*.ts"
+	}
+}

package/src/build.ts

@@ -0,0 +1,103 @@
+/**
+ * The single Model constructor. Resolution order is a dependency chain, each
+ * step materialized exactly once per spec:
+ *
+ *   1. compat   — URL/provider/id detection resolved into a complete record;
+ *   2. thinking — derived from identity + resolved compat (or trusted verbatim
+ *                 when the spec carries explicit metadata);
+ *
+ * Request handlers read fields — they never detect, parse ids, or allocate
+ * compat per request.
+ */
+
+import { buildAnthropicCompat } from "./compat/anthropic";
+import { buildBedrockCompat } from "./compat/bedrock";
+import { buildDevinCompat } from "./compat/devin";
+import { buildOpenAICompat, buildOpenAIResponsesCompat, buildOpenRouterCompat } from "./compat/openai";
+import { bareModelId, parseOpenAIModel, semverGte } from "./identity/classify";
+import { isClaudeModelId } from "./identity/family";
+import { resolveModelThinking } from "./model-thinking";
+import { resolveModelTokenizer } from "./model-tokenizer";
+import type { Api, CompatOf, Model, ModelSpec } from "./types";
+import { cleanModelName } from "./utils";
+
+function isDirectOpenAIResponsesEndpoint(spec: ModelSpec<Api>): boolean {
+	if (spec.api === "openai-responses") {
+		if (spec.provider !== "openai") return false;
+		if (!spec.baseUrl) return true;
+		try {
+			const url = new URL(spec.baseUrl);
+			return url.protocol === "https:" && url.hostname === "api.openai.com";
+		} catch {
+			return false;
+		}
+	}
+	if (spec.api !== "azure-openai-responses" || (spec.provider !== "azure" && spec.provider !== "azure-openai")) {
+		return false;
+	}
+	if (!spec.baseUrl) return true;
+	try {
+		const url = new URL(spec.baseUrl);
+		return (
+			url.protocol === "https:" &&
+			(url.hostname.endsWith(".openai.azure.com") || url.hostname === "models.inference.ai.azure.com")
+		);
+	} catch {
+		return false;
+	}
+}
+
+function explicitComputerUseConfig(spec: ModelSpec<Api>): boolean | undefined {
+	return "supportsComputerUseConfig" in spec
+		? (spec as Model<Api>).supportsComputerUseConfig
+		: spec.supportsComputerUse;
+}
+
+function supportsOpenAIGAComputerUse(spec: ModelSpec<Api>, explicitSupport: boolean | undefined): boolean {
+	if (explicitSupport !== undefined) return explicitSupport;
+	if (!isDirectOpenAIResponsesEndpoint(spec)) return false;
+	const parsed = parseOpenAIModel(bareModelId(spec.requestModelId ?? spec.id));
+	return parsed !== null && semverGte(parsed.version, "5.4");
+}
+
+/**
+ * Build one model from an authored spec. Bundled models.json rows are fully
+ * materialized by the generator and consumed directly (see `models.ts`), so
+ * this only runs for discovered/custom/override specs.
+ */
+export function buildModel<TApi extends Api>(spec: ModelSpec<TApi>): Model<TApi> {
+	const compat = buildCompat(spec) as CompatOf<TApi>;
+	const supportsComputerUseConfig = explicitComputerUseConfig(spec);
+	return {
+		...spec,
+		name: cleanModelName(spec.name),
+		requiresGlyphTokenization: isClaudeModelId(spec.id),
+		tokenizer: spec.tokenizer ?? resolveModelTokenizer(spec.requestModelId ?? spec.id),
+		thinking: resolveModelThinking(spec, compat),
+		supportsComputerUse: supportsOpenAIGAComputerUse(spec, supportsComputerUseConfig),
+		supportsComputerUseConfig,
+		compat,
+		compatConfig: spec.compat,
+	} as Model<TApi>;
+}
+
+export function buildCompat(spec: ModelSpec<Api>): CompatOf<Api> {
+	switch (spec.api) {
+		case "openrouter":
+			return buildOpenRouterCompat(spec as ModelSpec<"openrouter">);
+		case "openai-completions":
+			return buildOpenAICompat(spec as ModelSpec<"openai-completions">);
+		case "openai-responses":
+		case "azure-openai-responses":
+		case "openai-codex-responses":
+			return buildOpenAIResponsesCompat(spec as ModelSpec<"openai-responses">);
+		case "anthropic-messages":
+			return buildAnthropicCompat(spec as ModelSpec<"anthropic-messages">);
+		case "bedrock-converse-stream":
+			return buildBedrockCompat(spec as ModelSpec<"bedrock-converse-stream">);
+		case "devin-agent":
+			return buildDevinCompat(spec as ModelSpec<"devin-agent">);
+		default:
+			return undefined;
+	}
+}