Skip to content

The agent that grows with you

62.7 KB
Raw Blame
import type { ModelOptionProvider } from '@hermes/shared'
import { DEFAULT_REASONING_EFFORT, REASONING_EFFORT_VALUES } from '@hermes/shared'
import { useStore } from '@nanostores/react'
import { useCallback, useEffect, useMemo, useRef, useState } from 'react'
import type { Dispatch, SetStateAction } from 'react'

import { Button } from '@/components/ui/button'
import { Input } from '@/components/ui/input'
import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from '@/components/ui/select'
import { Skeleton } from '@/components/ui/skeleton'
import { Switch } from '@/components/ui/switch'
import {
  getAuxiliaryModels,
  getGlobalModelInfo,
  getGlobalModelOptions,
  getMoaModels,
  getRecommendedDefaultModel,
  saveHermesConfig,
  saveMoaModels,
  setEnvVar,
  setModelAssignment
} from '@/hermes'
import type {
  AuxiliaryModelsResponse,
  AuxiliaryTaskAssignment,
  MoaConfigResponse,
  MoaModelSlot,
  ModelAssignmentRequest,
  StaleAuxAssignment
} from '@/hermes'
import { useI18n } from '@/i18n'
import { isCodeSkewRestartRequired } from '@/lib/code-skew-error'
import { AlertTriangle, Cpu, Loader2 } from '@/lib/icons'
import { isSubmitEnter } from '@/lib/ime'
import { catalogProviderMatches, findCatalogProvider } from '@/lib/model-options'
import { composerServiceTier } from '@/lib/model-status-label'
import { cn } from '@/lib/utils'
import { showLargeModelNotice } from '@/store/agent-notices'
import { $customModels, withCustomModels } from '@/store/custom-models'
import { setMainModelAssignment } from '@/store/model-assignment'
import { notify, notifyError, readableError } from '@/store/notifications'
import { startManualLocalEndpoint, startManualOnboarding, startManualProviderOAuth } from '@/store/onboarding'

import { hermesConfigCacheWriter, invalidateHermesConfig, useHermesConfigRecord } from '../hooks/use-config-record'
import { useOnProfileSwitch } from '../hooks/use-on-profile-switch'
import { PanelEmpty } from '../overlays/panel'

import {
  AUX_FOLLOW_BASE,
  AuxFollowBaseButton,
  auxMainRoute,
  AuxTaskRouteSummary,
  useAuxTaskRows
} from './aux-task-rows'
import { CONTROL_TEXT } from './constants'
import { getNested, setNested } from './helpers'
import { ModelSelect, withActive } from './model-select'
import { ListRow, ListRowSkeleton, Pill, SectionHeading, SectionHeadingSkeleton } from './primitives'
import { dismissStaleAux, readStaleAuxDismissal, staleAuxFingerprint } from './stale-aux-dismissal'

// Skeleton mirror of the Model settings DOM so the page keeps its shape while
// the provider/model catalog loads, instead of collapsing to a centered
// spinner. Same containers/rhythm as the real render below.
export function ModelSettingsSkeleton({ subpage }: Pick<ModelSettingsProps, 'subpage'> = {}) {
  return (
    <div className="grid gap-6" data-slot="model-settings-skeleton">
      {(subpage === undefined || subpage === 'main') && (
        <section>
          <Skeleton className="mb-3 h-3 w-72 max-w-full" />
          <div className="grid gap-1">
            <ListRowSkeleton />
            <ListRowSkeleton />
          </div>
          <div className="flex justify-end pt-1">
            <Skeleton className="h-8 w-16" />
          </div>
          <div className="mt-6 grid gap-1">
            <Skeleton className="mb-1 h-3 w-16" />
            <ListRowSkeleton />
            <ListRowSkeleton />
          </div>
        </section>
      )}

      {(subpage === undefined || subpage === 'auxiliary' || subpage === 'moa') && (
        <section>
          <SectionHeadingSkeleton />
          <div className="grid gap-1">
            {[0, 1, 2, 3].map(row => (
              <ListRowSkeleton key={row} />
            ))}
          </div>
        </section>
      )}
    </div>
  )
}

type SpeedTier = 'fast' | 'normal' | 'ultrafast'

// A provider row is "ready" to pick a model from when it reports models. The
// backend now surfaces the full `hermes model` universe (every canonical
// provider), so unconfigured providers come back with `authenticated:false`
// and an empty `models` list — those need a setup step before a model exists.
function isProviderReady(p?: ModelOptionProvider): boolean {
  return !!p && (p.authenticated !== false || (p.models?.length ?? 0) > 0)
}

const NO_PROVIDERS: readonly ModelOptionProvider[] = [{ name: '—', slug: '', models: [] }]

// Options for the main provider Select: the full catalog, but a saved provider
// missing from it stays visible (Radix renders a blank trigger when the
// controlled value has no matching item) while remaining out of the real
// inventory used for readiness/setup metadata.
function mainProviderOptionsFor(providers: readonly ModelOptionProvider[], selectedProvider: string) {
  const options = providers.length ? providers : NO_PROVIDERS

  return selectedProvider && !findCatalogProvider(providers, selectedProvider)
    ? [{ name: selectedProvider, slug: selectedProvider, models: [] as string[] }, ...providers]
    : options
}

// True when the provider row is a configured endpoint the backend may know
// more models for than the normal (non-refresh) options load probed: that
// load probes only the CURRENT custom provider, so a named custom_providers
// entry the user just switched to arrives empty until an explicit refresh.
function mayDiscoverModels(row: ModelOptionProvider | undefined): boolean {
  if (!row || row.authenticated === false || (row.models?.length ?? 0) > 0) {
    return false
  }

  return !!row.api_url || row.source === 'model-config' || row.is_user_defined === true
}

// Switching to a configured endpoint whose models list is empty triggers one
// refresh-scoped options fetch so the row populates without blocking the
// switch (#59063). The normal (non-refresh) load probes only the CURRENT
// custom provider, so a freshly-selected one arrives empty. On failure the
// selection stays empty and the user can still type a custom model id in
// ModelSelect.
function refreshEmptyProviderModels(
  slug: string,
  providers: readonly ModelOptionProvider[],
  scopeProfile: string | undefined,
  isCurrentEpoch: () => boolean,
  apply: (providers: ModelOptionProvider[]) => void
): void {
  if (!mayDiscoverModels(providers.find(p => catalogProviderMatches(p, slug)))) {
    return
  }

  getGlobalModelOptions({ refresh: true }, scopeProfile)
    .then(options => {
      if (isCurrentEpoch()) {
        apply(options.providers || [])
      }
    })
    .catch(() => {})
}

// User-driven provider switch for the main picker: a provider's model list is
// per-provider, so switching must not carry the previous provider's model
// over — ModelSelect's withActive() would keep painting it as a selectable
// row, and Apply would pin the new provider to the old provider's model
// (#59063). Programmatic switches (initial load, profile switch,
// activate-key auto-select) set state directly and keep their own model
// restore semantics.
function switchProviderFor(
  providers: readonly ModelOptionProvider[],
  scopeProfile: string | undefined,
  profileEpoch: { current: number },
  setCatalogProviders: (rows: ModelOptionProvider[]) => void,
  setSelectedProvider: Dispatch<SetStateAction<string>>,
  setSelectedModel: Dispatch<SetStateAction<string>>
) {
  return (slug: string) => {
    const epoch = profileEpoch.current

    setSelectedProvider((prev: string) => {
      if (prev === slug) {
        return prev
      }

      setSelectedModel('')

      return slug
    })

    refreshEmptyProviderModels(slug, providers, scopeProfile, () => profileEpoch.current === epoch, setCatalogProviders)
  }
}

// A slot is complete when both halves are chosen. Changing a slot's provider
// intentionally clears its model (see updateMoaSlot), so every provider change
// passes through an incomplete state while the user picks the new model.
export const moaSlotComplete = (slot: MoaModelSlot): boolean => !!(slot.provider.trim() && slot.model.trim())

// True when every slot in every preset is fully specified — the only state
// that is safe to persist. The backend rejects configs with half-filled slots
// (HTTP 422) instead of silently swapping the preset for hardcoded defaults
// (#64156), so the autosave must simply wait for the edit to finish rather
// than trying to "repair" the payload.
export const moaConfigComplete = (config: MoaConfigResponse): boolean =>
  Object.values(config.presets).every(
    preset =>
      preset.reference_models.length > 0 &&
      preset.reference_models.every(moaSlotComplete) &&
      moaSlotComplete(preset.aggregator)
  )

// Persistent mismatch: any aux slot pinned to a provider different from the
// current main, regardless of whether the user just switched. Catches the
// "I pinned aux months ago and forgot, now it bills a dead provider" case.
// A pin on a private/LAN endpoint (per-task base_url, e.g. a home Ollama box)
// never bills a provider, so the backend's `local_endpoint` verdict exempts it.
export function staleAuxAssignments(
  tasks: readonly AuxiliaryTaskAssignment[],
  mainProvider: string
): StaleAuxAssignment[] {
  const main = mainProvider.toLowerCase()

  if (!main) {
    return []
  }

  return (
    tasks
      .filter(entry => {
        const p = (entry.provider ?? '').toLowerCase()

        // 'main' is a backend alias meaning "follow the current main provider"
        // (auxiliary_client._normalize_aux_provider), so it can never be a stale pin.
        return p && p !== 'auto' && p !== 'main' && p !== main && !entry.local_endpoint
      })
      // base_url rides along for the dismissal fingerprint (see
      // stale-aux-dismissal.ts): repointing a pin at a different endpoint changes
      // the billing surface and must re-arm an acknowledged banner.
      .map(entry => ({ base_url: entry.base_url, task: entry.task, provider: entry.provider, model: entry.model }))
  )
}

interface StaleAuxWarningProps {
  applying: boolean
  /** Offered only on the persistent variant — the post-switch notice announces
   *  a change that just happened and must not be silenced. */
  onDismiss?: () => void
  onReset: () => void
  slots: readonly StaleAuxAssignment[]
  taskLabel: (key: string) => string
}

// Shared notice: auxiliary tasks still pinned to a provider that isn't the
// current main. Surfaces the silent credit-burn path (e.g. aux pinned to a
// $0-balance provider after switching main away from it) and offers the
// existing one-click reset rather than auto-clearing legitimate pins.
// Sized to be read at a glance (#66740) with the theme-aware amber text the
// app's warn badges use, so light mode keeps its contrast.
function StaleAuxWarning({ applying, onDismiss, onReset, slots, taskLabel }: StaleAuxWarningProps) {
  const { t } = useI18n()
  const m = t.settings.model

  if (!slots.length) {
    return null
  }

  const provider = slots[0].provider
  const allSameProvider = slots.every(slot => slot.provider === provider)
  const names = slots.map(slot => taskLabel(slot.task)).join(', ')

  return (
    <div className="flex flex-wrap items-center gap-2 rounded-md border border-amber-400/60 bg-amber-500/15 px-3 py-2.5 text-sm text-amber-600 dark:text-amber-300">
      <AlertTriangle className="size-4 shrink-0" />
      <span className="grow font-medium">
        {m.staleAuxBefore(slots.length, names)}
        <span className="font-mono">{allSameProvider ? provider : m.staleAuxOtherProviders}</span>
        {m.staleAuxAfter}
      </span>
      <Button disabled={applying} onClick={onReset} size="sm" variant="textStrong">
        {m.resetAllToMain}
      </Button>
      {onDismiss && (
        <Button disabled={applying} onClick={onDismiss} size="sm" variant="textStrong">
          {m.staleAuxDismiss}
        </Button>
      )}
    </div>
  )
}

interface ModelSettingsProps {
  /** Visibility only: changing pages must not reset drafts or cancel autosave. */
  subpage?: string
  /** Notified after the main model is applied, so live UI stores can sync. */
  onMainModelChanged?: (provider: string, model: string) => void
  /** Shared settings "Applies to" scope: a concrete profile to edit instead of
   *  the app's active one, or undefined to follow the active profile (default).
   *  Request-shaped on purpose — the API helpers treat `null` as "deliberately
   *  target the primary/default backend", so this prop never carries null. */
  scopeProfile?: string
}

function MainModelDefaults({
  effortValue,
  fastOn,
  fastSupported,
  onChange,
  reasoningSupported,
  speedValue,
  ultrafastSupported
}: {
  effortValue: string
  fastOn: boolean
  fastSupported: boolean
  onChange: (key: string, value: boolean | string) => Promise<void>
  reasoningSupported: boolean
  speedValue: SpeedTier
  ultrafastSupported: boolean
}) {
  const { t } = useI18n()
  const m = t.settings.model

  return (
    <div className="mt-6 grid gap-1">
      <p className="mb-1 text-xs text-muted-foreground">{m.defaultsLabel}</p>
      {reasoningSupported && (
        <ListRow
          action={
            <Select onValueChange={value => void onChange('agent.reasoning_effort', value)} value={effortValue}>
              <SelectTrigger aria-label={m.reasoning} className={cn('min-w-28', CONTROL_TEXT)}>
                <SelectValue />
              </SelectTrigger>
              <SelectContent>
                {REASONING_EFFORT_VALUES.map(value => (
                  <SelectItem key={value} value={value}>
                    {value === 'none' ? m.reasoningOff : t.shell.modelOptions[value]}
                  </SelectItem>
                ))}
              </SelectContent>
            </Select>
          }
          title={m.reasoning}
        />
      )}
      {ultrafastSupported ? (
        <ListRow
          action={
            <Select onValueChange={value => void onChange('agent.service_tier', value)} value={speedValue}>
              <SelectTrigger aria-label={m.speed} className={cn('min-w-28', CONTROL_TEXT)}>
                <SelectValue />
              </SelectTrigger>
              <SelectContent>
                <SelectItem value="normal">{m.speedStandard}</SelectItem>
                {fastSupported && <SelectItem value="fast">{t.shell.modelOptions.fast}</SelectItem>}
                <SelectItem value="ultrafast">{t.shell.modelOptions.ultrafast}</SelectItem>
              </SelectContent>
            </Select>
          }
          title={m.speed}
        />
      ) : (
        fastSupported && (
          <ListRow
            action={
              <Switch
                aria-label={t.shell.modelOptions.fast}
                checked={fastOn}
                onCheckedChange={checked => void onChange('agent.service_tier', checked ? 'fast' : 'normal')}
                size="xs"
              />
            }
            title={t.shell.modelOptions.fast}
          />
        )
      )}
    </div>
  )
}

export function ModelSettings({ onMainModelChanged, scopeProfile, subpage }: ModelSettingsProps) {
  const { t } = useI18n()
  const m = t.settings.model
  const showMain = subpage === undefined || subpage === 'main'
  const showAuxiliary = subpage === undefined || subpage === 'auxiliary'
  const showMoa = subpage === undefined || subpage === 'moa'
  const [loading, setLoading] = useState(true)
  const [error, setError] = useState('')
  const [skewRestart, setSkewRestart] = useState(false)
  const [restartingBackend, setRestartingBackend] = useState(false)
  const [mainModel, setMainModel] = useState<{ model: string; provider: string } | null>(null)
  const [catalogProviders, setCatalogProviders] = useState<ModelOptionProvider[]>([])
  // Slugs typed into any picker ride along as rows of their provider, so a
  // model added from the composer is selectable here too.
  const customModels = useStore($customModels)
  const providers = useMemo(() => withCustomModels(catalogProviders, customModels), [catalogProviders, customModels])
  const [selectedProvider, setSelectedProvider] = useState('')
  const [selectedModel, setSelectedModel] = useState('')
  const [auxiliary, setAuxiliary] = useState<AuxiliaryModelsResponse | null>(null)
  const [moa, setMoa] = useState<MoaConfigResponse | null>(null)
  const [selectedMoaPreset, setSelectedMoaPreset] = useState('')
  const [newMoaPresetName, setNewMoaPresetName] = useState('')
  // agent.* defaults round-trip through the shared config cache (read → write
  // back the whole record), so a save here shows in the MCP/model surfaces.
  const { data: config, writeScope } = useHermesConfigRecord(scopeProfile)
  const setConfig = useMemo(() => hermesConfigCacheWriter(scopeProfile), [scopeProfile])
  const [applying, setApplying] = useState(false)
  const [editingAuxTask, setEditingAuxTask] = useState<null | string>(null)

  const [auxDraft, setAuxDraft] = useState<{ model: string; provider: string; reasoningEffort: string }>({
    model: '',
    provider: '',
    reasoningEffort: '__inherit__'
  })

  // Aux slots reported stale by the backend immediately after a main-model
  // switch (provider differs from the new main). Cleared on next switch/reset.
  const [switchStaleAux, setSwitchStaleAux] = useState<StaleAuxAssignment[]>([])
  // Inline API-key entry for picking an unconfigured `api_key` provider in
  // place — mirrors the onboarding ApiKeyForm but scoped to the model picker.
  const [apiKeyDraft, setApiKeyDraft] = useState('')
  const [activating, setActivating] = useState(false)

  // Every profile-scoped async here captures this and bails before writing back,
  // so a request in flight when the user switches profiles can't paint profile
  // A's models/providers into profile B (or fire onMainModelChanged for A).
  const profileEpoch = useRef(0)

  const setCaughtError = useCallback(
    (err: unknown, fallback: string) => {
      const skew = isCodeSkewRestartRequired(err)
      setSkewRestart(skew)
      setError(skew ? m.restartRequired : readableError(err, fallback).message)
    },
    [m.restartRequired]
  )

  const refresh = useCallback(
    async ({ replaceSelection = false }: { replaceSelection?: boolean } = {}) => {
      const epoch = profileEpoch.current
      setLoading(true)
      setError('')
      setSkewRestart(false)

      try {
        // Degrade per call: a hung /api/model/info (its context-length probe
        // hits the configured provider, which can be unreachable) must not
        // block the config-backed sections — auxiliary and MOA are fast
        // config-file reads — behind a single all-or-nothing Promise.all.
        const [modelInfoResult, modelOptionsResult, auxiliaryModelsResult, moaModelsResult] = await Promise.allSettled([
          getGlobalModelInfo(scopeProfile),
          getGlobalModelOptions(undefined, scopeProfile),
          getAuxiliaryModels(scopeProfile),
          getMoaModels(scopeProfile)
        ])

        if (profileEpoch.current !== epoch) {
          return
        }

        const failures: string[] = []

        const settledValue = <T,>(result: PromiseSettledResult<T>): T | null => {
          if (result.status === 'fulfilled') {
            return result.value
          }

          failures.push(result.reason instanceof Error ? result.reason.message : String(result.reason))

          return null
        }

        const modelInfo = settledValue(modelInfoResult)
        const modelOptions = settledValue(modelOptionsResult)
        const auxiliaryModels = settledValue(auxiliaryModelsResult)
        // MOA has always been optional-on-failure; keep it out of the banner.
        const moaModels = moaModelsResult.status === 'fulfilled' ? moaModelsResult.value : null
        // The main assignment also lives in the auxiliary config read, so the
        // page still knows the current model when only the live probe failed.
        const resolvedMain = modelInfo ?? auxiliaryModels?.main ?? null

        if (resolvedMain) {
          setMainModel({ model: resolvedMain.model, provider: resolvedMain.provider })

          if (replaceSelection) {
            setSelectedProvider(resolvedMain.provider)
            setSelectedModel(resolvedMain.model)
          } else {
            setSelectedProvider(prev => prev || resolvedMain.provider)
            setSelectedModel(prev => prev || resolvedMain.model)
          }
        }

        if (modelOptions) {
          setCatalogProviders(modelOptions.providers || [])
        }

        setAuxiliary(auxiliaryModels)
        setMoa(moaModels)

        if (moaModels) {
          setSelectedMoaPreset(prev => (prev && moaModels.presets[prev] ? prev : moaModels.default_preset))
        }

        if (failures.length > 0) {
          setCaughtError(new Error(failures.join('; ')), m.loadFailed)
        }

        // The config record loads via its own shared query; a model switch can
        // change it server-side (aux slots), so nudge that cache to refetch.
        void invalidateHermesConfig(scopeProfile)
      } catch (err) {
        if (profileEpoch.current === epoch) {
          setCaughtError(err, m.loadFailed)
        }
      } finally {
        if (profileEpoch.current === epoch) {
          setLoading(false)
        }
      }
    },
    [m.loadFailed, scopeProfile, setCaughtError]
  )

  useEffect(() => {
    void refresh()
  }, [refresh])

  // A profile switch swaps the backend under the mounted panel — reload for the
  // new profile (bumping the epoch first so any in-flight A request is discarded).
  useOnProfileSwitch(() => {
    profileEpoch.current += 1
    // The panel stays mounted across profile switches, so clear the previous
    // profile's draft selection before loading the new profile's source of
    // truth. Ordinary same-profile refreshes still preserve in-progress edits.
    setSelectedProvider('')
    setSelectedModel('')
    setApiKeyDraft('')
    void refresh({ replaceSelection: true })
  })

  const providerOptions = providers.length ? providers : NO_PROVIDERS
  const mainProviderOptions = mainProviderOptionsFor(providers, selectedProvider)

  // User-driven switch: never carries the old provider's model over (#59063).
  const switchProvider = useMemo(
    () =>
      switchProviderFor(
        providers,
        scopeProfile,
        profileEpoch,
        setCatalogProviders,
        setSelectedProvider,
        setSelectedModel
      ),
    [providers, scopeProfile]
  )

  // MoA reference/aggregator slots must never be the moa virtual provider —
  // that would create a recursive MoA tree (the backend rejects it on save).
  // Hide it from the slot selectors so it isn't offered as a dead choice.
  const moaSlotProviderOptions = providerOptions.filter(provider => (provider.slug || '').toLowerCase() !== 'moa')

  const selectedProviderRow = useMemo(
    () => findCatalogProvider(providers, selectedProvider),
    [providers, selectedProvider]
  )

  const selectedProviderModels = selectedProviderRow?.models ?? []

  // An unconfigured provider was picked: no credentials yet, so there are no
  // models to choose. `api_key` providers can be activated inline (paste key);
  // OAuth / external flows hand off to the onboarding sign-in.
  const needsSetup = !!selectedProvider && !isProviderReady(selectedProviderRow)
  const setupIsApiKey = needsSetup && selectedProviderRow?.auth_type === 'api_key' && !!selectedProviderRow?.key_env

  // Clear any half-typed key when switching provider so it can't leak across.
  useEffect(() => {
    setApiKeyDraft('')
  }, [selectedProvider])

  const auxDraftProviderModels = useMemo(
    () => findCatalogProvider(providers, auxDraft.provider)?.models ?? [],
    [auxDraft.provider, providers]
  )

  const modelsForProvider = useCallback(
    (provider: string) => findCatalogProvider(providers, provider)?.models ?? [],
    [providers]
  )

  const currentMoaPreset = useMemo(() => {
    if (!moa) {
      return null
    }

    return moa.presets[selectedMoaPreset] || moa.presets[moa.default_preset] || Object.values(moa.presets)[0] || null
  }, [moa, selectedMoaPreset])

  // Mirror of `moa` so inline edits compute the next state purely (outside the
  // setState updater) and hand it straight to the debounced autosave.
  const moaRef = useRef<MoaConfigResponse | null>(null)

  // eslint-disable-next-line no-restricted-syntax -- legitimate non-atom ref write (see eslint rule comment)
  useEffect(() => {
    moaRef.current = moa
  }, [moa])

  const moaSaveTimer = useRef<number | null>(null)

  useEffect(
    () => () => {
      if (moaSaveTimer.current) {
        window.clearTimeout(moaSaveTimer.current)
      }
    },
    []
  )

  // Guard against stale save responses overwriting newer state.
  const moaSaveGeneration = useRef(0)

  // Quiet debounced persist for inline MoA edits — mirrors the config page's
  // autosave so slot/aggregator tweaks save themselves, matching the
  // preset-level ops (set default / add / delete) that already persist on
  // click. No `applying` spinner, so selecting stays responsive.
  //
  // While any slot is half-filled (provider picked, model pending) the save is
  // HELD, not sent: the previous complete config stays on disk and the next
  // edit that completes the slot flushes the whole preset. Every edit bumps
  // the generation so an in-flight response from an older save can never
  // repaint over the user's mid-edit state.
  const scheduleMoaSave = useCallback(
    (next: MoaConfigResponse) => {
      if (moaSaveTimer.current) {
        window.clearTimeout(moaSaveTimer.current)
        moaSaveTimer.current = null
      }

      const generation = moaSaveGeneration.current + 1
      moaSaveGeneration.current = generation

      if (!moaConfigComplete(next)) {
        return
      }

      moaSaveTimer.current = window.setTimeout(() => {
        void saveMoaModels(next, scopeProfile)
          .then(saved => {
            if (moaSaveGeneration.current === generation) {
              setMoa(saved)
            }
          })
          .catch(err => {
            if (moaSaveGeneration.current === generation) {
              setCaughtError(err, m.loadFailed)
            }
          })
      }, 600)
    },
    [m.loadFailed, scopeProfile, setCaughtError]
  )

  const updateMoaPreset = useCallback(
    (updater: (preset: NonNullable<typeof currentMoaPreset>) => NonNullable<typeof currentMoaPreset>) => {
      const prev = moaRef.current

      if (!prev || !selectedMoaPreset || !prev.presets[selectedMoaPreset]) {
        return
      }

      const next: MoaConfigResponse = {
        ...prev,
        presets: {
          ...prev.presets,
          [selectedMoaPreset]: updater(prev.presets[selectedMoaPreset])
        }
      }

      moaRef.current = next
      setMoa(next)
      scheduleMoaSave(next)
    },
    [scheduleMoaSave, selectedMoaPreset]
  )

  const updateMoaSlot = useCallback((slot: MoaModelSlot, patch: Partial<MoaModelSlot>): MoaModelSlot => {
    const next = { ...slot, ...patch }

    // Picking a new provider invalidates the model choice (models are
    // per-provider). A same-provider update must not wipe the model — Radix
    // filters same-value changes, but programmatic callers may not.
    if (patch.provider && patch.provider !== slot.provider) {
      next.model = ''
    }

    return next
  }, [])

  const saveMoa = useCallback(
    async (next: MoaConfigResponse) => {
      const epoch = profileEpoch.current

      // Explicit preset ops (set default / add / delete) supersede any pending
      // debounced slot autosave — cancel it and invalidate in-flight responses
      // so the two writers can't race each other's state.
      if (moaSaveTimer.current) {
        window.clearTimeout(moaSaveTimer.current)
        moaSaveTimer.current = null
      }

      moaSaveGeneration.current += 1
      setApplying(true)
      setError('')

      try {
        const saved = await saveMoaModels(next, scopeProfile)

        if (profileEpoch.current !== epoch) {
          return
        }

        setMoa(saved)
      } catch (err) {
        setCaughtError(err, m.loadFailed)
      } finally {
        setApplying(false)
      }
    },
    [m.loadFailed, scopeProfile, setCaughtError]
  )

  const { auxRows, auxiliaryTaskLabel } = useAuxTaskRows(auxiliary?.tasks, { loading, visible: showAuxiliary })

  const persistentStaleAux = useMemo<StaleAuxAssignment[]>(
    () => staleAuxAssignments(auxiliary?.tasks ?? [], mainModel?.provider ?? ''),
    [auxiliary, mainModel]
  )

  // Acknowledgement of the persistent stale-aux banner (#66740): a dismissal
  // is bound to the exact pin configuration it acknowledged, so any slot edit,
  // main switch, or endpoint repoint produces a different fingerprint and
  // re-arms the warning. Seeded lazily at first render (before the data can
  // paint, so an acknowledged banner never flashes); the panel stays mounted
  // across profile switches, so re-read when the scope changes.
  const [dismissedStaleAux, setDismissedStaleAux] = useState<null | string>(() => readStaleAuxDismissal(scopeProfile))

  useEffect(() => {
    setDismissedStaleAux(readStaleAuxDismissal(scopeProfile))
  }, [scopeProfile])

  const staleAuxDismissed =
    persistentStaleAux.length > 0 &&
    dismissedStaleAux === staleAuxFingerprint(mainModel?.provider ?? '', persistentStaleAux)

  // Capabilities of the APPLIED main model — gates the profile-default
  // reasoning/speed controls the same way the composer picker gates per-model
  // edits (reasoning defaults on, fast defaults off when unreported).
  const mainCaps = useMemo(() => {
    const row = mainModel ? findCatalogProvider(providers, mainModel.provider) : undefined

    return mainModel ? row?.capabilities?.[mainModel.model] : undefined
  }, [providers, mainModel])

  const reasoningSupported = mainCaps?.reasoning ?? true
  const fastSupported = mainCaps?.fast ?? false
  const ultrafastSupported = mainCaps?.ultrafast ?? false

  // Hand-written `reasoning_effort: false`/`off` reaches us as boolean false
  // ("false" once stringified) — show it as Off, not an empty select.
  const rawEffort = String(getNested(config ?? {}, 'agent.reasoning_effort') ?? '')
    .trim()
    .toLowerCase()

  const effortValue = rawEffort === 'false' || rawEffort === 'disabled' ? 'none' : rawEffort || DEFAULT_REASONING_EFFORT

  // One profile-default speed: Standard, Fast (Priority) or Ultrafast. Ultrafast
  // only shows as a choice on models that offer it.
  const tier = composerServiceTier(getNested(config ?? {}, 'agent.service_tier'))
  const fastOn = tier === 'priority'
  const speedValue: SpeedTier = fastOn ? 'fast' : tier === 'ultrafast' ? 'ultrafast' : 'normal'

  // Persist a single agent.* default as a sparse patch (PUT /api/config
  // deep-merges onto disk). Never send the whole cached record: it is a
  // default-expanded snapshot, and echoing it back rewrites every key another
  // surface changed meanwhile — a CLI-pinned auxiliary slot came back as
  // provider "auto" / model "" (#95460). Optimistic, with rollback on failure.
  const writeAgentDefault = useCallback(
    async (key: string, value: boolean | string) => {
      if (!config) {
        return
      }

      const prev = config
      const next = setNested(config, key, value)
      setConfig(next)

      try {
        await saveHermesConfig(setNested({}, key, value), writeScope ?? scopeProfile)
      } catch (err) {
        setConfig(prev)
        notifyError(err, m.defaultsFailed)
      }
    },
    [config, m.defaultsFailed, scopeProfile, setConfig, writeScope]
  )

  // Paste an API key for the selected `api_key` provider, persist it, then
  // refresh so the now-authenticated provider's models populate. Auto-selects
  // the recommended default model so the user can Apply in one more click.
  const activateApiKeyProvider = useCallback(async () => {
    const keyEnv = selectedProviderRow?.key_env
    const slug = selectedProviderRow?.slug

    if (!keyEnv || !slug || !apiKeyDraft.trim()) {
      return
    }

    const epoch = profileEpoch.current
    setActivating(true)
    setError('')

    try {
      await setEnvVar(keyEnv, apiKeyDraft.trim(), scopeProfile, { providerSetup: true })
      setApiKeyDraft('')

      // Pick a sensible default for the freshly-activated provider (mirrors
      // `hermes model` curation). Best-effort — fall through to the refreshed
      // model list if it fails.
      let nextModel = ''

      try {
        const rec = await getRecommendedDefaultModel(slug, scopeProfile)
        nextModel = rec.model || ''
      } catch {
        nextModel = ''
      }

      const options = await getGlobalModelOptions(undefined, scopeProfile)

      if (profileEpoch.current !== epoch) {
        return
      }

      setCatalogProviders(options.providers || [])
      const refreshedRow = options.providers?.find(p => p.slug === slug)
      const fallbackModel = refreshedRow?.models?.[0] ?? ''
      setSelectedModel(nextModel || fallbackModel)
    } catch (err) {
      setCaughtError(err, m.loadFailed)
    } finally {
      setActivating(false)
    }
  }, [apiKeyDraft, m.loadFailed, scopeProfile, selectedProviderRow, setCaughtError])

  // OAuth / external providers can't be activated with a pasted key — hand off
  // to the shared onboarding flow scoped to this provider's real sign-in. The
  // custom / local endpoint is NOT an OAuth provider, so it gets the dedicated
  // local-endpoint form (URL + optional API key) instead of being dead-ended
  // on the OAuth picker (the original "booted back to the first screen" loop).
  const startProviderSetup = () => {
    const rowSlug = selectedProviderRow?.slug.trim() ?? ''
    const slug = rowSlug || selectedProvider.trim()

    if (!slug) {
      return
    }

    const lower = slug.toLowerCase()

    if (lower === 'custom' || lower === 'local' || lower.startsWith('custom:')) {
      startManualLocalEndpoint(null, scopeProfile)
    } else if (rowSlug) {
      startManualProviderOAuth(rowSlug, scopeProfile)
    } else {
      // An absent row has no trustworthy auth metadata. Open the generic
      // provider picker instead of deep-linking an unknown or stale slug.
      startManualOnboarding(undefined, scopeProfile)
    }
  }

  const applyMainModel = useCallback(async () => {
    if (!selectedProvider || !selectedModel) {
      return
    }

    const epoch = profileEpoch.current
    setApplying(true)
    setError('')

    try {
      const result = await setMainModelAssignment(
        {
          model: selectedModel,
          provider: selectedProvider,
          ...(selectedProviderRow?.api_url ? { base_url: selectedProviderRow.api_url } : {})
        },
        scopeProfile
      )

      if (profileEpoch.current !== epoch) {
        return
      }

      const provider = result.provider || selectedProvider
      const model = result.model || selectedModel
      setMainModel({ provider, model })

      if (result.notice) {
        showLargeModelNotice(result.notice)
      }
      setSwitchStaleAux(result.stale_aux ?? [])
      notify({ kind: 'success', title: m.mainAppliedTitle, message: m.mainAppliedMessage(model) })

      // Live UI stores mirror the ACTIVE profile's model; a scoped apply
      // changed a different profile and must not repaint them.
      if (scopeProfile == null) {
        onMainModelChanged?.(provider, model)
      }

      await refresh()
    } catch (err) {
      setCaughtError(err, m.loadFailed)
    } finally {
      setApplying(false)
    }
  }, [
    m,
    onMainModelChanged,
    refresh,
    scopeProfile,
    selectedModel,
    selectedProvider,
    selectedProviderRow,
    setCaughtError
  ])

  // Sibling of the applyMainModel endpoint passthrough (#65254): auxiliary
  // assignments targeting a user-defined provider must carry that provider's
  // endpoint too, or the backend pins the slot without a base_url and the
  // aux resolver falls back to the (possibly different, possibly cleared)
  // main endpoint.
  const endpointForProvider = useCallback(
    (provider: string) => {
      const row = findCatalogProvider(providers, provider)

      return row?.api_url ? { base_url: row.api_url } : {}
    },
    [providers]
  )

  const assignAuxiliary = useCallback(
    async (task: string, route: Omit<ModelAssignmentRequest, 'scope' | 'task'>) => {
      setApplying(true)
      setError('')

      try {
        await setModelAssignment({ ...route, scope: 'auxiliary', task }, scopeProfile)
        await refresh()
      } catch (err) {
        setCaughtError(err, m.loadFailed)
      } finally {
        setApplying(false)
      }
    },
    [m.loadFailed, refresh, scopeProfile, setCaughtError]
  )

  const applyAuxiliaryDraft = useCallback(
    async (task: string) => {
      if (!auxDraft.provider || !auxDraft.model) {
        return
      }

      setApplying(true)
      setError('')

      try {
        await setModelAssignment(
          {
            model: auxDraft.model,
            provider: auxDraft.provider,
            reasoning_effort: auxDraft.reasoningEffort === '__inherit__' ? null : auxDraft.reasoningEffort,
            scope: 'auxiliary',
            task,
            ...endpointForProvider(auxDraft.provider)
          },
          scopeProfile
        )
        setEditingAuxTask(null)
        await refresh()
      } catch (err) {
        setCaughtError(err, m.loadFailed)
      } finally {
        setApplying(false)
      }
    },
    [auxDraft, endpointForProvider, m.loadFailed, refresh, scopeProfile, setCaughtError]
  )

  const beginAuxiliaryEdit = useCallback(
    (task: string) => {
      const current = auxiliary?.tasks.find(entry => entry.task === task)

      const initialProvider =
        current?.provider && current.provider !== 'auto' ? current.provider : (mainModel?.provider ?? '')

      const initialModel = current?.model || mainModel?.model || ''
      const initialReasoningEffort = current?.reasoning_effort ?? '__inherit__'
      setAuxDraft({ provider: initialProvider, model: initialModel, reasoningEffort: initialReasoningEffort })
      setEditingAuxTask(task)
    },
    [auxiliary, mainModel]
  )

  const resetAuxiliaryModels = useCallback(async () => {
    if (!mainModel) {
      return
    }

    setApplying(true)
    setError('')

    try {
      await setModelAssignment(
        {
          model: mainModel.model,
          provider: mainModel.provider,
          scope: 'auxiliary',
          task: '__reset__'
        },
        scopeProfile
      )
      setSwitchStaleAux([])
      await refresh()
    } catch (err) {
      setCaughtError(err, m.loadFailed)
    } finally {
      setApplying(false)
    }
  }, [m.loadFailed, mainModel, refresh, scopeProfile, setCaughtError])

  const recycleStaleBackend = useCallback(async () => {
    setRestartingBackend(true)
    setError('')
    setSkewRestart(false)

    try {
      await window.hermesDesktop?.recycleBackend?.(scopeProfile)
      await refresh({ replaceSelection: true })
    } catch (err) {
      setCaughtError(err, m.restartFailed)
    } finally {
      setRestartingBackend(false)
    }
  }, [m.restartFailed, refresh, scopeProfile, setCaughtError])

  // Fallbacks are schema-backed controls in ConfigSettings. Keep this
  // controller alive there without rendering controls from another child page.
  if (!showMain && !showAuxiliary && !showMoa) {
    return null
  }

  if (loading && !mainModel) {
    return <ModelSettingsSkeleton subpage={subpage} />
  }

  const errorNotice = error && (
    <div className="mt-2 flex flex-wrap items-center gap-2 text-xs text-destructive">
      <span>{error}</span>
      {skewRestart && (
        <Button disabled={restartingBackend} onClick={() => void recycleStaleBackend()} size="sm" variant="textStrong">
          {restartingBackend && <Loader2 className="size-3.5 animate-spin" />}
          {restartingBackend ? m.restartingBackend : m.restartBackend}
        </Button>
      )}
    </div>
  )

  return (
    <div className="grid gap-6">
      {!showMain && errorNotice}
      {showMain && (
        <section>
          <p className="mb-3 text-xs text-muted-foreground">{m.appliesDesc}</p>
          <div className="grid gap-1">
            <ListRow
              action={
                <Select onValueChange={switchProvider} value={selectedProviderRow?.slug ?? selectedProvider}>
                  <SelectTrigger
                    aria-label={m.provider}
                    className={cn(
                      'w-full min-w-0 max-w-full @2xl:w-72 [&_[data-slot=select-value]]:truncate',
                      CONTROL_TEXT
                    )}
                  >
                    <SelectValue placeholder={m.provider} />
                  </SelectTrigger>
                  <SelectContent>
                    {mainProviderOptions.map(provider => (
                      <SelectItem key={provider.slug || 'none'} value={provider.slug || 'none'}>
                        {provider.name}
                      </SelectItem>
                    ))}
                  </SelectContent>
                </Select>
              }
              title={m.provider}
            />
            <ListRow
              action={
                needsSetup ? (
                  setupIsApiKey ? (
                    <div className="grid w-full min-w-0 max-w-full @2xl:w-72 justify-items-end gap-2">
                      <Input
                        autoComplete="off"
                        className={cn('min-w-0', CONTROL_TEXT)}
                        onChange={event => setApiKeyDraft(event.target.value)}
                        onKeyDown={event => {
                          if (isSubmitEnter(event)) {
                            void activateApiKeyProvider()
                          }
                        }}
                        placeholder={`Paste ${selectedProviderRow?.key_env ?? 'API key'}`}
                        type="password"
                        value={apiKeyDraft}
                      />
                      <Button
                        disabled={!apiKeyDraft.trim() || activating}
                        onClick={() => void activateApiKeyProvider()}
                        size="sm"
                      >
                        {activating && <Loader2 className="size-3.5 animate-spin" />}
                        {activating ? 'Activating...' : 'Activate'}
                      </Button>
                    </div>
                  ) : (
                    <Button onClick={startProviderSetup} size="sm" variant="textStrong">
                      {m.setUpProvider(selectedProviderRow?.name ?? m.setupProviderFallback)}
                    </Button>
                  )
                ) : (
                  <ModelSelect
                    aria-label={m.model}
                    className="w-full min-w-0 max-w-full @2xl:w-72 [&_[data-slot=select-value]]:truncate"
                    models={selectedProviderModels}
                    onValueChange={setSelectedModel}
                    provider={selectedProviderRow}
                    providerSlug={selectedProvider}
                    value={selectedModel}
                  />
                )
              }
              title={m.model}
            />
          </div>
          {!needsSetup && (
            <div className="flex justify-end pt-1">
              <Button
                disabled={!selectedProvider || !selectedModel || applying}
                onClick={() => void applyMainModel()}
                size="sm"
              >
                {applying && <Loader2 className="size-3.5 animate-spin" />}
                {applying ? m.applying : t.common.apply}
              </Button>
            </div>
          )}
          {needsSetup && !setupIsApiKey && selectedProviderRow && (
            <p className="mt-2 text-xs text-muted-foreground">
              {selectedProviderRow?.auth_type === 'api_key'
                ? `${selectedProviderRow?.name} needs an API key — set it up to choose a model.`
                : `${selectedProviderRow?.name} signs in through your browser — Hermes runs the flow for you.`}
            </p>
          )}
          {config && mainModel && (reasoningSupported || fastSupported || ultrafastSupported) && (
            <MainModelDefaults
              effortValue={effortValue}
              fastOn={fastOn}
              fastSupported={fastSupported}
              onChange={writeAgentDefault}
              reasoningSupported={reasoningSupported}
              speedValue={speedValue}
              ultrafastSupported={ultrafastSupported}
            />
          )}
          {errorNotice}
          {switchStaleAux.length > 0 && (
            <div className="mt-2">
              <StaleAuxWarning
                applying={applying}
                onReset={() => void resetAuxiliaryModels()}
                slots={switchStaleAux}
                taskLabel={auxiliaryTaskLabel}
              />
            </div>
          )}
        </section>
      )}

      {showAuxiliary && (
        <section>
          <div className={cn('mb-2.5 flex items-center', subpage === undefined ? 'justify-between' : 'justify-end')}>
            {subpage === undefined && <SectionHeading icon={Cpu} title={m.auxiliaryTitle} />}
            <Button
              disabled={!mainModel || applying}
              onClick={() => void resetAuxiliaryModels()}
              size="sm"
              variant="textStrong"
            >
              {m.resetAllToMain}
            </Button>
          </div>
          <p className="mb-2 text-xs text-muted-foreground">{m.auxiliaryDesc}</p>
          {(switchStaleAux.length === 0 || !showMain) && persistentStaleAux.length > 0 && !staleAuxDismissed && (
            <div className="mb-2.5">
              <StaleAuxWarning
                applying={applying}
                onDismiss={() => {
                  const mainProvider = mainModel?.provider ?? ''

                  dismissStaleAux(scopeProfile, mainProvider, persistentStaleAux)
                  setDismissedStaleAux(staleAuxFingerprint(mainProvider, persistentStaleAux))
                }}
                onReset={() => void resetAuxiliaryModels()}
                slots={persistentStaleAux}
                taskLabel={auxiliaryTaskLabel}
              />
            </div>
          )}
          <div className="grid gap-1">
            {auxRows.map(meta => {
              const copy = m.tasks[meta.key] ?? { label: meta.label ?? meta.key, hint: meta.hint ?? meta.key }
              const current = auxiliary?.tasks.find(entry => entry.task === meta.key)
              const isAuto = !current || !current.provider || current.provider === 'auto'
              const isEditing = editingAuxTask === meta.key

              return (
                <div className="scroll-mt-6 rounded-lg" id={`aux-task-${meta.key}`} key={meta.key}>
                  <ListRow
                    action={
                      !isEditing && (
                        <div className="flex shrink-0 items-center gap-1.5">
                          {meta.inheritFrom && !isAuto && (
                            <AuxFollowBaseButton
                              baseLabel={auxiliaryTaskLabel(meta.inheritFrom)}
                              disabled={applying}
                              onFollow={() => void assignAuxiliary(meta.key, AUX_FOLLOW_BASE)}
                            />
                          )}
                          <Button
                            disabled={!mainModel || applying}
                            onClick={() =>
                              mainModel && void assignAuxiliary(meta.key, auxMainRoute(mainModel, endpointForProvider))
                            }
                            size="sm"
                            variant="text"
                          >
                            {m.setToMain}
                          </Button>
                          <Button
                            disabled={!providers.length || applying}
                            onClick={() => beginAuxiliaryEdit(meta.key)}
                            size="sm"
                            variant="textStrong"
                          >
                            {m.change}
                          </Button>
                        </div>
                      )
                    }
                    below={
                      isEditing && (
                        <div className="mt-2 grid gap-2 pt-1">
                          <div className="flex flex-wrap items-center gap-2">
                            <Select
                              onValueChange={value => setAuxDraft(prev => ({ ...prev, provider: value, model: '' }))}
                              value={findCatalogProvider(providers, auxDraft.provider)?.slug ?? auxDraft.provider}
                            >
                              <SelectTrigger
                                aria-label={`${copy.label} provider`}
                                className={cn('min-w-32', CONTROL_TEXT)}
                              >
                                <SelectValue placeholder={m.provider} />
                              </SelectTrigger>
                              <SelectContent>
                                {providerOptions.map(provider => (
                                  <SelectItem key={provider.slug || 'none'} value={provider.slug || 'none'}>
                                    {provider.name}
                                  </SelectItem>
                                ))}
                              </SelectContent>
                            </Select>
                            <ModelSelect
                              aria-label={`${copy.label} model`}
                              className="min-w-48"
                              models={auxDraftProviderModels}
                              onValueChange={value => setAuxDraft(prev => ({ ...prev, model: value }))}
                              provider={findCatalogProvider(providers, auxDraft.provider)}
                              providerSlug={auxDraft.provider}
                              value={auxDraft.model}
                            />
                          </div>
                          <div className="flex flex-wrap items-center gap-2 text-xs">
                            <span className="text-muted-foreground">{m.reasoning}</span>
                            <Select
                              onValueChange={value => setAuxDraft(prev => ({ ...prev, reasoningEffort: value }))}
                              value={auxDraft.reasoningEffort}
                            >
                              <SelectTrigger
                                aria-label={`${copy.label} reasoning effort`}
                                className={cn('min-w-32', CONTROL_TEXT)}
                              >
                                <SelectValue />
                              </SelectTrigger>
                              <SelectContent>
                                <SelectItem value="__inherit__">{m.inheritMainEffort}</SelectItem>
                                {REASONING_EFFORT_VALUES.map(value => (
                                  <SelectItem key={value} value={value}>
                                    {value === 'none' ? m.reasoningOff : t.shell.modelOptions[value]}
                                  </SelectItem>
                                ))}
                              </SelectContent>
                            </Select>
                          </div>
                          <div className="flex flex-wrap items-center gap-2">
                            <Button
                              disabled={!auxDraft.provider || !auxDraft.model || applying}
                              onClick={() => void applyAuxiliaryDraft(meta.key)}
                              size="sm"
                            >
                              {applying ? m.applying : t.common.apply}
                            </Button>
                            <Button onClick={() => setEditingAuxTask(null)} size="sm" variant="ghost">
                              {t.common.cancel}
                            </Button>
                          </div>
                        </div>
                      )
                    }
                    description={
                      <AuxTaskRouteSummary
                        current={current}
                        inheritLabel={meta.inheritFrom ? auxiliaryTaskLabel(meta.inheritFrom) : undefined}
                      />
                    }
                    title={
                      <span className="flex items-baseline gap-2">
                        {copy.label}
                        <Pill>{copy.hint}</Pill>
                      </span>
                    }
                  />
                </div>
              )
            })}
          </div>
        </section>
      )}
      {showMoa && moa && currentMoaPreset && (
        <section>
          {subpage === undefined && <SectionHeading icon={Cpu} title={m.moaTitle} />}
          <p className="mb-2 text-xs text-muted-foreground">{m.moaDescription}</p>
          <div className="mb-2 flex flex-wrap items-center gap-2">
            <Select onValueChange={setSelectedMoaPreset} value={selectedMoaPreset || moa.default_preset}>
              <SelectTrigger className={cn('min-w-40', CONTROL_TEXT)}>
                <SelectValue placeholder={m.moaPreset} />
              </SelectTrigger>
              <SelectContent>
                {Object.keys(moa.presets).map(name => (
                  <SelectItem key={name} value={name}>
                    {name}
                  </SelectItem>
                ))}
              </SelectContent>
            </Select>
            <label className="flex items-center gap-2 rounded-sm border border-border px-2 py-1 text-xs">
              {m.moaEnabled}
              <Switch
                checked={currentMoaPreset.enabled !== false}
                disabled={applying}
                onCheckedChange={checked => updateMoaPreset(prev => ({ ...prev, enabled: checked }))}
                size="xs"
              />
            </label>
            <Button
              disabled={applying}
              onClick={() => {
                const next: MoaConfigResponse = {
                  ...moa,
                  default_preset: selectedMoaPreset || moa.default_preset
                }

                void saveMoa(next)
              }}
              size="sm"
              variant="text"
            >
              {m.moaSetDefault}
            </Button>
            <Button
              disabled={Object.keys(moa.presets).length <= 1 || applying}
              onClick={() => {
                if (Object.keys(moa.presets).length <= 1) {
                  return
                }

                const presets = { ...moa.presets }
                delete presets[selectedMoaPreset]
                const fallback = Object.keys(presets)[0]

                const next: MoaConfigResponse = {
                  ...moa,
                  presets,
                  default_preset: moa.default_preset === selectedMoaPreset ? fallback : moa.default_preset,
                  active_preset: moa.active_preset === selectedMoaPreset ? '' : moa.active_preset
                }

                setSelectedMoaPreset(Object.keys(moa.presets).find(name => name !== selectedMoaPreset) || '')
                void saveMoa(next)
              }}
              size="sm"
              variant="ghost"
            >
              {t.common.delete}
            </Button>
            <Input
              className={cn('w-40', CONTROL_TEXT)}
              onChange={event => setNewMoaPresetName(event.target.value)}
              placeholder={m.moaNewPresetPlaceholder}
              value={newMoaPresetName}
            />
            <Button
              disabled={!newMoaPresetName.trim() || !!moa.presets[newMoaPresetName.trim()] || applying}
              onClick={() => {
                const name = newMoaPresetName.trim()

                const next: MoaConfigResponse = {
                  ...moa,
                  presets: {
                    ...moa.presets,
                    [name]: { ...currentMoaPreset, reference_models: [...currentMoaPreset.reference_models] }
                  }
                }

                setSelectedMoaPreset(name)
                setNewMoaPresetName('')
                void saveMoa(next)
              }}
              size="sm"
              variant="textStrong"
            >
              {m.moaAddPreset}
            </Button>
          </div>
          <div className="mb-2 text-xs text-muted-foreground">
            {m.moaDefault} <span className="font-mono">{moa.default_preset}</span>
          </div>
          <div className="grid gap-1">
            {currentMoaPreset.reference_models.map((slot, index) => (
              <ListRow
                action={
                  <Switch
                    aria-label={m.moaReferenceToggle(slot.enabled !== false, index + 1)}
                    checked={slot.enabled !== false}
                    disabled={applying}
                    onCheckedChange={checked =>
                      updateMoaPreset(prev => ({
                        ...prev,
                        reference_models: prev.reference_models.map((s, i) =>
                          i === index ? { ...s, enabled: checked === true } : s
                        )
                      }))
                    }
                  />
                }
                below={
                  <div className="mt-2 flex flex-wrap items-center gap-2 pt-1">
                    <Select
                      onValueChange={value =>
                        updateMoaPreset(prev => ({
                          ...prev,
                          reference_models: prev.reference_models.map((s, i) =>
                            i === index ? updateMoaSlot(s, { provider: value }) : s
                          )
                        }))
                      }
                      value={slot.provider}
                    >
                      <SelectTrigger className={cn('min-w-32', CONTROL_TEXT)}>
                        <SelectValue placeholder={m.provider} />
                      </SelectTrigger>
                      <SelectContent>
                        {withActive(
                          moaSlotProviderOptions.map(p => p.slug || 'none'),
                          slot.provider
                        ).map(slug => {
                          const provider = moaSlotProviderOptions.find(p => (p.slug || 'none') === slug)

                          return (
                            <SelectItem key={slug} value={slug}>
                              {provider?.name || slug}
                            </SelectItem>
                          )
                        })}
                      </SelectContent>
                    </Select>
                    <ModelSelect
                      className="min-w-48"
                      models={modelsForProvider(slot.provider)}
                      onValueChange={value =>
                        updateMoaPreset(prev => ({
                          ...prev,
                          reference_models: prev.reference_models.map((s, i) =>
                            i === index ? updateMoaSlot(s, { model: value }) : s
                          )
                        }))
                      }
                      provider={findCatalogProvider(providers, slot.provider)}
                      providerSlug={slot.provider}
                      value={slot.model}
                    />
                    <Button
                      disabled={currentMoaPreset.reference_models.length <= 1 || applying}
                      onClick={() =>
                        updateMoaPreset(prev => ({
                          ...prev,
                          reference_models: prev.reference_models.filter((_, i) => i !== index)
                        }))
                      }
                      size="sm"
                      variant="ghost"
                    >
                      {t.common.remove}
                    </Button>
                  </div>
                }
                className={cn(slot.enabled === false && 'opacity-60')}
                description={
                  <span className="font-mono text-[0.68rem]">
                    {slot.provider} · {slot.model || m.model}
                  </span>
                }
                key={`${selectedMoaPreset}-${index}`}
                title={
                  <span className="flex items-baseline gap-2">
                    {m.moaReferenceTitle(index + 1)}
                    <Pill>{m.moaReferenceHint}</Pill>
                  </span>
                }
              />
            ))}
            <Button
              disabled={applying}
              onClick={() =>
                updateMoaPreset(prev => ({
                  ...prev,
                  reference_models: [...prev.reference_models, { ...prev.aggregator, enabled: true }]
                }))
              }
              size="sm"
              variant="textStrong"
            >
              {m.moaAddReference}
            </Button>
            <ListRow
              below={
                <div className="mt-2 flex flex-wrap items-center gap-2 pt-1">
                  <Select
                    onValueChange={value =>
                      updateMoaPreset(prev => ({
                        ...prev,
                        aggregator: updateMoaSlot(prev.aggregator, { provider: value })
                      }))
                    }
                    value={currentMoaPreset.aggregator.provider}
                  >
                    <SelectTrigger className={cn('min-w-32', CONTROL_TEXT)}>
                      <SelectValue placeholder={m.provider} />
                    </SelectTrigger>
                    <SelectContent>
                      {withActive(
                        moaSlotProviderOptions.map(p => p.slug || 'none'),
                        currentMoaPreset.aggregator.provider
                      ).map(slug => {
                        const provider = moaSlotProviderOptions.find(p => (p.slug || 'none') === slug)

                        return (
                          <SelectItem key={slug} value={slug}>
                            {provider?.name || slug}
                          </SelectItem>
                        )
                      })}
                    </SelectContent>
                  </Select>
                  <ModelSelect
                    className="min-w-48"
                    models={modelsForProvider(currentMoaPreset.aggregator.provider)}
                    onValueChange={value =>
                      updateMoaPreset(prev => ({
                        ...prev,
                        aggregator: updateMoaSlot(prev.aggregator, { model: value })
                      }))
                    }
                    provider={findCatalogProvider(providers, currentMoaPreset.aggregator.provider)}
                    providerSlug={currentMoaPreset.aggregator.provider}
                    value={currentMoaPreset.aggregator.model}
                  />
                </div>
              }
              description={
                <span className="font-mono text-[0.68rem]">
                  {currentMoaPreset.aggregator.provider} · {currentMoaPreset.aggregator.model}
                </span>
              }
              title={
                <span className="flex items-baseline gap-2">
                  {m.moaAggregator}
                  <Pill>{m.moaAggregatorBilled}</Pill>
                </span>
              }
            />
          </div>
        </section>
      )}
      {subpage === 'moa' && !loading && (!moa || !currentMoaPreset) && (
        <PanelEmpty
          action={
            <Button onClick={() => void refresh()} size="sm">
              {t.skills.refresh}
            </Button>
          }
          icon="error"
          title={m.loadFailed}
        />
      )}
    </div>
  )
}