Add fallback model

Author: jahooma

cli/src/components/freebuff-model-selector.tsx

@@ -4,7 +4,7 @@ import React, { useCallback, useEffect, useMemo, useState } from 'react'
 
 import { Button } from './button'
 import {
-  DEFAULT_FREEBUFF_MODEL_ID,
+  FALLBACK_FREEBUFF_MODEL_ID,
   FREEBUFF_DEPLOYMENT_HOURS_LABEL,
   FREEBUFF_GLM_MODEL_ID,
   FREEBUFF_MODELS,
@@ -60,11 +60,16 @@ export const FreebuffModelSelector: React.FC = () => {
   }, [selectedModel])
 
   useEffect(() => {
+    // Landing-screen safety net: if the in-memory selection becomes
+    // unavailable (e.g. deployment hours close while the picker is open),
+    // swap to the always-available fallback so Enter doesn't POST a model
+    // the server will immediately reject. In-memory only — the user's saved
+    // preference (e.g. GLM) is preserved for the next launch.
     if (
       (session?.status === 'none' || !session) &&
       !isFreebuffModelAvailable(selectedModel, new Date(now))
     ) {
-      setSelectedModel(DEFAULT_FREEBUFF_MODEL_ID)
+      setSelectedModel(FALLBACK_FREEBUFF_MODEL_ID)
     }
   }, [now, selectedModel, session, setSelectedModel])
 

cli/src/hooks/use-freebuff-session.ts

@@ -1,5 +1,8 @@
 import { env } from '@codebuff/common/env'
-import { DEFAULT_FREEBUFF_MODEL_ID } from '@codebuff/common/constants/freebuff-models'
+import {
+  FALLBACK_FREEBUFF_MODEL_ID,
+  resolveFreebuffModel,
+} from '@codebuff/common/constants/freebuff-models'
 import { useEffect } from 'react'
 
 import {
@@ -10,6 +13,7 @@ import { useFreebuffSessionStore } from '../state/freebuff-session-store'
 import { getAuthTokenDetails } from '../utils/auth'
 import { IS_FREEBUFF } from '../utils/constants'
 import { logger } from '../utils/logger'
+import { saveFreebuffModelPreference } from '../utils/settings'
 
 import type { FreebuffSessionResponse } from '../types/freebuff-session'
 
@@ -280,7 +284,13 @@ export function returnToFreebuffLanding(
  */
 export function joinFreebuffQueue(model: string): Promise<void> {
   if (!IS_FREEBUFF) return Promise.resolve()
-  useFreebuffModelStore.getState().setSelectedModel(model)
+  // This is the only explicit user-pick path (called from the picker on
+  // click / Enter), so persistence belongs here — and ONLY here. Server-
+  // driven flips (`model_locked`, `model_unavailable`, takeover) go
+  // through `setSelectedModel` directly, which never writes to disk.
+  const resolved = resolveFreebuffModel(model)
+  useFreebuffModelStore.getState().setSelectedModel(resolved)
+  saveFreebuffModelPreference(resolved)
   return restartFreebuffSession('rejoin')
 }
 
@@ -419,7 +429,14 @@ export function useFreebuffSession(): UseFreebuffSessionResult {
           return
         }
         if (next.status === 'model_unavailable') {
-          useFreebuffModelStore.getState().setSelectedModel(DEFAULT_FREEBUFF_MODEL_ID)
+          // Server says the requested model isn't available right now (e.g.
+          // GLM outside deployment hours). Flip to the always-available
+          // fallback for this run. In-memory only — `setSelectedModel`
+          // doesn't persist, so the user's saved preference (e.g. GLM)
+          // is preserved for their next launch during deployment hours.
+          useFreebuffModelStore
+            .getState()
+            .setSelectedModel(FALLBACK_FREEBUFF_MODEL_ID)
           nextMethod = 'GET'
           schedule(0)
           return

cli/src/state/freebuff-model-store.ts

@@ -1,19 +1,23 @@
 import {
   DEFAULT_FREEBUFF_MODEL_ID,
   resolveAvailableFreebuffModel,
+  resolveFreebuffModel,
 } from '@codebuff/common/constants/freebuff-models'
 import { create } from 'zustand'
 
-import {
-  loadFreebuffModelPreference,
-  saveFreebuffModelPreference,
-} from '../utils/settings'
+import { loadFreebuffModelPreference } from '../utils/settings'
 
 /**
  * Holds the user's currently-selected freebuff model. Initialized from the
  * persisted settings file so freebuff defaults to whatever model the user
- * last picked. Writing through `setSelectedModel` also persists to disk so
- * the next launch picks it up without an explicit save call.
+ * last picked.
+ *
+ * `setSelectedModel` is in-memory only — it does NOT persist. Persistence
+ * happens exclusively in `joinFreebuffQueue` (the explicit-pick path), so
+ * server-driven auto-flips (`model_locked`, `model_unavailable`, takeover)
+ * can update the in-memory selection without overwriting the user's saved
+ * preference. The latter previously caused users to get permanently flipped
+ * to the fallback model after a single auto-fallback.
  *
  * Components in the waiting room read this to highlight the current row in
  * the model picker; the session hook reads it to decide which queue to join.
@@ -27,11 +31,8 @@ export const useFreebuffModelStore = create<FreebuffModelStore>((set) => ({
   selectedModel: resolveAvailableFreebuffModel(
     loadFreebuffModelPreference() ?? DEFAULT_FREEBUFF_MODEL_ID,
   ),
-  setSelectedModel: (model) => {
-    const resolved = resolveAvailableFreebuffModel(model)
-    saveFreebuffModelPreference(resolved)
-    set({ selectedModel: resolved })
-  },
+  setSelectedModel: (model) =>
+    set({ selectedModel: resolveFreebuffModel(model) }),
 }))
 
 /** Imperative read for non-React callers (the session hook's tick loop and

common/src/constants/freebuff-models.ts

@@ -19,10 +19,11 @@ export interface FreebuffModelOption {
 
 export const FREEBUFF_DEPLOYMENT_HOURS_LABEL = '9am ET-5pm PT'
 export const FREEBUFF_GLM_MODEL_ID = 'z-ai/glm-5.1'
+export const FREEBUFF_MINIMAX_MODEL_ID = 'minimax/minimax-m2.7'
 
 export const FREEBUFF_MODELS = [
   {
-    id: 'minimax/minimax-m2.7',
+    id: FREEBUFF_MINIMAX_MODEL_ID,
     displayName: 'MiniMax M2.7',
     tagline: 'Fastest',
     availability: 'always',
@@ -37,7 +38,18 @@ export const FREEBUFF_MODELS = [
 
 export type FreebuffModelId = (typeof FREEBUFF_MODELS)[number]['id']
 
-export const DEFAULT_FREEBUFF_MODEL_ID: FreebuffModelId = FREEBUFF_MODELS[0].id
+/** What new freebuff users see selected in the picker. May not be currently
+ *  available (GLM is closed outside deployment hours); callers that need an
+ *  always-available id for resolution / auto-fallbacks should use
+ *  FALLBACK_FREEBUFF_MODEL_ID instead. */
+export const DEFAULT_FREEBUFF_MODEL_ID: FreebuffModelId = FREEBUFF_GLM_MODEL_ID
+
+/** Always-available fallback used when the requested model can't be served
+ *  right now (unknown id, deployment hours closed, etc.). Kept distinct from
+ *  DEFAULT_FREEBUFF_MODEL_ID so a new user's "preferred default" can be the
+ *  smartest model without auto-flipping anyone to a closed deployment. */
+export const FALLBACK_FREEBUFF_MODEL_ID: FreebuffModelId =
+  FREEBUFF_MINIMAX_MODEL_ID
 
 export function isFreebuffModelId(
   id: string | null | undefined,
@@ -49,13 +61,13 @@ export function isFreebuffModelId(
 export function resolveFreebuffModel(
   id: string | null | undefined,
 ): FreebuffModelId {
-  return isFreebuffModelId(id) ? id : DEFAULT_FREEBUFF_MODEL_ID
+  return isFreebuffModelId(id) ? id : FALLBACK_FREEBUFF_MODEL_ID
 }
 
 export function getFreebuffModel(id: string): FreebuffModelOption {
   return (
     FREEBUFF_MODELS.find((m) => m.id === id) ??
-    FREEBUFF_MODELS.find((m) => m.id === DEFAULT_FREEBUFF_MODEL_ID)!
+    FREEBUFF_MODELS.find((m) => m.id === FALLBACK_FREEBUFF_MODEL_ID)!
   )
 }
 
@@ -102,5 +114,5 @@ export function resolveAvailableFreebuffModel(
   const resolved = resolveFreebuffModel(id)
   return isFreebuffModelAvailable(resolved, now)
     ? resolved
-    : DEFAULT_FREEBUFF_MODEL_ID
+    : FALLBACK_FREEBUFF_MODEL_ID
 }