wehub-resource-sync
467 lines
15 KiB
TypeScript
467 lines
15 KiB
TypeScript
/**
|
||
* Unit tests for modelsDevSync.ts
|
||
*
|
||
* Tests: fetch, transform (pricing + capabilities), provider mapping,
|
||
* DB save/retrieve, and resolution order.
|
||
*/
|
||
|
||
import { describe, it, before, after } from "node:test";
|
||
import assert from "node:assert/strict";
|
||
import {
|
||
transformModelsDevToPricing,
|
||
transformModelsDevToCapabilities,
|
||
mapProviderId,
|
||
fetchModelsDev,
|
||
} from "../../src/lib/modelsDevSync.ts";
|
||
|
||
// ─── Mock data ───────────────────────────────────────────
|
||
|
||
const MOCK_MODELS_DEV_DATA = {
|
||
openai: {
|
||
id: "openai",
|
||
name: "OpenAI",
|
||
npm: "@ai-sdk/openai",
|
||
env: ["OPENAI_API_KEY"],
|
||
doc: "https://platform.openai.com/docs/models",
|
||
models: {
|
||
"gpt-4o": {
|
||
id: "gpt-4o",
|
||
name: "GPT-4o",
|
||
family: "gpt-4",
|
||
attachment: true,
|
||
reasoning: false,
|
||
tool_call: true,
|
||
structured_output: true,
|
||
temperature: true,
|
||
knowledge: "2024-10",
|
||
release_date: "2024-05-13",
|
||
last_updated: "2024-10-01",
|
||
open_weights: false,
|
||
cost: {
|
||
input: 2.5,
|
||
output: 10.0,
|
||
cache_read: 1.25,
|
||
cache_write: 2.5,
|
||
},
|
||
limit: {
|
||
context: 128000,
|
||
input: 128000,
|
||
output: 16384,
|
||
},
|
||
modalities: {
|
||
input: ["text", "image"],
|
||
output: ["text"],
|
||
},
|
||
},
|
||
"o3-mini": {
|
||
id: "o3-mini",
|
||
name: "o3-mini",
|
||
family: "o3",
|
||
attachment: false,
|
||
reasoning: true,
|
||
tool_call: true,
|
||
structured_output: true,
|
||
temperature: false,
|
||
release_date: "2025-01-31",
|
||
last_updated: "2025-01-31",
|
||
open_weights: false,
|
||
cost: {
|
||
input: 1.1,
|
||
output: 4.4,
|
||
reasoning: 4.4,
|
||
},
|
||
limit: {
|
||
context: 200000,
|
||
output: 100000,
|
||
},
|
||
modalities: {
|
||
input: ["text"],
|
||
output: ["text"],
|
||
},
|
||
},
|
||
},
|
||
},
|
||
anthropic: {
|
||
id: "anthropic",
|
||
name: "Anthropic",
|
||
npm: "@ai-sdk/anthropic",
|
||
env: ["ANTHROPIC_API_KEY"],
|
||
doc: "https://docs.anthropic.com/en/docs/about-claud/models",
|
||
models: {
|
||
"claude-sonnet-4-20250514": {
|
||
id: "claude-sonnet-4-20250514",
|
||
name: "Claude Sonnet 4",
|
||
family: "claude-4",
|
||
attachment: true,
|
||
reasoning: false,
|
||
tool_call: true,
|
||
structured_output: true,
|
||
temperature: true,
|
||
release_date: "2025-05-14",
|
||
last_updated: "2025-05-14",
|
||
open_weights: false,
|
||
cost: {
|
||
input: 3.0,
|
||
output: 15.0,
|
||
cache_read: 0.3,
|
||
cache_write: 3.75,
|
||
},
|
||
limit: {
|
||
context: 200000,
|
||
output: 64000,
|
||
},
|
||
modalities: {
|
||
input: ["text", "image"],
|
||
output: ["text"],
|
||
},
|
||
},
|
||
},
|
||
},
|
||
deepseek: {
|
||
id: "deepseek",
|
||
name: "DeepSeek",
|
||
npm: "@ai-sdk/openai-compatible",
|
||
api: "https://api.deepseek.com/v1",
|
||
env: ["DEEPSEEK_API_KEY"],
|
||
doc: "https://api-docs.deepseek.com/",
|
||
models: {
|
||
"deepseek-chat": {
|
||
id: "deepseek-chat",
|
||
name: "DeepSeek V3",
|
||
family: "deepseek-v3",
|
||
attachment: false,
|
||
reasoning: false,
|
||
tool_call: true,
|
||
temperature: true,
|
||
release_date: "2024-12-26",
|
||
last_updated: "2025-01-20",
|
||
open_weights: true,
|
||
cost: {
|
||
input: 0.27,
|
||
output: 1.1,
|
||
cache_read: 0.07,
|
||
},
|
||
limit: {
|
||
context: 64000,
|
||
output: 8192,
|
||
},
|
||
modalities: {
|
||
input: ["text"],
|
||
output: ["text"],
|
||
},
|
||
},
|
||
},
|
||
},
|
||
"unknown-provider": {
|
||
id: "unknown-provider",
|
||
name: "Unknown",
|
||
npm: "@ai-sdk/openai-compatible",
|
||
api: "https://api.unknown.com/v1",
|
||
env: ["UNKNOWN_API_KEY"],
|
||
models: {
|
||
"some-model": {
|
||
id: "some-model",
|
||
name: "Some Model",
|
||
attachment: false,
|
||
reasoning: false,
|
||
tool_call: false,
|
||
release_date: "2025-01-01",
|
||
last_updated: "2025-01-01",
|
||
open_weights: false,
|
||
cost: {
|
||
input: 1.0,
|
||
output: 2.0,
|
||
},
|
||
limit: {
|
||
context: 32000,
|
||
output: 4096,
|
||
},
|
||
modalities: {
|
||
input: ["text"],
|
||
output: ["text"],
|
||
},
|
||
},
|
||
},
|
||
},
|
||
};
|
||
|
||
// ─── Tests ───────────────────────────────────────────────
|
||
|
||
describe("modelsDevSync — transformModelsDevToPricing", () => {
|
||
it("transforms pricing data correctly for openai provider", () => {
|
||
const pricing = transformModelsDevToPricing(MOCK_MODELS_DEV_DATA);
|
||
|
||
// openai maps to ["openai", "cx"]
|
||
assert.ok(pricing.openai, "openai provider should exist");
|
||
assert.ok(pricing.openai["gpt-4o"], "gpt-4o pricing should exist");
|
||
assert.equal(pricing.openai["gpt-4o"].input, 2.5);
|
||
assert.equal(pricing.openai["gpt-4o"].output, 10.0);
|
||
assert.equal(pricing.openai["gpt-4o"].cached, 1.25);
|
||
assert.equal(pricing.openai["gpt-4o"].cache_creation, 2.5);
|
||
|
||
// cx (Codex alias) should also have the same pricing
|
||
assert.ok(pricing.cx, "cx provider should exist");
|
||
assert.ok(pricing.cx["gpt-4o"], "gpt-4o pricing in cx should exist");
|
||
assert.equal(pricing.cx["gpt-4o"].input, 2.5);
|
||
});
|
||
|
||
it("maps reasoning cost correctly", () => {
|
||
const pricing = transformModelsDevToPricing(MOCK_MODELS_DEV_DATA);
|
||
|
||
assert.ok(pricing.openai["o3-mini"], "o3-mini pricing should exist");
|
||
assert.equal(pricing.openai["o3-mini"].input, 1.1);
|
||
assert.equal(pricing.openai["o3-mini"].output, 4.4);
|
||
assert.equal(pricing.openai["o3-mini"].reasoning, 4.4);
|
||
// o3-mini has no cache_read/cache_write
|
||
assert.equal(pricing.openai["o3-mini"].cached, undefined);
|
||
assert.equal(pricing.openai["o3-mini"].cache_creation, undefined);
|
||
});
|
||
|
||
it("maps deepseek to both deepseek and if (Qoder) providers", () => {
|
||
const pricing = transformModelsDevToPricing(MOCK_MODELS_DEV_DATA);
|
||
|
||
assert.ok(pricing.deepseek, "deepseek provider should exist");
|
||
assert.ok(pricing.if, "if (Qoder) provider should exist");
|
||
assert.equal(pricing.deepseek["deepseek-chat"].input, 0.27);
|
||
assert.equal(pricing.deepseek["deepseek-chat"].output, 1.1);
|
||
assert.equal(pricing.deepseek["deepseek-chat"].cached, 0.07);
|
||
// Should be same in if provider
|
||
assert.equal(pricing.if["deepseek-chat"].input, 0.27);
|
||
});
|
||
|
||
it("handles unknown providers by using the models.dev ID as-is", () => {
|
||
const pricing = transformModelsDevToPricing(MOCK_MODELS_DEV_DATA);
|
||
|
||
assert.ok(pricing["unknown-provider"], "unknown-provider should exist");
|
||
assert.equal(pricing["unknown-provider"]["some-model"].input, 1.0);
|
||
assert.equal(pricing["unknown-provider"]["some-model"].output, 2.0);
|
||
});
|
||
|
||
it("skips models without cost data", () => {
|
||
const dataWithNoCost = {
|
||
testprovider: {
|
||
id: "testprovider",
|
||
models: {
|
||
"no-cost-model": {
|
||
id: "no-cost-model",
|
||
name: "No Cost Model",
|
||
attachment: false,
|
||
reasoning: false,
|
||
tool_call: false,
|
||
release_date: "2025-01-01",
|
||
last_updated: "2025-01-01",
|
||
open_weights: false,
|
||
// No cost field
|
||
limit: { context: 4096, output: 2048 },
|
||
modalities: { input: ["text"], output: ["text"] },
|
||
},
|
||
},
|
||
},
|
||
};
|
||
const pricing = transformModelsDevToPricing(dataWithNoCost);
|
||
assert.equal(pricing.testprovider, undefined, "provider without cost should not exist");
|
||
});
|
||
|
||
it("counts pricing entries correctly", () => {
|
||
const pricing = transformModelsDevToPricing(MOCK_MODELS_DEV_DATA);
|
||
const totalModels = Object.values(pricing).reduce(
|
||
(sum, models) => sum + Object.keys(models).length,
|
||
0
|
||
);
|
||
// openai: 2 models × 2 providers (openai, cx) = 4
|
||
// anthropic: 1 model × 2 providers (anthropic, cc) = 2
|
||
// deepseek: 1 model × 2 providers (deepseek, if) = 2
|
||
// unknown-provider: 1 model × 1 provider = 1
|
||
assert.equal(totalModels, 9);
|
||
});
|
||
});
|
||
|
||
describe("modelsDevSync — transformModelsDevToCapabilities", () => {
|
||
it("transforms capability data correctly", () => {
|
||
const caps = transformModelsDevToCapabilities(MOCK_MODELS_DEV_DATA);
|
||
|
||
assert.ok(caps.openai, "openai capabilities should exist");
|
||
assert.ok(caps.openai["gpt-4o"], "gpt-4o capabilities should exist");
|
||
|
||
const gpt4o = caps.openai["gpt-4o"];
|
||
assert.equal(gpt4o.tool_call, true);
|
||
assert.equal(gpt4o.reasoning, false);
|
||
assert.equal(gpt4o.attachment, true);
|
||
assert.equal(gpt4o.structured_output, true);
|
||
assert.equal(gpt4o.temperature, true);
|
||
assert.equal(gpt4o.limit_context, 128000);
|
||
assert.equal(gpt4o.limit_output, 16384);
|
||
assert.equal(gpt4o.status, null); // not set in mock
|
||
assert.equal(gpt4o.family, "gpt-4");
|
||
assert.equal(gpt4o.open_weights, false);
|
||
assert.equal(JSON.parse(gpt4o.modalities_input).length, 2);
|
||
assert.equal(JSON.parse(gpt4o.modalities_output).length, 1);
|
||
});
|
||
|
||
it("handles interleaved reasoning field", () => {
|
||
const dataWithInterleaved = {
|
||
testprovider: {
|
||
id: "testprovider",
|
||
models: {
|
||
"reasoning-model": {
|
||
id: "reasoning-model",
|
||
name: "Reasoning Model",
|
||
attachment: false,
|
||
reasoning: true,
|
||
tool_call: true,
|
||
release_date: "2025-01-01",
|
||
last_updated: "2025-01-01",
|
||
open_weights: true,
|
||
interleaved: { field: "reasoning_content" },
|
||
limit: { context: 200000, output: 64000 },
|
||
modalities: { input: ["text"], output: ["text"] },
|
||
},
|
||
},
|
||
},
|
||
};
|
||
const caps = transformModelsDevToCapabilities(dataWithInterleaved);
|
||
assert.equal(caps.testprovider["reasoning-model"].interleaved_field, "reasoning_content");
|
||
});
|
||
|
||
it("handles interleaved as boolean true", () => {
|
||
const dataWithBoolInterleaved = {
|
||
testprovider: {
|
||
id: "testprovider",
|
||
models: {
|
||
"bool-model": {
|
||
id: "bool-model",
|
||
name: "Bool Model",
|
||
attachment: false,
|
||
reasoning: true,
|
||
tool_call: true,
|
||
release_date: "2025-01-01",
|
||
last_updated: "2025-01-01",
|
||
open_weights: false,
|
||
interleaved: true,
|
||
limit: { context: 100000, output: 32000 },
|
||
modalities: { input: ["text"], output: ["text"] },
|
||
},
|
||
},
|
||
},
|
||
};
|
||
const caps = transformModelsDevToCapabilities(dataWithBoolInterleaved);
|
||
assert.equal(caps.testprovider["bool-model"].interleaved_field, "reasoning_content");
|
||
});
|
||
|
||
it("handles null/missing optional fields", () => {
|
||
const dataWithMinimal = {
|
||
minimal: {
|
||
id: "minimal",
|
||
models: {
|
||
"minimal-model": {
|
||
id: "minimal-model",
|
||
name: "Minimal",
|
||
attachment: false,
|
||
reasoning: false,
|
||
tool_call: false,
|
||
release_date: "2025-01-01",
|
||
last_updated: "2025-01-01",
|
||
open_weights: false,
|
||
// No cost, no interleaved, no status, no family
|
||
limit: { context: 4096, output: 2048 },
|
||
modalities: { input: ["text"], output: ["text"] },
|
||
},
|
||
},
|
||
},
|
||
};
|
||
const caps = transformModelsDevToCapabilities(dataWithMinimal);
|
||
const m = caps.minimal["minimal-model"];
|
||
assert.equal(m.tool_call, false);
|
||
assert.equal(m.reasoning, false);
|
||
assert.equal(m.attachment, false);
|
||
assert.equal(m.structured_output, null);
|
||
assert.equal(m.temperature, null);
|
||
assert.equal(m.knowledge_cutoff, null);
|
||
assert.equal(m.status, null);
|
||
assert.equal(m.family, null);
|
||
assert.equal(m.interleaved_field, null);
|
||
assert.equal(m.limit_context, 4096);
|
||
});
|
||
});
|
||
|
||
describe("modelsDevSync — mapProviderId", () => {
|
||
it("maps openai to [openai, cx]", () => {
|
||
assert.deepEqual(mapProviderId("openai"), ["openai", "cx"]);
|
||
});
|
||
|
||
it("maps anthropic to [anthropic, cc]", () => {
|
||
assert.deepEqual(mapProviderId("anthropic"), ["anthropic", "cc"]);
|
||
});
|
||
|
||
it("maps google to [gemini]", () => {
|
||
assert.deepEqual(mapProviderId("google"), ["gemini"]);
|
||
});
|
||
|
||
it("maps deepseek to [deepseek, if]", () => {
|
||
assert.deepEqual(mapProviderId("deepseek"), ["deepseek", "if"]);
|
||
});
|
||
|
||
it("falls back to original ID for unmapped providers", () => {
|
||
assert.deepEqual(mapProviderId("some-new-provider"), ["some-new-provider"]);
|
||
});
|
||
|
||
it("maps bedrock to [kiro, kr]", () => {
|
||
assert.deepEqual(mapProviderId("bedrock"), ["kiro", "kr"]);
|
||
});
|
||
|
||
it("maps moonshot to the canonical provider plus Kimi aliases", () => {
|
||
assert.deepEqual(mapProviderId("moonshot"), ["moonshot", "kimi", "kimi-coding", "kmc", "kmca"]);
|
||
});
|
||
|
||
it("maps current models.dev provider IDs used by OmniRoute-compatible providers", () => {
|
||
assert.deepEqual(mapProviderId("github-copilot"), ["github", "gh"]);
|
||
assert.deepEqual(mapProviderId("kilo"), ["kilocode", "kc", "kilo-gateway"]);
|
||
assert.deepEqual(mapProviderId("kimi-for-coding"), [
|
||
"kimi-coding",
|
||
"kmc",
|
||
"kimi-coding-apikey",
|
||
"kmca",
|
||
]);
|
||
assert.deepEqual(mapProviderId("fireworks-ai"), ["fireworks"]);
|
||
assert.deepEqual(mapProviderId("togetherai"), ["together", "openrouter"]);
|
||
});
|
||
});
|
||
|
||
describe("modelsDevSync — fetchModelsDev (live API)", () => {
|
||
it("fetches data from models.dev API", async () => {
|
||
const data = await fetchModelsDev();
|
||
assert.ok(typeof data === "object", "data should be an object");
|
||
|
||
const providerCount = Object.keys(data).length;
|
||
assert.ok(providerCount >= 100, `should have 100+ providers, got ${providerCount}`);
|
||
|
||
let modelCount = 0;
|
||
for (const provider of Object.values(data)) {
|
||
const p = provider;
|
||
if (p.models) {
|
||
modelCount += Object.keys(p.models).length;
|
||
}
|
||
}
|
||
assert.ok(modelCount >= 4000, `should have 4000+ models, got ${modelCount}`);
|
||
});
|
||
|
||
it("returns cached data on second call", async () => {
|
||
const data1 = await fetchModelsDev();
|
||
const data2 = await fetchModelsDev();
|
||
assert.strictEqual(data1, data2, "should return same cached reference");
|
||
});
|
||
|
||
it("has openai provider with gpt-4o model", async () => {
|
||
const data = await fetchModelsDev();
|
||
assert.ok(data.openai, "openai provider should exist");
|
||
assert.ok(data.openai.models["gpt-4o"], "gpt-4o model should exist");
|
||
});
|
||
|
||
it("has anthropic provider with claude models", async () => {
|
||
const data = await fetchModelsDev();
|
||
assert.ok(data.anthropic, "anthropic provider should exist");
|
||
const claudeModels = Object.keys(data.anthropic.models).filter((m) => m.includes("claude"));
|
||
assert.ok(claudeModels.length > 0, "should have claude models");
|
||
});
|
||
});
|