Unify dynamic fallback chains for background subagents

src/shared/fallback-chain-from-models.test.ts

@@ -0,0 +1,48 @@
+import { describe, test, expect } from "bun:test"
+import { buildFallbackChainFromModels, parseFallbackModelEntry } from "./fallback-chain-from-models"
+
+describe("fallback-chain-from-models", () => {
+  test("parses provider/model entry with parenthesized variant", () => {
+    //#given
+    const fallbackModel = "openai/gpt-5.2(high)"
+
+    //#when
+    const parsed = parseFallbackModelEntry(fallbackModel, "quotio")
+
+    //#then
+    expect(parsed).toEqual({
+      providers: ["openai"],
+      model: "gpt-5.2",
+      variant: "high",
+    })
+  })
+
+  test("uses default provider when fallback model omits provider prefix", () => {
+    //#given
+    const fallbackModel = "glm-5"
+
+    //#when
+    const parsed = parseFallbackModelEntry(fallbackModel, "quotio")
+
+    //#then
+    expect(parsed).toEqual({
+      providers: ["quotio"],
+      model: "glm-5",
+      variant: undefined,
+    })
+  })
+
+  test("builds fallback chain from normalized fallback_models input", () => {
+    //#given
+    const fallbackModels = ["quotio/kimi-k2.5", "gpt-5.2 medium"]
+
+    //#when
+    const chain = buildFallbackChainFromModels(fallbackModels, "quotio")
+
+    //#then
+    expect(chain).toEqual([
+      { providers: ["quotio"], model: "kimi-k2.5", variant: undefined },
+      { providers: ["quotio"], model: "gpt-5.2", variant: "medium" },
+    ])
+  })
+})

src/shared/fallback-chain-from-models.ts

@@ -0,0 +1,75 @@
+import type { FallbackEntry } from "./model-requirements"
+import { normalizeFallbackModels } from "./model-resolver"
+
+const KNOWN_VARIANTS = new Set([
+  "low",
+  "medium",
+  "high",
+  "xhigh",
+  "max",
+  "none",
+  "auto",
+  "thinking",
+])
+
+function parseVariantFromModel(rawModel: string): { modelID: string; variant?: string } {
+  const trimmedModel = rawModel.trim()
+  if (!trimmedModel) {
+    return { modelID: "" }
+  }
+
+  const parenthesizedVariant = trimmedModel.match(/^(.*)\(([^()]+)\)\s*$/)
+  if (parenthesizedVariant) {
+    const modelID = parenthesizedVariant[1]?.trim() ?? ""
+    const variant = parenthesizedVariant[2]?.trim()
+    return variant ? { modelID, variant } : { modelID }
+  }
+
+  const spaceVariant = trimmedModel.match(/^(.*\S)\s+([a-z][a-z0-9_-]*)$/i)
+  if (spaceVariant) {
+    const modelID = spaceVariant[1]?.trim() ?? ""
+    const variant = spaceVariant[2]?.trim().toLowerCase()
+    if (variant && KNOWN_VARIANTS.has(variant)) {
+      return { modelID, variant }
+    }
+  }
+
+  return { modelID: trimmedModel }
+}
+
+export function parseFallbackModelEntry(
+  model: string,
+  defaultProviderID: string,
+): FallbackEntry | undefined {
+  const trimmed = model.trim()
+  if (!trimmed) return undefined
+
+  const parts = trimmed.split("/")
+  const providerID = parts.length >= 2 ? parts[0].trim() : defaultProviderID
+  const rawModelID = parts.length >= 2 ? parts.slice(1).join("/").trim() : trimmed
+  if (!providerID || !rawModelID) return undefined
+
+  const parsed = parseVariantFromModel(rawModelID)
+  if (!parsed.modelID) return undefined
+
+  return {
+    providers: [providerID],
+    model: parsed.modelID,
+    variant: parsed.variant,
+  }
+}
+
+export function buildFallbackChainFromModels(
+  fallbackModels: string | string[] | undefined,
+  defaultProviderID: string,
+): FallbackEntry[] | undefined {
+  const normalized = normalizeFallbackModels(fallbackModels)
+  if (!normalized || normalized.length === 0) return undefined
+
+  const parsed = normalized
+    .map((model) => parseFallbackModelEntry(model, defaultProviderID))
+    .filter((entry): entry is FallbackEntry => entry !== undefined)
+
+  if (parsed.length === 0) return undefined
+  return parsed
+}