@crouton-kit/crouter 0.3.40 → 0.3.41

package/dist/builtin-pi-packages/pi-crtr-extensions/lib/subscription-state.ts

@@ -325,22 +325,52 @@ function splitModelRef(ref: string): FallbackTarget {
   };
 }
 
-function readModelLadders(): ModelLaddersConfig | undefined {
+// Vendored copy of crouter's `defaultModelLaddersConfig()` (src/types.ts).
+// This package is synced from a standalone repo (pi-personal-extensions) and
+// has no runtime import path into crouter's compiled internals, so the
+// builtin rungs are duplicated here rather than imported; keep the two in
+// sync by hand if either changes.
+const BUILTIN_MODEL_LADDERS: Record<LadderProviderId, ModelLadderConfig> = {
+  anthropic: {
+    ultra: "anthropic/claude-fable-5:high",
+    strong: "anthropic/claude-opus-4-8:high",
+    medium: "anthropic/claude-sonnet-5:high",
+    light: "anthropic/claude-haiku-4-5:high",
+  },
+  openai: {
+    ultra: "openai-codex/gpt-5.5:xhigh",
+    strong: "openai-codex/gpt-5.5:high",
+    medium: "openai-codex/gpt-5.5:medium",
+    light: "openai-codex/gpt-5.3-codex-spark",
+  },
+};
+
+// Layers ~/.crouter/config.json's `modelLadders` (if any) OVER the builtin
+// defaults above, per provider/strength — mirroring crouter's own
+// `mergeModelLadders` (src/core/config.ts), which is what a node's launcher
+// actually resolves models from. Without this fallback, a config-less user
+// (the common case: fresh install, no ~/.crouter/config.json) saw an EMPTY
+// ladder here while crtr itself launched them on the builtin defaults —
+// rotation could then never resolve a strength tier or a cross-provider
+// fallback for a model it was already running. Always returns a fully
+// populated ladder for both providers; a config.json override only replaces
+// the specific strengths it sets.
+function readModelLadders(): ModelLaddersConfig {
   const config = readJsonFile<{ modelLadders?: Partial<Record<LadderProviderId, Partial<ModelLadderConfig>>> }>(CROUTER_CONFIG_FILE);
-  const ladders = config?.modelLadders;
-  if (!ladders) return undefined;
+  const overrides = config?.modelLadders;
   const result: ModelLaddersConfig = {};
   for (const provider of ["anthropic", "openai"] as const) {
-    const source = ladders[provider];
-    if (!source) continue;
-    const normalized: ModelLadderConfig = {};
-    for (const strength of ["ultra", "strong", "medium", "light"] as const) {
-      const value = typeof source[strength] === "string" ? source[strength]?.trim() : "";
-      if (value) normalized[strength] = value;
+    const normalized: ModelLadderConfig = { ...BUILTIN_MODEL_LADDERS[provider] };
+    const override = overrides?.[provider];
+    if (override) {
+      for (const strength of ["ultra", "strong", "medium", "light"] as const) {
+        const value = typeof override[strength] === "string" ? override[strength]?.trim() : "";
+        if (value) normalized[strength] = value;
+      }
     }
-    if (Object.keys(normalized).length > 0) result[provider] = normalized;
+    result[provider] = normalized;
   }
-  return Object.keys(result).length > 0 ? result : undefined;
+  return result;
 }
 
 function findStrengthForModelId(
@@ -402,12 +432,16 @@ export function rememberPreferredModel(model: ModelRef): RotationConfig {
   return writeRotationConfig({ preferredModel: model });
 }
 
+// `readModelLadders()` always fills both providers from the builtin defaults, so this
+// only returns undefined (never throws) in the defensive case where a rung is still
+// genuinely missing; callers must treat that as a graceful "no fallback available" case
+// rather than a config error to surface mid-turn.
 export function resolveFallbackTarget(
   currentProviderId: ManagedProviderId,
   currentModelId?: string,
   config = readRotationConfig(),
   currentThinkingLevel?: string,
-): FallbackTarget {
+): FallbackTarget | undefined {
   const ladders = readModelLadders();
   const defaultStrength = config.defaultFallbackStrength ?? DEFAULT_FALLBACK_STRENGTH;
   const sourceStrength = findStrengthForModelId(currentProviderId, currentModelId, defaultStrength, ladders, currentThinkingLevel);
@@ -417,7 +451,7 @@ export function resolveFallbackTarget(
   const candidates = strength === defaultStrength ? [strength] : [strength, defaultStrength];
   const fallbackRef = candidates.map((candidate) => targetLadder?.[candidate]).find((ref): ref is string => typeof ref === "string" && ref.trim().length > 0);
   if (!fallbackRef) {
-    throw new Error(`Unable to resolve fallback model for strength ${strength}; configure a ${PROVIDERS[targetProvider].ladderProviderId} ladder in ~/.crouter/config.json`);
+    return undefined;
   }
   const parsed = splitModelRef(fallbackRef);
   const resolvedStrength = candidates.find((candidate) => targetLadder?.[candidate] === fallbackRef) ?? strength;
@@ -458,6 +492,7 @@ export async function switchToFallbackIfPossible(
   rememberPreferredModel(preferredModel);
   const currentThinkingLevel = piApi.getThinkingLevel?.();
   const target = resolveFallbackTarget(preferredModel.providerId, preferredModel.modelId, readRotationConfig(), currentThinkingLevel);
+  if (!target) return undefined;
   const current = getCurrentModelRef(ctx.model);
   const model = ctx.modelRegistry.find(target.providerId, target.modelId);
   if (!model) return undefined;
@@ -471,9 +506,11 @@ export async function switchToFallbackIfPossible(
 
 export function formatStatusLine(providerId: ManagedProviderId, now = Date.now()): string {
   const pool = readSubscriptionPool(providerId);
-  const fallback = resolveFallbackTarget(providerId, undefined, readRotationConfig());
   const ready = pool.filter((entry) => !entry.rateLimitedUntil || entry.rateLimitedUntil <= now);
   const label = getProviderLabel(providerId);
-  if (ready.length === 0) return `${label} pool exhausted -> ${fallback.label}`;
+  if (ready.length === 0) {
+    const fallback = resolveFallbackTarget(providerId, undefined, readRotationConfig());
+    return fallback ? `${label} pool exhausted -> ${fallback.label}` : `${label} pool exhausted (no fallback configured)`;
+  }
   return `${label} ${ready[0]?.label ?? providerId} (${ready.length}/${pool.length} ready)`;
 }