reslop 0.3.0 → 0.3.2

package/lib/agents/models.js

@@ -1,47 +1,16 @@
 'use strict';
 
-const { jsonParse, isHashObject } = require('metautil');
-const { stripAnsi } = require('../term/ansi.js');
+const { isHashObject } = require('metautil');
 const { trimText } = require('../common/utilities.js');
 
-const MODEL_ID = /^[A-Za-z][A-Za-z0-9_./:+#-]*$/;
-const SKIP_TOKEN = new RegExp(
-  '^(no|available|loading|fetching|usage|help|try|tip|error|' +
-    'warning|command|commands|options|flag|version|' +
-    'unknown|invalid)$',
-  'i',
-);
-const CURSOR_ROW = /^([A-Za-z][A-Za-z0-9_./:+#-]*)\s+-\s+\S/;
-const CURSOR_NOISE = /^(?:loading models|available models$|tip:|no models)/i;
-const AVAILABLE_LINE = /^Available models:\s*(.+)$/i;
-const WIDE_LABEL = /\b1M\b/;
-const CONTEXT_TAG = /\[context=[^\]]*\]$/;
-// list-models repeats one slug for every context, so 500k is unlabeled
-const MODEL_CONTEXTS = {
-  'grok-4.7': ['256k', '500k'],
-};
-const JSON_KEYS = ['slug', 'id', 'model', 'modelID', 'name'];
-const OPTION_LINE = /^\s*(?:-\w,\s*)?--[\w-]+/;
-// (a, b), <a|b>, {a,b} or [possible values: a, b] in an option's help
-const VALUE_LIST =
-  /[(<[{](?:[a-z ]+:)?\s*("?[\w-]+"?(?:\s*[,|]\s*"?[\w-]+"?)+)\s*[)>\]}]/i;
-const QUOTED_NAME = /'([A-Za-z][\w.:-]*)'/g;
-const FAST = '-fast';
-const THINKING = '-thinking';
-
-const EFFORT_LEVELS = [
-  'extra-high',
-  'xhigh',
-  'minimal',
-  'medium',
-  'none',
-  'high',
-  'max',
-  'low',
-];
+const EFFORT_KEYS = ['effort', 'reasoning_effort', 'reasoning'];
+const MODEL_ID = /^([^[\]]+)\[(.*)\]$/;
+const FAST_NAME = /fast/i;
+const CONTEXT_NAME = /^context/i;
+const FAST_VALUES = ['off', 'on'];
+const SWITCHES = [FAST_VALUES, ['false', 'true']];
 
 const EFFORT_RANK = [
-  'default',
   'none',
   'minimal',
   'low',
@@ -50,411 +19,316 @@ const EFFORT_RANK = [
   'xhigh',
   'extra-high',
   'max',
+  'ultra',
 ];
 
-const textLines = (text) => {
-  const lines = [];
-  for (const raw of stripAnsi(`${text ?? ''}`).split('\n')) {
-    const line = raw.trim();
-    if (line) lines.push(line);
-  }
-  return lines;
+const concrete = (name) => {
+  const text = trimText(name);
+  return text === 'default' ? '' : text;
 };
 
-const uniqueNames = (names) => {
-  const unique = new Set();
-  for (const raw of names) {
-    const name = trimText(raw);
-    if (name) unique.add(name);
-  }
-  return [...unique];
-};
+const unique = (values) => [...new Set(values.filter(Boolean))];
 
-const parseNameList = (text) => {
-  const names = [];
-  for (const line of textLines(text)) {
-    const token = line.split(/\s+/)[0].replace(/:+$/, '');
-    if (MODEL_ID.test(token) && !SKIP_TOKEN.test(token)) names.push(token);
-  }
-  return uniqueNames(names);
+const switchValue = (value) => {
+  if (value === 'true' || value === 'on') return 'on';
+  if (value === 'false' || value === 'off') return 'off';
+  return '';
 };
 
-const parseCursorModels = (text) => {
-  const names = [];
-  for (const line of textLines(text)) {
-    if (CURSOR_NOISE.test(line)) continue;
-    const listed = AVAILABLE_LINE.exec(line);
-    const row = listed ? null : CURSOR_ROW.exec(line);
-    if (listed) names.push(...listed[1].split(','));
-    else if (row) names.push(row[1]);
+// name[key=value,...] or name[effort]: one model id carries its own settings
+const parseModelId = (id) => {
+  const text = trimText(id);
+  const variant = { id: text, name: text, effort: '', context: '', fast: '' };
+  const match = MODEL_ID.exec(text);
+  if (!match) return variant;
+  variant.name = match[1].trim();
+  for (const part of match[2].split(',')) {
+    const [key, ...rest] = part.split('=');
+    const value = rest.join('=').trim();
+    const name = key.trim();
+    if (!rest.length) variant.effort ||= name;
+    else if (EFFORT_KEYS.includes(name)) variant.effort = value;
+    else if (name === 'context') variant.context = value;
+    else if (name === 'fast') variant.fast = switchValue(value);
   }
-  return names.length ? uniqueNames(names) : parseNameList(text);
+  return variant;
 };
 
-const parseCursorWide = (text) => {
-  const names = [];
-  for (const line of textLines(text)) {
-    const row = CURSOR_ROW.exec(line);
-    if (row && WIDE_LABEL.test(line)) names.push(row[1]);
-  }
-  return uniqueNames(names);
+const optionValues = (option) => {
+  const values = [];
+  const collect = (items) => {
+    for (const item of Array.isArray(items) ? items : []) {
+      if (!isHashObject(item)) continue;
+      if (Array.isArray(item.options)) collect(item.options);
+      else if (typeof item.value === 'string') values.push(item.value);
+    }
+  };
+  collect(option ? option.options : []);
+  return values;
 };
 
-// The help of one option: its line and the indented lines that follow
-const optionHelp = (text, flag) => {
-  const lines = stripAnsi(`${text ?? ''}`).split('\n');
-  const named = (line) => OPTION_LINE.test(line) && line.includes(flag);
-  const at = flag ? lines.findIndex(named) : -1;
-  if (at < 0) return '';
-  const block = [lines[at]];
-  for (const line of lines.slice(at + 1)) {
-    if (OPTION_LINE.test(line) || /^\S/.test(line)) break;
-    block.push(line.trim());
-  }
-  return block.join(' ');
+const selects = (options) => {
+  const listed = Array.isArray(options) ? options : [];
+  return listed.filter(
+    (option) => isHashObject(option) && typeof option.id === 'string',
+  );
 };
 
-const optionValues = (text, flag) => {
-  const listed = VALUE_LIST.exec(optionHelp(text, flag));
-  if (!listed) return [];
-  const values = listed[1].split(/[,|]/);
-  return uniqueNames(values.map((value) => value.replaceAll('"', '')));
+const optionIn = (options, category) => {
+  const listed = selects(options);
+  const byCategory = listed.find((option) => option.category === category);
+  return byCategory ?? listed.find((option) => option.id === category) ?? null;
 };
 
-const parseHelpModels = (text) => {
-  const help = optionHelp(text, '--model');
-  return uniqueNames([...help.matchAll(QUOTED_NAME)].map((hit) => hit[1]));
-};
+const optionsOf = (state) => (state ? state.configOptions : null);
 
-const jsonStart = (text) => {
-  const starts = [text.indexOf('{'), text.indexOf('[')].filter((at) => at >= 0);
-  return starts.length ? Math.min(...starts) : -1;
-};
+const optionOf = (state, category) => optionIn(optionsOf(state), category);
 
-const jsonModelId = (value) => {
-  for (const key of JSON_KEYS) {
-    const id = value[key];
-    if (typeof id === 'string' && id.trim()) return id.trim();
+// A switch is named by the agent: on and off, or true and false
+const fastIn = (options) => {
+  for (const option of selects(options)) {
+    if (!FAST_NAME.test(option.id)) continue;
+    const values = optionValues(option);
+    const pair = SWITCHES.find((names) =>
+      names.every((value) => values.includes(value)),
+    );
+    if (pair) return { option, off: pair[0], on: pair[1] };
   }
-  return '';
+  return null;
 };
 
-const jsonEfforts = (value) => {
-  const listed = value.supported_reasoning_levels;
-  if (!Array.isArray(listed)) return [];
-  const levels = listed.map((item) =>
-    isHashObject(item) ? item.effort : item,
-  );
-  return uniqueNames(levels.filter((level) => typeof level === 'string'));
+const contextIn = (options) =>
+  selects(options).find((option) => CONTEXT_NAME.test(option.id)) ?? null;
+
+const listedModels = (state) => {
+  const models = state && isHashObject(state.models) ? state.models : {};
+  const listed = Array.isArray(models.availableModels)
+    ? models.availableModels
+    : [];
+  const ids = listed.map((model) => (isHashObject(model) ? model.modelId : ''));
+  const current = trimText(models.currentModelId);
+  return { ids: ids.filter((id) => typeof id === 'string' && id), current };
 };
 
-const collectJsonModels = (value, found) => {
-  if (Array.isArray(value)) {
-    for (const item of value) {
-      if (typeof item === 'string') found.push({ id: item, efforts: [] });
-      else collectJsonModels(item, found);
+const groupVariants = (ids) => {
+  const entries = new Map();
+  for (const id of ids) {
+    const variant = parseModelId(id);
+    if (!variant.name) continue;
+    if (!entries.has(variant.name)) {
+      entries.set(variant.name, { name: variant.name, variants: [] });
     }
-    return found;
+    entries.get(variant.name).variants.push(variant);
   }
-  if (!isHashObject(value)) return found;
-  const id = jsonModelId(value);
-  const shown = id && value.visibility !== 'hide';
-  if (shown) found.push({ id, efforts: jsonEfforts(value) });
-  if (value.models) collectJsonModels(value.models, found);
-  if (value.data) collectJsonModels(value.data, found);
-  return found;
-};
-
-const jsonModels = (text) => {
-  const start = jsonStart(text);
-  const data = start < 0 ? null : jsonParse(text.slice(start));
-  return collectJsonModels(data, []);
+  return entries;
 };
 
-const parseJsonModels = (text) => {
-  const plain = stripAnsi(`${text ?? ''}`);
-  const names = jsonModels(plain).map((model) => model.id);
-  return names.length ? uniqueNames(names) : parseNameList(plain);
+const rankOf = (level) => {
+  const at = EFFORT_RANK.indexOf(level);
+  return at < 0 ? EFFORT_RANK.length : at;
 };
 
-// Effort levels each model lists for itself, keyed by the model id
-const parseJsonEfforts = (text) => {
-  const efforts = new Map();
-  for (const model of jsonModels(stripAnsi(`${text ?? ''}`))) {
-    if (model.efforts.length) efforts.set(model.id, model.efforts);
+const fitEffort = (levels, effort) => {
+  const want = concrete(effort);
+  if (!levels || !levels.length) return want;
+  if (levels.length === 1) return levels[0];
+  if (!want || levels.includes(want)) return want;
+  let best = levels[0];
+  for (const level of levels) {
+    const gap = Math.abs(rankOf(level) - rankOf(want));
+    if (gap < Math.abs(rankOf(best) - rankOf(want))) best = level;
   }
-  return efforts;
-};
-
-// A full listing replaces the built-in names, a partial one extends them
-const mergeModels = (fallback, listed, partial = false) => {
-  const names = listed ?? [];
-  const kept = partial || !names.length;
-  const known = kept && fallback ? fallback : [];
-  return uniqueNames(['default', ...names, ...known]);
+  return best;
 };
 
-const cutSuffix = (name, suffix) => {
-  if (!name.endsWith(suffix) || name.length <= suffix.length) return '';
-  return name.slice(0, -suffix.length);
-};
+const byRank = (left, right) => rankOf(left) - rankOf(right);
 
-const withoutFast = (name) => cutSuffix(name, FAST) || name;
+const variantValues = (entry, field) =>
+  entry ? unique(entry.variants.map((variant) => variant[field])) : [];
 
-const effortTail = (name) => {
-  for (const level of EFFORT_LEVELS) {
-    const base = cutSuffix(name, `-${level}`);
-    if (base) return { base, level };
+// What one agent session offers: its models and the settings of each
+class ModelCatalog {
+  constructor(state) {
+    const option = optionOf(state, 'model');
+    const listed = listedModels(state);
+    const ids = option ? optionValues(option) : listed.ids;
+    const current = option ? option.currentValue : listed.current;
+    this.loaded = Boolean(state);
+    this.configId = option ? option.id : '';
+    this.entries = groupVariants(ids);
+    this.names = [...this.entries.keys()];
+    this.currentId = trimText(current);
+    this.current = parseModelId(this.currentId).name;
+    // The model list can name the efforts of each model the option leaves out
+    this.listed = option ? groupVariants(listed.ids) : new Map();
+    this.session = selects(optionsOf(state));
+    // An agent asked model by model has options that are not the session's
+    this.byModel = state && state.byModel instanceof Map ? state.byModel : null;
   }
-  return null;
-};
 
-const hasFastTail = (name) => {
-  const unfast = cutSuffix(name, FAST);
-  if (!unfast) return false;
-  const unthink = cutSuffix(unfast, THINKING);
-  return Boolean(effortTail(unfast) || (unthink && effortTail(unthink)));
-};
-
-const splitEffortModel = (id) => {
-  const name = trimText(id);
-  if (!name) return null;
-  const fast = hasFastTail(name);
-  let rest = fast ? cutSuffix(name, FAST) : name;
-  let thinking = '';
-  const unthink = cutSuffix(rest, THINKING);
-  if (unthink && effortTail(unthink)) {
-    rest = unthink;
-    thinking = 'after';
+  find(name) {
+    return this.entries.get(trimText(name)) ?? null;
   }
-  const hit = effortTail(rest);
-  if (!hit) return null;
-  const before = cutSuffix(hit.base, THINKING);
-  if (before) thinking = 'before';
-  const base = before || hit.base;
-  return { base, effort: hit.level, thinking, fast, id: name };
-};
 
-const contextFamily = (model) => {
-  const raw = `${model ?? ''}`.replace(CONTEXT_TAG, '').trim();
-  const base = withoutFast(raw);
-  const part = splitEffortModel(base);
-  return part ? part.base : base;
-};
+  described(entry) {
+    const { byModel } = this;
+    const variant = entry.variants.find((item) => byModel.has(item.id));
+    return variant ? byModel.get(variant.id) : null;
+  }
 
-const contextMenu = (model, wide, catalog, fallback) => {
-  const sizes = [];
-  for (const size of fallback ?? []) {
-    const text = trimText(size);
-    if (text && text !== 'default') sizes.push(text);
+  // The settings of a model are unknown until the agent was asked about it
+  unknown(name) {
+    const entry = this.find(name);
+    return Boolean(entry && this.byModel && !this.described(entry));
   }
-  if (!sizes.length) return [];
-  const named = MODEL_CONTEXTS[contextFamily(model)];
-  if (named) return named.slice();
-  if (!trimText(model) || catalog.hasWide(wide, model)) return sizes;
-  return sizes.filter((size) => size !== '1m');
-};
 
-const modelLabel = (part) => {
-  const thinking = part.thinking ? THINKING : '';
-  return `${part.base}${thinking}${part.fast ? FAST : ''}`;
-};
+  options(name) {
+    const entry = this.find(name);
+    if (!entry) return [];
+    if (!this.byModel) return this.session;
+    return this.described(entry) ?? [];
+  }
 
-const groupKey = (part) =>
-  `${part.base}\0${part.thinking}\0${part.fast ? 'fast' : ''}`;
+  efforts(name) {
+    const own = variantValues(this.find(name), 'effort');
+    if (own.length) return own.sort(byRank);
+    const listed = variantValues(this.listed.get(trimText(name)), 'effort');
+    if (listed.length) return listed.sort(byRank);
+    const option = optionIn(this.options(name), 'thought_level');
+    return unique(optionValues(option).map(concrete));
+  }
 
-const rankedLevels = (ids) => {
-  const levels = EFFORT_RANK.filter((level) => ids.has(level));
-  for (const level of ids.keys()) {
-    if (!levels.includes(level)) levels.push(level);
+  contexts(name) {
+    const own = variantValues(this.find(name), 'context');
+    return own.length ? own : optionValues(contextIn(this.options(name)));
   }
-  return levels;
-};
 
-const groupEntry = (group) => ({
-  model: group.model,
-  encoded: true,
-  levels: rankedLevels(group.ids),
-  ids: group.ids,
-});
-
-const plainEntry = (name) => ({
-  model: name,
-  encoded: false,
-  levels: [],
-  ids: new Map([['default', name]]),
-});
-
-const defaultGroup = (groups, name) => {
-  const direct = groups.get(`${name}\0\0`);
-  if (direct && !direct.ids.has('default')) return direct;
-  for (const group of groups.values()) {
-    if (group.model === name && !group.ids.has('default')) return group;
+  fasts(name) {
+    const own = variantValues(this.find(name), 'fast');
+    if (own.length) return own;
+    return fastIn(this.options(name)) ? FAST_VALUES : [];
   }
-  return null;
-};
 
-const groupModels = (ids) => {
-  const names = uniqueNames(ids ?? []);
-  const groups = new Map();
-  const owners = new Map();
-  const plain = [];
-  for (const name of names) {
-    const part = splitEffortModel(name);
-    if (!part) {
-      plain.push(name);
-      continue;
+  variant(entry, picked) {
+    const effort = concrete(picked.effort);
+    const context = trimText(picked.context);
+    const fast = picked.fast === true ? 'on' : 'off';
+    let best = null;
+    let top = -1;
+    for (const variant of entry.variants) {
+      let score = variant.id === this.currentId ? 1 : 0;
+      if (effort && variant.effort === effort) score += 8;
+      if (context && variant.context === context) score += 4;
+      if (variant.fast === fast) score += 2;
+      if (score > top) [best, top] = [variant, score];
     }
-    const key = groupKey(part);
-    if (!groups.has(key)) {
-      groups.set(key, { model: modelLabel(part), ids: new Map() });
-    }
-    const group = groups.get(key);
-    if (!group.ids.has(part.effort)) group.ids.set(part.effort, name);
-    owners.set(name, group);
-  }
-  for (const name of plain) {
-    const group = defaultGroup(groups, name);
-    if (!group) continue;
-    group.ids.set('default', name);
-    owners.set(name, group);
+    return best;
   }
-  const entries = [];
-  const listed = new Set();
-  for (const name of names) {
-    const group = owners.get(name) ?? null;
-    const slot = group ?? name;
-    if (listed.has(slot)) continue;
-    listed.add(slot);
-    entries.push(group ? groupEntry(group) : plainEntry(name));
+
+  // What a run of the model gets: the picked settings where it offers them
+  resolve(name, picked) {
+    const entry = this.find(name);
+    const variant = entry ? this.variant(entry, picked) : {};
+    const options = this.options(name);
+    const given = (option) => trimText(option ? option.currentValue : '');
+    const pick = (offered, want, option) =>
+      offered.includes(want) ? want : given(option);
+    const levels = this.efforts(name);
+    const effort = optionIn(options, 'thought_level');
+    const level = concrete(pick(levels, concrete(picked.effort), effort));
+    const sizes = this.contexts(name);
+    const size = pick(sizes, trimText(picked.context), contextIn(options));
+    const asked = fastIn(options) && picked.fast === true ? 'on' : 'off';
+    return {
+      id: variant.id ?? '',
+      effort: variant.effort || (levels.includes(level) ? level : ''),
+      context: variant.context || (sizes.includes(size) ? size : ''),
+      fast: variant.fast || asked,
+    };
   }
-  return entries;
-};
+}
 
-const fitEffort = (levels, effort) => {
-  const want = trimText(effort) || 'default';
-  if (!levels || !levels.length) return 'default';
-  if (levels.includes(want)) return want;
-  const named = levels.find((level) => {
-    const name = trimText(level);
-    return name && name !== 'default';
-  });
-  return named ?? levels[0];
-};
+const EMPTY_CATALOG = new ModelCatalog(null);
+const catalogs = new WeakMap();
 
-const plainResolved = (model, effort) => ({
-  model,
-  encoded: false,
-  effort,
-  family: model,
-  levels: [],
-});
-
-const entryResolved = (entry, effort) => {
-  if (!entry.encoded) return plainResolved(entry.model, effort);
-  const level = fitEffort(entry.levels, effort);
-  return {
-    model: entry.ids.get(level) ?? entry.model,
-    encoded: true,
-    effort: level,
-    family: entry.model,
-    levels: entry.levels,
-  };
+const catalogOf = (state) => {
+  if (!isHashObject(state)) return EMPTY_CATALOG;
+  if (!catalogs.has(state)) catalogs.set(state, new ModelCatalog(state));
+  return catalogs.get(state);
 };
 
-const entryNames = (entry) => [entry.model, ...entry.ids.values()];
-
-class ModelCatalog {
-  constructor(ids) {
-    this.entries = groupModels(ids);
-    this.byName = new Map();
-    for (const entry of this.entries) {
-      if (!this.byName.has(entry.model)) this.byName.set(entry.model, entry);
-    }
-  }
+const setOption = (option, value) => {
+  if (!option || option.currentValue === value) return null;
+  if (!optionValues(option).includes(value)) return null;
+  const params = { configId: option.id, value };
+  return { method: 'session/set_config_option', params };
+};
 
-  find(name) {
-    return this.byName.get(name) ?? null;
+const modelRequest = (catalog, id) => {
+  if (!catalog.configId) {
+    return { method: 'session/set_model', params: { modelId: id } };
   }
+  const params = { configId: catalog.configId, value: id };
+  return { method: 'session/set_config_option', params };
+};
 
-  hasFast() {
-    return this.entries.some((entry) => entry.model.endsWith(FAST));
-  }
+// An unlisted model keeps the one the agent already runs
+const modelChange = (state, picked) => {
+  const catalog = catalogOf(state);
+  const name = catalog.find(picked.model) ? picked.model : catalog.current;
+  const { id } = catalog.resolve(name, picked);
+  if (!id || id === catalog.currentId) return null;
+  return modelRequest(catalog, id);
+};
 
-  prefixed(entry, name) {
-    if (entry && entry.encoded) return null;
-    const base = withoutFast(entry ? entry.model : trimText(name));
-    if (!base || base.startsWith('cursor-')) return null;
-    const found = this.find(`cursor-${base}`);
-    return found && found.encoded ? found : null;
-  }
+const effortChange = (state, picked) =>
+  setOption(optionOf(state, 'thought_level'), concrete(picked.effort));
 
-  resolve(choice) {
-    const effort = trimText(choice.effort) || 'default';
-    const entry = this.find(choice.model);
-    const prefixed = this.prefixed(entry, choice.model);
-    if (prefixed) return entryResolved(prefixed, effort);
-    if (entry) return entryResolved(entry, effort);
-    const part = splitEffortModel(choice.model);
-    const family = part ? this.find(modelLabel(part)) : null;
-    if (!family) return plainResolved(choice.model, effort);
-    return entryResolved(family, effort === 'default' ? part.effort : effort);
-  }
+const contextChange = (state, picked) =>
+  setOption(contextIn(optionsOf(state)), trimText(picked.context));
 
-  withFast(resolved, fast) {
-    const family = `${resolved.family ?? ''}`;
-    const onFast = family.endsWith(FAST);
-    if (!family || (fast === true) === onFast) return resolved;
-    const other = onFast ? withoutFast(family) : `${family}${FAST}`;
-    const entry = this.find(other);
-    return entry ? entryResolved(entry, resolved.effort) : resolved;
-  }
+const fastChange = (state, picked) => {
+  const fast = fastIn(optionsOf(state));
+  if (!fast) return null;
+  return setOption(fast.option, picked.fast === true ? fast.on : fast.off);
+};
 
-  hasWide(wide, model) {
-    if (!(wide instanceof Set)) return true;
-    const raw = `${model ?? ''}`.replace(CONTEXT_TAG, '');
-    const base = withoutFast(raw);
-    if (!base || base === 'default') return true;
-    if (wide.has(raw) || wide.has(base)) return true;
-    const wanted = new Set([base, `${base}${FAST}`, raw]);
-    return this.entries.some((entry) => {
-      const names = entryNames(entry);
-      if (!names.some((name) => wanted.has(name))) return false;
-      return names.some((name) => wide.has(name));
-    });
-  }
-}
+const modeChange = (state, mode) => {
+  if (!mode) return null;
+  const option = optionOf(state, 'mode');
+  if (option) return setOption(option, mode);
+  const modes = state && isHashObject(state.modes) ? state.modes : {};
+  const listed = Array.isArray(modes.availableModes)
+    ? modes.availableModes
+    : [];
+  const offered = listed.some((item) => isHashObject(item) && item.id === mode);
+  if (!offered || modes.currentModeId === mode) return null;
+  return { method: 'session/set_mode', params: { modeId: mode } };
+};
 
-const EMPTY_CATALOG = new ModelCatalog([]);
-const catalogs = new WeakMap();
+const emptyChoice = () => ({ model: '', effort: '', fast: false, context: '' });
 
-const catalogOf = (models) => {
-  if (!Array.isArray(models)) return EMPTY_CATALOG;
-  if (!catalogs.has(models)) catalogs.set(models, new ModelCatalog(models));
-  return catalogs.get(models);
+const choiceOf = (picked) => {
+  const from = isHashObject(picked) ? picked : {};
+  return {
+    model: trimText(from.model),
+    effort: concrete(from.effort),
+    fast: from.fast === true,
+    context: trimText(from.context),
+  };
 };
 
-const emptyChoice = (row) => ({
-  model: row && row.models && row.models[0] ? row.models[0] : 'default',
-  effort: 'default',
-  extra: '',
-  fast: false,
-  context: '',
-});
-
 module.exports = {
+  concrete,
+  parseModelId,
   catalogOf,
-  parseNameList,
-  parseCursorModels,
-  parseCursorWide,
-  parseJsonModels,
-  parseJsonEfforts,
-  parseHelpModels,
-  optionValues,
-  mergeModels,
-  contextMenu,
-  groupModels,
   fitEffort,
-  withoutFast,
+  modelRequest,
+  modelChange,
+  effortChange,
+  contextChange,
+  fastChange,
+  modeChange,
   emptyChoice,
+  choiceOf,
 };