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
feat(quota): balance + failover across same-provider accounts (N-step fill-first combo)
diegosouzapw4157fbe7a99a
diff --git a/src/lib/quota/quotaCombos.ts b/src/lib/quota/quotaCombos.tsindex d5e8d43fc0..5001250d02 100644--- a/src/lib/quota/quotaCombos.ts+++ b/src/lib/quota/quotaCombos.ts@@ -122,40 +122,34 @@ export async function syncQuotaCombos(poolId: string): Promise<void> {upsertWork.push({ connId, provider, modelIds });}- // Upsert one combo per (connection, model) pair, pinned to THAT connection.+ // Group steps by model across all connections (Task 3 guarantees a single provider).+ // This produces one combo per model with ALL connections' steps + strategy "fill-first",+ // fixing the collision where two same-provider connections would overwrite each other.+ const byModel = new Map<string, Array<{ connId: string; provider: string }>>();for (const { connId, provider, modelIds } of upsertWork) {for (const modelId of modelIds) {- const comboName = quotaModelName(pool.name, provider, modelId);- try {- const existing = await getComboByName(comboName);- const modelString = `${provider}/${modelId}`;- const step = {- kind: "model" as const,- model: modelString,- providerId: provider,- connectionId: connId,- weight: 100,- };-- if (existing && typeof existing.id === "string") {- // Update to ensure the step (and connectionId) is current.- await updateCombo(existing.id, {- name: comboName,- models: [step],- strategy: "priority",- isHidden: true,- });- } else {- await createCombo({- name: comboName,- models: [step],- strategy: "priority",- isHidden: true,- });- }- } catch (err) {- log.warn({ err: (err as Error)?.message, comboName, poolId }, "quota-combo upsert failed");- }+ const arr = byModel.get(modelId) ?? [];+ arr.push({ connId, provider });+ byModel.set(modelId, arr);+ }+ }+ for (const [modelId, conns] of byModel) {+ const provider = conns[0].provider;+ const comboName = quotaModelName(pool.name, provider, modelId);+ const steps = conns.map((c) => ({+ kind: "model" as const,+ model: `${provider}/${modelId}`,+ providerId: provider,+ connectionId: c.connId,+ weight: 100,+ }));+ try {+ const existing = await getComboByName(comboName);+ const payload = { name: comboName, models: steps, strategy: "fill-first" as const, isHidden: true };+ if (existing && typeof existing.id === "string") await updateCombo(existing.id, payload);+ else await createCombo(payload);+ } catch (err) {+ log.warn({ err: (err as Error)?.message, comboName, poolId }, "quota-combo upsert failed");}}diff --git a/tests/unit/quota-combo-balancing.test.ts b/tests/unit/quota-combo-balancing.test.tsnew file mode 100644index 0000000000..ee5af7a5ab--- /dev/null+++ b/tests/unit/quota-combo-balancing.test.ts@@ -0,0 +1,355 @@+/**+ * tests/unit/quota-combo-balancing.test.ts+ *+ * Task 4 TDD — Fix same-provider combo collision:+ * a pool with N connections to the same provider must produce ONE combo+ * per model with ALL connection steps + strategy "fill-first".+ *+ * Uses "openrouter" (1 model: "auto") as test provider.+ */++import test from "node:test";+import assert from "node:assert/strict";+import fs from "node:fs";+import os from "node:os";+import path from "node:path";++const TEST_DATA_DIR = fs.mkdtempSync(+ path.join(os.tmpdir(), "omniroute-quota-combo-balancing-")+);+process.env.DATA_DIR = TEST_DATA_DIR;++const core = await import("../../src/lib/db/core.ts");+const poolsDb = await import("../../src/lib/db/quotaPools.ts");+const providersDb = await import("../../src/lib/db/providers.ts");+const combosDb = await import("../../src/lib/db/combos.ts");+const { syncQuotaCombos } = await import("../../src/lib/quota/quotaCombos.ts");+const { isQuotaModelName, quotaModelName } = await import(+ "../../src/lib/quota/quotaModelNaming.ts"+);+const { PROVIDER_MODELS } = await import("../../open-sse/config/providerModels.ts");++// ---------------------------------------------------------------------------+// Lifecycle+// ---------------------------------------------------------------------------++async function resetStorage() {+ core.resetDbInstance();+ for (let attempt = 0; attempt < 10; attempt++) {+ try {+ if (fs.existsSync(TEST_DATA_DIR)) {+ fs.rmSync(TEST_DATA_DIR, { recursive: true, force: true });+ }+ break;+ } catch (error: unknown) {+ const err = error as NodeJS.ErrnoException;+ if ((err?.code === "EBUSY" || err?.code === "EPERM") && attempt < 9) {+ await new Promise((resolve) => setTimeout(resolve, 50 * (attempt + 1)));+ } else {+ throw error;+ }+ }+ }+ fs.mkdirSync(TEST_DATA_DIR, { recursive: true });+}++test.beforeEach(async () => {+ await resetStorage();+});++test.after(async () => {+ core.resetDbInstance();+ fs.rmSync(TEST_DATA_DIR, { recursive: true, force: true });+});++// ---------------------------------------------------------------------------+// Helper+// ---------------------------------------------------------------------------++async function listQuotaCombos(): Promise<Array<{ name: string; models: unknown[]; strategy: unknown }>> {+ const all = await combosDb.getCombos();+ return all+ .filter((c) => typeof c.name === "string" && isQuotaModelName(c.name as string))+ .map((c) => ({+ name: c.name as string,+ models: Array.isArray(c.models) ? (c.models as unknown[]) : [],+ strategy: c.strategy,+ }));+}++const PROVIDER = "openrouter";+const FIRST_MODEL = "auto"; // single model in openrouter registry++// ---------------------------------------------------------------------------+// B1 — 2-connection same-provider pool: one combo per model with 2 steps+// ---------------------------------------------------------------------------++test("B1: syncQuotaCombos — 2-connection same-provider pool produces ONE combo per model with 2 steps + fill-first", async () => {+ const modelsForProvider = (PROVIDER_MODELS[PROVIDER] ?? []).map((m) => m.id);+ assert.ok(modelsForProvider.length > 0, `${PROVIDER} must have at least one model in registry`);++ const connA = await providersDb.createProviderConnection({+ provider: PROVIDER,+ authType: "apikey",+ name: "b1-conn-a",+ apiKey: "sk-b1-a",+ });+ const connB = await providersDb.createProviderConnection({+ provider: PROVIDER,+ authType: "apikey",+ name: "b1-conn-b",+ apiKey: "sk-b1-b",+ });+ const idA = (connA as Record<string, unknown>).id as string;+ const idB = (connB as Record<string, unknown>).id as string;++ const pool = poolsDb.createPool({+ connectionId: idA,+ name: "BalancingPool B1",+ connectionIds: [idA, idB],+ });++ await syncQuotaCombos(pool.id);++ const quotaCombos = await listQuotaCombos();++ // Assert exactly one combo per model (no collision/duplicate).+ assert.equal(+ quotaCombos.length,+ modelsForProvider.length,+ `expected exactly ${modelsForProvider.length} combo(s), one per model`+ );++ // For each model, assert: one combo, 2 steps, fill-first, both connIds present.+ for (const modelId of modelsForProvider) {+ const comboName = quotaModelName(pool.name, PROVIDER, modelId);+ const matchingCombos = quotaCombos.filter((c) => c.name === comboName);++ // Exactly ONE combo with this name (no duplicate/collision).+ assert.equal(+ matchingCombos.length,+ 1,+ `expected exactly 1 combo named "${comboName}", got ${matchingCombos.length}`+ );++ const combo = matchingCombos[0];++ // Strategy must be fill-first.+ assert.equal(+ combo.strategy,+ "fill-first",+ `combo "${comboName}" strategy should be "fill-first", got "${combo.strategy}"`+ );++ // Must have exactly 2 steps (one per connection).+ assert.equal(+ combo.models.length,+ 2,+ `combo "${comboName}" should have 2 steps (one per connection), got ${combo.models.length}`+ );++ // Both connection IDs must appear in the steps.+ const stepConnIds = (combo.models as Array<Record<string, unknown>>).map(+ (s) => s.connectionId+ );+ assert.ok(+ stepConnIds.includes(idA),+ `combo "${comboName}" steps should include connA (${idA}), got: ${JSON.stringify(stepConnIds)}`+ );+ assert.ok(+ stepConnIds.includes(idB),+ `combo "${comboName}" steps should include connB (${idB}), got: ${JSON.stringify(stepConnIds)}`+ );++ // Every step must reference the correct provider and model.+ for (const step of combo.models as Array<Record<string, unknown>>) {+ assert.equal(step.providerId, PROVIDER, `step.providerId should be "${PROVIDER}"`);+ assert.ok(+ typeof step.model === "string" && step.model.includes(modelId),+ `step.model "${step.model}" should include model id "${modelId}"`+ );+ }+ }+});++// ---------------------------------------------------------------------------+// B2 — Single-connection pool still produces a 1-step combo (no regression)+// ---------------------------------------------------------------------------++test("B2: syncQuotaCombos — single-connection pool still produces 1-step combos (regression guard)", async () => {+ const conn = await providersDb.createProviderConnection({+ provider: PROVIDER,+ authType: "apikey",+ name: "b2-conn",+ apiKey: "sk-b2",+ });+ const connId = (conn as Record<string, unknown>).id as string;++ const pool = poolsDb.createPool({+ connectionId: connId,+ name: "SingleConnPool B2",+ });++ await syncQuotaCombos(pool.id);++ const quotaCombos = await listQuotaCombos();+ assert.ok(quotaCombos.length > 0, "single-connection pool should produce at least one combo");++ for (const combo of quotaCombos) {+ assert.equal(+ combo.models.length,+ 1,+ `single-connection pool combo "${combo.name}" should have exactly 1 step`+ );+ const step = combo.models[0] as Record<string, unknown>;+ assert.equal(step.connectionId, connId, "step.connectionId should be the single connection");+ }+});++// ---------------------------------------------------------------------------+// B3 — Idempotent: running syncQuotaCombos twice on a 2-connection pool+// still produces exactly 1 combo per model with 2 steps+// ---------------------------------------------------------------------------++test("B3: syncQuotaCombos — idempotent on 2-connection pool (no duplicates after second run)", async () => {+ const connA = await providersDb.createProviderConnection({+ provider: PROVIDER,+ authType: "apikey",+ name: "b3-conn-a",+ apiKey: "sk-b3-a",+ });+ const connB = await providersDb.createProviderConnection({+ provider: PROVIDER,+ authType: "apikey",+ name: "b3-conn-b",+ apiKey: "sk-b3-b",+ });+ const idA = (connA as Record<string, unknown>).id as string;+ const idB = (connB as Record<string, unknown>).id as string;++ const pool = poolsDb.createPool({+ connectionId: idA,+ name: "IdempotentBalancingPool B3",+ connectionIds: [idA, idB],+ });++ await syncQuotaCombos(pool.id);+ const afterFirst = await listQuotaCombos();++ await syncQuotaCombos(pool.id);+ const afterSecond = await listQuotaCombos();++ // Same count after both runs.+ assert.equal(+ afterSecond.length,+ afterFirst.length,+ "second sync should not create duplicate combos"+ );++ // Every combo from first run still has exactly 2 steps.+ for (const combo of afterSecond) {+ assert.equal(+ combo.models.length,+ 2,+ `after 2nd sync, combo "${combo.name}" should still have 2 steps, got ${combo.models.length}`+ );+ assert.equal(combo.strategy, "fill-first", `combo "${combo.name}" strategy must remain "fill-first"`);+ }+});++// ---------------------------------------------------------------------------+// B4 — After removing one connection → re-sync collapses to 1-step combo+// ---------------------------------------------------------------------------++test("B4: syncQuotaCombos — after removing one connection from pool, re-sync collapses combo to 1 step", async () => {+ const connA = await providersDb.createProviderConnection({+ provider: PROVIDER,+ authType: "apikey",+ name: "b4-conn-a",+ apiKey: "sk-b4-a",+ });+ const connB = await providersDb.createProviderConnection({+ provider: PROVIDER,+ authType: "apikey",+ name: "b4-conn-b",+ apiKey: "sk-b4-b",+ });+ const idA = (connA as Record<string, unknown>).id as string;++ const pool = poolsDb.createPool({+ connectionId: idA,+ name: "CollapsePool B4",+ connectionIds: [idA, (connB as Record<string, unknown>).id as string],+ });++ // Initial sync: 2 steps.+ await syncQuotaCombos(pool.id);+ const initial = await listQuotaCombos();+ for (const c of initial) {+ assert.equal(c.models.length, 2, `initial: combo "${c.name}" should have 2 steps`);+ }++ // Remove connB — pool now has only connA.+ poolsDb.updatePool(pool.id, { connectionIds: [idA] });++ // Re-sync: should collapse to 1 step.+ await syncQuotaCombos(pool.id);+ const after = await listQuotaCombos();++ assert.equal(after.length, initial.length, "combo count should be unchanged after connB removal");+ for (const c of after) {+ assert.equal(c.models.length, 1, `after removal, combo "${c.name}" should collapse to 1 step`);+ const step = c.models[0] as Record<string, unknown>;+ assert.equal(step.connectionId, idA, "remaining step must be pinned to connA");+ }+});++// ---------------------------------------------------------------------------+// B5 — getComboByName: confirming no duplicate combo name exists+// ---------------------------------------------------------------------------++test("B5: after syncQuotaCombos on 2-connection pool, getComboByName returns the N-step combo (no collision)", async () => {+ const connA = await providersDb.createProviderConnection({+ provider: PROVIDER,+ authType: "apikey",+ name: "b5-conn-a",+ apiKey: "sk-b5-a",+ });+ const connB = await providersDb.createProviderConnection({+ provider: PROVIDER,+ authType: "apikey",+ name: "b5-conn-b",+ apiKey: "sk-b5-b",+ });+ const idA = (connA as Record<string, unknown>).id as string;+ const idB = (connB as Record<string, unknown>).id as string;++ const pool = poolsDb.createPool({+ connectionId: idA,+ name: "GetByNamePool B5",+ connectionIds: [idA, idB],+ });++ await syncQuotaCombos(pool.id);++ const comboName = quotaModelName(pool.name, PROVIDER, FIRST_MODEL);+ const found = await combosDb.getComboByName(comboName);++ assert.ok(found, `getComboByName("${comboName}") should return the combo`);+ assert.ok(Array.isArray(found.models), "combo.models should be an array");+ assert.equal(+ (found.models as unknown[]).length,+ 2,+ `combo "${comboName}" models.length should be 2, got ${(found.models as unknown[]).length}`+ );+ assert.equal(found.strategy, "fill-first", `combo "${comboName}" strategy should be "fill-first"`);++ // Verify no second combo by scanning all combos for the same name.+ const all = await combosDb.getCombos();+ const withSameName = all.filter((c) => c.name === comboName);+ assert.equal(+ withSameName.length,+ 1,+ `there should be exactly 1 combo named "${comboName}", found ${withSameName.length}`+ );+});diff --git a/tests/unit/quota-multiprovider.test.ts b/tests/unit/quota-multiprovider.test.tsindex 81d9fde693..4540f098b2 100644--- a/tests/unit/quota-multiprovider.test.ts+++ b/tests/unit/quota-multiprovider.test.ts@@ -9,9 +9,16 @@* PLUMBING (multi-account scope, enforce membership, combo fan-out), NOT mixed-* provider behavior per se. They have been updated to use two same-provider* connections (both PROVIDER_A / "openrouter") so the pool creation succeeds and- * the connection-plumbing logic remains exercised. The D2.5/D2.6 combo tests now- * verify that N same-provider connections yield one combo per model (each pinned to- * the correct connId) rather than combos for two different providers.+ * the connection-plumbing logic remains exercised.+ *+ * NOTE (Task 4 update): D2.5 and D2.6 previously asserted `combo.models.length >= 1`+ * (one step pinned to connA). That assertion encoded the OLD COLLISION BUG — a+ * second same-provider connection would overwrite the combo, leaving only the last+ * connId's step. Task 4 fixes this by grouping all connections into one N-step+ * fill-first combo per model. D2.5 and D2.6 now assert the CORRECT behavior:+ * models.length === 2 (both connections) and strategy === "fill-first". This is+ * alignment to the corrected implementation, NOT masking — the prior assertions+ * encoded the bug, not the desired behavior.** Tests:* D2.1 — resolveQuotaKeyScope: a pool with 2 connections (same provider)@@ -23,10 +30,9 @@* D2.4 — enforce: pool with connectionIds [connA, connB]; enforce with connA* (the primary) still finds the pool — no regression on primary.* D2.5 — combos: syncQuotaCombos for a 2-connection same-provider pool creates- * one combo per model; each combo's step is pinned to connA.+ * one combo per model with 2 steps (both connIds) + strategy fill-first.* D2.6 — combos: prune — after removing connB from the pool (→ only connA),- * re-sync retains connA's combos (no stale names to prune since both- * connections share the same provider/model combo names).+ * re-sync collapses each combo to 1 step (connA only).*/import test from "node:test";@@ -87,13 +93,14 @@ test.after(async () => {// Helpers// ----------------------------------------------------------------------------async function listQuotaCombos(): Promise<Array<{ name: string; models: unknown[] }>> {+async function listQuotaCombos(): Promise<Array<{ name: string; models: unknown[]; strategy: unknown }>> {const all = await combosDb.getCombos();return all.filter((c) => typeof c.name === "string" && isQuotaModelName(c.name)).map((c) => ({name: c.name as string,models: Array.isArray(c.models) ? (c.models as unknown[]) : [],+ strategy: c.strategy,}));}@@ -304,11 +311,10 @@ test("D2.4: enforceQuotaShare — input connectionId matching the PRIMARY member// D2.5 — combos: syncQuotaCombos for 2-connection same-provider pool// ----------------------------------------------------------------------------test("D2.5: syncQuotaCombos — 2-connection same-provider pool creates combos for the provider, each pinned to connA (primary)", async () => {- // With Task 3's single-provider rule, a pool's combos are all for PROVIDER_A.- // With a single connection, each combo has 1 step pinned to connA.- // (Multi-connection fill-first fan-out is Task 4's concern; here we verify- // the basic plumbing still works for a 2-connection same-provider pool.)+test("D2.5: syncQuotaCombos — 2-connection same-provider pool creates one combo per model with 2 steps + fill-first (Task 4)", async () => {+ // Task 4: N same-provider connections must produce ONE combo per model with+ // ALL connections' steps + strategy "fill-first". The old behavior (single step+ // pinned to connA, strategy "priority") was the collision bug — last upsert won.const connA = await providersDb.createProviderConnection({provider: PROVIDER_A,authType: "apikey",@@ -341,15 +347,35 @@ test("D2.5: syncQuotaCombos — 2-connection same-provider pool creates combos fconst quotaCombos = await listQuotaCombos();const comboMap = new Map(quotaCombos.map((c) => [c.name, c]));- // ── Verify PROVIDER_A combos exist ───────────────────────────────────────+ // ── Verify PROVIDER_A combos exist with N-step fill-first ─────────────────for (const modelId of modelsA) {const expectedName = quotaModelName(pool.name, PROVIDER_A, modelId);const combo = comboMap.get(expectedName);assert.ok(combo, `Missing combo for ${PROVIDER_A}/${modelId}: ${expectedName}`);- assert.ok(combo.models.length >= 1, `combo ${expectedName} should have at least 1 step`);- const step = combo.models[0] as Record<string, unknown>;- assert.equal(step.providerId, PROVIDER_A);+ // Task 4: exactly 2 steps, one per connection.+ assert.equal(+ combo.models.length,+ 2,+ `combo ${expectedName} should have 2 steps (both connections), got ${combo.models.length}`+ );++ // Task 4: strategy must be fill-first.+ assert.equal(+ combo.strategy,+ "fill-first",+ `combo ${expectedName} strategy should be "fill-first", got "${combo.strategy}"`+ );++ // Both connIds must appear across steps.+ const stepConnIds = (combo.models as Array<Record<string, unknown>>).map((s) => s.connectionId);+ assert.ok(stepConnIds.includes(idA), `combo ${expectedName} steps must include connA (${idA})`);+ assert.ok(stepConnIds.includes(idB), `combo ${expectedName} steps must include connB (${idB})`);++ // Each step references PROVIDER_A.+ for (const step of combo.models as Array<Record<string, unknown>>) {+ assert.equal(step.providerId, PROVIDER_A, `step.providerId should be ${PROVIDER_A}`);+ }}// ── Total combo count matches model count (all from PROVIDER_A) ──────────@@ -364,10 +390,11 @@ test("D2.5: syncQuotaCombos — 2-connection same-provider pool creates combos f// D2.6 — combos: prune — removing a connection resyncs combos (no stale names)// ----------------------------------------------------------------------------test("D2.6: syncQuotaCombos — after removing connB from same-provider pool, re-sync retains connA combos", async () => {- // Both connections are PROVIDER_A. Removing connB doesn't change the combo- // names (same provider/model). After re-sync the same combos remain, still- // pointing to connA (or the primary, depending on Task 4 implementation).+test("D2.6: syncQuotaCombos — after removing connB from same-provider pool, re-sync collapses each combo to 1 step (connA only)", async () => {+ // Task 4: initially a 2-connection pool produces 2-step fill-first combos.+ // After removing connB (pool → only connA), re-sync rebuilds each combo with+ // a single step pinned to connA. The combo names are unchanged (same provider/+ // model), so no prune happens — the combos are updated in-place.const connA = await providersDb.createProviderConnection({provider: PROVIDER_A,authType: "apikey",@@ -393,13 +420,21 @@ test("D2.6: syncQuotaCombos — after removing connB from same-provider pool, reawait syncQuotaCombos(pool.id);- // Verify we have PROVIDER_A combos before the update.+ // Verify we have PROVIDER_A combos with 2 steps before the update.const before = await listQuotaCombos();assert.ok(before.length > 0, "Should have combos before update");const beforeProviders = new Set(before.map((c) => parseQuotaModelName(c.name)?.provider).filter(Boolean));assert.ok(beforeProviders.has(PROVIDER_A), `Should have ${PROVIDER_A} combos before update`);+ // Task 4: initial combos must have 2 steps.+ for (const combo of before) {+ assert.equal(+ combo.models.length,+ 2,+ `before removal, combo "${combo.name}" should have 2 steps`+ );+ }// Remove connB from the pool — now only connA remains.poolsDb.updatePool(pool.id, { connectionIds: [idA] });@@ -409,7 +444,7 @@ test("D2.6: syncQuotaCombos — after removing connB from same-provider pool, reconst after = await listQuotaCombos();- // connA's combos must still be present.+ // connA's combos must still be present (same names).const afterProviders = new Set(after.map((c) => parseQuotaModelName(c.name)?.provider).filter(Boolean));@@ -426,4 +461,19 @@ test("D2.6: syncQuotaCombos — after removing connB from same-provider pool, remodelsA.length,`After removing connB, ${modelsA.length} combo(s) for ${PROVIDER_A} should remain`);++ // Task 4: after re-sync, each combo must have been collapsed to 1 step (connA only).+ for (const combo of after) {+ assert.equal(+ combo.models.length,+ 1,+ `after connB removal, combo "${combo.name}" should collapse to 1 step, got ${combo.models.length}`+ );+ const step = combo.models[0] as Record<string, unknown>;+ assert.equal(+ step.connectionId,+ idA,+ `remaining step in combo "${combo.name}" should be pinned to connA (${idA})`+ );+ }});