fix(combo): restore routing module load

changelog.d/fixes/release-v3850-combo-module-load.md

@@ -0,0 +1 @@
+- Restore combo routing module loading by removing a duplicate compatibility constant and an unresolved Antigravity helper import.

open-sse/services/combo/comboStructure.ts

@@ -615,6 +615,12 @@ export type CompatFilterOptions = {
   failOpen?: boolean;
 };
 
+
+function hasHardCapabilityFailure(reasons: string[]): boolean {
+  return reasons.some((reason) => HARD_COMPAT_REASONS.has(reason));
+}
+
+
 /**
  * Summarize a capability-filter exhaustion for a 400-class combo error (#8488).
  * Returns null when the empty pool is not attributable to hard requirements.

open-sse/services/combo/quotaStrategies.ts

@@ -19,7 +19,6 @@
  * (D7a) so reset-aware tie rotation stays consistent with round-robin routing.
  *
  * @changes
- * - [2026-07-24] [Composer] - Exclude Antigravity accounts without stored projectId from reset-aware pool
  * - [2026-07-24] [Composer] - Skip quota-exhausted and rate-limited connections in reset-aware expansion
  *
  * Pure leaf: this module never imports from the combo barrel.
@@ -85,14 +84,9 @@ async function getQuotaAwareConnectionsForTarget(
         (async () => {
           try {
             const connections = await getCachedProviderConnections({ provider, isActive: true });
-            let activeConnections = Array.isArray(connections)
+            const activeConnections = Array.isArray(connections)
               ? (connections as Array<Record<string, unknown>>)
               : [];
-            if (provider === "antigravity" || provider === "agy") {
-              activeConnections = preferAntigravityConnectionsWithStoredProject(
-                activeConnections
-              ) as Array<Record<string, unknown>>;
-            }
             if (
               !resetAwareConnectionCache.has(provider) &&
               resetAwareConnectionCache.size >= MAX_RESET_AWARE_CACHE

tests/unit/combo-context-window-filter.test.ts

@@ -192,6 +192,26 @@ test("all known-too-small context targets still fall back to strategy order", ()
   );
 });
 
+test("output-token limits remain a hard compatibility requirement", () => {
+  saveModelsDevCapabilities({
+    "unit-output-limit": {
+      insufficient: capabilityEntryWithLimits(128_000, 128_000, 128),
+      sufficient: capabilityEntryWithLimits(128_000, 128_000, 4_096),
+    },
+  });
+
+  const out = filterTargetsByRequestCompatibility(
+    [target("unit-output-limit/insufficient"), target("unit-output-limit/sufficient")],
+    { messages: [{ role: "user", content: "hello" }], max_tokens: 512 },
+    noopLog
+  );
+
+  assert.deepEqual(
+    out.map((entry) => entry.modelStr),
+    ["unit-output-limit/sufficient"]
+  );
+});
+
 test("known context overflow reports the largest target limit", () => {
   saveModelsDevCapabilities({
     "unit-known-context": {
@@ -415,8 +435,8 @@ test("without an override the small-catalog target is ordered last for the large
       capped: capabilityEntry(8_000),
     },
   });
-  // No override: capped (8K) is genuinely too small and must be filtered out,
-  // guarding the override read-path from masking a real too-small target.
+  // No override: capped (8K) is catalog-too-small, so it stays behind the
+  // known-compatible target while remaining available as a runtime fallback.
   const out = filterTargetsByRequestCompatibility(
     [target("unit-override/capped"), target("unit-override/big")],
     largeContextBody(),

tests/unit/combo-module-load-basered.test.ts

@@ -0,0 +1,9 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+test("combo routing module loads without unresolved symbols", async () => {
+  const combo = await import("../../open-sse/services/combo.ts");
+
+  assert.equal(typeof combo.filterTargetsByRequestCompatibility, "function");
+  assert.equal(typeof combo.handleComboChat, "function");
+});