Skip to content

The ultimate harness for coding agents and beyond. All your agents. All your machines. One command center. Start with code, then follow your curiosity and build across disciplines: CAD, circuits, robots, games and music.

5.1 KB
Raw Blame
/**
 * Hermes model catalog + reasoning effort → runtime-profile options.
 *
 * Hermes is the only one of the eight with no way to print its catalog: `hermes model` is interactive and
 * has no list flag. What it does have is the picker's own **disk cache** — the file `hermes model
 * --refresh` exists to wipe — so the catalog is read from there rather than by driving a TUI:
 *
 *   ~/.hermes/provider_models_cache.json
 *   { "copilot":   { "fp": …, "at": …, "models": ["gpt-5.4", …] },
 *     "anthropic": { "fp": …, "at": …, "models": ["claude-fable-5", …] } }
 *
 * Verified against the live picker (hermes 2026.07): its "Anthropic (13 models)" page lists exactly the
 * 13 ids this file holds, in the same order. The provider actually in use may be absent from the cache
 * (a `custom` gateway is configured here, and the picker shows it as its own one-model page), so the
 * model named by `config.yaml` is always offered too — see hermesConfigProfile.
 *
 * Both axes live in `~/.hermes/config.yaml`, and both are GLOBAL to the computer rather than per session:
 *
 *   model:  { default: minimax/minimax-m3, provider: custom }
 *   agent:  { reasoning_effort: medium }
 */

/** Levels hermes accepts for `agent.reasoning_effort`. */
export const HERMES_EFFORTS = new Set(['auto', 'low', 'medium', 'high'])
export const HERMES_EFFORT_LEVELS = ['low', 'medium', 'high'] as const

export interface HermesModelTarget {
  /** Model id as the picker lists it. */
  id: string
  /** Cache key of the provider page it belongs to (`anthropic`, `copilot`, …). */
  provider: string
}

function str(value: unknown): string {
  return typeof value === 'string' ? value : ''
}

/**
 * Read `provider_models_cache.json`. Each provider contributes its `models` array; anything that is not a
 * list of non-empty strings is skipped, so a half-written cache cannot invent models.
 */
export function parseHermesModelsCache(raw: unknown): HermesModelTarget[] {
  if (!raw || typeof raw !== 'object' || Array.isArray(raw)) return []
  const targets: HermesModelTarget[] = []
  const seen = new Set<string>()
  for (const [provider, blob] of Object.entries(raw as Record<string, unknown>)) {
    if (!blob || typeof blob !== 'object') continue
    const models = (blob as Record<string, unknown>).models
    if (!Array.isArray(models)) continue
    for (const entry of models) {
      const id = str(entry).trim()
      if (!id || seen.has(id)) continue
      seen.add(id)
      targets.push({ id, provider })
    }
  }
  return targets
}

/**
 * Model + reasoning effort out of `config.yaml`. Parsed by hand rather than with a YAML library: these are
 * two scalars at known paths, the adapter ships no YAML dependency, and the file is the user's — a parser
 * that only ever reads two keys cannot damage it.
 */
export function parseHermesConfig(yaml: string): { model: string | null; effort: string | null } {
  let section = ''
  let model: string | null = null
  let effort: string | null = null
  for (const rawLine of yaml.split('\n')) {
    const line = rawLine.replace(/\s+$/, '')
    if (!line.trim() || line.trimStart().startsWith('#')) continue
    if (!/^\s/.test(line)) {
      section = line.replace(/:.*$/, '').trim()
      continue
    }
    // Only the top nesting level of a section, so a `models:` block elsewhere cannot be mistaken for it.
    const entry = /^\s{2}([a-z_]+):\s*(.+?)\s*$/i.exec(line)
    if (!entry) continue
    const value = entry[2].replace(/^["']|["']$/g, '')
    if (section === 'model' && entry[1] === 'default') model = value || null
    if (section === 'agent' && entry[1] === 'reasoning_effort') {
      const level = value.toLowerCase()
      effort = HERMES_EFFORTS.has(level) ? level : null
    }
  }
  return { model, effort }
}

/**
 * The model hermes shows in its status line (`⚕ minimax-m3 │ ctx -- │ …`). It is the SHORT name — the
 * config says `minimax/minimax-m3` while the status line says `minimax-m3` — so it is only used to notice
 * that a switch landed, never as the identity itself.
 */
export function hermesStatusModel(capture: string): string | null {
  const lines = capture.split('\n')
  for (let i = lines.length - 1; i >= 0; i--) {
    const match = /⚕\s*([^\s│|]+)/.exec(lines[i])
    if (match) return match[1]
  }
  return null
}

/** The row hermes marks with `❯` in a picker page, and every selectable row on that page. */
export function parseHermesPickerPage(capture: string): { rows: string[]; selected: string | null } | null {
  const lines = capture.split('\n')
  const top = lines.findLastIndex((line) => /Model Picker/i.test(line))
  if (top < 0) return null
  const rows: string[] = []
  let selected: string | null = null
  for (const line of lines.slice(top)) {
    // Rows live inside a box: `│ ❯ claude-fable-5    │`.
    const match = /^\s*│\s*(❯)?\s*(\S.*?)\s*│\s*$/.exec(line)
    if (!match) continue
    const label = match[2].replace(/\s*←\s*current\s*$/i, '').trim()
    if (!label || /^Current:/i.test(label)) continue
    rows.push(label)
    if (match[1]) selected = label
  }
  return rows.length ? { rows, selected } : null
}