@x12i/ai-tools 1.0.2

package/dist/models/index.d.ts

@@ -0,0 +1,75 @@
+import { a as AiModelRecord, M as ModelListFilters, g as ModelListResult, j as ModelResolutionResult, m as OpenRouterModelApi } from '../types-DdGB3YaA.js';
+export { A as AiModelPricing, O as OpenRouterArchitectureApi, n as OpenRouterModelsQuery, o as OpenRouterModelsResponse, p as OpenRouterOutputModality, q as OpenRouterPricingApi, s as OpenRouterTopProviderApi } from '../types-DdGB3YaA.js';
+import { Catalox, CatalogQueryOptions } from '@x12i/catalox';
+
+type AiModelsServiceOptions = {
+    catalox: Catalox;
+    appId?: string;
+    catalogId?: string;
+    cacheTtlMs?: number;
+};
+/**
+ * High-level model catalog API — list, filter, count, and get full model info.
+ */
+declare class AiModelsService {
+    private readonly client;
+    private readonly catalox;
+    private readonly appId;
+    private readonly catalogId;
+    constructor(options: AiModelsServiceOptions);
+    private context;
+    /** Load all models (cached). */
+    getAllModels(): Promise<Map<string, AiModelRecord>>;
+    /** List models with in-memory filters (fast after cache warm). */
+    listModels(filters?: ModelListFilters): Promise<ModelListResult>;
+    /** Count models matching filters. */
+    countModels(filters?: Omit<ModelListFilters, "limit" | "offset">): Promise<number>;
+    /**
+     * Full model record by id or alias (same resolution as cost calculator).
+     */
+    getModelInfo(modelIdOrAlias: string): Promise<AiModelRecord | null>;
+    /**
+     * Query via Catalox indexed fields (provider, status, output modality, tools).
+     * Falls back to in-memory filter when Catalox returns partial pages.
+     */
+    listModelsFromCatalog(filters?: ModelListFilters, options?: CatalogQueryOptions): Promise<ModelListResult>;
+    resolve(modelIdOrAlias: string, provider?: string): Promise<ModelResolutionResult>;
+    refresh(): Promise<void>;
+}
+/** Convenience: getModelInfo */
+declare function getModelInfo(service: AiModelsService, modelIdOrAlias: string): Promise<AiModelRecord | null>;
+
+declare function filterModels(models: Iterable<AiModelRecord>, filters?: ModelListFilters): AiModelRecord[];
+declare function countModels(models: Iterable<AiModelRecord>, filters?: Omit<ModelListFilters, "limit" | "offset">): number;
+
+declare function extractProviderId(modelId: string): string;
+declare function normalizeOpenRouterModel(row: OpenRouterModelApi, syncedAt: string): AiModelRecord;
+
+/** OpenRouter `supported_parameters` values that indicate reasoning API support. */
+declare const REASONING_SUPPORTED_PARAMETERS: readonly ["reasoning", "include_reasoning"];
+type ReasoningModelInput = Pick<AiModelRecord, "supportedParameters" | "pricing" | "openRouterPricing"> & {
+    supportsReasoning?: boolean;
+};
+/**
+ * Whether the model accepts OpenRouter's `reasoning` request parameter
+ * (effort, max_tokens, exclude, enabled).
+ */
+declare function supportsReasoningParameter(model: Pick<AiModelRecord, "supportedParameters">): boolean;
+/**
+ * Whether the model bills separate reasoning / thinking tokens
+ * (`internal_reasoning` in OpenRouter pricing).
+ */
+declare function hasReasoningPricing(model: Pick<AiModelRecord, "pricing" | "openRouterPricing">): boolean;
+/**
+ * Compute `supportsReasoning` from catalog fields (used during sync normalization).
+ */
+declare function computeSupportsReasoning(model: ReasoningModelInput): boolean;
+/**
+ * True when the model supports reasoning tokens (API param and/or separate reasoning pricing).
+ *
+ * Prefer `model.supportsReasoning` on {@link AiModelRecord} after catalog sync;
+ * this helper also works when only partial fields are available.
+ */
+declare function isReasoningModel(model: ReasoningModelInput): boolean;
+
+export { AiModelRecord, AiModelsService, type AiModelsServiceOptions, ModelListFilters, ModelListResult, OpenRouterModelApi, REASONING_SUPPORTED_PARAMETERS, type ReasoningModelInput, computeSupportsReasoning, countModels, extractProviderId, filterModels, getModelInfo, hasReasoningPricing, isReasoningModel, normalizeOpenRouterModel, supportsReasoningParameter };

package/dist/models/index.js

@@ -0,0 +1,33 @@
+import "../chunk-COK34C6P.js";
+import {
+  AiModelsService,
+  countModels,
+  filterModels,
+  getModelInfo
+} from "../chunk-4NAY6HRP.js";
+import {
+  REASONING_SUPPORTED_PARAMETERS,
+  computeSupportsReasoning,
+  extractProviderId,
+  hasReasoningPricing,
+  isReasoningModel,
+  normalizeOpenRouterModel,
+  supportsReasoningParameter
+} from "../chunk-6QGDZTGH.js";
+import "../chunk-KQOALKKX.js";
+import "../chunk-DJ5SWJDY.js";
+import "../chunk-AJEKEWWB.js";
+export {
+  AiModelsService,
+  REASONING_SUPPORTED_PARAMETERS,
+  computeSupportsReasoning,
+  countModels,
+  extractProviderId,
+  filterModels,
+  getModelInfo,
+  hasReasoningPricing,
+  isReasoningModel,
+  normalizeOpenRouterModel,
+  supportsReasoningParameter
+};
+//# sourceMappingURL=index.js.map

package/dist/models/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/sync/index.cjs

@@ -0,0 +1,38 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+var _chunkLYOU7CA2cjs = require('../chunk-LYOU7CA2.cjs');
+
+
+
+var _chunkONA73BU6cjs = require('../chunk-ONA73BU6.cjs');
+require('../chunk-HHNHWYTP.cjs');
+require('../chunk-AV6OE2YQ.cjs');
+
+
+
+
+
+
+
+
+
+var _chunkTF4L2NECcjs = require('../chunk-TF4L2NEC.cjs');
+require('../chunk-7Q742NI3.cjs');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.ModelNameResolver = _chunkTF4L2NECcjs.ModelNameResolver; exports.OpenRouterSyncProvider = _chunkONA73BU6cjs.OpenRouterSyncProvider; exports.buildCatalogIndexes = _chunkTF4L2NECcjs.buildCatalogIndexes; exports.createModelNameResolver = _chunkLYOU7CA2cjs.createModelNameResolver; exports.isRoutedViaOpenRouter = _chunkLYOU7CA2cjs.isRoutedViaOpenRouter; exports.loadOpenRouterRoutingEnv = _chunkTF4L2NECcjs.loadOpenRouterRoutingEnv; exports.normalizeProvider = _chunkTF4L2NECcjs.normalizeProvider; exports.normalizeString = _chunkTF4L2NECcjs.normalizeString; exports.providerIdToEnvKeyPrefix = _chunkTF4L2NECcjs.providerIdToEnvKeyPrefix; exports.resolveModel = _chunkLYOU7CA2cjs.resolveModel; exports.shouldDefaultRouteViaOpenRouter = _chunkTF4L2NECcjs.shouldDefaultRouteViaOpenRouter; exports.syncAiModelsCatalog = _chunkONA73BU6cjs.syncAiModelsCatalog; exports.vendorApiKeyEnvName = _chunkTF4L2NECcjs.vendorApiKeyEnvName;
+//# sourceMappingURL=index.cjs.map

package/dist/sync/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/ami/Documents/prometheus/x12i/ai-tools/dist/sync/index.cjs"],"names":[],"mappings":"AAAA;AACE;AACA;AACA;AACF,yDAA8B;AAC9B;AACE;AACA;AACF,yDAA8B;AAC9B,iCAA8B;AAC9B,iCAA8B;AAC9B;AACE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACF,yDAA8B;AAC9B,iCAA8B;AAC9B;AACE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACF,g6BAAC","file":"/Users/ami/Documents/prometheus/x12i/ai-tools/dist/sync/index.cjs"}

package/dist/sync/index.d.cts

@@ -0,0 +1,12 @@
+export { M as ModelNameResolver, O as OpenRouterSyncProvider, a as OpenRouterSyncProviderOptions, S as SyncOptions, b as SyncResult, c as createModelNameResolver, i as isRoutedViaOpenRouter, r as resolveModel, s as syncAiModelsCatalog } from '../modelNameResolver-bZD-eBSJ.cjs';
+import { a as AiModelRecord, C as CatalogIndexes } from '../types-DdGB3YaA.cjs';
+export { h as ModelResolutionInput, j as ModelResolutionResult, k as ModelResolutionSuccess, l as ModelResolverOptions, r as OpenRouterRoutingConfig, R as ResolutionStrategy, t as ResolvedModel, v as loadOpenRouterRoutingEnv, w as providerIdToEnvKeyPrefix, x as shouldDefaultRouteViaOpenRouter, y as vendorApiKeyEnvName } from '../types-DdGB3YaA.cjs';
+import '@x12i/catalox';
+import 'firebase-admin/firestore';
+
+declare function buildCatalogIndexes(catalog: Map<string, AiModelRecord>): CatalogIndexes;
+
+declare function normalizeString(input: string): string;
+declare function normalizeProvider(provider: string | undefined): string | undefined;
+
+export { buildCatalogIndexes, normalizeProvider, normalizeString };

package/dist/sync/index.d.ts

@@ -0,0 +1,12 @@
+export { M as ModelNameResolver, O as OpenRouterSyncProvider, a as OpenRouterSyncProviderOptions, S as SyncOptions, b as SyncResult, c as createModelNameResolver, i as isRoutedViaOpenRouter, r as resolveModel, s as syncAiModelsCatalog } from '../modelNameResolver-Bn8QnkSj.js';
+import { a as AiModelRecord, C as CatalogIndexes } from '../types-DdGB3YaA.js';
+export { h as ModelResolutionInput, j as ModelResolutionResult, k as ModelResolutionSuccess, l as ModelResolverOptions, r as OpenRouterRoutingConfig, R as ResolutionStrategy, t as ResolvedModel, v as loadOpenRouterRoutingEnv, w as providerIdToEnvKeyPrefix, x as shouldDefaultRouteViaOpenRouter, y as vendorApiKeyEnvName } from '../types-DdGB3YaA.js';
+import '@x12i/catalox';
+import 'firebase-admin/firestore';
+
+declare function buildCatalogIndexes(catalog: Map<string, AiModelRecord>): CatalogIndexes;
+
+declare function normalizeString(input: string): string;
+declare function normalizeProvider(provider: string | undefined): string | undefined;
+
+export { buildCatalogIndexes, normalizeProvider, normalizeString };

package/dist/sync/index.js

@@ -0,0 +1,38 @@
+import {
+  createModelNameResolver,
+  isRoutedViaOpenRouter,
+  resolveModel
+} from "../chunk-G2G4KSC5.js";
+import {
+  OpenRouterSyncProvider,
+  syncAiModelsCatalog
+} from "../chunk-MLRHYOCD.js";
+import "../chunk-ML2FRR4L.js";
+import "../chunk-6QGDZTGH.js";
+import {
+  ModelNameResolver,
+  buildCatalogIndexes,
+  loadOpenRouterRoutingEnv,
+  normalizeProvider,
+  normalizeString,
+  providerIdToEnvKeyPrefix,
+  shouldDefaultRouteViaOpenRouter,
+  vendorApiKeyEnvName
+} from "../chunk-DJ5SWJDY.js";
+import "../chunk-AJEKEWWB.js";
+export {
+  ModelNameResolver,
+  OpenRouterSyncProvider,
+  buildCatalogIndexes,
+  createModelNameResolver,
+  isRoutedViaOpenRouter,
+  loadOpenRouterRoutingEnv,
+  normalizeProvider,
+  normalizeString,
+  providerIdToEnvKeyPrefix,
+  resolveModel,
+  shouldDefaultRouteViaOpenRouter,
+  syncAiModelsCatalog,
+  vendorApiKeyEnvName
+};
+//# sourceMappingURL=index.js.map

package/dist/sync/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/toolbox/index.cjs

@@ -0,0 +1,7 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunk5HNFAYTOcjs = require('../chunk-5HNFAYTO.cjs');
+
+
+exports.AIToolbox = _chunk5HNFAYTOcjs.AIToolbox;
+//# sourceMappingURL=index.cjs.map

package/dist/toolbox/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/ami/Documents/prometheus/x12i/ai-tools/dist/toolbox/index.cjs"],"names":[],"mappings":"AAAA;AACE;AACF,yDAA8B;AAC9B;AACE;AACF,gDAAC","file":"/Users/ami/Documents/prometheus/x12i/ai-tools/dist/toolbox/index.cjs"}

package/dist/toolbox/index.d.cts

@@ -0,0 +1,72 @@
+type FallbackChain = {
+    primary: string;
+    fallbackChain: string[];
+    maxRetries?: number;
+};
+interface Fallback {
+    execute<T>(chain: FallbackChain, fn: (model: string) => Promise<T>): Promise<T>;
+}
+
+type GuardConfig = {
+    jsonSchema?: object;
+    banPhrases?: string[];
+    minGroundingScore?: number;
+    sourceText?: string;
+};
+interface Guard {
+    verify(response: string, config: GuardConfig): {
+        isValid: boolean;
+        errors: string[];
+    };
+}
+
+type RouteRule = {
+    maxTokens?: number;
+    keywords?: string[];
+    complexity: "low" | "medium" | "high";
+    targetModel: string;
+};
+interface Router {
+    addRule(rule: RouteRule): void;
+    determineModel(prompt: string): Promise<{
+        model: string;
+        reason: string;
+    }>;
+}
+
+type TrackResult = {
+    requestId: string;
+    durationMs: number;
+    promptTokens: number;
+    completionTokens: number;
+    estimatedCostUSD: number;
+    requestPayload: unknown;
+    responsePayload: unknown;
+};
+type TrackerStorage = "memory" | "sqlite";
+type TrackerOptions = {
+    storage?: TrackerStorage;
+    sqlitePath?: string;
+};
+interface Tracker {
+    logExchange(request: unknown, response: unknown): Promise<TrackResult>;
+    wrap<T extends (...args: unknown[]) => Promise<unknown>>(fn: T): T;
+    on(event: "exchange", handler: (data: TrackResult) => void): void;
+}
+
+type AiToolboxOptions = {
+    defaultProvider?: string;
+    defaultModel?: string;
+    apiKey?: string;
+    storage?: TrackerOptions["storage"];
+    sqlitePath?: string;
+};
+declare class AIToolbox {
+    readonly tracker: Tracker;
+    readonly router: Router;
+    readonly guard: Guard;
+    readonly fallback: Fallback;
+    constructor(options?: AiToolboxOptions);
+}
+
+export { AIToolbox, type AiToolboxOptions, type Fallback, type FallbackChain, type Guard, type GuardConfig, type RouteRule, type Router, type TrackResult, type Tracker, type TrackerOptions };

package/dist/toolbox/index.d.ts

@@ -0,0 +1,72 @@
+type FallbackChain = {
+    primary: string;
+    fallbackChain: string[];
+    maxRetries?: number;
+};
+interface Fallback {
+    execute<T>(chain: FallbackChain, fn: (model: string) => Promise<T>): Promise<T>;
+}
+
+type GuardConfig = {
+    jsonSchema?: object;
+    banPhrases?: string[];
+    minGroundingScore?: number;
+    sourceText?: string;
+};
+interface Guard {
+    verify(response: string, config: GuardConfig): {
+        isValid: boolean;
+        errors: string[];
+    };
+}
+
+type RouteRule = {
+    maxTokens?: number;
+    keywords?: string[];
+    complexity: "low" | "medium" | "high";
+    targetModel: string;
+};
+interface Router {
+    addRule(rule: RouteRule): void;
+    determineModel(prompt: string): Promise<{
+        model: string;
+        reason: string;
+    }>;
+}
+
+type TrackResult = {
+    requestId: string;
+    durationMs: number;
+    promptTokens: number;
+    completionTokens: number;
+    estimatedCostUSD: number;
+    requestPayload: unknown;
+    responsePayload: unknown;
+};
+type TrackerStorage = "memory" | "sqlite";
+type TrackerOptions = {
+    storage?: TrackerStorage;
+    sqlitePath?: string;
+};
+interface Tracker {
+    logExchange(request: unknown, response: unknown): Promise<TrackResult>;
+    wrap<T extends (...args: unknown[]) => Promise<unknown>>(fn: T): T;
+    on(event: "exchange", handler: (data: TrackResult) => void): void;
+}
+
+type AiToolboxOptions = {
+    defaultProvider?: string;
+    defaultModel?: string;
+    apiKey?: string;
+    storage?: TrackerOptions["storage"];
+    sqlitePath?: string;
+};
+declare class AIToolbox {
+    readonly tracker: Tracker;
+    readonly router: Router;
+    readonly guard: Guard;
+    readonly fallback: Fallback;
+    constructor(options?: AiToolboxOptions);
+}
+
+export { AIToolbox, type AiToolboxOptions, type Fallback, type FallbackChain, type Guard, type GuardConfig, type RouteRule, type Router, type TrackResult, type Tracker, type TrackerOptions };

package/dist/toolbox/index.js

@@ -0,0 +1,7 @@
+import {
+  AIToolbox
+} from "../chunk-XRBZQQQU.js";
+export {
+  AIToolbox
+};
+//# sourceMappingURL=index.js.map

package/dist/toolbox/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/types-DdGB3YaA.d.cts

@@ -0,0 +1,278 @@
+/** OpenRouter Models API — https://openrouter.ai/api/v1/models */
+type OpenRouterOutputModality = "text" | "image" | "audio" | "embeddings" | "video" | "speech" | "transcription" | "all";
+type OpenRouterModelsQuery = {
+    /** Comma-separated or "all" — default on our sync is "all". */
+    output_modalities?: string;
+    supported_parameters?: string;
+};
+type OpenRouterPricingApi = {
+    prompt: string;
+    completion: string;
+    request: string;
+    image: string;
+    web_search?: string;
+    internal_reasoning?: string;
+    input_cache_read?: string;
+    input_cache_write?: string;
+};
+type OpenRouterArchitectureApi = {
+    modality?: string;
+    input_modalities: string[];
+    output_modalities: string[];
+    tokenizer: string;
+    instruct_type: string | null;
+};
+type OpenRouterTopProviderApi = {
+    context_length: number;
+    max_completion_tokens: number | null;
+    is_moderated: boolean;
+};
+type OpenRouterDefaultParametersApi = {
+    temperature?: number | null;
+    top_p?: number | null;
+    top_k?: number | null;
+    frequency_penalty?: number | null;
+    presence_penalty?: number | null;
+    repetition_penalty?: number | null;
+};
+type OpenRouterModelApi = {
+    id: string;
+    canonical_slug: string;
+    hugging_face_id?: string | null;
+    name: string;
+    created: number;
+    description: string;
+    context_length: number;
+    architecture: OpenRouterArchitectureApi;
+    pricing: OpenRouterPricingApi;
+    top_provider: OpenRouterTopProviderApi;
+    per_request_limits: unknown | null;
+    supported_parameters: string[];
+    default_parameters: OpenRouterDefaultParametersApi | null;
+    supported_voices?: unknown | null;
+    knowledge_cutoff?: string | null;
+    expiration_date?: string | null;
+    links?: {
+        details?: string;
+    } | null;
+};
+type OpenRouterModelsResponse = {
+    data: OpenRouterModelApi[];
+};
+
+type AiModelPricing = {
+    promptUsdPerToken: number;
+    completionUsdPerToken: number;
+    imageUsdPerUnit: number;
+    requestUsdPerRequest: number;
+    cacheReadUsdPerToken?: number;
+    cacheWriteUsdPerToken?: number;
+    reasoningUsdPerToken?: number;
+    webSearchUsdPerRequest?: number;
+    openRouterMarkupUsdPerInputToken?: number;
+    openRouterMarkupUsdPerOutputToken?: number;
+    pricedAt: string;
+    source: "openrouter" | "direct" | "manual";
+};
+/**
+ * Canonical catalog record — mirrors OpenRouter Models API fields plus normalized pricing.
+ * Stored as-is in Catalox `data`; scalar fields duplicated in `indexed` for queries.
+ */
+type AiModelRecord = {
+    modelId: string;
+    name: string;
+    providerId: string;
+    canonicalSlug: string;
+    status: "active" | "deprecated" | "unknown";
+    description: string;
+    created: number;
+    expirationDate: string | null;
+    contextLength: number;
+    maxCompletionTokens: number | null;
+    isModerated: boolean;
+    modality: string;
+    inputModalities: string[];
+    outputModalities: string[];
+    tokenizer: string;
+    instructType: string | null;
+    supportedParameters: string[];
+    defaultParameters: OpenRouterDefaultParametersApi | null;
+    perRequestLimits: unknown | null;
+    pricing: AiModelPricing;
+    /** Raw OpenRouter pricing strings (USD per token/request/unit). */
+    openRouterPricing: OpenRouterPricingApi;
+    architecture: OpenRouterArchitectureApi;
+    topProvider: OpenRouterTopProviderApi;
+    /** Full OpenRouter API object — complete mirror for forward compatibility. */
+    openRouter: OpenRouterModelApi;
+    aliases: string[];
+    availableOnOpenRouter: boolean;
+    supportsStreaming: boolean;
+    supportsTools: boolean;
+    /** Exposes reasoning/thinking tokens (OpenRouter `reasoning` param and/or `internal_reasoning` pricing). */
+    supportsReasoning: boolean;
+    primaryOutputModality: string;
+    syncedAt: string;
+    syncSource: "openrouter" | "manual";
+};
+type ModelListFilters = {
+    providerId?: string;
+    status?: AiModelRecord["status"];
+    outputModality?: string;
+    inputModality?: string;
+    supportedParameter?: string;
+    supportsTools?: boolean;
+    supportsReasoning?: boolean;
+    search?: string;
+    limit?: number;
+    offset?: number;
+};
+type ModelListResult = {
+    models: AiModelRecord[];
+    total: number;
+    limit: number;
+    offset: number;
+};
+
+type AliasEntry = {
+    modelId: string;
+    provider: string;
+    description?: string;
+    tags?: string[];
+    addedAt: string;
+    updatedAt: string;
+};
+type AliasFileSchema = {
+    $schema?: string;
+    version: 1;
+    updatedAt: string;
+    aliases: Record<string, AliasEntry>;
+};
+type ResolvedModelRef = {
+    alias: string;
+    entry: AliasEntry;
+    modelRecord: AiModelRecord | null;
+    modelId: string;
+    provider: string;
+    name: string;
+};
+type AliasValidationReport = {
+    total: number;
+    ok: number;
+    unknown: number;
+    broken: number;
+    entries: Array<{
+        name: string;
+        status: "ok" | "unknown" | "broken";
+        modelId: string;
+        resolvedName?: string;
+        issue?: string;
+    }>;
+};
+
+type AliasRegistryOptions = {
+    aliasesPath?: string;
+};
+declare class AliasRegistry {
+    private readonly aliasesPath;
+    constructor(options?: AliasRegistryOptions);
+    get path(): string;
+    exists(): boolean;
+    init(): void;
+    load(): AliasFileSchema;
+    get(aliasName: string): AliasEntry | null;
+    list(filter?: {
+        tag?: string;
+    }): Array<{
+        name: string;
+    } & AliasEntry>;
+    set(aliasName: string, entry: Omit<AliasEntry, "addedAt" | "updatedAt">): AliasEntry;
+    remove(aliasName: string): boolean;
+    rename(from: string, to: string, options?: {
+        force?: boolean;
+    }): void;
+    private writeFile;
+}
+
+/**
+ * Env naming for vendor direct API keys: `{VENDOR}_API_KEY`
+ * where VENDOR is the provider id in UPPER_SNAKE (hyphens → underscores).
+ *
+ * Examples: `OPENAI_API_KEY`, `ANTHROPIC_API_KEY`, `META_LLAMA_API_KEY`, `X_AI_API_KEY`
+ */
+declare function providerIdToEnvKeyPrefix(providerId: string): string;
+declare function vendorApiKeyEnvName(providerId: string): string;
+type OpenRouterRoutingConfig = {
+    /** OPENROUTER_API_KEY is set and non-empty */
+    hasOpenRouterKey: boolean;
+    /** USE_OPENROUTER=true or USE_OPENROUTER=1 */
+    useOpenRouterExplicit: boolean;
+    /** Read `{PROVIDER}_API_KEY` for a catalog provider id */
+    getVendorApiKey(providerId: string): string | undefined;
+};
+/**
+ * Load routing hints from process env and optional `.env` (via @x12/env).
+ */
+declare function loadOpenRouterRoutingEnv(env?: Record<string, string | undefined>): OpenRouterRoutingConfig;
+/**
+ * Default route via OpenRouter when:
+ * 1. OPENROUTER_API_KEY is set AND USE_OPENROUTER=true|1, or
+ * 2. OPENROUTER_API_KEY is set AND the vendor's `{VENDOR}_API_KEY` is missing.
+ */
+declare function shouldDefaultRouteViaOpenRouter(providerId: string | undefined, config: OpenRouterRoutingConfig): boolean;
+
+type ModelResolutionInput = {
+    /** Provider hint (openrouter, openai, anthropic, …). May be omitted. */
+    provider?: string;
+    /** Model id, alias, shorthand, or partial name. Required. */
+    model: string;
+};
+type ResolutionStrategy = "alias-registry" | "alias-as-provider-correction" | "exact-match" | "catalog-alias-match" | "canonical-slug-match" | "provider-prefix-injection" | "cross-provider-correction" | "version-suffix-strip" | "date-suffix-strip" | "shorthand-expansion" | "partial-name-match" | "local-provider-passthrough";
+type ModelResolutionSuccess = {
+    found: true;
+    modelId: string;
+    record: AiModelRecord | null;
+    routedViaOpenRouter: boolean;
+    confidence: number;
+    resolvedVia: ResolutionStrategy[];
+    resolvedReason: string;
+    normalisedInput: string;
+};
+type ModelResolutionNotFound = {
+    found: false;
+    modelId: null;
+    record: null;
+    attemptedStrategies: ResolutionStrategy[];
+    bestRejectedCandidate?: {
+        modelId: string;
+        confidence: number;
+        reason: string;
+    };
+    reason: string;
+};
+type ModelResolutionResult = ModelResolutionSuccess | ModelResolutionNotFound;
+type ModelResolverOptions = {
+    confidenceThreshold?: number;
+    aliasRegistry?: AliasRegistry;
+    additionalShorthands?: Record<string, string>;
+    additionalProviderPatterns?: Array<{
+        pattern: RegExp;
+        provider: string;
+    }>;
+    additionalLocalProviders?: string[];
+    /** Env-based OpenRouter vs direct routing. Defaults to loadOpenRouterRoutingEnv(). */
+    routingEnv?: OpenRouterRoutingConfig;
+};
+type CatalogIndexes = {
+    aliasIndex: Map<string, string>;
+    slugIndex: Map<string, string>;
+    providerPrefixesBySize: string[];
+};
+/** @deprecated Use ModelResolutionSuccess via ModelNameResolver */
+type ResolvedModel = {
+    catalogModel: AiModelRecord;
+    matchedAlias: string;
+    routedViaOpenRouter: boolean;
+};
+
+export { type AiModelPricing as A, type CatalogIndexes as C, type ModelListFilters as M, type OpenRouterArchitectureApi as O, type ResolutionStrategy as R, type AiModelRecord as a, type AliasEntry as b, type AliasFileSchema as c, AliasRegistry as d, type AliasRegistryOptions as e, type AliasValidationReport as f, type ModelListResult as g, type ModelResolutionInput as h, type ModelResolutionNotFound as i, type ModelResolutionResult as j, type ModelResolutionSuccess as k, type ModelResolverOptions as l, type OpenRouterModelApi as m, type OpenRouterModelsQuery as n, type OpenRouterModelsResponse as o, type OpenRouterOutputModality as p, type OpenRouterPricingApi as q, type OpenRouterRoutingConfig as r, type OpenRouterTopProviderApi as s, type ResolvedModel as t, type ResolvedModelRef as u, loadOpenRouterRoutingEnv as v, providerIdToEnvKeyPrefix as w, shouldDefaultRouteViaOpenRouter as x, vendorApiKeyEnvName as y };