mirror of
https://github.com/tiennm99/ccs.git
synced 2026-07-16 20:17:45 +00:00
Tam Nhu Tran
982ffc5895
- add per-profile native image preferences and native-capability detection - redesign Settings -> Image around compact sections with Web-style autosave - expose richer backend/profile status and update Gemini Flash defaults
413 lines
16 KiB
JavaScript
413 lines
16 KiB
JavaScript
/**
|
|
* Tests for CLIProxy Model Catalog
|
|
* Verifies model database structure and lookup functions
|
|
*/
|
|
|
|
const assert = require('assert');
|
|
|
|
describe('Model Catalog', () => {
|
|
const modelCatalog = require('../../../dist/cliproxy/model-catalog');
|
|
|
|
describe('MODEL_CATALOG structure', () => {
|
|
it('contains AGY provider catalog', () => {
|
|
const { MODEL_CATALOG } = modelCatalog;
|
|
assert(MODEL_CATALOG.agy, 'Should have agy provider');
|
|
assert.strictEqual(MODEL_CATALOG.agy.provider, 'agy');
|
|
assert.strictEqual(MODEL_CATALOG.agy.displayName, 'Antigravity');
|
|
});
|
|
|
|
it('contains Gemini provider catalog', () => {
|
|
const { MODEL_CATALOG } = modelCatalog;
|
|
assert(MODEL_CATALOG.gemini, 'Should have gemini provider');
|
|
assert.strictEqual(MODEL_CATALOG.gemini.provider, 'gemini');
|
|
assert.strictEqual(MODEL_CATALOG.gemini.displayName, 'Gemini');
|
|
});
|
|
|
|
it('contains Codex provider catalog', () => {
|
|
const { MODEL_CATALOG } = modelCatalog;
|
|
assert(MODEL_CATALOG.codex, 'Should have codex provider');
|
|
assert.strictEqual(MODEL_CATALOG.codex.provider, 'codex');
|
|
assert.strictEqual(MODEL_CATALOG.codex.displayName, 'Copilot Codex');
|
|
});
|
|
|
|
it('does not contain qwen (not configurable)', () => {
|
|
const { MODEL_CATALOG } = modelCatalog;
|
|
assert.strictEqual(MODEL_CATALOG.qwen, undefined);
|
|
});
|
|
});
|
|
|
|
describe('Kimi models', () => {
|
|
it('contains Kimi provider catalog', () => {
|
|
const { MODEL_CATALOG } = modelCatalog;
|
|
assert(MODEL_CATALOG.kimi, 'Should have kimi provider');
|
|
assert.strictEqual(MODEL_CATALOG.kimi.provider, 'kimi');
|
|
assert.strictEqual(MODEL_CATALOG.kimi.displayName, 'Kimi (Moonshot)');
|
|
});
|
|
|
|
it('has correct default model', () => {
|
|
const { MODEL_CATALOG } = modelCatalog;
|
|
assert.strictEqual(MODEL_CATALOG.kimi.defaultModel, 'kimi-k2.5');
|
|
});
|
|
|
|
it('includes K2.5, K2 Thinking, K2', () => {
|
|
const { MODEL_CATALOG } = modelCatalog;
|
|
const ids = MODEL_CATALOG.kimi.models.map((m) => m.id);
|
|
assert(ids.includes('kimi-k2.5'), 'Should include kimi-k2.5');
|
|
assert(ids.includes('kimi-k2-thinking'), 'Should include kimi-k2-thinking');
|
|
assert(ids.includes('kimi-k2'), 'Should include kimi-k2');
|
|
});
|
|
|
|
it('has 3 models total', () => {
|
|
const { MODEL_CATALOG } = modelCatalog;
|
|
assert.strictEqual(MODEL_CATALOG.kimi.models.length, 3);
|
|
});
|
|
});
|
|
|
|
describe('AGY models', () => {
|
|
it('has correct default model', () => {
|
|
const { MODEL_CATALOG } = modelCatalog;
|
|
assert.strictEqual(MODEL_CATALOG.agy.defaultModel, 'claude-opus-4-6-thinking');
|
|
});
|
|
|
|
it('includes Claude Opus 4.6 Thinking', () => {
|
|
const { MODEL_CATALOG } = modelCatalog;
|
|
const opus = MODEL_CATALOG.agy.models.find((m) => m.id === 'claude-opus-4-6-thinking');
|
|
assert(opus, 'Should include Claude Opus 4.6 Thinking');
|
|
assert.strictEqual(opus.name, 'Claude Opus 4.6 Thinking');
|
|
});
|
|
|
|
it('includes Claude Sonnet 4.6', () => {
|
|
const { MODEL_CATALOG } = modelCatalog;
|
|
const sonnet = MODEL_CATALOG.agy.models.find((m) => m.id === 'claude-sonnet-4-6');
|
|
assert(sonnet, 'Should include Claude Sonnet 4.6');
|
|
assert.strictEqual(sonnet.name, 'Claude Sonnet 4.6');
|
|
});
|
|
|
|
it('does not include deprecated Claude 4.5 AGY models', () => {
|
|
const { MODEL_CATALOG } = modelCatalog;
|
|
const ids = MODEL_CATALOG.agy.models.map((m) => m.id);
|
|
assert.strictEqual(ids.includes('claude-opus-4-5-thinking'), false);
|
|
assert.strictEqual(ids.includes('claude-sonnet-4-5-thinking'), false);
|
|
assert.strictEqual(ids.includes('claude-sonnet-4-5'), false);
|
|
});
|
|
|
|
it('includes Gemini 3.1 Pro (free via Antigravity)', () => {
|
|
const { MODEL_CATALOG } = modelCatalog;
|
|
const gem3 = MODEL_CATALOG.agy.models.find((m) => m.id === 'gemini-3.1-pro-preview');
|
|
assert(gem3, 'Should include Gemini 3.1 Pro');
|
|
assert.strictEqual(gem3.name, 'Gemini 3.1 Pro');
|
|
// AGY models are all free - no paid tier
|
|
assert.strictEqual(gem3.tier, undefined, 'AGY models should not have paid tier');
|
|
});
|
|
|
|
it('includes Gemini Flash via Antigravity', () => {
|
|
const { MODEL_CATALOG } = modelCatalog;
|
|
const flash = MODEL_CATALOG.agy.models.find((m) => m.id === 'gemini-3-1-flash-preview');
|
|
assert(flash, 'Should include Gemini Flash');
|
|
assert.strictEqual(flash.name, 'Gemini Flash');
|
|
assert.strictEqual(flash.tier, undefined, 'AGY models should not have paid tier');
|
|
});
|
|
|
|
it('has 4 models total', () => {
|
|
const { MODEL_CATALOG } = modelCatalog;
|
|
assert.strictEqual(MODEL_CATALOG.agy.models.length, 4);
|
|
});
|
|
});
|
|
|
|
describe('Claude models', () => {
|
|
it('contains Claude provider catalog', () => {
|
|
const { MODEL_CATALOG } = modelCatalog;
|
|
assert(MODEL_CATALOG.claude, 'Should have Claude provider');
|
|
assert.strictEqual(MODEL_CATALOG.claude.provider, 'claude');
|
|
assert.strictEqual(MODEL_CATALOG.claude.displayName, 'Claude (Anthropic)');
|
|
});
|
|
it('has correct default model', () => {
|
|
const { MODEL_CATALOG } = modelCatalog;
|
|
assert.strictEqual(MODEL_CATALOG.claude.defaultModel, 'claude-sonnet-4-6');
|
|
});
|
|
|
|
it('includes Claude Sonnet 4.6', () => {
|
|
const { MODEL_CATALOG } = modelCatalog;
|
|
const sonnet = MODEL_CATALOG.claude.models.find((m) => m.id === 'claude-sonnet-4-6');
|
|
assert(sonnet, 'Should include Claude Sonnet 4.6');
|
|
assert.strictEqual(sonnet.name, 'Claude Sonnet 4.6');
|
|
});
|
|
|
|
it('retains previous 4.5 snapshot models for explicit selection', () => {
|
|
const { MODEL_CATALOG } = modelCatalog;
|
|
const ids = MODEL_CATALOG.claude.models.map((m) => m.id);
|
|
assert(ids.includes('claude-opus-4-5-20251101'));
|
|
assert(ids.includes('claude-sonnet-4-5-20250929'));
|
|
});
|
|
});
|
|
|
|
describe('Gemini models', () => {
|
|
it('has correct default model', () => {
|
|
const { MODEL_CATALOG } = modelCatalog;
|
|
assert.strictEqual(MODEL_CATALOG.gemini.defaultModel, 'gemini-2.5-pro');
|
|
});
|
|
|
|
it('includes Gemini 3.1 Pro with pro tier', () => {
|
|
const { MODEL_CATALOG } = modelCatalog;
|
|
const gem3 = MODEL_CATALOG.gemini.models.find((m) => m.id === 'gemini-3.1-pro-preview');
|
|
assert(gem3, 'Should include Gemini 3.1 Pro');
|
|
assert.strictEqual(gem3.name, 'Gemini 3.1 Pro');
|
|
assert.strictEqual(gem3.tier, 'pro');
|
|
});
|
|
|
|
it('includes Gemini 2.5 Pro without tier (free)', () => {
|
|
const { MODEL_CATALOG } = modelCatalog;
|
|
const gem25 = MODEL_CATALOG.gemini.models.find((m) => m.id === 'gemini-2.5-pro');
|
|
assert(gem25, 'Should include Gemini 2.5 Pro');
|
|
assert.strictEqual(gem25.name, 'Gemini 2.5 Pro');
|
|
assert.strictEqual(gem25.tier, undefined);
|
|
});
|
|
|
|
it('includes Gemini Flash with pro tier', () => {
|
|
const { MODEL_CATALOG } = modelCatalog;
|
|
const flash = MODEL_CATALOG.gemini.models.find((m) => m.id === 'gemini-3-flash-preview');
|
|
assert(flash, 'Should include Gemini Flash');
|
|
assert.strictEqual(flash.name, 'Gemini Flash');
|
|
assert.strictEqual(flash.tier, 'pro');
|
|
});
|
|
|
|
it('has 3 models total', () => {
|
|
const { MODEL_CATALOG } = modelCatalog;
|
|
assert.strictEqual(MODEL_CATALOG.gemini.models.length, 3);
|
|
});
|
|
});
|
|
|
|
describe('supportsModelConfig', () => {
|
|
it('returns true for agy', () => {
|
|
const { supportsModelConfig } = modelCatalog;
|
|
assert.strictEqual(supportsModelConfig('agy'), true);
|
|
});
|
|
|
|
it('returns true for gemini', () => {
|
|
const { supportsModelConfig } = modelCatalog;
|
|
assert.strictEqual(supportsModelConfig('gemini'), true);
|
|
});
|
|
|
|
it('returns true for codex', () => {
|
|
const { supportsModelConfig } = modelCatalog;
|
|
assert.strictEqual(supportsModelConfig('codex'), true);
|
|
});
|
|
|
|
it('returns true for kimi', () => {
|
|
const { supportsModelConfig } = modelCatalog;
|
|
assert.strictEqual(supportsModelConfig('kimi'), true);
|
|
});
|
|
|
|
it('returns false for qwen', () => {
|
|
const { supportsModelConfig } = modelCatalog;
|
|
assert.strictEqual(supportsModelConfig('qwen'), false);
|
|
});
|
|
});
|
|
|
|
describe('getProviderCatalog', () => {
|
|
it('returns catalog for agy', () => {
|
|
const { getProviderCatalog } = modelCatalog;
|
|
const catalog = getProviderCatalog('agy');
|
|
assert(catalog, 'Should return catalog');
|
|
assert.strictEqual(catalog.provider, 'agy');
|
|
assert(Array.isArray(catalog.models));
|
|
});
|
|
|
|
it('returns catalog for gemini', () => {
|
|
const { getProviderCatalog } = modelCatalog;
|
|
const catalog = getProviderCatalog('gemini');
|
|
assert(catalog, 'Should return catalog');
|
|
assert.strictEqual(catalog.provider, 'gemini');
|
|
});
|
|
|
|
it('returns catalog for codex', () => {
|
|
const { getProviderCatalog } = modelCatalog;
|
|
const catalog = getProviderCatalog('codex');
|
|
assert(catalog, 'Should return catalog');
|
|
assert.strictEqual(catalog.provider, 'codex');
|
|
assert(Array.isArray(catalog.models));
|
|
});
|
|
|
|
it('returns catalog for kimi', () => {
|
|
const { getProviderCatalog } = modelCatalog;
|
|
const catalog = getProviderCatalog('kimi');
|
|
assert(catalog, 'Should return catalog');
|
|
assert.strictEqual(catalog.provider, 'kimi');
|
|
assert(Array.isArray(catalog.models));
|
|
});
|
|
});
|
|
|
|
describe('findModel', () => {
|
|
it('finds Claude Opus 4.6 Thinking in agy', () => {
|
|
const { findModel } = modelCatalog;
|
|
const model = findModel('agy', 'claude-opus-4-6-thinking');
|
|
assert(model, 'Should find model');
|
|
assert.strictEqual(model.name, 'Claude Opus 4.6 Thinking');
|
|
});
|
|
|
|
it('finds Gemini 2.5 Pro in gemini', () => {
|
|
const { findModel } = modelCatalog;
|
|
const model = findModel('gemini', 'gemini-2.5-pro');
|
|
assert(model, 'Should find model');
|
|
assert.strictEqual(model.name, 'Gemini 2.5 Pro');
|
|
});
|
|
|
|
it('maps legacy AGY 4.5 IDs to supported 4.6 models', () => {
|
|
const { findModel } = modelCatalog;
|
|
const legacyOpus = findModel('agy', 'claude-opus-4-5-thinking');
|
|
const legacySonnetThinking = findModel('agy', 'claude-sonnet-4-5-thinking');
|
|
const legacySonnet = findModel('agy', 'claude-sonnet-4-5');
|
|
assert.strictEqual(legacyOpus?.id, 'claude-opus-4-6-thinking');
|
|
assert.strictEqual(legacySonnetThinking?.id, 'claude-sonnet-4-6');
|
|
assert.strictEqual(legacySonnet?.id, 'claude-sonnet-4-6');
|
|
});
|
|
|
|
it('treats Gemini 3 and 3.1 preview IDs as the same catalog family', () => {
|
|
const { findModel, getSuggestedReplacementModel } = modelCatalog;
|
|
const legacyAgyGemini = findModel('agy', 'gemini-3-pro-preview');
|
|
const legacyGemini = findModel('gemini', 'gemini-3-pro-preview');
|
|
const currentGemini = findModel('gemini', 'gemini-3.1-pro-preview');
|
|
|
|
assert.strictEqual(legacyAgyGemini?.id, 'gemini-3.1-pro-preview');
|
|
assert.strictEqual(legacyGemini?.id, 'gemini-3.1-pro-preview');
|
|
assert.strictEqual(currentGemini?.id, 'gemini-3.1-pro-preview');
|
|
assert.strictEqual(
|
|
getSuggestedReplacementModel('gemini', 'gemini-3.1-pro-preview'),
|
|
'gemini-2.5-pro'
|
|
);
|
|
});
|
|
|
|
it('falls back to the next supported model when the default is excluded', () => {
|
|
const { getSuggestedReplacementModel } = modelCatalog;
|
|
|
|
expect(getSuggestedReplacementModel('agy', 'claude-opus-4-6-thinking')).toBe(
|
|
'claude-sonnet-4-6'
|
|
);
|
|
expect(getSuggestedReplacementModel('agy')).toBe('claude-opus-4-6-thinking');
|
|
});
|
|
|
|
it('returns undefined when no provider catalog exists', () => {
|
|
const { getSuggestedReplacementModel } = modelCatalog;
|
|
|
|
expect(getSuggestedReplacementModel('qwen')).toBeUndefined();
|
|
});
|
|
|
|
it('returns undefined for unknown model', () => {
|
|
const { findModel } = modelCatalog;
|
|
const model = findModel('agy', 'unknown-model');
|
|
assert.strictEqual(model, undefined);
|
|
});
|
|
|
|
it('returns undefined for unsupported provider', () => {
|
|
const { findModel } = modelCatalog;
|
|
const model = findModel('codex', 'any-model');
|
|
assert.strictEqual(model, undefined);
|
|
});
|
|
});
|
|
|
|
describe('Model entry structure', () => {
|
|
it('all models have required fields', () => {
|
|
const { MODEL_CATALOG } = modelCatalog;
|
|
|
|
for (const [provider, catalog] of Object.entries(MODEL_CATALOG)) {
|
|
for (const model of catalog.models) {
|
|
assert(model.id, `Model in ${provider} should have id`);
|
|
assert(typeof model.id === 'string', `Model id should be string`);
|
|
assert(model.name, `Model ${model.id} should have name`);
|
|
assert(typeof model.name === 'string', `Model name should be string`);
|
|
// tier is optional
|
|
if (model.tier !== undefined) {
|
|
assert(['free', 'pro', 'ultra'].includes(model.tier), `Invalid tier: ${model.tier}`);
|
|
}
|
|
}
|
|
}
|
|
});
|
|
|
|
it('all model IDs are unique within provider', () => {
|
|
const { MODEL_CATALOG } = modelCatalog;
|
|
|
|
for (const [provider, catalog] of Object.entries(MODEL_CATALOG)) {
|
|
const ids = catalog.models.map((m) => m.id);
|
|
const uniqueIds = new Set(ids);
|
|
assert.strictEqual(ids.length, uniqueIds.size, `Duplicate model IDs in ${provider}`);
|
|
}
|
|
});
|
|
|
|
it('default model exists in models array', () => {
|
|
const { MODEL_CATALOG } = modelCatalog;
|
|
|
|
for (const [provider, catalog] of Object.entries(MODEL_CATALOG)) {
|
|
const defaultExists = catalog.models.some((m) => m.id === catalog.defaultModel);
|
|
assert(defaultExists, `Default model ${catalog.defaultModel} not found in ${provider}`);
|
|
}
|
|
});
|
|
});
|
|
|
|
describe('Thinking models ordering', () => {
|
|
it('Claude Opus 4.6 Thinking is not deprecated', () => {
|
|
const { MODEL_CATALOG } = modelCatalog;
|
|
const opus = MODEL_CATALOG.agy.models.find((m) => m.id === 'claude-opus-4-6-thinking');
|
|
assert(opus, 'Should include Claude Opus 4.6 Thinking');
|
|
assert.strictEqual(opus.deprecated, undefined, 'Should not be marked as deprecated');
|
|
});
|
|
|
|
it('Claude Sonnet 4.6 is not deprecated', () => {
|
|
const { MODEL_CATALOG } = modelCatalog;
|
|
const sonnetThinking = MODEL_CATALOG.agy.models.find((m) => m.id === 'claude-sonnet-4-6');
|
|
assert(sonnetThinking, 'Should include Claude Sonnet 4.6');
|
|
assert.strictEqual(
|
|
sonnetThinking.deprecated,
|
|
undefined,
|
|
'Should not be marked as deprecated'
|
|
);
|
|
});
|
|
|
|
it('thinking models are at the top of the list', () => {
|
|
const { MODEL_CATALOG } = modelCatalog;
|
|
const models = MODEL_CATALOG.agy.models;
|
|
|
|
// Find indices of thinking models
|
|
const opusIdx = models.findIndex((m) => m.id === 'claude-opus-4-6-thinking');
|
|
const sonnetThinkingIdx = models.findIndex((m) => m.id === 'claude-sonnet-4-6');
|
|
|
|
// Find indices of the remaining non-Claude model
|
|
const geminiIdx = models.findIndex((m) => m.id === 'gemini-3.1-pro-preview');
|
|
|
|
// Primary Claude choices should appear ahead of Gemini fallback.
|
|
assert(opusIdx < geminiIdx, 'Opus should be above Gemini');
|
|
assert(sonnetThinkingIdx < geminiIdx, 'Sonnet should be above Gemini');
|
|
});
|
|
});
|
|
|
|
describe('isModelDeprecated', () => {
|
|
it('returns false for active AGY Claude models', () => {
|
|
const { isModelDeprecated } = modelCatalog;
|
|
assert.strictEqual(isModelDeprecated('agy', 'claude-opus-4-6-thinking'), false);
|
|
assert.strictEqual(isModelDeprecated('agy', 'claude-sonnet-4-6'), false);
|
|
});
|
|
|
|
it('returns false for non-deprecated models', () => {
|
|
const { isModelDeprecated } = modelCatalog;
|
|
assert.strictEqual(isModelDeprecated('agy', 'gemini-3-pro-preview'), false);
|
|
});
|
|
|
|
it('returns false for unknown models', () => {
|
|
const { isModelDeprecated } = modelCatalog;
|
|
assert.strictEqual(isModelDeprecated('agy', 'unknown-model'), false);
|
|
});
|
|
});
|
|
|
|
describe('getModelDeprecationReason', () => {
|
|
it('returns undefined for active AGY Claude models', () => {
|
|
const { getModelDeprecationReason } = modelCatalog;
|
|
assert.strictEqual(getModelDeprecationReason('agy', 'claude-opus-4-6-thinking'), undefined);
|
|
assert.strictEqual(getModelDeprecationReason('agy', 'claude-sonnet-4-6'), undefined);
|
|
});
|
|
|
|
it('returns undefined for non-deprecated models', () => {
|
|
const { getModelDeprecationReason } = modelCatalog;
|
|
assert.strictEqual(getModelDeprecationReason('agy', 'gemini-3-pro-preview'), undefined);
|
|
});
|
|
});
|
|
});
|