Never stop coding. Free MIT AI gateway: one endpoint, 375 providers (150+ free), 1,400+ models Kimi, Claude, GPT, Gemini, GLM, DeepSeek, MiniMax. Works with Claude Code, Codex, Cursor, OpenCode, Cline & Copilot. Quota-aware auto-fallback, RTK+Caveman compression saves 15-95% tokens, MCP/A2A, Desktop/PWA. Built by 900+ contributors
TypeScript a2aai-agentsai-gatewayanthropicclaudeclaude-codeclinecodexcopilotcursordeepseekfree-aigeminikimillm-gatewaymcpopenaiopenai-proxyqwentoken-saver
// tests/unit/combo/comboSort.test.ts
import { describe, it } from "node:test";
import assert from "node:assert/strict";
import {
PROVIDER_ORDER,
sortComboStepsSync,
sortComboStepsByScore,
reapplyCurrentSort,
type ComboStep,
} from "@/lib/combos/comboSort";
const m = (id: string, providerId: string, model: string): ComboStep => ({
id,
kind: "model",
model,
providerId,
weight: 0,
});
const ref = (id: string, comboName: string): ComboStep => ({
id,
kind: "combo-ref",
comboName,
weight: 0,
});
describe("sortComboStepsSync", () => {
it("manual returns the input unchanged", () => {
const steps = [m("a", "openai", "gpt"), m("b", "anthropic", "claude")];
assert.equal(sortComboStepsSync(steps, "manual"), steps);
});
it("provider groups by PROVIDER_ORDER, stable intra-group, combo-ref at end", () => {
const steps = [
m("x", "anthropic", "claude-3"),
m("y", "openai", "gpt-4"),
ref("r", "other-combo"),
m("z", "anthropic", "claude-2"),
];
const out = sortComboStepsSync(steps, "provider");
// combo-ref always last (no providerId).
assert.equal(out[out.length - 1].id, "r");
const nonRef = out.filter((s) => s.id !== "r").map((s) => s.id);
// all three model steps are present, and the two anthropic steps stay grouped.
assert.deepEqual(nonRef.slice().sort(), ["x", "y", "z"]);
const ai = nonRef.indexOf("x");
const zi = nonRef.indexOf("z");
assert.ok(Math.abs(ai - zi) === 1, "steps of the same provider are adjacent");
});
it("name sorts alphabetically with a stable tiebreak", () => {
const steps = [m("a", "openai", "zeta"), m("b", "openai", "alpha"), m("c", "openai", "alpha")];
const out = sortComboStepsSync(steps, "name");
assert.deepEqual(
out.map((s) => s.id),
["b", "c", "a"]
);
});
it("PROVIDER_ORDER is non-empty and stable", () => {
assert.ok(PROVIDER_ORDER.length > 0);
});
});
describe("score sort", () => {
it("sorts scored steps descending, unscored stable at end", async () => {
const steps = [
m("a", "openai", "gpt"), // score 90
m("b", "anthropic", "claude"), // no score
m("c", "google", "gemini"), // score 70
ref("r", "other"), // no providerId
];
const rankings = new Map<string, number>([
["openai", 90],
["google", 70],
]);
const out = await sortComboStepsByScore(steps, rankings);
assert.deepEqual(
out.map((s) => s.id),
["a", "c", "b", "r"]
);
});
it("reapplyCurrentSort applies score async and sync methods", async () => {
const steps = [m("a", "openai", "gpt"), m("b", "claude", "claude")];
const syncOut = await reapplyCurrentSort(steps, "provider");
assert.deepEqual(
syncOut.map((s) => s.id),
["b", "a"]
); // claude (anthropic) before openai
const rankOut = await reapplyCurrentSort(steps, "score", async () => new Map([["openai", 5]]));
assert.deepEqual(
rankOut.map((s) => s.id),
["a", "b"]
);
});
it("reapplyCurrentSort after an add keeps provider grouping", async () => {
const base = [m("a", "anthropic", "claude")];
const added = [...base, m("b", "openai", "gpt")];
const out = await reapplyCurrentSort(added, "provider");
// Expected order derived from PROVIDER_ORDER (robust to provider precedence).
const expected = ["a", "b"].sort((x, y) => {
const px = x === "a" ? "anthropic" : "openai";
const py = y === "a" ? "anthropic" : "openai";
return PROVIDER_ORDER.indexOf(px) - PROVIDER_ORDER.indexOf(py);
});
assert.deepEqual(
out.map((s) => s.id),
expected
);
});
});