llm-zoo 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,260 @@
+import { M as ModelConfig, a as ModelProvider, b as ModelCapabilities } from './index-CQCjbg9k.js';
+export { A as ANTHROPIC_MODELS, C as COPILOT_MODELS, h as DASHSCOPE_MODELS, f as DEEPSEEK_MODELS, c as DEFAULT_CONTEXT_WINDOW, D as DEFAULT_MODEL_CAPABILITIES, G as GOOGLE_MODELS, g as MOONSHOT_MODELS, e as OPENAI_DEEP_RESEARCH_MODELS, O as OPENAI_MODELS, d as OPENAI_REASONING_MODELS, i as OTHER_MODELS, R as ReasoningEffort, X as XAI_MODELS } from './index-CQCjbg9k.js';
+
+/**
+ * Central registry of all available language model configurations.
+ * This module aggregates model configurations from all providers and
+ * exports them as a unified registry.
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * Complete registry of all available model configurations.
+ * Models are indexed by their short name (e.g., "sonnet45", "gpt4o").
+ *
+ * @example
+ * ```typescript
+ * import { MODEL_CONFIGS } from 'llm-model-registry';
+ *
+ * const sonnetConfig = MODEL_CONFIGS['sonnet45'];
+ * console.log(sonnetConfig.contextWindow); // 200000
+ * console.log(sonnetConfig.inputPrice);    // 3.0 ($/1M tokens)
+ * ```
+ */
+declare const MODEL_CONFIGS: Record<string, ModelConfig>;
+/**
+ * Array of all available model short names.
+ * Derived from MODEL_CONFIGS keys.
+ *
+ * @example
+ * ```typescript
+ * import { MODELS } from 'llm-model-registry';
+ *
+ * console.log(MODELS); // ['opus45T', 'opus45', 'sonnet45', ...]
+ * ```
+ */
+declare const MODELS: string[];
+
+/**
+ * Utility functions for working with model configurations.
+ * @packageDocumentation
+ */
+
+/**
+ * Get a model by short name.
+ *
+ * @example
+ * ```typescript
+ * const claude = lookup('sonnet45');
+ * const gpt = lookup('gpt4o');
+ * ```
+ */
+declare function lookup(name: string): ModelConfig | undefined;
+/**
+ * Resolve a model by its full API identifier.
+ *
+ * @example
+ * ```typescript
+ * const model = resolve('claude-sonnet-4-5');
+ * const model2 = resolve('gpt-4o-2024-11-20');
+ * ```
+ */
+declare function resolve(fullName: string): ModelConfig | undefined;
+/**
+ * Check if a model exists.
+ */
+declare function exists(name: string): boolean;
+/**
+ * Get all models from a provider.
+ *
+ * @example
+ * ```typescript
+ * const claudeModels = from(ModelProvider.ANTHROPIC);
+ * const geminiModels = from(ModelProvider.GOOGLE);
+ * ```
+ */
+declare function from(provider: ModelProvider): ModelConfig[];
+/**
+ * Find models matching a capability predicate.
+ *
+ * @example
+ * ```typescript
+ * // Vision + reasoning models
+ * const smart = where(c => c.supportsVision && c.supportsReasoning);
+ *
+ * // Models with great caching
+ * const cached = where(c => c.cacheDiscountFactor <= 0.1);
+ * ```
+ */
+declare function where(predicate: (capabilities: ModelCapabilities) => boolean): ModelConfig[];
+/**
+ * Get models supporting a specific capability.
+ *
+ * @example
+ * ```typescript
+ * const reasoners = supporting('supportsReasoning');
+ * const visionaries = supporting('supportsVision');
+ * const coders = supporting('supportsNativeCodeExecution');
+ * ```
+ */
+declare function supporting(capability: keyof ModelCapabilities): ModelConfig[];
+/**
+ * Filter by context window size.
+ *
+ * @example
+ * ```typescript
+ * const longContext = withContext(200000);  // 200K+ context
+ * const million = withContext(1000000);     // 1M+ context
+ * ```
+ */
+declare function withContext(minTokens: number): ModelConfig[];
+/**
+ * Get models accessible via direct API (not OpenRouter-only).
+ */
+declare function directAccess(): ModelConfig[];
+/**
+ * Get models only available through OpenRouter.
+ */
+declare function openRouterOnly(): ModelConfig[];
+/**
+ * Calculate exact cost for a request.
+ *
+ * @example
+ * ```typescript
+ * // Basic usage
+ * const price = cost('sonnet45', { input: 10000, output: 5000 });
+ *
+ * // With prompt caching
+ * const cached = cost('sonnet45', {
+ *   input: 10000,
+ *   output: 5000,
+ *   cached: 8000  // 8K tokens were cache hits
+ * });
+ * ```
+ */
+declare function cost(model: ModelConfig | string, tokens: {
+    input: number;
+    output: number;
+    cached?: number;
+}): number;
+/**
+ * Estimate worst-case cost (max output tokens).
+ *
+ * @example
+ * ```typescript
+ * const worst = maxCost('gpt4o', 50000);
+ * console.log(`Budget up to $${worst.toFixed(2)}`);
+ * ```
+ */
+declare function maxCost(model: ModelConfig | string, inputTokens: number): number;
+/**
+ * Compare cost across models for the same workload.
+ *
+ * @example
+ * ```typescript
+ * const comparison = compareCosts(
+ *   ['sonnet45', 'gpt4o', 'gemini25p'],
+ *   { input: 10000, output: 2000 }
+ * );
+ * // Returns sorted by cost: [{ model, cost }, ...]
+ * ```
+ */
+declare function compareCosts(models: (ModelConfig | string)[], tokens: {
+    input: number;
+    output: number;
+    cached?: number;
+}): {
+    model: ModelConfig;
+    cost: number;
+}[];
+/**
+ * Find the cheapest model meeting your requirements.
+ *
+ * @example
+ * ```typescript
+ * // Cheapest with vision
+ * const budget = cheapest({ supportsVision: true });
+ *
+ * // Cheapest reasoning model with 100K+ context
+ * const thinker = cheapest(
+ *   { supportsReasoning: true },
+ *   { minContext: 100000 }
+ * );
+ * ```
+ */
+declare function cheapest(capabilities: Partial<ModelCapabilities>, options?: {
+    minContext?: number;
+    provider?: ModelProvider;
+}): ModelConfig | undefined;
+/**
+ * Find the most capable model within a budget.
+ * Returns the priciest model under the limit (more expensive = usually better).
+ *
+ * @example
+ * ```typescript
+ * // Best model under $5/1M combined tokens
+ * const best = smartpick(5);
+ *
+ * // Best reasoning model under $10
+ * const bestReasoner = smartpick(10, { supportsReasoning: true });
+ * ```
+ */
+declare function smartpick(maxPricePerMillion: number, capabilities?: Partial<ModelCapabilities>): ModelConfig | undefined;
+/**
+ * Rank models by a metric.
+ *
+ * @example
+ * ```typescript
+ * const byPrice = ranked('price');        // Cheapest first
+ * const byContext = ranked('context', 'desc');  // Largest context first
+ * const byOutput = ranked('output', 'desc');    // Most output first
+ * ```
+ */
+declare function ranked(by: 'price' | 'context' | 'output', order?: 'asc' | 'desc'): ModelConfig[];
+/**
+ * Get registry statistics and insights.
+ *
+ * @example
+ * ```typescript
+ * const { totalModels, providers, capabilities } = insights();
+ * console.log(`${totalModels} models across ${Object.keys(providers).length} providers`);
+ * ```
+ */
+declare function insights(): {
+    totalModels: number;
+    providers: Record<ModelProvider, number>;
+    capabilities: Record<string, number>;
+    pricing: {
+        cheapest: ModelConfig;
+        mostExpensive: ModelConfig;
+    };
+    context: {
+        smallest: ModelConfig;
+        largest: ModelConfig;
+    };
+};
+/** @deprecated Use `lookup()` instead */
+declare const getModel: typeof lookup;
+/** @deprecated Use `resolve()` instead */
+declare const getModelByFullName: typeof resolve;
+/** @deprecated Use `exists()` instead */
+declare const hasModel: typeof exists;
+/** @deprecated Use `from()` instead */
+declare const getModelsByProvider: typeof from;
+/** @deprecated Use `where()` instead */
+declare const filterByCapability: typeof where;
+/** @deprecated Use `supporting()` instead */
+declare const getModelsWithCapability: typeof supporting;
+/** @deprecated Use `cost()` instead */
+declare function calculateCost(model: ModelConfig | string, inputTokens: number, outputTokens: number, cachedInputTokens?: number): number;
+/** @deprecated Use `maxCost()` instead */
+declare const estimateMaxCost: typeof maxCost;
+/** @deprecated Use `ranked()` instead */
+declare function sortModelsByMetric(metric: 'price' | 'context' | 'output', ascending?: boolean): ModelConfig[];
+/** @deprecated Use `cheapest()` instead */
+declare function findCheapestModel(requirements: Partial<ModelCapabilities>, minContextWindow?: number): ModelConfig | undefined;
+/** @deprecated Use `insights()` instead */
+declare const getRegistryStats: typeof insights;
+
+export { MODELS, MODEL_CONFIGS, ModelCapabilities, ModelConfig, ModelProvider, calculateCost, cheapest, compareCosts, cost, directAccess, estimateMaxCost, exists, filterByCapability, findCheapestModel, from, getModel, getModelByFullName, getModelsByProvider, getModelsWithCapability, getRegistryStats, hasModel, insights, lookup, maxCost, openRouterOnly, ranked, resolve, smartpick, sortModelsByMetric, supporting, where, withContext };