fix(combos): align strategy contracts

open-sse/mcp-server/schemas/tools.ts

@@ -10,6 +10,10 @@
  */
 
 import { z } from "zod";
+import {
+  AUTO_ROUTING_STRATEGY_VALUES,
+  ROUTING_STRATEGY_VALUES,
+} from "../../../src/shared/constants/routingStrategies.ts";
 
 // ============ Shared Types ============
 
@@ -109,17 +113,7 @@ export const listCombosOutput = z.object({
           priority: z.number(),
         })
       ),
-      strategy: z.enum([
-        "priority",
-        "weighted",
-        "round-robin",
-        "context-relay",
-        "strict-random",
-        "random",
-        "least-used",
-        "cost-optimized",
-        "auto",
-      ]),
+      strategy: z.enum(ROUTING_STRATEGY_VALUES),
       enabled: z.boolean(),
       metrics: z
         .object({
@@ -545,20 +539,10 @@ export const setBudgetGuardTool: McpToolDefinition<
 export const setRoutingStrategyInput = z.object({
   comboId: z.string().describe("Combo ID or name to update"),
   strategy: z
-    .enum([
-      "priority",
-      "weighted",
-      "round-robin",
-      "context-relay",
-      "strict-random",
-      "random",
-      "least-used",
-      "cost-optimized",
-      "auto",
-    ])
+    .enum(ROUTING_STRATEGY_VALUES)
     .describe("Routing strategy to apply"),
   autoRoutingStrategy: z
-    .enum(["rules", "cost", "eco", "latency", "fast"])
+    .enum(AUTO_ROUTING_STRATEGY_VALUES)
     .optional()
     .describe("Optional strategy used by auto mode (only used when strategy='auto')"),
 });

open-sse/mcp-server/tools/advancedTools.ts

@@ -26,6 +26,11 @@ import {
   getComboModelString,
   getComboStepTarget,
 } from "../../../src/lib/combos/steps.ts";
+import type {
+  AutoRoutingStrategyValue,
+  RoutingStrategyValue,
+} from "../../../src/shared/constants/routingStrategies.ts";
+import { normalizeRoutingStrategy } from "../../../src/shared/constants/routingStrategies.ts";
 
 const OMNIROUTE_BASE_URL = resolveOmniRouteBaseUrl();
 const OMNIROUTE_API_KEY = process.env.OMNIROUTE_API_KEY || "";
@@ -372,17 +377,8 @@ export async function handleSetBudgetGuard(args: {
 
 export async function handleSetRoutingStrategy(args: {
   comboId: string;
-  strategy:
-    | "priority"
-    | "weighted"
-    | "round-robin"
-    | "context-relay"
-    | "strict-random"
-    | "random"
-    | "least-used"
-    | "cost-optimized"
-    | "auto";
-  autoRoutingStrategy?: "rules" | "cost" | "eco" | "latency" | "fast";
+  strategy: RoutingStrategyValue;
+  autoRoutingStrategy?: AutoRoutingStrategyValue;
 }) {
   const start = Date.now();
   try {
@@ -424,8 +420,9 @@ export async function handleSetRoutingStrategy(args: {
       Object.keys(toRecord(combo.config)).length > 0 ? combo.config : comboData.config
     );
 
+    const normalizedStrategy = normalizeRoutingStrategy(args.strategy);
     let nextConfig: JsonRecord | undefined = undefined;
-    if (args.strategy === "auto" && args.autoRoutingStrategy) {
+    if (normalizedStrategy === "auto" && args.autoRoutingStrategy) {
       const currentAutoConfig = toRecord(currentConfig.auto);
       nextConfig = {
         ...currentConfig,
@@ -436,7 +433,7 @@ export async function handleSetRoutingStrategy(args: {
       };
     }
 
-    const payload: JsonRecord = { strategy: args.strategy };
+    const payload: JsonRecord = { strategy: normalizedStrategy };
     if (nextConfig && Object.keys(nextConfig).length > 0) {
       payload.config = nextConfig;
     }
@@ -451,16 +448,16 @@ export async function handleSetRoutingStrategy(args: {
     const updatedConfig = toRecord(updatedCombo.config);
     const resolvedAutoStrategy =
       toString(toRecord(updatedConfig.auto).routingStrategy) ||
-      (args.strategy === "auto" ? (args.autoRoutingStrategy ?? "rules") : "");
+      (normalizedStrategy === "auto" ? (args.autoRoutingStrategy ?? "rules") : "");
 
     const result = {
       success: true,
       combo: {
         id: toString(updatedCombo.id, comboId),
         name: toString(updatedCombo.name, toString(combo.name, comboId)),
-        strategy: toString(updatedCombo.strategy, args.strategy),
+        strategy: toString(updatedCombo.strategy, normalizedStrategy),
         autoRoutingStrategy:
-          toString(updatedCombo.strategy, args.strategy) === "auto" ? resolvedAutoStrategy : null,
+          toString(updatedCombo.strategy, normalizedStrategy) === "auto" ? resolvedAutoStrategy : null,
       },
     };
 

open-sse/services/autoCombo/index.ts

@@ -17,11 +17,6 @@ export { SelfHealingManager, getSelfHealingManager } from "./selfHealing";
 export { MODE_PACKS, getModePack, getModePackNames } from "./modePacks";
 export {
   selectProvider,
-  createAutoCombo,
-  getAutoCombo,
-  updateAutoCombo,
-  deleteAutoCombo,
-  listAutoCombos,
   type AutoComboConfig,
   type SelectionResult,
 } from "./engine";

open-sse/services/combo.ts

@@ -48,6 +48,7 @@ import {
   resolveRequestRoutingTags,
   type RoutingTagMatchMode,
 } from "../../src/domain/tagRouter.ts";
+import { normalizeRoutingStrategy } from "../../src/shared/constants/routingStrategies.ts";
 
 // Status codes that should mark round-robin target semaphores as cooling down.
 const TRANSIENT_FOR_SEMAPHORE = [429, 502, 503, 504];
@@ -630,17 +631,25 @@ function sortTargetsByUsage(targets: ResolvedComboTarget[], comboName: string) {
  */
 function sortModelsByContextSize(models) {
   const withContext = models.map((modelStr) => {
-    const parsed = parseModel(modelStr);
-    const provider = parsed.provider || parsed.providerAlias || "unknown";
-    const model = parsed.model || modelStr;
-    const limit = getModelContextLimit(provider, model);
-    return { modelStr, context: limit ?? 0 };
+    return { modelStr, context: getModelContextLimitForModelString(modelStr) ?? 0 };
   });
   withContext.sort((a, b) => b.context - a.context);
   return withContext.map((e) => e.modelStr);
 }
 
+function getModelContextLimitForModelString(modelStr: string) {
+  const parsed = parseModel(modelStr);
+  const provider = parsed.provider || parsed.providerAlias || "unknown";
+  const model = parsed.model || modelStr;
+  return getModelContextLimit(provider, model);
+}
+
 function sortTargetsByContextSize(targets: ResolvedComboTarget[]) {
+  const hasKnownContext = targets.some(
+    (target) => getModelContextLimitForModelString(target.modelStr) != null
+  );
+  if (!hasKnownContext) return targets;
+
   const orderedModels = sortModelsByContextSize(targets.map((target) => target.modelStr));
   const byModel = new Map<string, ResolvedComboTarget[]>();
   for (const target of targets) {
@@ -656,6 +665,34 @@ function sortTargetsByContextSize(targets: ResolvedComboTarget[]) {
     .filter((target): target is ResolvedComboTarget => target !== null);
 }
 
+function getP2CTargetScore(target: ResolvedComboTarget, metrics: ReturnType<typeof getComboMetrics>): number {
+  const breakerState = getCircuitBreaker(target.provider)?.getStatus?.()?.state;
+  if (breakerState === "OPEN") return -Infinity;
+  const modelMetric = metrics?.byModel?.[target.modelStr] || null;
+  const successRate = Number(modelMetric?.successRate);
+  const avgLatency = Number(modelMetric?.avgLatencyMs);
+  const successScore = Number.isFinite(successRate) ? successRate / 100 : 0.5;
+  const latencyScore = Number.isFinite(avgLatency) && avgLatency > 0 ? 1 / Math.log10(avgLatency + 10) : 0.25;
+  const breakerPenalty = breakerState === "HALF_OPEN" ? 0.25 : 0;
+  return successScore + latencyScore - breakerPenalty;
+}
+
+function orderTargetsByPowerOfTwoChoices(targets: ResolvedComboTarget[], comboName: string) {
+  if (targets.length <= 1) return targets;
+  const metrics = getComboMetrics(comboName);
+  const firstIndex = Math.floor(Math.random() * targets.length);
+  let secondIndex = Math.floor(Math.random() * (targets.length - 1));
+  if (secondIndex >= firstIndex) secondIndex++;
+
+  const first = targets[firstIndex];
+  const second = targets[secondIndex];
+  const selectedIndex =
+    getP2CTargetScore(second, metrics) > getP2CTargetScore(first, metrics)
+      ? secondIndex
+      : firstIndex;
+  return [targets[selectedIndex], ...targets.filter((_, index) => index !== selectedIndex)];
+}
+
 function toTextContent(content) {
   if (typeof content === "string") return content;
   if (!Array.isArray(content)) return "";
@@ -1034,7 +1071,7 @@ export async function handleComboChat({
   relayOptions,
   signal,
 }) {
-  const strategy = combo.strategy || "priority";
+  const strategy = normalizeRoutingStrategy(combo.strategy || "priority");
   const relayConfig =
     strategy === "context-relay" ? resolveContextRelayConfig(relayOptions?.config || null) : null;
 
@@ -1427,6 +1464,11 @@ export async function handleComboChat({
   } else if (strategy === "random") {
     orderedTargets = fisherYatesShuffle([...orderedTargets]);
     log.info("COMBO", `Random shuffle: ${orderedTargets.length} targets`);
+  } else if (strategy === "fill-first") {
+    log.info("COMBO", `Fill-first ordering: preserving priority order (${orderedTargets.length} targets)`);
+  } else if (strategy === "p2c") {
+    orderedTargets = orderTargetsByPowerOfTwoChoices(orderedTargets, combo.name);
+    log.info("COMBO", `Power-of-two-choices ordering: selected ${orderedTargets[0]?.modelStr}`);
   } else if (strategy === "least-used") {
     orderedTargets = sortTargetsByUsage(orderedTargets, combo.name);
     log.info("COMBO", `Least-used ordering: ${orderedTargets[0]?.modelStr} has fewest requests`);

src/app/(dashboard)/dashboard/settings/components/ComboDefaultsTab.tsx

@@ -3,7 +3,10 @@
 import { useState, useEffect } from "react";
 import { Card, Button, Input, Toggle } from "@/shared/components";
 import { cn } from "@/shared/utils/cn";
-import { ROUTING_STRATEGIES } from "@/shared/constants/routingStrategies";
+import {
+  ROUTING_STRATEGIES,
+  SETTINGS_FALLBACK_STRATEGY_VALUES,
+} from "@/shared/constants/routingStrategies";
 import { useTranslations } from "next-intl";
 
 const STRATEGY_LABEL_FALLBACKS: Record<string, string> = {
@@ -15,6 +18,7 @@ const LEGACY_COMBO_RESILIENCE_KEYS = new Set([
   "healthCheckEnabled",
   "healthCheckTimeoutMs",
 ]);
+const ACCOUNT_FALLBACK_STRATEGIES = new Set<string>(SETTINGS_FALLBACK_STRATEGY_VALUES);
 
 function translateOrFallback(
   t: ReturnType<typeof useTranslations>,
@@ -44,6 +48,17 @@ function sanitizeProviderOverrides(overrides?: Record<string, any> | null) {
   );
 }
 
+function toGlobalRoutingPatch(strategy: string | undefined, stickyRoundRobinLimit?: number) {
+  const patch: Record<string, unknown> = {};
+  if (strategy && ACCOUNT_FALLBACK_STRATEGIES.has(strategy)) {
+    patch.fallbackStrategy = strategy;
+  }
+  if (strategy === "round-robin" && stickyRoundRobinLimit !== undefined) {
+    patch.stickyRoundRobinLimit = stickyRoundRobinLimit;
+  }
+  return patch;
+}
+
 export default function ComboDefaultsTab() {
   const [comboDefaults, setComboDefaults] = useState<any>({
     strategy: "priority",
@@ -89,8 +104,7 @@ export default function ComboDefaultsTab() {
         setComboDefaults((prev) => ({
           ...prev,
           ...sanitizeComboRuntimeConfig(comboData.comboDefaults),
-          strategy:
-            settingsData.fallbackStrategy ?? comboData.comboDefaults?.strategy ?? prev.strategy,
+          strategy: comboData.comboDefaults?.strategy ?? settingsData.fallbackStrategy ?? prev.strategy,
           stickyRoundRobinLimit:
             settingsData.stickyRoundRobinLimit ??
             comboData.comboDefaults?.stickyRoundRobinLimit ??
@@ -109,8 +123,7 @@ export default function ComboDefaultsTab() {
   };
 
   const syncGlobalRoutingSettings = async (patch: Record<string, unknown>) => {
-    const keys = Object.keys(patch);
-    if (keys.length === 0) return true;
+    if (Object.keys(patch).length === 0) return;
 
     const res = await fetch("/api/settings", {
       method: "PATCH",
@@ -121,21 +134,13 @@ export default function ComboDefaultsTab() {
     if (!res.ok) {
       throw new Error("Failed to sync global routing settings");
     }
-
-    return true;
   };
 
   const saveComboDefaults = async () => {
     setSaving(true);
     try {
       const { stickyRoundRobinLimit, ...comboDefaultsPayload } = comboDefaults;
-      const settingsPatch: Record<string, unknown> = {};
-      if (comboDefaults.strategy) {
-        settingsPatch.fallbackStrategy = comboDefaults.strategy;
-      }
-      if (comboDefaults.strategy === "round-robin" && stickyRoundRobinLimit !== undefined) {
-        settingsPatch.stickyRoundRobinLimit = stickyRoundRobinLimit;
-      }
+      const settingsPatch = toGlobalRoutingPatch(comboDefaults.strategy, stickyRoundRobinLimit);
 
       const comboDefaultsRes = await fetch("/api/settings/combo-defaults", {
         method: "PATCH",
@@ -243,7 +248,7 @@ export default function ComboDefaultsTab() {
                 onClick={async () => {
                   setComboDefaults((prev) => ({ ...prev, strategy: s.value }));
                   try {
-                    await syncGlobalRoutingSettings({ fallbackStrategy: s.value });
+                    await syncGlobalRoutingSettings(toGlobalRoutingPatch(s.value));
                   } catch (error) {
                     console.error("Failed to sync fallback strategy:", error);
                     showStatus("error", t("errorOccurred"));

src/lib/db/jsonMigration.ts

@@ -12,6 +12,7 @@
  */
 
 import type Database from "better-sqlite3";
+import { normalizeRoutingStrategy } from "@/shared/constants/routingStrategies";
 
 type SqliteDatabase = InstanceType<typeof Database>;
 
@@ -172,8 +173,19 @@ export function runJsonMigration(
 
     // 5. Combos
     for (const [index, combo] of (data.combos ?? []).entries()) {
-      const normalizedCombo = {
+      const config =
+        combo.config && typeof combo.config === "object" && !Array.isArray(combo.config)
+          ? { ...(combo.config as Record<string, unknown>) }
+          : combo.config;
+      if (config && typeof config === "object" && !Array.isArray(config) && "strategy" in config) {
+        (config as Record<string, unknown>).strategy = normalizeRoutingStrategy(
+          (config as Record<string, unknown>).strategy
+        );
+      }
+      const normalizedCombo: Record<string, unknown> = {
         ...combo,
+        strategy: normalizeRoutingStrategy(combo.strategy),
+        config,
         sortOrder: typeof combo.sortOrder === "number" ? combo.sortOrder : index + 1,
       };
       insertCombo.run({