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.2 KB
Raw Blame
/**
 * Pi model catalog + thinking level → runtime-profile options.
 *
 * `pi --list-models` prints a fixed-width table on stdout (columns separated by runs of spaces):
 *
 *   provider  model               context  max-out  thinking  images
 *   vibe      minimax/minimax-m3  500K     65.5K    yes       no
 *
 * The `thinking` column is what makes pi's effort axis honest: only a model marked `yes` accepts a
 * reasoning depth, so effort rows are attached per model rather than assumed (verified live, pi 0.82).
 *
 * Pi separates the two axes in its UI, and both were driven end to end during the probe:
 *  - **model** — `/model <provider/model>` takes the target directly (its own autocomplete documents
 *    `<provider/model> — Select model (opens selector UI)`).
 *  - **thinking** — `/settings` → filter `thinking` → the "Thinking Level" list, a fixed ladder navigated
 *    with the arrow keys. There is no slash command for it.
 *
 * The idle footer carries **both**: `minimax/minimax-m3 • high`. That single line is the observation
 * source, and watching it flip `medium` → `high` is how the applied profile is confirmed.
 */

/** Pi's thinking ladder, in the order its settings list renders — the step count drives the arrow keys. */
export const PI_THINKING_LEVELS = ['off', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max'] as const
export const PI_EFFORTS = new Set<string>(['auto', ...PI_THINKING_LEVELS])

export interface PiModelTarget {
  /** `<provider>/<model>` as printed — also the argument for `/model`. */
  id: string
  provider: string
  /** The model column verbatim; it can itself contain a slash (`minimax/minimax-m3`). */
  model: string
  /** True when the `thinking` column says `yes`; only then are effort rows offered. */
  thinking: boolean
}

const HEADER_RE = /^\s*provider\s+model\s/i

/**
 * Parse `pi --list-models`. The header row and anything that does not have at least the provider, model
 * and thinking columns are skipped, so a future column or a wrapped warning line cannot invent a model.
 */
export function parsePiModelsOutput(output: string): PiModelTarget[] {
  const targets: PiModelTarget[] = []
  const seen = new Set<string>()
  for (const rawLine of output.split('\n')) {
    if (!rawLine.trim() || HEADER_RE.test(rawLine)) continue
    const cells = rawLine.trim().split(/\s{2,}/)
    if (cells.length < 5) continue
    const [provider, model] = cells
    if (!/^[\w.-]+$/.test(provider) || !model) continue
    // `thinking` is the second-to-last column (`images` closes the row).
    const thinking = /^yes$/i.test(cells[cells.length - 2] ?? '')
    const id = `${provider}/${model}`
    if (seen.has(id)) continue
    seen.add(id)
    targets.push({ id, provider, model, thinking })
  }
  return targets
}

/**
 * Model + thinking level out of pi's idle footer (`minimax/minimax-m3 • high`). Returns null rather than a
 * half-read pair, so a redraw mid-capture can never be mistaken for a profile change.
 */
export function parsePiFooterProfile(capture: string): { model: string; effort: string } | null {
  const lines = capture.split('\n')
  for (let i = lines.length - 1; i >= 0; i--) {
    // Two shapes in the wild: `minimax/minimax-m3 • high`, and `… • thinking off` once the level is off.
    const match = /(\S+)\s+•\s+(?:thinking\s+)?([a-z]+)\s*$/i.exec(lines[i].replace(/\s+$/, ''))
    if (!match) continue
    const effort = match[2].toLowerCase()
    if (!PI_EFFORTS.has(effort)) continue
    return { model: match[1], effort }
  }
  return null
}

/**
 * The model at the right of Pi 1.0's usage line (`0.0%/256k (auto)          Qwen/Qwen3.8-27B`), which no
 * longer says the thinking level. The window's edge clips a long name (`DeepSeek-V4-Fla`), so only a name
 * that is exactly one of [known] (the `pi --list-models` catalog) is taken: a clipped one is no model at
 * all. A Pi that has not answered yet has no session record to say it, so this is all there is then.
 */
export function parsePi1FooterModel(capture: string, known: ReadonlySet<string>): string | null {
  const lines = capture.split('\n')
  for (let i = lines.length - 1; i >= 0; i--) {
    const match = /\d%\/\d+(?:\.\d+)?[kKmM]\b.*?\s{2,}(\S+)\s*$/.exec(lines[i])
    if (match) return known.has(match[1]) ? match[1] : null
  }
  return null
}

/**
 * Steps to walk pi's "Thinking Level" list from one level to another: positive means Down. Null when
 * either end is not on the ladder, which the caller must treat as "do not drive the list blind".
 */
export function piThinkingSteps(from: string, to: string): number | null {
  const start = PI_THINKING_LEVELS.indexOf(from as typeof PI_THINKING_LEVELS[number])
  const end = PI_THINKING_LEVELS.indexOf(to as typeof PI_THINKING_LEVELS[number])
  if (start < 0 || end < 0) return null
  return end - start
}

/** The level pi marks as current in its Thinking Level list (`→ medium  Moderate reasoning`). */
export function parsePiThinkingSelection(capture: string): string | null {
  for (const line of capture.split('\n')) {
    const match = /^\s*[→>]\s+([a-z]+)\b/i.exec(line)
    if (!match) continue
    const level = match[1].toLowerCase()
    if (PI_EFFORTS.has(level) && level !== 'auto') return level
  }
  return null
}