language-models 2.1.3 → 2.4.0

package/src/aliases.test.js

@@ -1,264 +0,0 @@
-/**
- * Tests for model aliases
- *
- * These tests verify the alias mapping and ensure all documented
- * aliases are present and correctly mapped.
- */
-import { describe, it, expect } from 'vitest';
-import { ALIASES } from './aliases.js';
-describe('ALIASES', () => {
-    it('is an object', () => {
-        expect(typeof ALIASES).toBe('object');
-        expect(ALIASES).not.toBeNull();
-    });
-    it('has string keys and values', () => {
-        for (const [key, value] of Object.entries(ALIASES)) {
-            expect(typeof key).toBe('string');
-            expect(typeof value).toBe('string');
-        }
-    });
-    it('has no empty keys or values', () => {
-        for (const [key, value] of Object.entries(ALIASES)) {
-            expect(key.length).toBeGreaterThan(0);
-            expect(value.length).toBeGreaterThan(0);
-        }
-    });
-    it('all values are valid model IDs with provider prefix', () => {
-        for (const [key, value] of Object.entries(ALIASES)) {
-            expect(value).toContain('/');
-            const [provider, modelName] = value.split('/');
-            expect(provider.length).toBeGreaterThan(0);
-            expect(modelName.length).toBeGreaterThan(0);
-        }
-    });
-    describe('Claude (Anthropic) aliases', () => {
-        it('has opus alias', () => {
-            expect(ALIASES['opus']).toBe('anthropic/claude-opus-4.5');
-        });
-        it('has sonnet alias', () => {
-            expect(ALIASES['sonnet']).toBe('anthropic/claude-sonnet-4.5');
-        });
-        it('has haiku alias', () => {
-            expect(ALIASES['haiku']).toBe('anthropic/claude-haiku-4.5');
-        });
-        it('has claude default alias', () => {
-            expect(ALIASES['claude']).toBe('anthropic/claude-sonnet-4.5');
-        });
-        it('claude aliases point to anthropic provider', () => {
-            expect(ALIASES['opus']).toContain('anthropic/');
-            expect(ALIASES['sonnet']).toContain('anthropic/');
-            expect(ALIASES['haiku']).toContain('anthropic/');
-            expect(ALIASES['claude']).toContain('anthropic/');
-        });
-    });
-    describe('GPT (OpenAI) aliases', () => {
-        it('has gpt alias', () => {
-            expect(ALIASES['gpt']).toBe('openai/gpt-4o');
-        });
-        it('has gpt-4o alias', () => {
-            expect(ALIASES['gpt-4o']).toBe('openai/gpt-4o');
-        });
-        it('has gpt-4o-mini alias', () => {
-            expect(ALIASES['gpt-4o-mini']).toBe('openai/gpt-4o-mini');
-        });
-        it('has 4o shorthand', () => {
-            expect(ALIASES['4o']).toBe('openai/gpt-4o');
-        });
-        it('has o1 alias', () => {
-            expect(ALIASES['o1']).toBe('openai/o1');
-        });
-        it('has o3 alias', () => {
-            expect(ALIASES['o3']).toBe('openai/o3');
-        });
-        it('has o3-mini alias', () => {
-            expect(ALIASES['o3-mini']).toBe('openai/o3-mini');
-        });
-        it('has o4-mini alias', () => {
-            expect(ALIASES['o4-mini']).toBe('openai/o4-mini');
-        });
-        it('openai aliases point to openai provider', () => {
-            expect(ALIASES['gpt']).toContain('openai/');
-            expect(ALIASES['gpt-4o']).toContain('openai/');
-            expect(ALIASES['4o']).toContain('openai/');
-            expect(ALIASES['o1']).toContain('openai/');
-            expect(ALIASES['o3']).toContain('openai/');
-        });
-    });
-    describe('Gemini (Google) aliases', () => {
-        it('has gemini alias', () => {
-            expect(ALIASES['gemini']).toBe('google/gemini-2.5-flash');
-        });
-        it('has flash alias', () => {
-            expect(ALIASES['flash']).toBe('google/gemini-2.5-flash');
-        });
-        it('has gemini-flash alias', () => {
-            expect(ALIASES['gemini-flash']).toBe('google/gemini-2.5-flash');
-        });
-        it('has gemini-pro alias', () => {
-            expect(ALIASES['gemini-pro']).toBe('google/gemini-2.5-pro');
-        });
-        it('google aliases point to google provider', () => {
-            expect(ALIASES['gemini']).toContain('google/');
-            expect(ALIASES['flash']).toContain('google/');
-            expect(ALIASES['gemini-flash']).toContain('google/');
-            expect(ALIASES['gemini-pro']).toContain('google/');
-        });
-    });
-    describe('Llama (Meta) aliases', () => {
-        it('has llama alias', () => {
-            expect(ALIASES['llama']).toBe('meta-llama/llama-4-maverick');
-        });
-        it('has llama-4 alias', () => {
-            expect(ALIASES['llama-4']).toBe('meta-llama/llama-4-maverick');
-        });
-        it('has llama-70b alias', () => {
-            expect(ALIASES['llama-70b']).toBe('meta-llama/llama-3.3-70b-instruct');
-        });
-        it('llama aliases point to meta-llama provider', () => {
-            expect(ALIASES['llama']).toContain('meta-llama/');
-            expect(ALIASES['llama-4']).toContain('meta-llama/');
-            expect(ALIASES['llama-70b']).toContain('meta-llama/');
-        });
-    });
-    describe('DeepSeek aliases', () => {
-        it('has deepseek alias', () => {
-            expect(ALIASES['deepseek']).toBe('deepseek/deepseek-chat');
-        });
-        it('has r1 alias', () => {
-            expect(ALIASES['r1']).toBe('deepseek/deepseek-r1');
-        });
-        it('deepseek aliases point to deepseek provider', () => {
-            expect(ALIASES['deepseek']).toContain('deepseek/');
-            expect(ALIASES['r1']).toContain('deepseek/');
-        });
-    });
-    describe('Mistral aliases', () => {
-        it('has mistral alias', () => {
-            expect(ALIASES['mistral']).toBe('mistralai/mistral-large-2411');
-        });
-        it('has codestral alias', () => {
-            expect(ALIASES['codestral']).toBe('mistralai/codestral-2501');
-        });
-        it('mistral aliases point to mistralai provider', () => {
-            expect(ALIASES['mistral']).toContain('mistralai/');
-            expect(ALIASES['codestral']).toContain('mistralai/');
-        });
-    });
-    describe('Qwen aliases', () => {
-        it('has qwen alias', () => {
-            expect(ALIASES['qwen']).toBe('qwen/qwen3-235b-a22b');
-        });
-        it('qwen alias points to qwen provider', () => {
-            expect(ALIASES['qwen']).toContain('qwen/');
-        });
-    });
-    describe('Grok (X.AI) aliases', () => {
-        it('has grok alias', () => {
-            expect(ALIASES['grok']).toBe('x-ai/grok-3');
-        });
-        it('grok alias points to x-ai provider', () => {
-            expect(ALIASES['grok']).toContain('x-ai/');
-        });
-    });
-    describe('Perplexity aliases', () => {
-        it('has sonar alias', () => {
-            expect(ALIASES['sonar']).toBe('perplexity/sonar-pro');
-        });
-        it('sonar alias points to perplexity provider', () => {
-            expect(ALIASES['sonar']).toContain('perplexity/');
-        });
-    });
-    describe('alias uniqueness', () => {
-        it('has no duplicate keys', () => {
-            const keys = Object.keys(ALIASES);
-            const uniqueKeys = new Set(keys);
-            expect(keys.length).toBe(uniqueKeys.size);
-        });
-        it('has unique lowercase keys', () => {
-            const lowerKeys = Object.keys(ALIASES).map(k => k.toLowerCase());
-            const uniqueLowerKeys = new Set(lowerKeys);
-            expect(lowerKeys.length).toBe(uniqueLowerKeys.size);
-        });
-    });
-    describe('alias conventions', () => {
-        it('uses lowercase keys', () => {
-            for (const key of Object.keys(ALIASES)) {
-                expect(key).toBe(key.toLowerCase());
-            }
-        });
-        it('uses lowercase provider names in values', () => {
-            for (const value of Object.values(ALIASES)) {
-                const provider = value.split('/')[0];
-                expect(provider).toBe(provider.toLowerCase());
-            }
-        });
-        it('uses kebab-case or lowercase for model names', () => {
-            for (const value of Object.values(ALIASES)) {
-                const modelName = value.split('/')[1];
-                // Model names should not have uppercase letters or spaces
-                expect(modelName).not.toMatch(/[A-Z]/);
-                expect(modelName).not.toContain(' ');
-            }
-        });
-    });
-    describe('provider coverage', () => {
-        it('covers major AI providers', () => {
-            const providers = new Set(Object.values(ALIASES).map(v => v.split('/')[0]));
-            expect(providers.has('anthropic')).toBe(true);
-            expect(providers.has('openai')).toBe(true);
-            expect(providers.has('google')).toBe(true);
-            expect(providers.has('meta-llama')).toBe(true);
-        });
-        it('has multiple aliases per major provider', () => {
-            const providerCounts = {};
-            for (const value of Object.values(ALIASES)) {
-                const provider = value.split('/')[0];
-                providerCounts[provider] = (providerCounts[provider] || 0) + 1;
-            }
-            // Major providers should have multiple aliases
-            expect(providerCounts['anthropic']).toBeGreaterThanOrEqual(3);
-            expect(providerCounts['openai']).toBeGreaterThanOrEqual(5);
-            expect(providerCounts['google']).toBeGreaterThanOrEqual(3);
-        });
-    });
-    describe('README documentation alignment', () => {
-        it('matches all aliases documented in README', () => {
-            // These are the aliases listed in the README.md table
-            const documentedAliases = {
-                'opus': 'anthropic/claude-opus-4.5',
-                'sonnet': 'anthropic/claude-sonnet-4.5',
-                'haiku': 'anthropic/claude-haiku-4.5',
-                'claude': 'anthropic/claude-sonnet-4.5',
-                'gpt': 'openai/gpt-4o',
-                'gpt-4o': 'openai/gpt-4o',
-                '4o': 'openai/gpt-4o',
-                'o1': 'openai/o1',
-                'o3': 'openai/o3',
-                'o3-mini': 'openai/o3-mini',
-                'gemini': 'google/gemini-2.5-flash',
-                'flash': 'google/gemini-2.5-flash',
-                'gemini-pro': 'google/gemini-2.5-pro',
-                'llama': 'meta-llama/llama-4-maverick',
-                'llama-4': 'meta-llama/llama-4-maverick',
-                'llama-70b': 'meta-llama/llama-3.3-70b-instruct',
-                'mistral': 'mistralai/mistral-large-2411',
-                'codestral': 'mistralai/codestral-2501',
-                'deepseek': 'deepseek/deepseek-chat',
-                'r1': 'deepseek/deepseek-r1',
-                'qwen': 'qwen/qwen3-235b-a22b',
-                'grok': 'x-ai/grok-3',
-                'sonar': 'perplexity/sonar-pro',
-            };
-            for (const [alias, expectedId] of Object.entries(documentedAliases)) {
-                expect(ALIASES[alias]).toBe(expectedId);
-            }
-        });
-    });
-    describe('alias count', () => {
-        it('has reasonable number of aliases', () => {
-            const count = Object.keys(ALIASES).length;
-            expect(count).toBeGreaterThanOrEqual(20);
-            expect(count).toBeLessThanOrEqual(100);
-        });
-    });
-});

package/src/index.js

@@ -1,9 +0,0 @@
-/**
- * language-models - Model listing and resolution
- *
- * Lists all available models and resolves aliases to full model IDs.
- *
- * @packageDocumentation
- */
-export { resolve, resolveWithProvider, list, get, search, DIRECT_PROVIDERS } from './models.js';
-export { ALIASES } from './aliases.js';

package/src/index.test.js

@@ -1,320 +0,0 @@
-/**
- * Integration tests for the language-models package
- *
- * These tests verify the public API exports and end-to-end functionality.
- */
-import { describe, it, expect } from 'vitest';
-import { resolve, resolveWithProvider, list, get, search, DIRECT_PROVIDERS, ALIASES, } from './index.js';
-describe('package exports', () => {
-    it('exports resolve function', () => {
-        expect(typeof resolve).toBe('function');
-    });
-    it('exports resolveWithProvider function', () => {
-        expect(typeof resolveWithProvider).toBe('function');
-    });
-    it('exports list function', () => {
-        expect(typeof list).toBe('function');
-    });
-    it('exports get function', () => {
-        expect(typeof get).toBe('function');
-    });
-    it('exports search function', () => {
-        expect(typeof search).toBe('function');
-    });
-    it('exports DIRECT_PROVIDERS constant', () => {
-        expect(DIRECT_PROVIDERS).toBeDefined();
-        expect(Array.isArray(DIRECT_PROVIDERS)).toBe(true);
-    });
-    it('exports ALIASES constant', () => {
-        expect(ALIASES).toBeDefined();
-        expect(typeof ALIASES).toBe('object');
-    });
-});
-describe('type exports', () => {
-    it('ModelInfo type is available', () => {
-        // Type check - if this compiles, the type is exported correctly
-        const model = {
-            id: 'test/model',
-            name: 'Test Model',
-            context_length: 8192,
-            pricing: {
-                prompt: '0',
-                completion: '0',
-            },
-        };
-        expect(model).toBeDefined();
-    });
-    it('ProviderEndpoint type is available', () => {
-        const endpoint = {
-            baseUrl: 'https://api.example.com',
-            modelId: 'test-model-id',
-        };
-        expect(endpoint).toBeDefined();
-    });
-    it('ResolvedModel type is available', () => {
-        const resolved = {
-            id: 'test/model',
-            provider: 'test',
-            supportsDirectRouting: false,
-        };
-        expect(resolved).toBeDefined();
-    });
-    it('DirectProvider type is available', () => {
-        const provider = 'anthropic';
-        expect(provider).toBeDefined();
-    });
-});
-describe('end-to-end workflows', () => {
-    describe('simple alias resolution', () => {
-        it('resolves opus and gets model info', () => {
-            const modelId = resolve('opus');
-            expect(modelId).toBe('anthropic/claude-opus-4.5');
-            const model = get(modelId);
-            if (model) {
-                expect(model.id).toBe(modelId);
-                expect(model.name).toContain('Claude');
-            }
-        });
-        it('resolves gpt and gets model info', () => {
-            const modelId = resolve('gpt');
-            expect(modelId).toBe('openai/gpt-4o');
-            const model = get(modelId);
-            if (model) {
-                expect(model.id).toBe(modelId);
-                expect(model.name).toContain('GPT');
-            }
-        });
-    });
-    describe('advanced resolution with provider info', () => {
-        it('resolves opus with full provider details', () => {
-            const resolved = resolveWithProvider('opus');
-            expect(resolved.id).toBe('anthropic/claude-opus-4.5');
-            expect(resolved.provider).toBe('anthropic');
-            expect(resolved.supportsDirectRouting).toBe(true);
-            if (resolved.model) {
-                expect(resolved.model.name).toBeTruthy();
-                expect(resolved.model.context_length).toBeGreaterThan(0);
-            }
-        });
-        it('resolves with provider model ID if available', () => {
-            const resolved = resolveWithProvider('opus');
-            if (resolved.model?.provider_model_id) {
-                expect(resolved.providerModelId).toBe(resolved.model.provider_model_id);
-            }
-        });
-    });
-    describe('search and select workflow', () => {
-        it('searches for claude models and selects one', () => {
-            const matches = search('claude');
-            expect(matches.length).toBeGreaterThan(0);
-            const first = matches[0];
-            expect(first.id).toContain('/');
-            expect(first.name).toBeTruthy();
-            const retrieved = get(first.id);
-            expect(retrieved).toBeDefined();
-            expect(retrieved?.id).toBe(first.id);
-        });
-        it('searches for openai models', () => {
-            const matches = search('openai');
-            expect(matches.length).toBeGreaterThan(0);
-            for (const model of matches) {
-                expect(model.id).toContain('openai/');
-            }
-        });
-    });
-    describe('listing and filtering', () => {
-        it('lists all models and filters by provider', () => {
-            const allModels = list();
-            expect(allModels.length).toBeGreaterThanOrEqual(0);
-            if (allModels.length > 0) {
-                const anthropicModels = allModels.filter(m => m.id.startsWith('anthropic/'));
-                const openaiModels = allModels.filter(m => m.id.startsWith('openai/'));
-                if (anthropicModels.length > 0) {
-                    expect(anthropicModels[0].id).toContain('anthropic/');
-                }
-                if (openaiModels.length > 0) {
-                    expect(openaiModels[0].id).toContain('openai/');
-                }
-            }
-        });
-        it('lists models and checks for direct routing', () => {
-            const allModels = list();
-            if (allModels.length > 0) {
-                const directModels = allModels.filter(m => {
-                    const provider = m.id.split('/')[0];
-                    return DIRECT_PROVIDERS.includes(provider);
-                });
-                for (const model of directModels) {
-                    const resolved = resolveWithProvider(model.id);
-                    expect(resolved.supportsDirectRouting).toBe(true);
-                }
-            }
-        });
-    });
-    describe('case insensitivity', () => {
-        it('resolves aliases case-insensitively', () => {
-            const lower = resolve('opus');
-            const upper = resolve('OPUS');
-            const mixed = resolve('OpUs');
-            expect(lower).toBe(upper);
-            expect(lower).toBe(mixed);
-        });
-        it('searches case-insensitively', () => {
-            const lower = search('claude');
-            const upper = search('CLAUDE');
-            expect(lower).toEqual(upper);
-        });
-    });
-    describe('unknown inputs', () => {
-        it('handles unknown alias gracefully', () => {
-            const result = resolve('unknown-alias-xyz');
-            expect(result).toBe('unknown-alias-xyz');
-        });
-        it('handles unknown model ID gracefully', () => {
-            const model = get('unknown/model-id');
-            expect(model).toBeUndefined();
-        });
-        it('handles unknown search gracefully', () => {
-            const results = search('this-should-not-exist-xyz123');
-            expect(results).toEqual([]);
-        });
-        it('resolves unknown with provider info', () => {
-            const resolved = resolveWithProvider('unknown/model');
-            expect(resolved.id).toBe('unknown/model');
-            expect(resolved.provider).toBe('unknown');
-            expect(resolved.model).toBeUndefined();
-        });
-    });
-    describe('README examples', () => {
-        it('works with README quick start examples', () => {
-            // Examples from README.md Quick Start section
-            const opus = resolve('opus');
-            expect(opus).toBe('anthropic/claude-opus-4.5');
-            const gpt4o = resolve('gpt-4o');
-            expect(gpt4o).toBe('openai/gpt-4o');
-            const llama70b = resolve('llama-70b');
-            expect(llama70b).toBe('meta-llama/llama-3.3-70b-instruct');
-            const mistral = resolve('mistral');
-            expect(mistral).toBe('mistralai/mistral-large-2411');
-        });
-        it('works with README API examples', () => {
-            // Examples from README.md API section
-            const opus = resolve('opus');
-            expect(opus).toBe('anthropic/claude-opus-4.5');
-            const sonnet = resolve('sonnet');
-            expect(sonnet).toBe('anthropic/claude-sonnet-4.5');
-            const gpt = resolve('gpt');
-            expect(gpt).toBe('openai/gpt-4o');
-            const llama = resolve('llama');
-            expect(llama).toBe('meta-llama/llama-4-maverick');
-            // Pass-through example
-            const fullId = resolve('anthropic/claude-opus-4.5');
-            expect(fullId).toBe('anthropic/claude-opus-4.5');
-        });
-        it('list returns array as shown in README', () => {
-            const models = list();
-            expect(Array.isArray(models)).toBe(true);
-        });
-        it('search returns matching models as shown in README', () => {
-            const claudeModels = search('claude');
-            expect(Array.isArray(claudeModels)).toBe(true);
-            if (claudeModels.length > 0) {
-                expect(claudeModels.some(m => m.id.includes('claude') || m.name.toLowerCase().includes('claude'))).toBe(true);
-            }
-        });
-    });
-    describe('data directory integration', () => {
-        it('loads models from data/models.json', () => {
-            const models = list();
-            // Should load from data directory, even if empty
-            expect(Array.isArray(models)).toBe(true);
-        });
-        it('handles missing data file gracefully', () => {
-            // Even without data/models.json, functions should not throw
-            expect(() => list()).not.toThrow();
-            expect(() => get('test/model')).not.toThrow();
-            expect(() => search('test')).not.toThrow();
-        });
-    });
-    describe('model metadata completeness', () => {
-        it('models have pricing information', () => {
-            const models = list();
-            if (models.length > 0) {
-                const model = models[0];
-                expect(model.pricing).toBeDefined();
-                expect(model.pricing.prompt).toBeDefined();
-                expect(model.pricing.completion).toBeDefined();
-            }
-        });
-        it('models have context length', () => {
-            const models = list();
-            if (models.length > 0) {
-                for (const model of models.slice(0, 5)) {
-                    expect(typeof model.context_length).toBe('number');
-                    expect(model.context_length).toBeGreaterThan(0);
-                }
-            }
-        });
-        it('models may have architecture info', () => {
-            const models = list();
-            if (models.length > 0) {
-                const modelWithArch = models.find(m => m.architecture);
-                if (modelWithArch?.architecture) {
-                    expect(modelWithArch.architecture.modality).toBeDefined();
-                    expect(Array.isArray(modelWithArch.architecture.input_modalities)).toBe(true);
-                    expect(Array.isArray(modelWithArch.architecture.output_modalities)).toBe(true);
-                }
-            }
-        });
-    });
-    describe('provider routing', () => {
-        it('correctly identifies direct routing providers', () => {
-            const directProviders = ['anthropic', 'openai', 'google'];
-            for (const provider of directProviders) {
-                const models = list().filter(m => m.id.startsWith(`${provider}/`));
-                if (models.length > 0) {
-                    const resolved = resolveWithProvider(models[0].id);
-                    expect(resolved.supportsDirectRouting).toBe(true);
-                    expect(resolved.provider).toBe(provider);
-                }
-            }
-        });
-        it('identifies non-direct routing providers', () => {
-            const models = list();
-            const nonDirectModel = models.find(m => {
-                const provider = m.id.split('/')[0];
-                return !DIRECT_PROVIDERS.includes(provider);
-            });
-            if (nonDirectModel) {
-                const resolved = resolveWithProvider(nonDirectModel.id);
-                expect(resolved.supportsDirectRouting).toBe(false);
-            }
-        });
-    });
-});
-describe('consistency checks', () => {
-    it('all aliases resolve to valid format', () => {
-        for (const [alias, modelId] of Object.entries(ALIASES)) {
-            expect(modelId).toContain('/');
-            const [provider, model] = modelId.split('/');
-            expect(provider.length).toBeGreaterThan(0);
-            expect(model.length).toBeGreaterThan(0);
-        }
-    });
-    it('resolve and resolveWithProvider are consistent', () => {
-        const testCases = ['opus', 'gpt', 'gemini', 'llama'];
-        for (const alias of testCases) {
-            const simpleResolve = resolve(alias);
-            const fullResolve = resolveWithProvider(alias);
-            expect(fullResolve.id).toBe(simpleResolve);
-        }
-    });
-    it('search results are all valid models', () => {
-        const results = search('claude');
-        for (const model of results) {
-            const retrieved = get(model.id);
-            // All search results should be retrievable
-            expect(retrieved?.id).toBe(model.id);
-        }
-    });
-});