@tiens.nguyen/gu-cli 1.0.782 → 1.0.784

package/model-prices.mjs

@@ -0,0 +1,484 @@
+/**
+ * MODEL PRICES AND WHAT A TURN COST (#323).
+ *
+ * The user: "estimate cost of USD after each turn" — from each provider's price per 1 million INPUT
+ * tokens (output ignored for now, but stored so turning it on needs no migration), with the cheaper
+ * CACHED-input price for the part of each step the provider served from its prompt cache.
+ *
+ * HOW MUCH WAS CACHED. The agent reads the provider's own count when it reports one (OpenAI
+ * usage.prompt_tokens_details.cached_tokens, Anthropic cache_read_input_tokens, Kimi cached_tokens
+ * — see _cached_tokens_from_usage in gonext_agent_chat.py) and the cost then uses it: "$0.04".
+ * When nothing is reported, gu ASSUMES 90% of every step after the first was cached — what the
+ * user sees on the Kimi and Claude consoles for gu's turns — and says so: "~$0.04".
+ *
+ * Prices live in the user's own Mongo (one row per server + model, via the local API); this file is
+ * pure — the table it ships (PRICE_TABLE) is what an empty Mongo is seeded with, and what the Deploy
+ * app's "Prices" button exports for the admin to publish.
+ */
+
+export const PRICE_TABLE_VERSION = "1.0";
+/** Of a step after the first, the share assumed served from the cache when the provider says nothing. */
+export const ASSUMED_CACHED_SHARE = 0.9;
+export const MAX_PRICE_ROWS = 500;
+const MAX_PRICE = 1000; // USD per 1M tokens — anything above is a typo (per-token, per-1k…)
+
+const ANTHROPIC = "https://platform.claude.com/docs/en/about-claude/pricing";
+const OPENAI = "https://developers.openai.com/api/docs/pricing";
+const KIMI = "https://platform.kimi.ai/docs/pricing/chat";
+const OLLAMA = "https://ollama.com/pricing";
+const CHECKED = "2026-10-01";
+
+/** [host, model, input, cachedInput, output, cacheWrite?] — USD per 1M tokens. */
+const ROWS = [
+  // Anthropic — cache write (5 minutes) is 1.25× input; gu does not price writes yet (noted per row).
+  ["api.anthropic.com", "claude-fable-5-1", 10, 0.25, 50, 12.5],
+  ["api.anthropic.com", "claude-opus-5-5", 4, 0.2, 20, 5],
+  ["api.anthropic.com", "claude-opus-5", 5, 0.5, 25, 6.25],
+  ["api.anthropic.com", "claude-opus-4-8", 5, 0.5, 25, 6.25],
+  ["api.anthropic.com", "claude-sonnet-5-5", 2, 0.2, 10, 2.5],
+  ["api.anthropic.com", "claude-sonnet-5", 2, 0.2, 10, 2.5],
+  ["api.anthropic.com", "claude-sonnet-4-6", 3, 0.3, 15, 3.75],
+  ["api.anthropic.com", "claude-sonnet-4-5", 3, 0.3, 15, 3.75],
+  ["api.anthropic.com", "claude-haiku-4-5", 1, 0.1, 5, 1.25],
+  // OpenAI (standard tier)
+  ["api.openai.com", "gpt-6-astra", 10, 1, 50],
+  ["api.openai.com", "gpt-6.1-sol", 2, 0.1, 10],
+  ["api.openai.com", "gpt-6-sol", 2, 0.2, 10],
+  ["api.openai.com", "gpt-6-luna", 0.1, 0.01, 0.5],
+  ["api.openai.com", "gpt-5.6-sol", 4, 0.4, 20],
+  ["api.openai.com", "gpt-5.6-terra", 2, 0.2, 12],
+  ["api.openai.com", "gpt-5.6-luna", 0.2, 0.02, 1.2],
+  ["api.openai.com", "gpt-5.5", 5, 0.5, 30],
+  ["api.openai.com", "gpt-5.4", 2.5, 0.25, 15],
+  ["api.openai.com", "gpt-5.3-codex", 1.75, 0.175, 14],
+  ["api.openai.com", "gpt-5.2", 1.75, 0.175, 14],
+  ["api.openai.com", "gpt-5.1", 1.25, 0.125, 10],
+  ["api.openai.com", "gpt-5", 1.25, 0.125, 10],
+  ["api.openai.com", "gpt-4.1", 2, 0.5, 8],
+  ["api.openai.com", "gpt-4o", 2.5, 1.25, 10],
+  // Moonshot / Kimi
+  ["api.moonshot.ai", "kimi-k3", 3, 0.3, 15, 3], // cache write (5 min) = the input price
+  ["api.moonshot.ai", "kimi-k2.7-code", 0.95, 0.19, 4],
+  ["api.moonshot.ai", "kimi-k2.7-code-highspeed", 1.9, 0.38, 8],
+  ["api.moonshot.ai", "kimi-k2.6", 0.95, 0.16, 4],
+  // Ollama cloud — pay-as-you-go credits (peak price; off-peak is about half)
+  ["ollama.com", "kimi-k3", 3, 0.3, 15],
+  ["ollama.com", "kimi-k2.7-code", 0.95, 0.19, 4],
+  ["ollama.com", "kimi-k2.6", 0.95, 0.16, 4],
+  ["ollama.com", "glm-5.3", 1.4, 0.26, 4.4],
+  ["ollama.com", "glm-5.3-flash", 0.15, 0.03, 0.5],
+  ["ollama.com", "glm-5.2", 1.4, 0.26, 4.4],
+  ["ollama.com", "deepseek-v4-pro", 1.32, 0.044, 3.96],
+  ["ollama.com", "deepseek-v4.1-flash", 0.3, 0.006, 1.2],
+  ["ollama.com", "minimax-m3", 0.6, 0.12, 2.4],
+  ["ollama.com", "minimax-m2.7", 0.3, 0.06, 1.2],
+  ["ollama.com", "gpt-oss:120b", 0.15, 0.014, 0.6],
+  ["ollama.com", "gpt-oss:20b", 0.07, 0.035, 0.3],
+  ["ollama.com", "gemma4", 0.14, 0.05, 0.4],
+  ["ollama.com", "mistral-large-3", 0.5, null, 1.5],
+  ["ollama.com", "nemotron-3-nano", 0.06, null, 0.24],
+  ["ollama.com", "nemotron-3-super", 0.015, 0.015, 0.6],
+  ["ollama.com", "nemotron-3-ultra", 0.1, 0.1, 3],
+];
+const PROVIDER = { "api.anthropic.com": "Anthropic", "api.openai.com": "OpenAI", "api.moonshot.ai": "Moonshot (Kimi)", "ollama.com": "Ollama cloud" };
+const SOURCE = { "api.anthropic.com": ANTHROPIC, "api.openai.com": OPENAI, "api.moonshot.ai": KIMI, "ollama.com": OLLAMA };
+
+/** The table gu ships — what an empty Mongo is seeded with and what the Deploy app exports. */
+export const PRICE_TABLE = Object.freeze({
+  gu: "prices",
+  version: PRICE_TABLE_VERSION,
+  publishedAt: CHECKED,
+  currency: "USD",
+  unit: "per 1M tokens",
+  note: "input = uncached prompt tokens; cachedInput = prompt tokens served from the provider's cache; output is stored but not yet used. Anthropic cache writes (cacheWrite) are not priced yet. Ollama cloud: peak prices — off-peak is about half.",
+  prices: ROWS.map(([host, model, input, cachedInput, output, cacheWrite]) => ({
+    provider: PROVIDER[host],
+    host,
+    model,
+    input,
+    cachedInput,
+    output,
+    ...(cacheWrite != null ? { cacheWrite } : {}),
+    // Used only when the provider does not report its cached count: Kimi and OpenAI cache prompt
+    // prefixes automatically; Anthropic only when the request asks (gu's Claude path does); Ollama
+    // cloud lists cache prices. No cache price → no discount, so no share.
+    ...(cachedInput != null ? { assumedCacheShare: ASSUMED_CACHED_SHARE } : {}),
+    source: SOURCE[host],
+    checkedAt: CHECKED,
+  })),
+});
+
+// ---------------------------------------------------------------------------------------------
+// keys and lookup
+// ---------------------------------------------------------------------------------------------
+
+/** A server URL (or bare host) → its host: "https://api.moonshot.ai/v1/" → "api.moonshot.ai". */
+export function hostOf(urlOrHost) {
+  const raw = String(urlOrHost ?? "").trim();
+  if (!raw) return "";
+  try {
+    return new URL(raw.includes("://") ? raw : `https://${raw}`).host.toLowerCase();
+  } catch {
+    return raw.replace(/^[a-z]+:\/\//i, "").replace(/\/.*$/, "").toLowerCase();
+  }
+}
+
+/** One row's identity: host + model, lower-cased. */
+export const priceKey = (host, model) => `${hostOf(host)}|${String(model ?? "").trim().toLowerCase()}`;
+
+/**
+ * The price for a server + model, or null. Exact first; then without a dated suffix
+ * ("claude-haiku-4-5-20251001" → "claude-haiku-4-5"); then without an Ollama tag ("kimi-k3:cloud",
+ * "kimi-k3:latest" → "kimi-k3"). Never a different host — the same model costs differently there.
+ */
+export function findPrice(rows, url, model) {
+  const host = hostOf(url);
+  const m = String(model ?? "").trim().toLowerCase();
+  if (!host || !m || !Array.isArray(rows)) return null;
+  const byKey = new Map(rows.map((r) => [priceKey(r.host, r.model), r]));
+  const tries = [m, m.replace(/-\d{8}$/, ""), m.replace(/:(cloud|latest)$/, "")];
+  for (const t of tries) {
+    const r = byKey.get(`${host}|${t}`);
+    if (r) return r;
+  }
+  return null;
+}
+
+// ---------------------------------------------------------------------------------------------
+// what a turn cost
+// ---------------------------------------------------------------------------------------------
+
+/**
+ * The input cost of one turn.
+ *   input          prompt tokens sent, summed over every step of the turn
+ *   cached         prompt tokens the provider served from its cache (summed), when it reported them
+ *   cacheReported  whether the provider reported a cached count at all
+ *   firstIn        the first step's prompt tokens (nothing is cached on the first step of a turn)
+ * → { usd, estimated, cachedTokens } — or null when there is no price (never a misleading $0).
+ */
+export function turnCost({ input = 0, cached = 0, cacheReported = false, firstIn = 0, price, assumedShare } = {}) {
+  if (!price || !Number.isFinite(price.input)) return null;
+  // The row's own assumption wins (providers cache differently), else the 90% default.
+  const share = Number.isFinite(assumedShare) ? assumedShare
+    : Number.isFinite(price.assumedCacheShare) ? price.assumedCacheShare
+    : ASSUMED_CACHED_SHARE;
+  const sent = Math.max(0, Number(input) || 0);
+  let cachedTokens;
+  let estimated = false;
+  if (cacheReported) {
+    cachedTokens = Math.min(sent, Math.max(0, Number(cached) || 0));
+  } else {
+    cachedTokens = Math.round(Math.min(1, Math.max(0, share)) * Math.max(0, sent - Math.max(0, Number(firstIn) || 0)));
+    estimated = cachedTokens > 0;
+  }
+  const cachedRate = Number.isFinite(price.cachedInput) ? price.cachedInput : price.input; // no cache price → no discount
+  const usd = ((sent - cachedTokens) * price.input + cachedTokens * cachedRate) / 1e6;
+  return { usd, estimated, cachedTokens };
+}
+
+/** "$1.23", "$0.123", "$0.0042"; "~" in front when the cached share was assumed. */
+export function formatUsd(usd, { estimated = false } = {}) {
+  if (!Number.isFinite(usd)) return "";
+  const v = Math.max(0, usd);
+  const s = v >= 1 ? v.toFixed(2) : v >= 0.01 ? v.toFixed(3) : v > 0 ? v.toFixed(4) : "0";
+  return `${estimated ? "~" : ""}$${s}`;
+}
+
+// ---------------------------------------------------------------------------------------------
+// checking a price table (the published one, before it is applied)
+// ---------------------------------------------------------------------------------------------
+
+const ROW_FIELDS = new Set(["provider", "host", "url", "model", "input", "cachedInput", "output", "cacheWrite", "assumedCacheShare", "source", "checkedAt", "remove"]);
+const price = (v) => v === null || (typeof v === "number" && Number.isFinite(v) && v >= 0 && v <= MAX_PRICE);
+
+/**
+ * Check a price table (the shape PRICE_TABLE has; a bare array of rows is accepted too).
+ * → { ok, version, rows, removes, warnings } | { ok: false, problem }.
+ * A row with "remove": true deletes that server + model — nothing is ever deleted otherwise.
+ */
+export function validatePriceTable(input) {
+  let doc = input;
+  if (typeof input === "string") {
+    const src = input.replace(/^[ \t]*\/\/.*$/gm, "");
+    if (!src.trim()) return { ok: false, empty: true, problem: "nothing was pasted." };
+    try {
+      doc = JSON.parse(src);
+    } catch (e) {
+      return { ok: false, problem: `that is not valid JSON — ${String(e?.message ?? e).replace(/\s*in JSON at position \d+.*$/, "")}.` };
+    }
+  }
+  const list = Array.isArray(doc) ? doc : doc?.prices;
+  if (!Array.isArray(list)) return { ok: false, problem: 'expected { "prices": [ … ] } or a list of rows.' };
+  if (list.length === 0) return { ok: false, problem: "the table has no rows." };
+  if (list.length > MAX_PRICE_ROWS) return { ok: false, problem: `${list.length} rows — at most ${MAX_PRICE_ROWS}.` };
+  const version = !Array.isArray(doc) && doc.version != null ? String(doc.version).slice(0, 40) : "";
+  const rows = [];
+  const removes = [];
+  const warnings = [];
+  const seen = new Set();
+  for (let i = 0; i < list.length; i++) {
+    const r = list[i];
+    const at = `row ${i + 1}`;
+    if (!r || typeof r !== "object" || Array.isArray(r)) return { ok: false, problem: `${at} is not an object.` };
+    const host = hostOf(r.host ?? r.url);
+    const model = typeof r.model === "string" ? r.model.trim() : "";
+    if (!host) return { ok: false, problem: `${at} needs "host" (or "url") — the server it is priced on.` };
+    if (!model || model.length > 120) return { ok: false, problem: `${at} needs "model" (at most 120 characters).` };
+    const key = priceKey(host, model);
+    if (seen.has(key)) return { ok: false, problem: `${at}: ${host} ${model} appears twice.` };
+    seen.add(key);
+    const extra = Object.keys(r).filter((k) => !ROW_FIELDS.has(k));
+    if (extra.length) warnings.push(`${at} (${model}): ignored ${extra.map((k) => `"${k}"`).join(", ")}`);
+    if (r.remove === true) {
+      removes.push({ host, model });
+      continue;
+    }
+    if (!(typeof r.input === "number" && price(r.input))) {
+      return { ok: false, problem: `${at} (${model}): "input" must be a number of USD per 1M tokens, 0 to ${MAX_PRICE}.` };
+    }
+    for (const f of ["cachedInput", "output", "cacheWrite"]) {
+      if (r[f] !== undefined && !price(r[f])) return { ok: false, problem: `${at} (${model}): "${f}" must be a number 0 to ${MAX_PRICE}, or null.` };
+    }
+    if (r.assumedCacheShare !== undefined && !(typeof r.assumedCacheShare === "number" && r.assumedCacheShare >= 0 && r.assumedCacheShare <= 1)) {
+      return { ok: false, problem: `${at} (${model}): "assumedCacheShare" must be a number from 0 to 1 (0.9 = 90%).` };
+    }
+    if (typeof r.cachedInput === "number" && r.cachedInput > r.input) warnings.push(`${at} (${model}): cachedInput is MORE than input — check it`);
+    rows.push({
+      ...(typeof r.provider === "string" && r.provider.trim() ? { provider: r.provider.trim().slice(0, 60) } : {}),
+      host,
+      model,
+      input: r.input,
+      cachedInput: r.cachedInput ?? null,
+      output: r.output ?? null,
+      ...(typeof r.cacheWrite === "number" ? { cacheWrite: r.cacheWrite } : {}),
+      ...(typeof r.assumedCacheShare === "number" ? { assumedCacheShare: r.assumedCacheShare } : {}),
+      ...(typeof r.source === "string" && /^https?:\/\//.test(r.source) ? { source: r.source.slice(0, 300) } : {}),
+      ...(typeof r.checkedAt === "string" && !Number.isNaN(Date.parse(r.checkedAt)) ? { checkedAt: r.checkedAt.slice(0, 30) } : {}),
+    });
+  }
+  return { ok: true, version, rows, removes, warnings };
+}
+
+const COMPARED = ["input", "cachedInput", "output", "cacheWrite", "assumedCacheShare", "provider"];
+
+/** What applying `incoming` to `current` would do. → { added, changed:[{row, was, fields}], unchanged, removed, missingRemoves } */
+export function diffPrices(current, incoming, removes = []) {
+  const now = new Map((current ?? []).map((r) => [priceKey(r.host, r.model), r]));
+  const added = [];
+  const changed = [];
+  let unchanged = 0;
+  for (const r of incoming) {
+    const was = now.get(priceKey(r.host, r.model));
+    if (!was) {
+      added.push(r);
+      continue;
+    }
+    const fields = COMPARED.filter((f) => (r[f] ?? null) !== (was[f] ?? null) && !(f === "provider" && r[f] == null));
+    if (fields.length) changed.push({ row: r, was, fields });
+    else unchanged++;
+  }
+  const removed = removes.filter((x) => now.has(priceKey(x.host, x.model)));
+  const missingRemoves = removes.filter((x) => !now.has(priceKey(x.host, x.model)));
+  return { added, changed, unchanged, removed, missingRemoves };
+}
+
+/** The diff as lines, for the "apply? [y/N]" question. */
+export function diffLines(d) {
+  const p = (v) => (v == null ? "—" : `$${v}`);
+  const out = [];
+  for (const r of d.added) out.push(`+ ${r.host}  ${r.model}  in ${p(r.input)} · cached ${p(r.cachedInput)}`);
+  const pct = (v) => (v == null ? "—" : `${Math.round(v * 100)}%`);
+  const show = (f, v) => (f === "assumedCacheShare" ? pct(v) : p(v));
+  for (const c of d.changed) out.push(`~ ${c.row.host}  ${c.row.model}  ${c.fields.map((f) => (f === "provider" ? `provider → ${c.row.provider}` : `${f} ${show(f, c.was[f])} → ${show(f, c.row[f])}`)).join(", ")}`);
+  for (const r of d.removed) out.push(`- ${r.host}  ${r.model}  (removed)`);
+  out.push(`${d.added.length} new · ${d.changed.length} changed · ${d.unchanged} unchanged${d.removed.length ? ` · ${d.removed.length} removed` : ""}`);
+  return out;
+}
+
+// ---------------------------------------------------------------------------------------------
+// /price
+// ---------------------------------------------------------------------------------------------
+
+/**
+ * The table for /price, grouped by server, newest-first nowhere — alphabetical, so a model is easy
+ * to find. `current` = { url, model } of the coder in use: its row is marked "▸".
+ * Columns: model · input · cached · output (USD per 1M). Fits `width` (80 on a server over SSH).
+ */
+export function priceTableLines(rows, { width = 80, current = null, version = "" } = {}) {
+  const cur = current ? findPrice(rows, current.url, current.model) : null;
+  const money = (v) => (v == null ? "—" : `$${Number(v) < 0.1 && v !== 0 ? Number(v).toString() : Number(v).toFixed(2)}`);
+  const numW = 9;
+  const modelW = Math.max(12, Math.min(34, width - 4 - 2 - numW * 3));
+  const cut = (s, w) => (s.length > w ? s.slice(0, w - 1) + "…" : s.padEnd(w));
+  const out = [`USD per 1M tokens${version ? ` · table v${version}` : ""}`];
+  out.push(`  ${"model".padEnd(modelW)}${"input".padStart(numW)}${"cached".padStart(numW)}${"output".padStart(numW)}`);
+  const hosts = [...new Set(rows.map((r) => r.host))].sort();
+  for (const h of hosts) {
+    const group = rows.filter((r) => r.host === h).sort((a, b) => a.model.localeCompare(b.model));
+    out.push(`${h}${group[0]?.provider ? `  (${group[0].provider})` : ""}`);
+    for (const r of group) {
+      out.push(`${r === cur ? "▸ " : "  "}${cut(r.model, modelW)}${money(r.input).padStart(numW)}${money(r.cachedInput).padStart(numW)}${money(r.output).padStart(numW)}`);
+    }
+  }
+  return out;
+}
+
+// ---------------------------------------------------------------------------------------------
+// THE ASSUMED-CACHE-SHARE TABLE (#323 follow-up) — its own table so the admin can review and
+// publish it on its own (Deploy app → "Cache shares" → Update to API), and users can read it with
+// /prices. Made FROM the price table (the rows that have a cache price), so the two cannot
+// disagree.
+// ---------------------------------------------------------------------------------------------
+
+/** Why each provider's share is what it is — shown beside the number, so it can be reviewed. */
+export const CACHE_SHARE_WHY = Object.freeze({
+  "api.moonshot.ai": "automatic prefix caching (Kimi reports cached_tokens)",
+  "api.openai.com": "automatic prefix caching for prompts ≥ 1024 tokens (reports cached_tokens)",
+  "api.anthropic.com": "cached only when the request asks — gu's Claude path does (reports cache reads)",
+  "ollama.com": "lists cache prices; whether it reports a count is not yet verified",
+});
+
+export const CACHE_SHARE_TABLE = Object.freeze({
+  gu: "cache-shares",
+  version: PRICE_TABLE_VERSION,
+  publishedAt: PRICE_TABLE.publishedAt,
+  note: "The share of a step's prompt (after a turn's first step) assumed served from the provider's cache, used ONLY when the provider does not report its own cached count. 0.9 = 90%.",
+  shares: PRICE_TABLE.prices
+    .filter((r) => r.cachedInput != null)
+    .map((r) => ({ provider: r.provider, host: r.host, model: r.model, assumedCacheShare: r.assumedCacheShare ?? ASSUMED_CACHED_SHARE, why: CACHE_SHARE_WHY[r.host] ?? "" })),
+});
+
+/** Check a cache-share table → { ok, version, shares } | { ok: false, problem }. */
+export function validateCacheShareTable(input) {
+  let doc = input;
+  if (typeof input === "string") {
+    try {
+      doc = JSON.parse(input.replace(/^[ \t]*\/\/.*$/gm, ""));
+    } catch (e) {
+      return { ok: false, problem: `that is not valid JSON — ${String(e?.message ?? e).replace(/\s*in JSON at position \d+.*$/, "")}.` };
+    }
+  }
+  const list = Array.isArray(doc) ? doc : doc?.shares;
+  if (!Array.isArray(list) || list.length === 0) return { ok: false, problem: 'expected { "shares": [ … ] } with at least one row.' };
+  if (list.length > MAX_PRICE_ROWS) return { ok: false, problem: `${list.length} rows — at most ${MAX_PRICE_ROWS}.` };
+  const seen = new Set();
+  const shares = [];
+  for (const [i, r] of list.entries()) {
+    const at = `row ${i + 1}`;
+    const host = hostOf(r?.host ?? r?.url);
+    const model = typeof r?.model === "string" ? r.model.trim() : "";
+    if (!host || !model) return { ok: false, problem: `${at} needs "host" and "model".` };
+    if (!(typeof r.assumedCacheShare === "number" && r.assumedCacheShare >= 0 && r.assumedCacheShare <= 1)) {
+      return { ok: false, problem: `${at} (${model}): "assumedCacheShare" must be a number from 0 to 1 (0.9 = 90%).` };
+    }
+    const key = priceKey(host, model);
+    if (seen.has(key)) return { ok: false, problem: `${at}: ${host} ${model} appears twice.` };
+    seen.add(key);
+    shares.push({
+      ...(typeof r.provider === "string" && r.provider.trim() ? { provider: r.provider.trim().slice(0, 60) } : {}),
+      host,
+      model,
+      assumedCacheShare: r.assumedCacheShare,
+      ...(typeof r.why === "string" && r.why.trim() ? { why: r.why.trim().slice(0, 200) } : {}),
+    });
+  }
+  const version = !Array.isArray(doc) && doc.version != null ? String(doc.version).slice(0, 40) : "";
+  return { ok: true, version, shares };
+}
+
+/**
+ * The cache table in /prices: the share each model is assumed to cache — THIS ACCOUNT's (its price rows, what its
+ * estimates use) beside the one gu PUBLISHED (when the API has one), marking where they differ.
+ * Fits `width`; the coder in use is marked "▸".
+ */
+export function cacheShareLines({ yours = [], published = null, width = 80, current = null } = {}) {
+  const pub = new Map((published?.shares ?? []).map((s) => [priceKey(s.host, s.model), s.assumedCacheShare]));
+  const mine = (yours ?? []).filter((r) => r.cachedInput != null || pub.has(priceKey(r.host, r.model)));
+  const cur = current ? findPrice(mine, current.url, current.model) : null;
+  const pct = (v) => (Number.isFinite(v) ? `${Math.round(v * 100)}%` : "—");
+  const colW = 8;
+  const modelW = Math.max(12, Math.min(34, width - 4 - 2 - colW * 2 - 2));
+  const cut = (s, w) => (s.length > w ? s.slice(0, w - 1) + "…" : s.padEnd(w));
+  const out = [];
+  out.push(`  ${"model".padEnd(modelW)}${"yours".padStart(colW)}${published ? "gu".padStart(colW) : ""}`);
+  const keys = new Set([...mine.map((r) => priceKey(r.host, r.model)), ...pub.keys()]);
+  const rows = [...keys].map((k) => {
+    const r = mine.find((x) => priceKey(x.host, x.model) === k);
+    const s = published?.shares?.find((x) => priceKey(x.host, x.model) === k);
+    return { host: r?.host ?? s.host, model: r?.model ?? s.model, yours: r ? (Number.isFinite(r.assumedCacheShare) ? r.assumedCacheShare : ASSUMED_CACHED_SHARE) : undefined, gu: pub.get(k), row: r };
+  });
+  for (const h of [...new Set(rows.map((r) => r.host))].sort()) {
+    out.push(h);
+    for (const r of rows.filter((x) => x.host === h).sort((a, b) => a.model.localeCompare(b.model))) {
+      const differs = published && r.gu !== undefined && r.yours !== undefined && Math.abs(r.gu - r.yours) > 1e-9;
+      out.push(`${r.row && r.row === cur ? "▸ " : "  "}${cut(r.model, modelW)}${pct(r.yours).padStart(colW)}${published ? pct(r.gu).padStart(colW) : ""}${differs ? " *" : ""}`);
+    }
+  }
+  return out;
+}
+
+// ---------------------------------------------------------------------------------------------
+// "NEW PRICES UPDATED <date>" (#323): gu checks the hosted API's GET /api/get-price-and-cache-table
+// (the newest tables the admin published from the Deploy app); when they are newer than what this
+// account last applied, the notice row offers them, and a click writes both into the user's Mongo.
+// ---------------------------------------------------------------------------------------------
+
+/** Is the published stamp newer than the one this account applied? ("" applied = never.) */
+export function hasNewerPublished(appliedAt, publishedAt) {
+  const p = Date.parse(publishedAt ?? "");
+  if (!Number.isFinite(p)) return false;
+  const a = Date.parse(appliedAt ?? "");
+  return !Number.isFinite(a) || p > a;
+}
+
+/** The notice: "new prices updated 1 Oct 2026". */
+export function priceUpdateLabel(publishedAt) {
+  const d = new Date(publishedAt);
+  if (Number.isNaN(d.getTime())) return "new prices updated";
+  const m = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"][d.getUTCMonth()];
+  return `new prices updated ${d.getUTCDate()} ${m} ${d.getUTCFullYear()}`;
+}
+
+/**
+ * The published tables onto this account's rows → what to write.
+ *   · the published PRICE table's rows replace the same server + model here (others are kept —
+ *     a self-hosted server priced by hand stays);
+ *   · the published CACHE table's share is set on each matching row (published price rows and the
+ *     account's own);
+ *   · nothing is deleted.
+ * → { ok, rows: the rows that change (to PUT), diff, version, publishedAt } | { ok: false, problem }
+ */
+export function mergePublishedTables(current, cloud) {
+  const pub = cloud ?? {};
+  const priceRows = [];
+  if (pub.prices) {
+    const c = validatePriceTable(pub.prices);
+    if (!c.ok) return { ok: false, problem: `the published price table is not usable — ${c.problem}` };
+    priceRows.push(...c.rows);
+  }
+  let shares = [];
+  if (pub.cacheShares) {
+    const c = validateCacheShareTable(pub.cacheShares);
+    if (!c.ok) return { ok: false, problem: `the published cache table is not usable — ${c.problem}` };
+    shares = c.shares;
+  }
+  if (!priceRows.length && !shares.length) return { ok: false, problem: "nothing has been published yet." };
+  const share = new Map(shares.map((s) => [priceKey(s.host, s.model), s.assumedCacheShare]));
+  const byKey = new Map((current ?? []).map((r) => [priceKey(r.host, r.model), { ...r }]));
+  for (const r of priceRows) {
+    const was = byKey.get(priceKey(r.host, r.model));
+    // A published price row without its own share keeps the one this account has, until the cache
+    // table says otherwise.
+    byKey.set(priceKey(r.host, r.model), { ...r, ...(r.assumedCacheShare == null && was?.assumedCacheShare != null ? { assumedCacheShare: was.assumedCacheShare } : {}) });
+  }
+  for (const [k, row] of byKey) if (share.has(k) && row.cachedInput != null) row.assumedCacheShare = share.get(k);
+  const merged = [...byKey.values()];
+  const diff = diffPrices(current ?? [], merged);
+  return {
+    ok: true,
+    rows: [...diff.added, ...diff.changed.map((c) => c.row)],
+    diff,
+    version: pub.prices?.version || pub.cacheShares?.version || "",
+    publishedAt: pub.publishedAt || [pub.prices?.publishedAt, pub.cacheShares?.publishedAt].filter(Boolean).sort().at(-1) || "",
+  };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiens.nguyen/gu-cli",
-  "version": "1.0.782",
+  "version": "1.0.784",
   "description": "Gu CLI — the gu terminal plus the local worker that runs agent / OCR / PDF / embedding jobs on your Mac (Ollama / MLX / OpenAI-compatible).",
   "type": "module",
   "license": "MIT",
@@ -69,6 +69,7 @@
     "image-capable-coders.json",
     "preset-editor.mjs",
     "preset-apply.mjs",
+    "model-prices.mjs",
     "device-login.mjs",
     "daemon-control.mjs",
     "log-policy.mjs",

package/preset-apply.mjs

@@ -4,7 +4,7 @@
  * here the REAL code runs in tests against a fake API that records every call and can be told to
  * fail — which is how "loading a preset cannot break the workspace" is checked rather than hoped.
  *
- * Used for /save-preset, /load-presets (a version-2 preset) and /load-settings — one path for all.
+ * Used for /use-presets (a version-2 preset) and /load-settings — one path for all.
  *
  *   api = {
  *     settings():                Promise<object|null>   GET  /api/worker/settings
@@ -101,7 +101,7 @@ export async function applyTransfer(value, { api, io, fromLine = "", carriesSecr
     }
     out.backup = b.file;
     say(`backup of your current setup: ${b.file}`);
-    say(`to undo: /open-presets ${b.file}`);
+    say(`to undo: /use-presets ${b.file}`);
   }
   const patch = toSettingsPatch(value, current);
   const saved = Object.keys(patch).length ? await api.saveSettings(patch) : true;