@rigelbuild/omp-catalog 18.0.3

package/dist/types/build.d.ts

@@ -0,0 +1,19 @@
+/**
+ * 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 type { Api, CompatOf, Model, ModelSpec } from "./types.js";
+/**
+ * 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 declare function buildModel<TApi extends Api>(spec: ModelSpec<TApi>): Model<TApi>;
+export declare function buildCompat(spec: ModelSpec<Api>): CompatOf<Api>;

package/dist/types/compat/anthropic.d.ts

@@ -0,0 +1,18 @@
+import type { ModelSpec, ResolvedAnthropicCompat } from "../types.js";
+/**
+ * Official first-party Anthropic API. A missing baseUrl is official on purpose:
+ * request dispatch falls back to `https://api.anthropic.com`. This is the one
+ * auth-sensitive host check — OAuth credentials are attached based on it — so
+ * it requires the exact origin or a path boundary (`/`) after it; a bare
+ * prefix check would accept lookalikes like `https://api.anthropic.com.evil.com`.
+ */
+export declare function isOfficialAnthropicApiUrl(baseUrl?: string): boolean;
+/**
+ * Known non-official URLs that enforce Anthropic thinking signatures on replay.
+ *
+ * Runtime routing calls this with the effective URL because a model's resolved
+ * compat can be stale after Foundry or a provider base-URL override reroutes it.
+ */
+export declare function isAnthropicSigningProxyUrl(baseUrl?: string): boolean;
+/** Build the resolved anthropic-messages compat record for a model spec. */
+export declare function buildAnthropicCompat(spec: ModelSpec<"anthropic-messages">): ResolvedAnthropicCompat;

package/dist/types/compat/apply.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Assign defined override values onto a freshly-built resolved compat record,
+ * in place. Keys the record doesn't declare are ignored (loosely-typed config
+ * may carry junk). `buildModel` is the only intended caller — the record being
+ * mutated is the single per-model allocation; nothing here runs per request.
+ */
+export declare function applyCompatOverrides(compat: object, overrides: object | undefined): void;

package/dist/types/compat/bedrock.d.ts

@@ -0,0 +1,3 @@
+import type { ModelSpec, ResolvedBedrockCompat } from "../types.js";
+/** Resolve Bedrock Converse prompt-cache and stream-watchdog compat once per model. */
+export declare function buildBedrockCompat(spec: ModelSpec<"bedrock-converse-stream">): ResolvedBedrockCompat;

package/dist/types/compat/devin.d.ts

@@ -0,0 +1,9 @@
+import type { ModelSpec, ResolvedDevinCompat } from "../types.js";
+/**
+ * Resolve devin-agent (Codeium Cascade) compat. Cascade has no wire
+ * reasoning/effort field — effort is selected by routing to a sibling model id
+ * (the `thinking.effortRouting` baked by variant-collapse). So the thinking
+ * deriver must never fabricate an effort ladder from identity for these models;
+ * only explicit routed metadata counts.
+ */
+export declare function buildDevinCompat(_spec: ModelSpec<"devin-agent">): ResolvedDevinCompat;

package/dist/types/compat/openai.d.ts

@@ -0,0 +1,28 @@
+import type { ModelSpec, OpenAICompat, ResolvedOpenAICompat, ResolvedOpenAIResponsesCompat, ResolvedOpenRouterCompat } from "../types.js";
+/** Wire effort remap for first-party xAI Responses. */
+export declare function xaiResponsesReasoningEffortMap(modelId: string): NonNullable<OpenAICompat["reasoningEffortMap"]>;
+/**
+ * Build the resolved chat-completions compat record for a model spec.
+ * Provider takes precedence over URL-based detection since it's explicitly configured.
+ */
+export declare function buildOpenAICompat(spec: ModelSpec<"openai-completions">): ResolvedOpenAICompat;
+interface OpenAIResponsesSpecLike {
+    id?: string;
+    provider: string;
+    name: string;
+    baseUrl: string;
+    reasoning?: boolean;
+    compat?: OpenAICompat;
+}
+/**
+ * Build the resolved Responses-API compat record. Most shared OpenAI-compatible
+ * capability defaults intentionally mirror chat-completions, while Responses-
+ * only behavior (developer role, prompt cache, pairing strictness, image detail)
+ * keeps endpoint-specific detection. Azure is detected by provider id as well
+ * as URL — bundled `azure` models carry no baseUrl (the deployment host is per-
+ * resource, resolved at runtime) — while OpenAI/Copilot developer-role and
+ * prompt-cache detection stay URL-keyed, as the historical call sites were.
+ */
+export declare function buildOpenAIResponsesCompat(spec: OpenAIResponsesSpecLike): ResolvedOpenAIResponsesCompat;
+export declare function buildOpenRouterCompat(spec: ModelSpec<"openrouter">): ResolvedOpenRouterCompat;
+export {};

package/dist/types/discovery/antigravity.d.ts

@@ -0,0 +1,70 @@
+import type { ModelSpec } from "../types.js";
+import { type VariantCollapseTable } from "../variant-collapse.js";
+export declare const ANTIGRAVITY_PRIMARY_ENDPOINT = "https://daily-cloudcode-pa.googleapis.com";
+export declare const ANTIGRAVITY_SANDBOX_ENDPOINT = "https://daily-cloudcode-pa.sandbox.googleapis.com";
+/**
+ * Raw model metadata returned by Antigravity's `fetchAvailableModels` endpoint.
+ */
+export interface AntigravityDiscoveryApiModel {
+    displayName?: string;
+    supportsImages?: boolean;
+    supportsThinking?: boolean;
+    thinkingBudget?: number;
+    recommended?: boolean;
+    maxTokens?: number;
+    maxOutputTokens?: number;
+    model?: string;
+    apiProvider?: string;
+    modelProvider?: string;
+    isInternal?: boolean;
+    supportsVideo?: boolean;
+}
+/**
+ * Grouping metadata used by Antigravity to surface recommended model ids.
+ */
+export interface AntigravityDiscoveryAgentModelGroup {
+    modelIds?: string[];
+}
+/**
+ * Sort/group metadata used by Antigravity to surface recommended model ids.
+ */
+export interface AntigravityDiscoveryAgentModelSort {
+    groups?: AntigravityDiscoveryAgentModelGroup[];
+}
+/**
+ * Response payload returned by Antigravity's `fetchAvailableModels` endpoint.
+ */
+export interface AntigravityDiscoveryApiResponse {
+    models?: Record<string, AntigravityDiscoveryApiModel>;
+    agentModelSorts?: AntigravityDiscoveryAgentModelSort[];
+}
+/**
+ * Options for fetching Antigravity discovery models.
+ */
+export interface FetchAntigravityDiscoveryModelsOptions {
+    /** OAuth access token used as `Authorization: Bearer <token>`. */
+    token: string;
+    /** Optional endpoint override. Defaults to Antigravity fallback endpoints. */
+    endpoint?: string;
+    /** Deprecated and ignored for antigravity discovery parity. */
+    project?: string;
+    /** Optional user agent override. */
+    userAgent?: string;
+    /** Optional abort signal for request cancellation. */
+    signal?: AbortSignal;
+    /** Optional fetch implementation override for tests. */
+    fetcher?: typeof fetch;
+    /**
+     * Hand collapse table to apply to the discovered list. Defaults to the
+     * Antigravity (budget-transport) table; `googleGeminiCli` passes the
+     * level-transport table so cloudcode-pa keeps `thinkingLevel`.
+     */
+    collapseTable?: VariantCollapseTable;
+}
+/**
+ * Fetches discoverable Antigravity models and normalizes them into canonical model entries.
+ *
+ * Returns `null` on network/payload/auth failures.
+ * Returns `[]` only when the endpoint responds successfully with no usable models.
+ */
+export declare function fetchAntigravityDiscoveryModels(options: FetchAntigravityDiscoveryModelsOptions): Promise<ModelSpec<"google-gemini-cli">[] | null>;

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

@@ -0,0 +1,36 @@
+import type { FetchImpl, ModelSpec } from "../types.js";
+/**
+ * Fetch options for OpenAI Codex model discovery.
+ */
+export interface CodexModelDiscoveryOptions {
+    /** OAuth access token used for `Authorization: Bearer ...`. */
+    accessToken: string;
+    /** ChatGPT account id value used for `chatgpt-account-id` header. */
+    accountId?: string;
+    /** Base URL for Codex backend. Defaults to `https://chatgpt.com/backend-api`. */
+    baseUrl?: string;
+    /** Optional client version attached as `client_version` query parameter. */
+    clientVersion?: string;
+    /** Optional endpoint path candidates. Defaults to `/codex/models`, then `/models`. */
+    paths?: readonly string[];
+    /** Additional headers merged on top of required Codex headers. */
+    headers?: Record<string, string>;
+    /** Abort signal for network request cancellation. */
+    signal?: AbortSignal;
+    /** Optional fetch implementation override for tests. */
+    fetchFn?: FetchImpl;
+}
+/**
+ * Normalized Codex discovery response.
+ */
+export interface CodexModelDiscoveryResult {
+    models: ModelSpec<"openai-codex-responses">[];
+    etag?: string;
+}
+/**
+ * Fetches model metadata from Codex backend and normalizes it for pi model management.
+ *
+ * Returns `null` when no supported model-list route can be fetched/parsed.
+ * Returns `{ models: [] }` when a route succeeds but yields no usable models.
+ */
+export declare function fetchCodexModels(options: CodexModelDiscoveryOptions): Promise<CodexModelDiscoveryResult | null>;