llm-zoo 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 texra-ai
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,269 @@
+# llm-zoo 🦁
+
+LLM pricing and capabilities change weekly. Docs are scattered. There's no single source of truth.
+
+**One package. 78 models. Always current.**
+
+```typescript
+import { lookup, cost, cheapest } from 'llm-zoo';
+
+// Know everything about any model
+const claude = lookup('sonnet45');
+console.log(claude.contextWindow);  // 200000
+console.log(claude.inputPrice);     // 3
+
+// Calculate exact costs
+const price = cost('gpt4o', { input: 50000, output: 10000 });
+
+// Find the right model
+const budget = cheapest({ supportsVision: true, supportsReasoning: true });
+```
+
+**Zero dependencies. Full TypeScript. Tree-shakeable. Zod schemas included.**
+
+## Install
+
+```bash
+npm install llm-zoo
+```
+
+---
+
+## Model Rankings
+
+### Cheapest ($/1M tokens)
+
+| Model | Input | Output | Provider |
+|-------|-------|--------|----------|
+| `qwenturbo` | $0.05 | $0.50 | DashScope |
+| `gpt41--` | $0.10 | $0.40 | OpenAI |
+| `gemini25f-` | $0.10 | $0.40 | Google |
+| `dsv3` | $0.14 | $0.28 | DeepSeek |
+| `gpt4o-` | $0.15 | $0.60 | OpenAI |
+| `haiku3` | $0.25 | $1.25 | Anthropic |
+| `deepseek` | $0.28 | $0.42 | DeepSeek |
+| `gemini3f` | $0.30 | $2.50 | Google |
+
+### Premium ($/1M tokens)
+
+| Model | Input | Output | Reasoning | Provider |
+|-------|-------|--------|-----------|----------|
+| `o1pro` | $150 | $600 | ✓ | OpenAI |
+| `gpt45` | $75 | $150 | - | OpenAI |
+| `gpt52pro` | $21 | $168 | ✓ | OpenAI |
+| `o3pro` | $20 | $80 | ✓ | OpenAI |
+| `opus45T` | $5 | $25 | ✓ | Anthropic |
+| `opus45` | $5 | $25 | - | Anthropic |
+| `opus41T` | $15 | $75 | ✓ | Anthropic |
+| `opus41` | $15 | $75 | - | Anthropic |
+
+### Largest Context
+
+| Model | Context | Provider |
+|-------|---------|----------|
+| `gemini3p` | 1M | Google |
+| `gemini25p` | 1M | Google |
+| `qwenplus` | 1M | DashScope |
+| `gpt41` | 1M | OpenAI |
+| `gpt5` | 400K | OpenAI |
+| `kimi2` | 262K | Moonshot |
+| `grok4` | 256K | xAI |
+| `sonnet45` | 200K | Anthropic |
+
+### Capabilities
+
+| Capability | Count | Examples |
+|------------|-------|----------|
+| Vision | 45+ | `sonnet45`, `gpt4o`, `gemini25p` |
+| Reasoning | 30+ | `opus45T`, `o3`, `deepseekT`, `grok4` |
+| Code Execution | 20+ | `sonnet45`, `gpt41`, `gemini3p` |
+| Web Search | 15+ | `opus45`, `gpt4o`, `o3` |
+| Prompt Caching | 25+ | All Claude, Gemini, DeepSeek |
+
+### Providers
+
+| Provider | Models | Highlights |
+|----------|--------|------------|
+| **Anthropic** | 20 | 90% cache savings, PDF support |
+| **OpenAI** | 27 | o-series reasoning, deep research |
+| **Google** | 6 | 1M context, audio input |
+| **DeepSeek** | 7 | Budget reasoning ($0.28/1M) |
+| **xAI** | 5 | Grok 4 with 256K context |
+| **Moonshot** | 7 | Kimi K2 thinking mode |
+| **DashScope** | 3 | Qwen with 1M context |
+| **Copilot** | 1 | Free GPT-4o |
+| **OpenRouter** | 2 | Llama 405B, QVQ-72B |
+
+---
+
+## API
+
+### Lookup
+
+```typescript
+lookup('sonnet45')              // → ModelConfig | undefined
+resolve('claude-sonnet-4-5')    // → by full API name
+exists('gpt4o')                 // → true
+```
+
+### Filter
+
+```typescript
+from(ModelProvider.ANTHROPIC)   // → all Claude models
+where(c => c.supportsVision)    // → by capability predicate
+supporting('supportsReasoning') // → models with reasoning
+withContext(500000)             // → 500K+ context models
+```
+
+### Cost
+
+```typescript
+cost('sonnet45', { input: 10000, output: 5000 })
+cost('sonnet45', { input: 10000, output: 5000, cached: 8000 })  // with caching
+maxCost('gpt4o', 50000)                                         // worst case
+compareCosts(['sonnet45', 'gpt4o'], { input: 10000, output: 2000 })
+```
+
+### Select
+
+```typescript
+cheapest({ supportsVision: true })
+cheapest({ supportsReasoning: true }, { minContext: 100000 })
+smartpick(5)                    // best model under $5/1M tokens
+ranked('price')                 // cheapest first
+ranked('context', 'desc')       // largest context first
+```
+
+### Insights
+
+```typescript
+const { totalModels, providers, pricing, context } = insights();
+```
+
+---
+
+## Zod Schemas
+
+Validate model configs at runtime:
+
+```typescript
+import { ModelConfigSchema } from 'llm-zoo';
+// or import { ModelConfigSchema } from 'llm-zoo/schemas';
+
+// Validate custom model config
+const result = ModelConfigSchema.safeParse(myConfig);
+if (!result.success) {
+  console.error(result.error);
+}
+
+// Validate API responses
+const validatedModel = ModelConfigSchema.parse(apiResponse);
+```
+
+Available schemas:
+- `ModelConfigSchema` — Full model configuration
+- `ModelCapabilitiesSchema` — Capability flags
+- `ModelProviderSchema` — Provider enum
+- `ReasoningEffortSchema` — Reasoning levels
+
+---
+
+## Data Structure
+
+```typescript
+interface ModelConfig {
+  name: string;              // 'sonnet45'
+  fullName: string;          // 'claude-sonnet-4-5'
+  provider: ModelProvider;
+  inputPrice: number;        // $/1M tokens
+  outputPrice: number;
+  contextWindow: number;
+  maxOutputTokens: number;
+  capabilities: ModelCapabilities;
+  openRouterOnly: boolean;
+  openrouterFullName?: string;
+}
+
+interface ModelCapabilities {
+  supportsFunctionCalling: boolean;
+  supportsVision: boolean;
+  supportsReasoning: boolean;
+  supportsNativeCodeExecution: boolean;
+  supportsNativeWebSearch: boolean;
+  supportsPromptCaching: boolean;
+  cacheDiscountFactor: number;   // 0.1 = 90% savings
+  // ... and more
+}
+```
+
+---
+
+## Use Cases
+
+### LLM Router
+
+```typescript
+import { where, cost } from 'llm-zoo';
+
+function route(needs: { vision?: boolean; budget: number; tokens: number }) {
+  return where(c => !needs.vision || c.supportsVision)
+    .filter(m => cost(m, { input: needs.tokens, output: 4000 }) <= needs.budget)
+    .sort((a, b) => a.inputPrice - b.inputPrice)[0];
+}
+```
+
+### Edge Function (Supabase/Vercel)
+
+```typescript
+import { lookup, exists, cost } from 'llm-zoo';
+
+export async function validateRequest(model: string, tokens: number, tier: string) {
+  if (!exists(model)) return { error: 'Unknown model' };
+
+  const config = lookup(model)!;
+  if (tier === 'free' && config.inputPrice > 1) {
+    return { error: 'Upgrade for premium models' };
+  }
+
+  return {
+    allowed: true,
+    estimatedCost: cost(model, { input: tokens, output: 4000 })
+  };
+}
+```
+
+### Cost Dashboard
+
+```typescript
+import { cost, MODEL_CONFIGS } from 'llm-zoo';
+
+const report = Object.entries(usage).map(([model, tokens]) => ({
+  model,
+  spent: cost(model, tokens),
+  provider: MODEL_CONFIGS[model]?.provider,
+}));
+```
+
+---
+
+## Direct Access
+
+```typescript
+import { MODEL_CONFIGS, MODELS, ANTHROPIC_MODELS } from 'llm-zoo';
+
+MODEL_CONFIGS['sonnet45'].inputPrice;
+MODELS.forEach(name => console.log(name));
+Object.keys(ANTHROPIC_MODELS);
+```
+
+---
+
+## Contributing
+
+Found incorrect pricing? Missing capability? New model released? **PRs welcome!**
+
+Model data lives in `src/providers/`. Just update the relevant file and submit a PR.
+
+## License
+
+MIT

package/dist/index-CQCjbg9k.d.cts

@@ -0,0 +1,226 @@
+/**
+ * Configuration types and constants for language model interactions and capabilities.
+ * This module provides a comprehensive type system for describing LLM capabilities,
+ * pricing, and provider-specific configurations.
+ *
+ * @packageDocumentation
+ */
+/**
+ * Default context window size in tokens.
+ * Used as fallback when model doesn't specify a custom context window.
+ */
+declare const DEFAULT_CONTEXT_WINDOW = 128000;
+/**
+ * Reasoning effort levels for models that support configurable reasoning depth.
+ * Higher effort typically results in better reasoning quality but increased latency and cost.
+ */
+declare enum ReasoningEffort {
+    /** Extra high reasoning effort - maximum depth analysis */
+    XHIGH = "xhigh",
+    /** High reasoning effort - thorough analysis */
+    HIGH = "high",
+    /** Medium reasoning effort - balanced analysis */
+    MEDIUM = "medium",
+    /** Low reasoning effort - quick analysis */
+    LOW = "low",
+    /** No explicit reasoning - standard model behavior */
+    NONE = "none"
+}
+/**
+ * Supported language model providers.
+ * Each provider has specific API formats, capabilities, and pricing structures.
+ */
+declare enum ModelProvider {
+    /** Anthropic (Claude models) */
+    ANTHROPIC = "anthropic",
+    /** OpenAI (GPT, o-series models) */
+    OPENAI = "openai",
+    /** Google (Gemini models) */
+    GOOGLE = "google",
+    /** DeepSeek (V3, R1 models) */
+    DEEPSEEK = "deepseek",
+    /** xAI (Grok models) */
+    XAI = "xai",
+    /** Moonshot AI (Kimi models) */
+    MOONSHOT = "moonshot",
+    /** Alibaba DashScope (Qwen models) */
+    DASHSCOPE = "dashscope",
+    /** GitHub Copilot */
+    COPILOT = "copilot",
+    /** Other providers (OpenRouter-only models, etc.) */
+    OTHERS = "others"
+}
+/**
+ * Feature flags defining a model's supported capabilities and behaviors.
+ * These capabilities help determine which features can be used with a specific model.
+ */
+interface ModelCapabilities {
+    /** Whether the model supports function/tool calling */
+    supportsFunctionCalling: boolean;
+    /** Whether the model supports native MCP (Model Context Protocol) servers */
+    supportsNativeMCPServer: boolean;
+    /** Whether the model has built-in web search capability */
+    supportsNativeWebSearch: boolean;
+    /** Whether the model can execute code natively (e.g., Python sandbox) */
+    supportsNativeCodeExecution: boolean;
+    /** Whether the model supports explicit prompt caching */
+    supportsPromptCaching: boolean;
+    /** Whether the model automatically caches prompts without explicit markers */
+    supportsAutoPromptCaching: boolean;
+    /**
+     * Cost multiplier for cached tokens (0.0-1.0).
+     * Lower values mean greater savings when using cached content.
+     * Example: 0.1 means cached tokens cost 10% of normal price.
+     */
+    cacheDiscountFactor: number;
+    /** Whether the model supports extended reasoning/thinking */
+    supportsReasoning: boolean;
+    /** Whether reasoning can be interleaved with regular output */
+    supportsInterleavedThinking: boolean;
+    /** Whether the model supports configurable reasoning effort levels */
+    supportsReasoningEffort: boolean;
+    /** Default reasoning effort level when reasoning is enabled */
+    reasoningEffort: ReasoningEffort;
+    /** Whether the model can process images */
+    supportsVision: boolean;
+    /** Whether the model can process PDF documents natively */
+    supportsNativePdf: boolean;
+    /** Whether the model can process audio input natively */
+    supportsNativeAudio: boolean;
+    /** Whether the model supports assistant message prefilling */
+    supportsAssistantPrefill: boolean;
+    /** Whether the model supports predictive/speculative output */
+    supportsPredictiveOutput: boolean;
+    /** Whether the model provides accurate token counting */
+    supportsTokenCounting: boolean;
+    /** Whether the model supports system prompts */
+    supportsSystemPrompt: boolean;
+    /** Whether the model supports intermediate developer messages */
+    supportsIntermDevMsgs: boolean;
+}
+/**
+ * Base model capabilities with sensible defaults.
+ * Models should spread this and override specific capabilities.
+ */
+declare const DEFAULT_MODEL_CAPABILITIES: ModelCapabilities;
+/**
+ * Complete configuration for a language model.
+ * Contains all metadata needed to work with the model including
+ * pricing, capabilities, and provider-specific settings.
+ */
+interface ModelConfig {
+    /**
+     * Short identifier for the model (e.g., "sonnet45", "gpt4o").
+     * Used as the key in the registry and for quick reference.
+     */
+    name: string;
+    /**
+     * Full API model identifier (e.g., "claude-sonnet-4-5", "gpt-4o-2024-11-20").
+     * This is the actual string sent to the provider's API.
+     */
+    fullName: string;
+    /** The model's provider */
+    provider: ModelProvider;
+    /** Maximum tokens the model can generate in a single response */
+    maxOutputTokens: number;
+    /** Cost per million input tokens in USD */
+    inputPrice: number;
+    /** Cost per million output tokens in USD */
+    outputPrice: number;
+    /** Maximum context window size in tokens */
+    contextWindow: number;
+    /** Model capability flags */
+    capabilities: ModelCapabilities;
+    /**
+     * Whether this model is only available through OpenRouter.
+     * When true, direct API access is not available.
+     */
+    openRouterOnly: boolean;
+    /**
+     * Model identifier for OpenRouter API.
+     * Example: "anthropic/claude-sonnet-4.5"
+     */
+    openrouterFullName?: string;
+    /**
+     * Custom base URL for this specific model.
+     * Overrides the provider's default endpoint.
+     */
+    baseUrl?: string;
+    /**
+     * Whether this model requires OpenAI's Responses API format.
+     * Used for special models like deep research that bypass standard chat completions.
+     */
+    requiresResponsesAPI?: boolean;
+}
+
+/**
+ * Anthropic Claude model configurations.
+ * Includes Claude 4.x, 3.x Opus, Sonnet, and Haiku variants.
+ */
+declare const ANTHROPIC_MODELS: Record<string, ModelConfig>;
+
+/**
+ * GitHub Copilot model configurations.
+ * These models are free-tier and powered by GPT-4o.
+ */
+declare const COPILOT_MODELS: Record<string, ModelConfig>;
+
+/**
+ * Alibaba DashScope (Qwen) model configurations.
+ * Includes Qwen 3 Max, Plus, and Turbo variants.
+ */
+declare const DASHSCOPE_MODELS: Record<string, ModelConfig>;
+
+/**
+ * DeepSeek model configurations.
+ * Includes V3.2, R1, and thinking variants.
+ *
+ * Model name conventions:
+ * - fullName: Model name for native DeepSeek API (e.g., 'deepseek-chat', 'deepseek-reasoner')
+ * - openrouterFullName: Model name for OpenRouter API (e.g., 'deepseek/deepseek-v3.2')
+ */
+declare const DEEPSEEK_MODELS: Record<string, ModelConfig>;
+
+/**
+ * Google Gemini model configurations.
+ * Includes Gemini 3.x and 2.5 Pro/Flash variants.
+ */
+declare const GOOGLE_MODELS: Record<string, ModelConfig>;
+
+/**
+ * Moonshot AI (Kimi) model configurations.
+ * Includes Kimi K2 and thinking variants.
+ */
+declare const MOONSHOT_MODELS: Record<string, ModelConfig>;
+
+/**
+ * OpenAI deep research model configurations.
+ * These models require the Responses API and are optimized for research tasks.
+ */
+declare const OPENAI_DEEP_RESEARCH_MODELS: Record<string, ModelConfig>;
+
+/**
+ * OpenAI GPT model configurations.
+ * Includes GPT-4.x, GPT-4o, and GPT-4.5 variants.
+ */
+declare const OPENAI_MODELS: Record<string, ModelConfig>;
+
+/**
+ * OpenAI reasoning model configurations.
+ * Includes o1, o3, o4, and GPT-5 reasoning variants.
+ */
+declare const OPENAI_REASONING_MODELS: Record<string, ModelConfig>;
+
+/**
+ * Other model configurations (OpenRouter-only models).
+ * Includes models that are only available through OpenRouter proxy.
+ */
+declare const OTHER_MODELS: Record<string, ModelConfig>;
+
+/**
+ * xAI Grok model configurations.
+ * Includes Grok 4, 3, and 2 variants.
+ */
+declare const XAI_MODELS: Record<string, ModelConfig>;
+
+export { ANTHROPIC_MODELS as A, COPILOT_MODELS as C, DEFAULT_MODEL_CAPABILITIES as D, GOOGLE_MODELS as G, type ModelConfig as M, OPENAI_MODELS as O, ReasoningEffort as R, XAI_MODELS as X, ModelProvider as a, type ModelCapabilities as b, DEFAULT_CONTEXT_WINDOW as c, OPENAI_REASONING_MODELS as d, OPENAI_DEEP_RESEARCH_MODELS as e, DEEPSEEK_MODELS as f, MOONSHOT_MODELS as g, DASHSCOPE_MODELS as h, OTHER_MODELS as i };