@rigelbuild/omp-catalog 18.0.3

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

@@ -0,0 +1,24 @@
+import type { FetchImpl, ModelSpec } from "../types.js";
+/**
+ * Options for fetching dynamic Devin (Codeium Cascade) models from `GetCliModelConfigs`.
+ */
+export interface DevinModelDiscoveryOptions {
+    /** Codeium session token carried inside protobuf `Metadata.apiKey`. */
+    apiKey?: string;
+    /** Optional Codeium API base URL override. */
+    baseUrl?: string;
+    /** Optional request timeout in milliseconds (default 5000). */
+    timeoutMs?: number;
+    /** Optional caller abort signal, combined with the internal timeout. */
+    signal?: AbortSignal;
+    /** Optional fetch implementation for request-debug/proxy/test transports. */
+    fetch?: FetchImpl;
+}
+/**
+ * Fetches Devin models through the `GetCliModelConfigs` unary Connect RPC and
+ * normalizes them into canonical model entries.
+ *
+ * Returns `null` on request/decode failures.
+ * Returns `[]` only when the endpoint responds successfully with no usable models.
+ */
+export declare function fetchDevinModels(options: DevinModelDiscoveryOptions): Promise<ModelSpec<"devin-agent">[] | null>;

package/dist/types/discovery/gemini-cli.d.ts

@@ -0,0 +1,33 @@
+import type { ModelSpec } from "../types.js";
+import { type VariantCollapseTable } from "../variant-collapse.js";
+/**
+ * Options for the Gemini CLI quota-based discovery fallback.
+ */
+export interface FetchGeminiCliQuotaModelsOptions {
+    /** OAuth access token sent as `Authorization: Bearer <token>`. */
+    token: string;
+    /** Cloud Code Assist endpoint. Defaults to `https://cloudcode-pa.googleapis.com`. */
+    endpoint?: string;
+    /** Pre-resolved GCP project id; otherwise discovered via `loadCodeAssist`. */
+    projectId?: string;
+    /** Optional abort signal for request cancellation. */
+    signal?: AbortSignal;
+    /** Optional fetch implementation override for tests. */
+    fetcher?: typeof fetch;
+    /** Effort-tier collapse table applied to the discovered list. */
+    collapseTable?: VariantCollapseTable;
+}
+/**
+ * Discovers the Gemini models available to a `google-gemini-cli` credential via
+ * the account's own `retrieveUserQuota` endpoint on Cloud Code Assist.
+ *
+ * This is the fallback for accounts whose credential is not authorized for the
+ * Antigravity `fetchAvailableModels` endpoint (e.g. Gemini Code Assist Standard
+ * tiers, which return HTTP 403 there). Quota buckets carry only model ids, so
+ * metadata is filled from the bundled catalog where the id is known and
+ * synthesized with Gemini CLI defaults otherwise.
+ *
+ * Returns `null` on network/payload/auth failure (the caller keeps the bundled
+ * catalog). Returns `[]` when the quota response lists no usable Gemini models.
+ */
+export declare function fetchGeminiCliQuotaModels(options: FetchGeminiCliQuotaModelsOptions): Promise<ModelSpec<"google-gemini-cli">[] | null>;

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

@@ -0,0 +1,25 @@
+import type { FetchImpl, ModelSpec } from "../types.js";
+/**
+ * Configuration for Google Generative AI model discovery.
+ */
+export interface GeminiDiscoveryOptions {
+    /** API key for the Google Generative AI public endpoint. */
+    apiKey: string;
+    /** Optional endpoint override for testing or proxying. */
+    baseUrl?: string;
+    /** Optional requested page size for model listing. */
+    pageSize?: number;
+    /** Maximum number of pages to request before stopping pagination. */
+    maxPages?: number;
+    /** Optional abort signal for HTTP requests. */
+    signal?: AbortSignal;
+    /** Optional fetch implementation override for tests. */
+    fetch?: FetchImpl;
+}
+/**
+ * Fetches and normalizes Google Generative AI models from the public models endpoint.
+ *
+ * Returns `null` on transport/protocol failures.
+ * Returns `[]` only when the endpoint responds successfully with no usable models.
+ */
+export declare function fetchGeminiModels(options: GeminiDiscoveryOptions): Promise<ModelSpec<"google-generative-ai">[] | null>;

package/dist/types/discovery/gitlab-duo-workflow.d.ts

@@ -0,0 +1,30 @@
+import type { FetchImpl, ModelSpec } from "../types.js";
+type GitLabDuoWorkflowCandidateSource = "override" | "project" | "remote" | "group";
+export interface GitLabDuoWorkflowModelRef {
+    name: string;
+    ref: string;
+}
+/**
+ * GitLab Duo Workflow model/namespace discovery configuration.
+ */
+export interface GitLabDuoWorkflowDiscoveryConfig {
+    apiKey: string;
+    baseUrl?: string;
+    fetch?: FetchImpl;
+    namespaceId?: string;
+    projectId?: string;
+    projectPath?: string;
+    cwd?: string;
+}
+export interface GitLabDuoWorkflowNamespaceSelection {
+    rootNamespaceId: string;
+    namespacePath?: string;
+    projectPath?: string;
+    source: GitLabDuoWorkflowCandidateSource;
+}
+export declare function discoverGitLabDuoWorkflowNamespace(config: GitLabDuoWorkflowDiscoveryConfig): Promise<GitLabDuoWorkflowNamespaceSelection>;
+export declare function discoverGitLabDuoWorkflowRuntimeNamespace(config: GitLabDuoWorkflowDiscoveryConfig): Promise<GitLabDuoWorkflowNamespaceSelection>;
+export declare function fetchGitLabDuoWorkflowModels(config: GitLabDuoWorkflowDiscoveryConfig): Promise<readonly ModelSpec<"gitlab-duo-agent">[] | null>;
+export declare function buildGitLabDuoWorkflowModelSpec(model: GitLabDuoWorkflowModelRef, baseUrl?: string, rootNamespaceId?: string): ModelSpec<"gitlab-duo-agent">;
+export declare function buildGitLabDuoWorkflowFallbackModel(id?: string, name?: string, baseUrl?: string): ModelSpec<"gitlab-duo-agent">;
+export {};

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

@@ -0,0 +1,7 @@
+export * from "./antigravity.js";
+export * from "./codex.js";
+export * from "./gemini.js";
+export * from "./gemini-cli.js";
+export * from "./gitlab-duo-workflow.js";
+export * from "./openai-compatible.js";
+export * from "./protobuf.js";

package/dist/types/discovery/openai-compatible.d.ts

@@ -0,0 +1,89 @@
+import type { Api, FetchImpl, ModelSpec, Provider } from "../types.js";
+/**
+ * Default hard deadline applied to an OpenAI-compatible `/models` probe when
+ * the caller supplies neither an `AbortSignal` nor an explicit `timeoutMs`.
+ *
+ * Built-in provider model managers (openrouter, xAI, DeepSeek, …) call
+ * {@link fetchOpenAICompatibleModels} with no timeout, so without this bound a
+ * stalled endpoint left the request pending forever and blocked startup's
+ * awaited `resolveModelDiscoveryFallback` discovery pass indefinitely
+ * (issue #8315). 10s matches the coding-agent's remote-discovery budget.
+ */
+export declare const DEFAULT_OPENAI_COMPATIBLE_DISCOVERY_TIMEOUT_MS = 10000;
+/**
+ * Minimal OpenAI-style model entry shape consumed by discovery.
+ *
+ * Providers may return additional fields; this type only captures
+ * fields that are useful for generic normalization.
+ */
+export interface OpenAICompatibleModelRecord {
+    id?: unknown;
+    name?: unknown;
+    object?: unknown;
+    owned_by?: unknown;
+    [key: string]: unknown;
+}
+/**
+ * Tolerant envelope for OpenAI-compatible `/models` responses.
+ *
+ * Common providers return `{ data: [...] }`, but variants such as
+ * `{ models: [...] }`, `{ result: [...] }`, or direct arrays are also
+ * accepted during extraction.
+ */
+export interface OpenAICompatibleModelsEnvelope {
+    data?: unknown;
+    models?: unknown;
+    result?: unknown;
+    items?: unknown;
+    [key: string]: unknown;
+}
+/**
+ * Context passed to custom OpenAI-compatible model mappers.
+ */
+export interface OpenAICompatibleModelMapperContext<TApi extends Api> {
+    api: TApi;
+    provider: Provider;
+    baseUrl: string;
+}
+/**
+ * Options for fetching and normalizing OpenAI-compatible `/models` catalogs.
+ */
+export interface FetchOpenAICompatibleModelsOptions<TApi extends Api> {
+    /** API type assigned to normalized models. */
+    api: TApi;
+    /** Provider id assigned to normalized models. */
+    provider: Provider;
+    /** Provider base URL used for both fetch and normalized model records. */
+    baseUrl: string;
+    /** Optional bearer token for Authorization header. */
+    apiKey?: string;
+    /** Additional request headers. */
+    headers?: Record<string, string>;
+    /** Optional AbortSignal for request cancellation; caller owns its lifecycle. */
+    signal?: AbortSignal;
+    /**
+     * Optional cancellable request timeout used when `signal` is omitted.
+     * Defaults to {@link DEFAULT_OPENAI_COMPATIBLE_DISCOVERY_TIMEOUT_MS} so a
+     * stalled endpoint can never hang discovery indefinitely.
+     */
+    timeoutMs?: number;
+    /** Optional fetch implementation override for testing/custom runtimes. */
+    fetch?: FetchImpl;
+    /**
+     * Optional post-normalization filter.
+     * Return false to skip a model.
+     */
+    filterModel?: (entry: OpenAICompatibleModelRecord, model: ModelSpec<TApi>) => boolean;
+    /**
+     * Optional mapper override for provider-specific quirks.
+     * Return null to skip a model.
+     */
+    mapModel?: (entry: OpenAICompatibleModelRecord, defaults: ModelSpec<TApi>, context: OpenAICompatibleModelMapperContext<TApi>) => ModelSpec<TApi> | null;
+}
+/**
+ * Fetches and normalizes an OpenAI-compatible `/models` catalog.
+ *
+ * Returns `null` on transport/protocol failures.
+ * Returns `[]` only when the endpoint responds successfully with no usable models.
+ */
+export declare function fetchOpenAICompatibleModels<TApi extends Api>(options: FetchOpenAICompatibleModelsOptions<TApi>): Promise<ModelSpec<TApi>[] | null>;

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

@@ -0,0 +1,102 @@
+/**
+ * High-performance, zero-builder protobuf wire codecs for @oh-my-pi/pi-catalog.
+ *
+ * Schemas are declared as static IR descriptors with near-zero module load overhead
+ * and lazy compilation on first encode/decode/create invocation.
+ */
+/** JSON values carried by `google.protobuf.Value` fields. */
+export type JsonValue = null | boolean | number | string | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+/** An unrecognised wire field retained for forward-compatible round-trips. */
+export interface ProtoUnknownField {
+    no: number;
+    wireType: number;
+    data: Uint8Array;
+}
+/** Shared internal metadata present on every decoded protocol message. */
+export interface ProtoMessage {
+    $typeName?: string;
+    $unknown?: ProtoUnknownField[];
+}
+/** A bidirectional codec for one protobuf message type. */
+export interface MessageCodec<T extends ProtoMessage = ProtoMessage> {
+    (value: T): Uint8Array;
+    (value: Uint8Array): T;
+    /** Creates a message with protobuf defaults for omitted fields. */
+    create(value?: Partial<T>): T;
+    /** Encodes one message into protobuf wire bytes. */
+    encode(value: T): Uint8Array;
+    /** Decodes one protobuf message from wire bytes. */
+    decode(value: Uint8Array): T;
+    /** Converts a message to its protobuf JSON representation. */
+    toJson(value: T): JsonValue;
+}
+/** Infers a message shape from a codec result. */
+export type InferMessage<TCodec> = TCodec extends MessageCodec<infer TMessage> ? TMessage : never;
+/** Erases a referenced message's concrete shape for static field descriptors. */
+export interface MessageReference {
+    encode(value: unknown): Uint8Array;
+    decode(value: Uint8Array): ProtoMessage;
+    toJson(value: unknown): JsonValue;
+}
+export type ScalarKind = "bool" | "bytes" | "double" | "enum" | "float" | "int32" | "int64" | "string" | "uint32" | "uint64";
+export type WireType = 0 | 1 | 2 | 5;
+export interface ScalarFieldDesc {
+    readonly no: number;
+    readonly name: string;
+    readonly kind: ScalarKind;
+    readonly optional?: boolean;
+    readonly repeat?: boolean;
+}
+export interface MessageFieldDesc {
+    readonly no: number;
+    readonly name: string;
+    readonly kind: "message";
+    readonly T: () => MessageReference;
+    readonly repeat?: boolean;
+}
+export interface EnumFieldDesc {
+    readonly no: number;
+    readonly name: string;
+    readonly kind: "enum";
+    readonly optional?: boolean;
+    readonly repeat?: boolean;
+}
+export interface MapFieldDesc {
+    readonly no: number;
+    readonly name: string;
+    readonly kind: "map";
+    readonly K: "string";
+    readonly V: ScalarKind | (() => MessageReference);
+}
+export type VariantDesc = {
+    readonly no: number;
+    readonly name: string;
+    readonly kind: ScalarKind;
+} | {
+    readonly no: number;
+    readonly name: string;
+    readonly kind: "message";
+    readonly T: () => MessageReference;
+};
+export interface OneofFieldDesc {
+    readonly kind: "oneof";
+    readonly name: string;
+    readonly variants: readonly VariantDesc[];
+}
+export type FieldDesc = ScalarFieldDesc | MessageFieldDesc | EnumFieldDesc | MapFieldDesc | OneofFieldDesc;
+/** Creates a high-performance, lazy protobuf message codec from an IR field descriptor list. */
+export declare function pb<T extends ProtoMessage = ProtoMessage>(typeName: string, fields?: readonly FieldDesc[]): MessageCodec<T>;
+/** Creates a message using its codec's protobuf defaults. */
+export declare function create<TMessage extends ProtoMessage>(codec: MessageCodec<TMessage>, value?: Partial<TMessage>): TMessage;
+/** Encodes a message using its codec. */
+export declare function toBinary<TMessage extends ProtoMessage>(codec: MessageCodec<TMessage>, value: TMessage): Uint8Array;
+/** Decodes wire bytes using a message codec. */
+export declare function fromBinary<TMessage extends ProtoMessage>(codec: MessageCodec<TMessage>, value: Uint8Array): TMessage;
+/** Converts a message to protobuf JSON using its codec. */
+export declare function toJson<TMessage extends ProtoMessage>(codec: MessageCodec<TMessage>, value: TMessage): JsonValue;
+/** Encodes a JSON value as `google.protobuf.Value`. */
+export declare function encodeJsonValue(value: JsonValue): Uint8Array;
+/** Decodes `google.protobuf.Value` wire bytes into a JSON value. */
+export declare function decodeJsonValue(value: Uint8Array): JsonValue;

package/dist/types/effort.d.ts

@@ -0,0 +1,10 @@
+/** User-facing thinking levels, ordered least to most intensive. */
+export declare const enum Effort {
+    Minimal = "minimal",
+    Low = "low",
+    Medium = "medium",
+    High = "high",
+    XHigh = "xhigh",
+    Max = "max"
+}
+export declare const THINKING_EFFORTS: readonly Effort[];

package/dist/types/fireworks-model-id.d.ts

@@ -0,0 +1,23 @@
+export declare function toFireworksPublicModelId(modelId: string): string;
+export declare function toFireworksWireModelId(modelId: string): string;
+/**
+ * Fire Pass exposes its Kimi K2.6 Turbo subscription through a dedicated router
+ * endpoint at `accounts/fireworks/routers/<id>` rather than the `models/` namespace.
+ * We keep a friendly public id (e.g. `kimi-k2.6-turbo`) in the catalog and translate
+ * to the wire form (`accounts/fireworks/routers/kimi-k2p6-turbo`) at request time.
+ */
+export declare function toFirepassPublicModelId(modelId: string): string;
+export declare function toFirepassWireModelId(modelId: string): string;
+/**
+ * Public-id suffix marking a Fireworks "Fast" serving-path variant. Fast is a
+ * higher-throughput route (100+ tok/s) exposed under a dedicated router id
+ * (`accounts/fireworks/routers/<id>-fast`), not a separate model — same weights,
+ * higher price, no Priority tier. We keep a friendly `<id>-fast` public id and
+ * translate it to the router wire form at request time (compat
+ * `wireModelIdMode: "firepass"`). See https://docs.fireworks.ai/serverless/serving-paths.
+ */
+export declare const FIREWORKS_FAST_SUFFIX = "-fast";
+/** True for a Fireworks public model id that selects the Fast serving path. */
+export declare function isFireworksFastModelId(modelId: string): boolean;
+/** Strip the Fast suffix to recover the base (Standard-tier) model id. */
+export declare function toFireworksBaseModelId(modelId: string): string;

package/dist/types/hosts.d.ts

@@ -0,0 +1,169 @@
+/**
+ * Known model-endpoint host classification — the single vocabulary for the
+ * `provider === id || baseUrl.includes(marker)` idiom that gates wire-level
+ * behavior (compat detection, routing, header shaping, watchdog floors).
+ *
+ * Markers are case-insensitive substrings matched against the base URL, NOT
+ * parsed hostnames: proxies regularly embed the upstream host in a path
+ * segment, and the historical call sites all used substring semantics.
+ * Callers that need strict hostname matching — where a substring false
+ * positive is dangerous, e.g. the Anthropic official-endpoint OAuth gate —
+ * parse the URL and compare the hostname themselves.
+ */
+export declare const KNOWN_HOSTS: {
+    readonly openai: {
+        readonly providers: readonly ["openai"];
+        readonly urlMarkers: readonly ["api.openai.com"];
+    };
+    readonly azureOpenAI: {
+        readonly providers: readonly ["azure"];
+        readonly urlMarkers: readonly [".openai.azure.com", "azure.com/openai", "models.inference.ai.azure.com"];
+    };
+    readonly openrouter: {
+        readonly providers: readonly ["openrouter"];
+        readonly urlMarkers: readonly ["openrouter.ai"];
+    };
+    readonly vercelAIGateway: {
+        readonly providers: readonly ["vercel-ai-gateway"];
+        readonly urlMarkers: readonly ["ai-gateway.vercel.sh"];
+    };
+    readonly githubCopilot: {
+        readonly providers: readonly ["github-copilot"];
+        readonly urlMarkers: readonly ["githubcopilot.com", "copilot-api."];
+    };
+    readonly anthropic: {
+        readonly providers: readonly ["anthropic"];
+        readonly urlMarkers: readonly ["api.anthropic.com"];
+    };
+    /** DeepSeek's first-party API only — gates direct-API quirks (max_tokens field, thinking extraBody). */
+    readonly deepseekDirect: {
+        readonly providers: readonly ["deepseek"];
+        readonly urlMarkers: readonly ["api.deepseek.com"];
+    };
+    /** Any DeepSeek-operated host (first-party API, web-chat fronts). Wider than `deepseekDirect` on purpose. */
+    readonly deepseekFamily: {
+        readonly providers: readonly ["deepseek"];
+        readonly urlMarkers: readonly ["deepseek.com"];
+    };
+    readonly cerebras: {
+        readonly providers: readonly ["cerebras"];
+        readonly urlMarkers: readonly ["cerebras.ai"];
+    };
+    readonly zai: {
+        readonly providers: readonly ["zai"];
+        readonly urlMarkers: readonly ["api.z.ai"];
+    };
+    readonly zhipu: {
+        readonly providers: readonly ["zhipu-coding-plan"];
+        readonly urlMarkers: readonly ["open.bigmodel.cn"];
+    };
+    readonly kilo: {
+        readonly providers: readonly ["kilo"];
+        readonly urlMarkers: readonly ["api.kilo.ai"];
+    };
+    readonly alibabaDashscope: {
+        readonly providers: readonly ["alibaba-coding-plan", "alibaba-token-plan"];
+        readonly urlMarkers: readonly ["dashscope", "token-plan."];
+    };
+    readonly umans: {
+        readonly providers: readonly ["umans"];
+        readonly urlMarkers: readonly ["api.code.umans.ai"];
+    };
+    readonly xiaomi: {
+        readonly providers: readonly ["xiaomi"];
+        readonly providerPrefixes: readonly ["xiaomi-token-plan-"];
+        readonly urlMarkers: readonly ["xiaomimimo.com"];
+    };
+    readonly xai: {
+        readonly providers: readonly ["xai", "xai-oauth"];
+        readonly urlMarkers: readonly ["api.x.ai"];
+    };
+    readonly mistral: {
+        readonly providers: readonly ["mistral"];
+        readonly urlMarkers: readonly ["mistral.ai"];
+    };
+    readonly together: {
+        readonly providers: readonly ["together"];
+        readonly urlMarkers: readonly ["api.together.xyz"];
+    };
+    readonly baseten: {
+        readonly providers: readonly ["baseten"];
+        readonly urlMarkers: readonly ["baseten.co"];
+    };
+    /** URL-only on purpose: the `fireworks`/`firepass` providers route per-model and not every model is Fireworks-shaped. */
+    readonly fireworks: {
+        readonly urlMarkers: readonly ["fireworks.ai"];
+    };
+    readonly groq: {
+        readonly providers: readonly ["groq"];
+        readonly urlMarkers: readonly ["api.groq.com"];
+    };
+    readonly minimax: {
+        readonly providers: readonly ["minimax", "minimax-code", "minimax-code-cn"];
+        readonly urlMarkers: readonly ["api.minimax.io", "api.minimaxi.com"];
+    };
+    readonly qwenPortal: {
+        readonly providers: readonly ["qwen-portal"];
+        readonly urlMarkers: readonly ["portal.qwen.ai"];
+    };
+    /** NVIDIA NIM (`integrate.api.nvidia.com`). Qwen NIM endpoints take `chat_template_kwargs.enable_thinking`, never top-level `enable_thinking`. */
+    readonly nvidia: {
+        readonly providers: readonly ["nvidia"];
+        readonly urlMarkers: readonly ["integrate.api.nvidia.com"];
+    };
+    /** Venice AI (`api.venice.ai`). OpenAI-compatible; drives reasoning via top-level `reasoning_effort` (and `venice_parameters.disable_thinking`), and rejects DashScope's top-level `enable_thinking` with a 400 (`additionalProperties: false` request schema). */
+    readonly venice: {
+        readonly providers: readonly ["venice"];
+        readonly urlMarkers: readonly ["api.venice.ai"];
+    };
+    readonly moonshotNative: {
+        readonly providers: readonly ["moonshot", "kimi-code"];
+        readonly urlMarkers: readonly ["api.moonshot.ai", "api.kimi.com"];
+    };
+    /** Google AI Studio's OpenAI-compatible shim (`/v1beta/openai`) — a subset of chat-completions; rejects `store` with a 400. Native Gemini uses `google-generative-ai` api instead. */
+    readonly googleAistudio: {
+        readonly providers: readonly [];
+        readonly urlMarkers: readonly ["generativelanguage.googleapis.com"];
+    };
+    readonly opencode: {
+        readonly providers: readonly ["opencode-go", "opencode-zen"];
+        readonly urlMarkers: readonly ["opencode.ai"];
+    };
+    /** ZenMux's Anthropic-compatible proxy (`zenmux.ai/api/anthropic`) forwards to signature-enforcing Anthropic. */
+    readonly zenmux: {
+        readonly providers: readonly ["zenmux"];
+        readonly urlMarkers: readonly ["zenmux.ai"];
+    };
+    readonly chutes: {
+        readonly urlMarkers: readonly ["chutes.ai"];
+    };
+};
+export type KnownHost = keyof typeof KNOWN_HOSTS;
+/** URL-only host check (for call sites that have no provider id, e.g. raw env config). */
+export declare function hostMatchesUrl(baseUrl: string | undefined, host: KnownHost): boolean;
+/** Provider-or-URL host check — the canonical `provider === id || baseUrl.includes(marker)` idiom. */
+export declare function modelMatchesHost(model: {
+    provider: string;
+    baseUrl: string;
+}, host: KnownHost): boolean;
+/**
+ * Hostname for a Vertex AI GenerateContent / rawPredict / OpenAI-compat
+ * request for the given location.
+ *
+ * - `global` → global endpoint (`aiplatform.googleapis.com`)
+ * - `eu` / `us` multi-regions → REP endpoints (`aiplatform.{eu|us}.rep.googleapis.com`)
+ * - every other location → regional (`{location}-aiplatform.googleapis.com`)
+ *
+ * Multi-region codes do NOT follow the regional `{location}-aiplatform` pattern;
+ * interpolating them that way yields hosts like `eu-aiplatform.googleapis.com`
+ * that 404.
+ */
+export declare function resolveVertexEndpointHost(location: string): string;
+/** Vertex AI express-mode OpenAI-compatible endpoint (`…/endpoints/openapi`). */
+export declare function isVertexExpressOpenAIUrl(baseUrl: string): boolean;
+/** Vertex AI Anthropic raw-predict endpoints (`:streamRawPredict` / `:rawPredict`). */
+export declare function isVertexRawPredictUrl(baseUrl: string): boolean;
+/** Azure OpenAI deployment-scoped path (`…/deployments/<name>/…`). */
+export declare function isAzureDeploymentsUrl(baseUrl: string): boolean;
+/** Alibaba DashScope consumer `compatible-mode` endpoint (rejects multimodal arrays for some text-only SKUs). */
+export declare function isDashscopeCompatibleModeUrl(baseUrl: string): boolean;

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

@@ -0,0 +1,3 @@
+import { type ModelReferenceIndex } from "./reference.js";
+/** Proxy-reference index over the bundled catalog. */
+export declare function getBundledModelReferenceIndex(): ModelReferenceIndex;

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

@@ -0,0 +1,69 @@
+/**
+ * Model-id classification: parse a model id into its family (gemini / anthropic /
+ * openai), kind/variant, and version. This is the shared layer both catalog
+ * policy rules (`model-thinking.ts`) and downstream consumers build on —
+ * classification lives here, the rules that consume it stay with their domain.
+ */
+export type SemVer = {
+    major: number;
+    minor: number;
+    patch: number;
+};
+export type GeminiKind = "pro" | "flash";
+export type AnthropicKind = "opus" | "sonnet" | "fable" | "mythos";
+export type OpenAIVariant = "base" | "codex" | "codex-max" | "codex-mini" | "codex-spark" | "mini" | "max" | "nano";
+export type GlmVariant = "base" | "air" | "turbo" | "flash" | "flashx" | "preview";
+export interface GeminiModel {
+    family: "gemini";
+    kind: GeminiKind;
+    version: SemVer;
+}
+export interface AnthropicModel {
+    family: "anthropic";
+    kind: AnthropicKind;
+    version: SemVer;
+}
+export interface OpenAIModel {
+    family: "openai";
+    variant: OpenAIVariant;
+    version: SemVer;
+}
+export interface GlmModel {
+    family: "glm";
+    /** Suffix variant (`-air`, `-turbo`, `-flash`, `-flashx`, `-preview`); `base` when none. */
+    variant: GlmVariant;
+    /** Vision SKU — the `v` that attaches directly to the version (`glm-4v`, `glm-4.5v`). */
+    vision: boolean;
+    version: SemVer;
+}
+export interface UnknownModel {
+    family: "unknown";
+    id: string;
+}
+export type ParsedModel = GeminiModel | AnthropicModel | OpenAIModel | UnknownModel;
+export declare function bareModelId(modelId: string): string;
+export declare function parseKnownModel(modelId: string): ParsedModel;
+export declare const parseGeminiModel: (modelId: string) => GeminiModel | null;
+export declare const parseAnthropicModel: (modelId: string) => AnthropicModel | null;
+export declare const parseOpenAIModel: (modelId: string) => OpenAIModel | null;
+/**
+ * Parse a GLM (Zhipu / Z.AI) model id into family + variant + vision + version.
+ * Shape: `glm-<version>[v][-<variant>]` — e.g. `glm-4.5`, `glm-4.5-air`,
+ * `glm-5-turbo`, `glm-4.5v`, `glm-5-preview`. The `v` (vision) attaches to the
+ * version; other variants are `-` suffixes. Standalone like `parseAnthropicModel`
+ * is used in family.ts — GLM needs no global thinking policy, so it stays out of
+ * `parseKnownModel`.
+ */
+export declare const parseGlmModel: (modelId: string) => GlmModel | null;
+export declare function isFableOrMythos(kind: AnthropicKind): boolean;
+/**
+ * Returns true if the parsed Anthropic model is part of the adaptive-thinking
+ * Claude generation at or above a specific capability threshold.
+ * - Opus has a configurable minimum version floor (e.g. "4.6", "4.7", "4.8").
+ * - Sonnet, Fable, and Mythos all require version 5 or higher.
+ */
+export declare function isAnthropicAdaptiveGenAtLeast(parsed: AnthropicModel, opusMin: "4.6" | "4.7" | "4.8"): boolean;
+export declare function parseSemVer(version: string): SemVer | null;
+export declare function semverGte(left: SemVer | string, right: SemVer | string): boolean;
+export declare function semverEqual(left: SemVer | string, right: SemVer | string): boolean;
+export declare function compareSemVer(left: SemVer | string | null, right: SemVer | string | null): number;

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

@@ -0,0 +1,3 @@
+export type Dialect = "glm" | "hermes" | "kimi" | "xml" | "anthropic" | "deepseek" | "harmony" | "qwen3" | "gemini" | "gemma" | "minimax";
+export declare const FALLBACK_DIALECT: Dialect;
+export declare function preferredDialect(modelId: string): Dialect;