The agent that grows with you
Python aiai-agentai-agentsanthropicchatgptclaudeclaude-codecodexhermeshermes-agentllmnous-researchopenai
"""Window vs. credit-grant chrome for the model pickers."""
from dataclasses import replace
from types import SimpleNamespace
from hermes_cli.auth_model_picker import _ModelPickerRows
from tests.usage_window_fixtures import FAR, usage_window
from hermes_cli.model_picker_usage import (
GAUGE_MONTH,
GAUGE_TODAY,
GAUGE_WEEK,
TOP_TIER_FOOTNOTE,
format_percent_used,
picker_usage_from_account,
plan_gauge_lines,
render_bar,
usage_levels,
usage_tag_levels,
)
def test_render_bar_fills_with_the_fraction_given():
assert render_bar(1.0) == "[||||||||||]"
assert render_bar(0.0) == "[ ]"
assert "|" in render_bar(0.01) and render_bar(0.01) != "[||||||||||]"
assert render_bar(0.999) != "[||||||||||]"
def test_percent_used_matches_the_portal_rule():
assert format_percent_used(0.0) == "0%"
assert format_percent_used(0.0001) == "<1%"
assert format_percent_used(0.0047) == "<1%"
assert format_percent_used(0.01) == "1%"
assert format_percent_used(0.996) == "99%"
assert format_percent_used(0.9999) == "99%"
assert format_percent_used(1.0) == "100%"
def test_window_gauges_read_as_used_and_fill_up():
# 47 bp of the day used → "<1% used", one cell filled (never "99% left").
usage = _window_usage(day_used_bp=47, week_used_bp=0, top_tier_used_bp=10_000)
lines = plan_gauge_lines(usage)
today = next(l for l in lines if l.startswith("today"))
week = next(l for l in lines if l.startswith("week"))
top = next(l for l in lines if l.startswith("large models"))
assert "[| ]" in today and "<1% used" in today
assert "[ ]" in week and "0% used" in week
assert "[||||||||||]" in top and "100% used" in top
assert usage.gauge(GAUGE_TODAY).style == "green" and usage.gauge("top_tier").style == "red"
def test_usage_level_is_the_gateway_word_never_computed_here():
pricing = {
"small": {"prompt": "0.00000014", "completion": "0.00000028", "usage_level": "low"},
"medium": {"prompt": "0.000001", "completion": "0.0000032", "usage_level": "medium"},
"large": {"prompt": "0.000005", "completion": "0.000025", "usage_level": "top_tier", "top_tier": True},
"gift:free": {"prompt": "0", "completion": "0", "usage_level": "free"},
}
assert usage_levels(list(pricing), pricing) == {
"small": "low", "medium": "medium", "large": "top_tier", "gift:free": "free"}
# Same prices with no gateway word: Hermes does not invent low / medium.
bare = {m: {k: v for k, v in p.items() if k != "usage_level"} for m, p in pricing.items()}
assert usage_levels(list(bare), bare) == {"large": "top_tier", "gift:free": "free"}
# Unknown price is not a promise of free; an unknown word is ignored.
assert usage_levels(["u", "x"], {"u": {}, "x": {"usage_level": "huge"}}) == {}
assert usage_levels(["large"], pricing) == {"large": "top_tier"}
def test_window_picker_shows_the_usage_word_not_prices_or_bars():
usage = picker_usage_from_account(SimpleNamespace(
logged_in=True,
subscription=SimpleNamespace(plan="Window Plan"),
usage_window=SimpleNamespace(**usage_window(
day_used_bp=2000, week_used_bp=1000, top_tier_used_bp=0,
day_resets_at_ms=1, week_resets_at_ms=2, paused_reason=None,
)),
))
assert usage is not None
rows = _ModelPickerRows(
["cheap/m", "pricey/m"],
{
"cheap/m": {"prompt": "0.00000006", "completion": "0.00000012", "usage_level": "low"},
"pricey/m": {"prompt": "0.000003", "completion": "0.000015", "usage_level": "top_tier",
"top_tier": True},
},
current_model="", sale_chrome=True, usage=usage,
)
cheap, pricey = rows.label("cheap/m"), rows.label("pricey/m")
assert "$" not in cheap and "$" not in pricey and "[" not in cheap and "[" not in pricey
# Only Large / Free carry a tag; a Small / Medium row is the bare name.
assert cheap.strip() == "cheap/m" and pricey.rstrip().endswith("Large")
assert not pricey.startswith("★")
assert len(cheap.rstrip()) <= len(pricey) # one aligned column
header = "\n".join(rows.description_lines())
assert "Usage" in header and "bar" not in header and "★" not in header
assert rows.footnote() == TOP_TIER_FOOTNOTE
desc = rows.description_lines()
today_line = next(line for line in desc if "today" in line.lower())
week_line = next(line for line in desc if "week" in line.lower())
top_line = next(line for line in desc if "large models" in line.lower())
assert today_line != week_line != top_line
assert "Window Plan" in desc[0] and "included" in desc[0]
def test_footnote_only_when_a_top_tier_row_is_listed():
rows = _ModelPickerRows(["cheap/m"], {"cheap/m": {"prompt": "0.0000001", "completion": "0.0000002",
"usage_level": "low"}},
current_model="", sale_chrome=True, usage=_window_usage())
assert rows.footnote() == ""
# Credit-grant accounts never get it.
assert _ModelPickerRows(["x"], {"x": {"top_tier": True}}, current_model="", sale_chrome=True).footnote() == ""
def test_credit_grant_account_gets_no_plan_line():
"""Credit-grant accounts get no plan chrome: pickers stay exactly as on main (no gauge, no badge)."""
assert picker_usage_from_account({
"logged_in": True,
"subscription": {"plan": "Credit Plan", "monthly_credits": 20, "credits_remaining": 12.4},
"usage_window": None,
}) is None
def test_free_or_payg_account_has_no_picker_usage():
assert picker_usage_from_account(SimpleNamespace(logged_in=True, subscription=None, usage_window=None)) is None
assert picker_usage_from_account(None) is None
def test_window_plan_gauges_stack_on_separate_lines():
usage = picker_usage_from_account(SimpleNamespace(
logged_in=True, subscription=SimpleNamespace(plan="Window Plan"),
usage_window=SimpleNamespace(**usage_window(
day_used_bp=0, week_used_bp=0, top_tier_used_bp=0,
day_resets_at_ms=FAR, week_resets_at_ms=FAR, paused_reason=None,
)),
))
stacked = plan_gauge_lines(usage)
assert stacked[0] == "Window Plan"
assert any(line.startswith("today") for line in stacked)
assert any(line.startswith("week") for line in stacked)
assert any(line.startswith("large models") for line in stacked)
assert len(stacked) == 4
def test_window_gauges_for_model_omit_top_tier_on_regular_ids():
usage = picker_usage_from_account(SimpleNamespace(
logged_in=True, subscription=SimpleNamespace(plan="Window Plan"),
usage_window=SimpleNamespace(**usage_window(
day_used_bp=0, week_used_bp=0, top_tier_used_bp=5000, day_resets_at_ms=1, week_resets_at_ms=2,
)),
)).with_pricing({"example/model-b": {"prompt": "0.000005", "completion": "0.000025", "top_tier": True}})
assert [g.label for g in usage.gauges_for_model("example/model-a")] == [GAUGE_TODAY, GAUGE_WEEK]
assert [g.label for g in usage.gauges_for_model("example/model-b")][-1] == "top_tier"
def _window_usage(**window):
"""A window plan where the gateway marked Model B top tier."""
base = dict(day_used_bp=0, week_used_bp=0, top_tier_used_bp=0,
day_resets_at_ms=FAR, week_resets_at_ms=FAR, paused_reason=None)
usage = picker_usage_from_account(SimpleNamespace(
logged_in=True, subscription=SimpleNamespace(plan="Window Plan"),
usage_window=SimpleNamespace(**usage_window(**{**base, **window})),
))
return replace(usage, top_tier_ids=frozenset({"example/model-b"})) if usage is not None else None
def test_month_row_only_when_the_server_lists_it():
assert _window_usage().gauge(GAUGE_MONTH) is None # no month allowance listed: no month row
usage = _window_usage(month_used_bp=10_000, month_resets_at_ms=333, top_tier_used_bp=2_000)
assert [g.label for g in usage.gauges] == [GAUGE_TODAY, GAUGE_WEEK, GAUGE_MONTH, "top_tier"]
assert usage.gauge(GAUGE_MONTH).resets_at_ms == 333
assert [line.split()[0] for line in plan_gauge_lines(usage)[1:]] == ["today", "week", "month", "large"]
# A used-up month stops every non-free model, like a used-up day or week.
assert usage.included_summary.startswith("Monthly limit reached") and usage.blocks("any/model")
def test_picker_draws_whatever_allowances_the_server_lists():
"""A new allowance (a 5-hour window) shows with the server's label and stops every model when full,
with no Hermes release; the order is the server's."""
usage = picker_usage_from_account(SimpleNamespace(
logged_in=True, subscription=SimpleNamespace(plan="Window Plan"),
usage_window=SimpleNamespace(gauges=[
{"id": "five_hour", "scope": "all", "label": "Next 5 hours", "used_bp": 10_000, "resets_at_ms": FAR},
*usage_window()["gauges"],
], featured_model_ids=()),
))
assert next(g.label for g in usage.gauges) == "five_hour"
assert plan_gauge_lines(usage)[1].startswith("Next 5 hours")
assert usage.included_summary.startswith("Next 5 hours limit reached")
assert usage.blocks("any/model")
def test_top_tier_gauge_is_labelled_monthly_and_resets_on_its_own_clock():
usage = _window_usage(top_tier_used_bp=2_000, day_resets_at_ms=111, top_tier_resets_at_ms=222)
assert usage.gauge("top_tier").resets_at_ms == 222
assert any(line.startswith("large models (monthly) ") for line in plan_gauge_lines(usage))
# No large-model reset listed: the day's reset.
assert _window_usage(top_tier_used_bp=2_000, day_resets_at_ms=111).gauge("top_tier").resets_at_ms == 111
def test_blocks_only_models_whose_allowance_is_empty():
usage = _window_usage(top_tier_used_bp=10_000)
assert usage.blocks("example/model-b")
assert not usage.blocks("example/model-a")
assert usage.included_summary.startswith("Monthly large-model limit reached")
assert _window_usage().included_summary == "every model below is included"
def test_blocks_every_paid_model_when_the_day_is_spent():
usage = _window_usage(day_used_bp=10_000)
assert usage.blocks("example/model-a")
assert usage.included_summary.startswith("Daily limit reached")
def test_pay_as_you_go_wording_when_top_up_credits_pay():
from dataclasses import replace as _replace
usage = _replace(_window_usage(day_used_bp=10_000), credits_pay=True)
# Credits pay: the row stays usable; the limit line says so once.
assert not usage.blocks("example/model-a")
assert usage.limit_line().startswith("Daily limit reached · resets ")
assert usage.limit_line().endswith(" · paid models now use your credits (pay as you go)")
stops = _replace(usage, credits_pay=False)
assert stops.blocks("example/model-a")
assert stops.limit_line().endswith(" · only Free models until then")
def test_large_model_limit_blocks_only_large_rows():
from dataclasses import replace as _replace
usage = _replace(_window_usage(top_tier_used_bp=10_000), credits_pay=True)
assert not usage.blocks("example/model-b") and not usage.blocks("example/model-a")
stops = _replace(usage, credits_pay=False)
assert stops.blocks("example/model-b") and not stops.blocks("example/model-a")
assert usage.limit_line().startswith("Monthly large-model limit reached")
assert usage.limit_line().endswith(" · Large models now use your credits (pay as you go)")
assert _replace(usage, credits_pay=False).limit_line().endswith(" · Large models paused until then")
def test_credits_pay_reads_keep_going_and_the_top_up_balance():
from hermes_cli.model_picker_usage import _credits_pay
window = SimpleNamespace(keep_going_on_credits=True)
with_balance = SimpleNamespace(paid_service_access_info=SimpleNamespace(purchased_credits_remaining=12.5))
empty = SimpleNamespace(paid_service_access_info=SimpleNamespace(purchased_credits_remaining=0.0))
unknown = SimpleNamespace(paid_service_access_info=None)
assert _credits_pay(with_balance, window) is True
assert _credits_pay(empty, window) is False
assert _credits_pay(unknown, window) is None
assert _credits_pay(with_balance, SimpleNamespace(keep_going_on_credits=False)) is False
def test_a_free_model_is_never_used_up():
"""Same rule as agent/plan_limits.py: a $0 row or a ``:free`` id draws on no allowance, so a spent day
(or large-model allowance) never marks it."""
pricing = {
"gift/m:free": {"prompt": "0", "completion": "0"},
"zero/m": {"prompt": "0", "completion": "0"},
"paid/m": {"prompt": "0.000001", "completion": "0.000002"},
}
usage = _window_usage(day_used_bp=10_000, top_tier_used_bp=10_000).with_pricing(pricing)
assert not usage.blocks("gift/m:free")
assert not usage.blocks("zero/m")
assert usage.blocks("paid/m")
# Without a catalog, a ``:free`` id is still known free.
assert not _window_usage(day_used_bp=10_000).blocks("other/x:free")
def test_the_note_names_the_allowance_that_frees_up_last():
"""Day and week both spent: the day's reset alone lets nothing through, so the note waits for the week."""
usage = _window_usage(day_used_bp=10_000, week_used_bp=10_000, day_resets_at_ms=1_000, week_resets_at_ms=FAR)
assert usage.exhausted_gauge("paid/m").label == GAUGE_WEEK
def test_window_picker_labels_free_models_from_the_catalog_price():
usage = _window_usage()
pricing = {
"cheap/m": {"prompt": "0.00000006", "completion": "0.00000012", "usage_level": "low"},
"gift/m:free": {"prompt": "0", "completion": "0"},
"unpriced/m": {},
}
models = list(pricing)
rows = _ModelPickerRows(models, pricing, current_model="", sale_chrome=True, usage=usage)
free = rows.label("gift/m:free")
assert free.split("gift/m:free", 1)[1].strip() == "Free"
# Unknown price is not a promise of free: no word at all.
assert rows.label("unpriced/m").split("unpriced/m", 1)[1].strip() == ""
assert len(free) == len(rows.label("cheap/m")) # column stays aligned
def test_credit_picker_free_rows_are_unchanged():
rows = _ModelPickerRows(["gift/m:free"], {"gift/m:free": {"prompt": "0", "completion": "0"}},
current_model="", sale_chrome=True)
assert not rows.window_mode and "free" in rows.label("gift/m:free")
# ── gateway top-tier marks + featured ordering ──────────────────────────────────
# Picker pricing shape; the gateway marks top-tier rows for window callers only.
_PRICES = {
"example/model-a": {"prompt": "0.0000000108", "completion": "0.00000128"},
"example/model-b": {"prompt": "0.00000041", "completion": "0.00000399"},
"example/model-c": {"prompt": "0.000005", "completion": "0.000025", "top_tier": True},
}
def test_top_tier_comes_from_the_gateway_marks():
usage = _window_usage(featured_model_ids=("example/model-a", "example/model-b"))
marked = usage.with_pricing(_PRICES)
assert marked.is_top_tier("example/model-c")
# The catalog's marks replace any earlier ones: the medium model is unmarked here, so not top tier.
assert not marked.is_top_tier("example/model-b")
payload = marked.to_payload()
assert payload["top_tier_model_ids"] == ["example/model-c"]
assert payload["featured_model_ids"] == ["example/model-a", "example/model-b"]
def test_no_marks_means_nothing_is_top_tier():
"""Fail open: an older gateway, an unpriced model or no catalog marks nothing top tier."""
unmarked = {k: {kk: vv for kk, vv in v.items() if kk != "top_tier"} for k, v in _PRICES.items()}
usage = _window_usage().with_pricing(unmarked)
assert not usage.is_top_tier("example/model-b")
assert not usage.is_top_tier("example/model-c")
bare = picker_usage_from_account(SimpleNamespace(
logged_in=True, subscription=SimpleNamespace(plan="Window Plan"),
usage_window=SimpleNamespace(**usage_window(top_tier_used_bp=10_000)),
))
assert bare is not None and not bare.is_top_tier("example/model-b") and not bare.blocks("example/model-b")
assert bare.to_payload()["top_tier_model_ids"] == []
def test_featured_first_puts_plan_picks_first_and_keeps_the_rest_in_order():
from hermes_cli.model_picker_usage import featured_first, split_recommended
listed = ["a/x", "example/model-b", "b/y", "example/model-a"]
featured = ("example/model-a", "example/model-b", "not/listed")
assert featured_first(listed, featured) == [
"example/model-a", "example/model-b", "a/x", "b/y"]
assert featured_first(listed, ()) == listed
assert split_recommended(listed, featured) == (
["example/model-a", "example/model-b"], ["a/x", "b/y"])
assert split_recommended(listed, ()) == ([], listed)
def test_cli_rows_mark_top_tier_from_the_gateway_word():
prices = {**_PRICES, "example/model-c": {**_PRICES["example/model-c"],
"usage_level": "top_tier"}}
rows = _ModelPickerRows(list(prices), prices, current_model="", sale_chrome=True, usage=_window_usage())
assert rows.has_top_tier
assert rows.label("example/model-c").endswith("Large")
assert rows.usage.is_top_tier("example/model-c")
assert not rows.usage.is_top_tier("example/model-b")
def test_catalog_parse_keeps_the_gateway_usage_level_for_nous_only(monkeypatch):
from hermes_cli import models_pricing as mp
payload = {"data": [
{"id": "a/m", "pricing": {"prompt": "0.000001", "completion": "0.000002"}, "usage_level": "medium"},
{"id": "b/m", "pricing": {"prompt": "0.000001", "completion": "0.000002"}},
]}
monkeypatch.setattr(mp, "_get_json", lambda *a, **k: payload)
monkeypatch.setattr(mp, "_seed_reasoning_caps", lambda *a, **k: None)
nous = mp.fetch_models_with_pricing("k", "https://nous.example", force_refresh=True,
include_sale_original=True)
assert nous["a/m"]["usage_level"] == "medium" and "usage_level" not in nous["b/m"]
other = mp.fetch_models_with_pricing("k", "https://other.example", force_refresh=True)
assert "usage_level" not in other["a/m"]
def test_catalog_parse_keeps_the_top_tier_mark_for_nous_only(monkeypatch):
from hermes_cli import models_pricing as mp
payload = {"data": [
{"id": "a/m", "pricing": {"prompt": "0.000001", "completion": "0.000002"}, "top_tier": True},
{"id": "b/m", "pricing": {"prompt": "0.000001", "completion": "0.000002"}},
]}
monkeypatch.setattr(mp, "_get_json", lambda *a, **k: payload)
monkeypatch.setattr(mp, "_seed_reasoning_caps", lambda *a, **k: None)
nous = mp.fetch_models_with_pricing("k", "https://nous.example", force_refresh=True,
include_sale_original=True)
assert nous["a/m"]["top_tier"] is True and "top_tier" not in nous["b/m"]
other = mp.fetch_models_with_pricing("k", "https://other.example", force_refresh=True)
assert "top_tier" not in other["a/m"]
def test_account_payload_parses_featured_ids():
from hermes_cli import nous_account as na
info = na._coerced_dataclass(na.NousUsageWindowInfo, usage_window(featured_model_ids=["a/b", "c/d"]))
assert info.featured_model_ids == ("a/b", "c/d")
def _stub_account_cache(monkeypatch, stale, fetched):
"""Fresh cache empty, last snapshot ``stale``; a fetch records its force_fresh and fills the cache."""
from hermes_cli import nous_account as na
calls, fresh = [], {}
def cached(*, any_age=False):
return fresh.get("info") or (stale if any_age else None)
def get(*, force_fresh=False, **_):
calls.append(force_fresh)
if force_fresh:
fresh["info"] = fetched
return fetched
monkeypatch.setattr(na, "cached_nous_portal_account_info", cached)
monkeypatch.setattr(na, "get_nous_portal_account_info", get)
return calls
def test_warm_picker_refetches_a_known_window_plan_past_the_cache_ttl(monkeypatch):
from hermes_cli.model_picker_usage import nous_picker_usage
window = SimpleNamespace(logged_in=True, subscription=SimpleNamespace(plan="Window Plan"),
usage_window=SimpleNamespace(**usage_window(day_used_bp=100, week_used_bp=200)))
calls = _stub_account_cache(monkeypatch, stale=window, fetched=window)
usage = nous_picker_usage(warm=True)
assert calls == [True]
assert usage is not None and usage.gauge(GAUGE_TODAY) is not None
def test_warm_picker_never_forces_a_fetch_for_a_non_window_account(monkeypatch):
from hermes_cli.model_picker_usage import nous_picker_usage
credit = SimpleNamespace(logged_in=True, subscription=SimpleNamespace(plan="Credit Plan"), usage_window=None)
for stale in (credit, None):
calls = _stub_account_cache(monkeypatch, stale=stale, fetched=credit)
assert nous_picker_usage(warm=True) is None
assert calls == [False]
# ── where the "used up" note reaches outside the pickers above ───────────────────
def test_the_in_chat_cli_picker_says_the_limit_once_on_nous_only(monkeypatch):
from hermes_cli import model_picker_usage as mpu
monkeypatch.setattr(mpu, "nous_picker_usage", lambda **kw: _window_usage(day_used_bp=10_000))
rows, line = mpu.annotate_window_plan_rows({"slug": "nous"}, ["paid/m", "gift/m:free"])
# Rows stay the bare ids; the limit is said once, above the list.
assert rows == ["paid/m", "gift/m:free"] and line.startswith("Daily limit reached")
# Any other provider, or no fresh snapshot: the bare ids and no line.
assert mpu.annotate_window_plan_rows({"slug": "example"}, ["paid/m"]) == (["paid/m"], None)
monkeypatch.setattr(mpu, "nous_picker_usage", lambda **kw: None)
assert mpu.annotate_window_plan_rows({"slug": "nous"}, ["paid/m"]) == (["paid/m"], None)
def test_the_in_chat_cli_picker_tags_large_and_free_rows_on_window_plans_only(monkeypatch):
from hermes_cli import model_picker_usage as mpu
monkeypatch.setattr(mpu, "nous_picker_usage", lambda **kw: None)
window = {"slug": "nous", "plan_usage": {"kind": "usage_window"},
"usage_levels": {"example/model-b": "top_tier", "example/model-a": "low", "example/model-free:free": "free"}}
ids = ["example/model-b", "example/model-a", "example/model-free:free"]
rows, _line = mpu.annotate_window_plan_rows(window, ids)
assert [r.split() for r in rows] == [["example/model-b", "Large"], ["example/model-a"], ["example/model-free:free", "Free"]]
# Same payload without a window plan (or a stray levels map): the bare ids.
assert mpu.annotate_window_plan_rows({**window, "plan_usage": None}, ids)[0] == ids
_LEVELS = {"example/model-b": {"usage_level": "top_tier", "top_tier": True},
"example/model-a": {"usage_level": "low"}}
def test_messaging_pickers_get_large_free_labels_and_the_limit_line(monkeypatch):
from hermes_cli import model_picker_usage as mpu
from hermes_cli import model_switch_providers as msp
from agent import plan_limits as pl
monkeypatch.setattr(mpu, "nous_picker_usage", lambda **kw: _window_usage(top_tier_used_bp=10_000))
monkeypatch.setattr(pl, "cached_pricing", lambda base_url="": dict(_LEVELS))
providers = [{"slug": "nous", "api_url": "https://x/v1", "models": ["example/model-b", "example/model-a"]},
{"slug": "example", "models": ["example/model-b"]}]
msp._attach_window_model_notes(providers)
nous = providers[0]
# Only Large / Free are tagged; no per-row limit notes (the plan line says it once).
assert nous["model_labels"] == {"example/model-b": "Large"}
assert nous["plan_line"].startswith("Monthly large-model limit reached")
assert "model_notes" not in nous
assert mpu.picker_row_suffix(nous, "example/model-b") == "Large"
assert mpu.picker_row_suffix(nous, "example/model-a") == ""
assert not {"model_labels", "plan_line"} & set(providers[1])
# Nothing spent: labels only. Not a window plan: no field at all (pickers unchanged).
quiet = [{"slug": "nous", "api_url": "https://x/v1", "models": ["example/model-b"]}]
monkeypatch.setattr(mpu, "nous_picker_usage", lambda **kw: _window_usage())
msp._attach_window_model_notes(quiet)
assert quiet[0].get("model_labels") == {"example/model-b": "Large"}
assert "plan_line" not in quiet[0]
plain = [{"slug": "nous", "api_url": "https://x/v1", "models": ["example/model-b"]}]
monkeypatch.setattr(mpu, "nous_picker_usage", lambda **kw: None)
msp._attach_window_model_notes(plain)
assert plain == [{"slug": "nous", "api_url": "https://x/v1", "models": ["example/model-b"]}]
assert mpu.picker_row_suffix(plain[0], "example/model-b") == ""
def test_large_model_notice_window_plans_only(monkeypatch):
from dataclasses import replace as _replace
from hermes_cli import model_picker_usage as mpu
monkeypatch.setattr(mpu, "_nous_catalog", lambda fetch=False: dict(_LEVELS))
monkeypatch.setattr(mpu, "nous_picker_usage", lambda **kw: _window_usage())
note = mpu.large_model_notice("example/model-b", "nous")
assert note.startswith("Large model: uses more of your plan's usage per message.") and "Monthly large-model limit:" in note
assert mpu.large_model_notice("example/model-a", "nous") is None # not Large
assert mpu.large_model_notice("example/model-b", "example") is None # not Nous
# Pay as you go past the large-model limit: the credits wording.
monkeypatch.setattr(mpu, "nous_picker_usage",
lambda **kw: _replace(_window_usage(top_tier_used_bp=10_000), credits_pay=True))
assert mpu.large_model_notice("example/model-b", "nous") == "Large model: uses more credits per message (pay as you go)."
# No plan snapshot yet (cold CLI): a Large mark in the resident catalog alone proves a window plan.
monkeypatch.setattr(mpu, "nous_picker_usage", lambda **kw: None)
assert mpu.large_model_notice("example/model-b", "nous") == "Large model: uses more of your plan's usage per message."
# Any other account: its catalog carries no marks (None), and it is never fetched.
seen = []
monkeypatch.setattr(mpu, "_nous_catalog",
lambda fetch=False: seen.append(fetch) or {"example/model-b": {"prompt": "0.000001"}})
assert mpu.large_model_notice("example/model-b", "nous", fetch=True) is None
assert seen == [False]
def test_catalog_reads_never_answer_from_another_profiles_cache(monkeypatch):
"""One process, several profiles: tags and the Large notice read only this profile's catalog, never the
newest catalog cached for any credential (another plan can mark different models Large)."""
import hermes_cli.models_pricing as mp
from agent import plan_limits as pl
from hermes_cli import model_picker_usage as mpu
monkeypatch.setattr(mp, "peek_cached_pricing", lambda base_url: dict(_LEVELS)) # another profile's catalog
monkeypatch.setattr(mp, "get_pricing_for_provider", lambda provider, **kw: {}) # this profile: cold
monkeypatch.setattr(mpu, "nous_picker_usage", lambda **kw: None) # this profile: no window plan
assert pl.cached_pricing("https://inference-api.nousresearch.com/v1") == {}
assert mpu.large_model_notice("example/model-b", "nous") is None
def test_picker_words_follow_the_display_language(monkeypatch):
"""Pickers main translates read the catalog: English stays byte-identical, other languages translate."""
from hermes_cli import model_picker_usage as mpu
monkeypatch.delenv("HERMES_LANGUAGE", raising=False)
assert mpu.usage_level_label("top_tier") == "Large"
assert mpu.usage_level_label("bogus") == ""
spent = _replace_credits(_window_usage(day_used_bp=10_000), True)
assert spent.limit_line().startswith("Daily limit reached · resets ")
monkeypatch.setenv("HERMES_LANGUAGE", "de")
assert mpu.usage_level_label("top_tier") == "Groß"
assert spent.limit_line().startswith("Tageslimit erreicht · Zurücksetzung in ")
assert not spent.blocks("example/model-a")
# Surfaces whose own text is English (setup picker, ACP) ask for English explicitly.
assert spent.limit_line(lang="en").startswith("Daily limit reached")
assert spent.included_summary.startswith("Daily limit reached")
def _replace_credits(usage, credits_pay):
from dataclasses import replace as _replace
return _replace(usage, credits_pay=credits_pay)
def test_window_plan_feeds_the_existing_usage_chip(monkeypatch):
"""A window plan fills main's ``usage.windows`` (the existing usage chip) from the same snapshot; a
paused plan or any other account adds nothing, and a provider usage row is never overwritten."""
from hermes_cli import inventory
from hermes_cli import model_picker_usage as mpu
usage = _window_usage(day_used_bp=8_500)
monkeypatch.setattr(mpu, "nous_picker_usage", lambda **kw: usage)
row: dict = {"slug": "nous"}
inventory._attach_nous_plan_usage(row, warm=False)
windows = row["usage"]["windows"]
assert windows[0] == {**windows[0], "label": "Today", "used_percent": 85.0, "scope": "account"}
assert all(w["resets_at"] for w in windows)
# A full allowance: the picker's limit line says it, so no chip repeats it.
full: dict = {"slug": "nous"}
monkeypatch.setattr(mpu, "nous_picker_usage", lambda **kw: _window_usage(day_used_bp=10_000))
inventory._attach_nous_plan_usage(full, warm=False)
assert "plan_usage" in full and "usage" not in full
paused: dict = {"slug": "nous"}
monkeypatch.setattr(mpu, "nous_picker_usage", lambda **kw: replace(usage, paused_reason="renewal_unpaid"))
inventory._attach_nous_plan_usage(paused, warm=False)
assert "plan_usage" in paused and "usage" not in paused
monkeypatch.setattr(mpu, "nous_picker_usage", lambda **kw: None)
other: dict = {"slug": "nous"}
inventory._attach_nous_plan_usage(other, warm=False)
assert other == {"slug": "nous"}
# ── subscription-billed rows ────────────────────────────────
# Picker pricing shape. The gateway marks a subscription-billed row ``billing_mode: subscription`` and gives it no
# ``usage_level``; its listed price never applies.
_SUBSCRIPTION_BILLED = {
"example/model-sub": {"prompt": "0.000005", "completion": "0.00004", "billing_mode": "subscription"},
"gift/m:free": {"prompt": "0", "completion": "0"},
"example/model-b": {"prompt": "0.000005", "completion": "0.000025", "usage_level": "top_tier", "top_tier": True},
}
def test_subscription_billed_rows_draw_nothing_but_carry_no_free_tag():
# Still ``free`` to the window: nothing dims it, and the payload level the desktop/TUI dim from stays.
assert usage_levels(list(_SUBSCRIPTION_BILLED), _SUBSCRIPTION_BILLED)["example/model-sub"] == "free"
# The tag set drops it; real $0 rows and Large rows keep theirs.
assert usage_tag_levels(list(_SUBSCRIPTION_BILLED), _SUBSCRIPTION_BILLED) == {
"gift/m:free": "free", "example/model-b": "top_tier"}
usage = _window_usage(day_used_bp=10_000, top_tier_used_bp=10_000).with_pricing(_SUBSCRIPTION_BILLED)
assert not usage.blocks("example/model-sub")
assert not usage.blocks("gift/m:free")
assert usage.blocks("example/model-b")
assert usage.to_payload()["subscription_model_ids"] == ["example/model-sub"]
# No catalog: nothing marked.
assert _window_usage().to_payload()["subscription_model_ids"] == []
def test_window_picker_rows_leave_subscription_billed_rows_untagged():
rows = _ModelPickerRows(list(_SUBSCRIPTION_BILLED), _SUBSCRIPTION_BILLED, current_model="", sale_chrome=True,
usage=_window_usage(day_used_bp=10_000))
assert rows.label("example/model-sub").split("example/model-sub", 1)[1].strip() == ""
assert rows.label("gift/m:free").split("gift/m:free", 1)[1].strip() == "Free"
assert rows.label("example/model-b").split("example/model-b", 1)[1].strip() == "Large"
assert rows.has_top_tier
# Dimming is unchanged: the full day stops the paid Large row only.
assert not rows.usage.blocks("example/model-sub") and rows.usage.blocks("example/model-b")
def test_the_in_chat_cli_picker_leaves_subscription_billed_rows_untagged(monkeypatch):
from hermes_cli import model_picker_usage as mpu
monkeypatch.setattr(mpu, "nous_picker_usage", lambda **kw: None)
row = {"slug": "nous",
"plan_usage": {"kind": "usage_window", "subscription_model_ids": ["example/model-sub"]},
"usage_levels": {"example/model-sub": "free", "gift/m:free": "free"}}
rows, _line = mpu.annotate_window_plan_rows(row, ["example/model-sub", "gift/m:free"])
assert [r.split() for r in rows] == [["example/model-sub"], ["gift/m:free", "Free"]]
# An older payload without the field: unchanged (both tagged Free).
old = {**row, "plan_usage": {"kind": "usage_window"}}
assert [r.split() for r in mpu.annotate_window_plan_rows(old, ["example/model-sub"])[0]] == \
[["example/model-sub", "Free"]]
def test_messaging_pickers_leave_subscription_billed_rows_untagged(monkeypatch):
from hermes_cli import model_picker_usage as mpu
from hermes_cli import model_switch_providers as msp
from agent import plan_limits as pl
monkeypatch.setattr(mpu, "nous_picker_usage", lambda **kw: _window_usage())
monkeypatch.setattr(pl, "cached_pricing", lambda base_url="": dict(_SUBSCRIPTION_BILLED))
providers = [{"slug": "nous", "api_url": "https://x/v1", "models": list(_SUBSCRIPTION_BILLED)}]
msp._attach_window_model_notes(providers)
assert providers[0]["model_labels"] == {"gift/m:free": "Free", "example/model-b": "Large"}
assert mpu.picker_row_suffix(providers[0], "example/model-sub") == ""