roadmodel 0.2.72__tar.gz → 0.2.74__tar.gz

{roadmodel-0.2.72 → roadmodel-0.2.74}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: roadmodel
-Version: 0.2.72
+Version: 0.2.74
 Summary: BYO-key CLI that recommends the right AI model, platform, and settings for a prompt.
 Project-URL: Homepage, https://roadmodel.ai
 Project-URL: Repository, https://github.com/nathanramoscfa/roadmodel

{roadmodel-0.2.72/roadmodel/data → roadmodel-0.2.74/docs}/catalog.json

@@ -1,7 +1,7 @@
 {
   "schema_version": "4",
   "output_contract_version": 2,
-  "generated_at_utc": "2026-10-07T18:08:11Z",
+  "generated_at_utc": "2026-10-07T20:14:28Z",
   "source_doc_sha256": {
     "model-selector.txt": "6a75e2265459fa7302cb80d0faf5ec2aad575034fc29866238cd1579c001cc2d",
     "model-tier-cost-scale.md": "2b3b0eb82237eb5cb5bf468a3fe971bcaf0160ad7d0bc700698d2c16640bc41d"

{roadmodel-0.2.72 → roadmodel-0.2.74}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "roadmodel"
-version = "0.2.72"
+version = "0.2.74"
 description = "BYO-key CLI that recommends the right AI model, platform, and settings for a prompt."
 readme = "README.md"
 requires-python = ">=3.11"

{roadmodel-0.2.72/docs → roadmodel-0.2.74/roadmodel/data}/catalog.json

@@ -1,7 +1,7 @@
 {
   "schema_version": "4",
   "output_contract_version": 2,
-  "generated_at_utc": "2026-10-07T18:08:11Z",
+  "generated_at_utc": "2026-10-07T20:14:28Z",
   "source_doc_sha256": {
     "model-selector.txt": "6a75e2265459fa7302cb80d0faf5ec2aad575034fc29866238cd1579c001cc2d",
     "model-tier-cost-scale.md": "2b3b0eb82237eb5cb5bf468a3fe971bcaf0160ad7d0bc700698d2c16640bc41d"

{roadmodel-0.2.72 → roadmodel-0.2.74}/src/roadmodel/__init__.py

@@ -1,2 +1,2 @@
 # src/roadmodel/__init__.py
-__version__ = "0.2.72"
+__version__ = "0.2.74"

{roadmodel-0.2.72 → roadmodel-0.2.74}/src/roadmodel/recommend.py

@@ -479,7 +479,11 @@ _SAAS_LADDER_TABLE_HEADER: Final = (
     "1. One line `CLASSIFICATION: <category> / <complexity> / <novel|routine>`. "
     "<category> is the task's PRIMARY category (coding, planning, agentic, multimodal, "
     "long-context, knowledge or speed) per Step 1 of the selection algorithm; "
-    "<complexity> is low, medium or high per its Step 2. `novel` marks "
+    "<complexity> is low, medium or high per its Step 2. High-volume routine work "
+    "(classifying, tagging, extracting or summarizing many similar items) is `speed` "
+    "whatever accuracy it needs, and its complexity is how hard ONE item is. Building an "
+    "agent or an app (writing its code) is `coding`; running one, where the model itself "
+    "acts through tools in a loop, is `agentic`. `novel` marks "
     "research-grade work only: an open problem, a new algorithm, or a proof of a "
     "result with no known proof. Writing out a known result (a textbook proof, a "
     "standard derivation) is `routine` however many steps it takes, and its "
@@ -1487,12 +1491,18 @@ def _fit_row_to_input(
     """The row with every model whose context window cannot hold the task's
     material left out (scoring.too_small_for), and what the check found. The
     table is computed before the engine reads the task, so the row is
-    recomputed here when a model its frontier draws on is too small; with
-    none left that fits, the row stands and ``fits`` says so."""
+    recomputed here when a model its frontier draws on is too small. When the
+    material is larger than every known window, or none left fits, the row
+    stands and ``fits`` says so."""
     small = set(scoring.too_small_for(input_tokens))
     drawn = {p.candidate.model_id for p in [*row.frontier, *row.points]}
     excluded = sorted(small & drawn)
     report: dict[str, Any] = {"input_tokens": input_tokens, "excluded": excluded, "fits": True}
+    if scoring.nothing_fits(input_tokens):
+        # Larger than every known window: no pick holds it, and one whose
+        # window is unknown would stand only by default.
+        report["fits"] = False
+        return row, report
     if not excluded:
         return row, report
     refit = scoring.ladder(

{roadmodel-0.2.72 → roadmodel-0.2.74}/src/roadmodel/scoring.py

@@ -330,6 +330,14 @@ def context_windows() -> dict[str, int]:
     return {str(k): v for k, v in models.items() if isinstance(v, int) and v > 0}
 
 
+def nothing_fits(input_tokens: int, windows: dict[str, int] | None = None) -> bool:
+    """True when no model with a known context window can hold
+    ``input_tokens`` of material: the material is larger than any model
+    takes, and a model whose window is unknown is no answer."""
+    known = windows if windows is not None else context_windows()
+    return bool(known) and len(too_small_for(input_tokens, known)) == len(known)
+
+
 def too_small_for(input_tokens: int, windows: dict[str, int] | None = None) -> list[str]:
     """The catalog ids whose context window cannot hold ``input_tokens`` of
     material with CONTEXT_HEADROOM to spare. A model with no known window is
@@ -953,10 +961,20 @@ def rank(
     catalog: dict[str, Any] | None = None,
     benchmarks: dict[str, Any] | None = None,
     top: int | None = None,
+    effort_aware: bool = True,
 ) -> Ranking:
-    """Rank every reachable (model, platform) pair for ``task``."""
+    """Rank every reachable (model, platform) pair for ``task``.
+
+    With ``effort_aware`` (the default), a model AA has measured at several
+    efforts stands at the one that scores best for the task's posture, among
+    those it may run (:func:`effort_settings`), its quality, requirement
+    penalty (in the category and in general capability) and cost read there;
+    a model measured only at efforts the task does not run is left out. Off,
+    every model stands on its headline row at its posture's effort: the pool
+    :func:`ladder` expands itself."""
     cat = catalog if catalog is not None else _cost._load_catalog()
-    bench = with_composites(benchmarks if benchmarks is not None else _load_benchmarks())
+    raw_bench = benchmarks if benchmarks is not None else _load_benchmarks()
+    bench = with_composites(raw_bench)
     text = user_context_text or ""
     headroom = consumption_headroom(text)
     pools = pool_states(text)
@@ -1092,6 +1110,28 @@ def rank(
             continue
         candidates.append(best_for_model)
 
+    if effort_aware and candidates:
+        settings = effort_settings(
+            candidates, task, headroom, lam=lam, k=k, catalog=cat, benchmarks=raw_bench
+        )
+        best: dict[str, Candidate] = {}
+        for c in settings:
+            held = best.get(c.model_id)
+            if held is None or (c.score, -c.effective_cost_usd) > (
+                held.score,
+                -held.effective_cost_usd,
+            ):
+                best[c.model_id] = c
+        for c in candidates:
+            if c.model_id not in best:
+                excluded.append(
+                    {
+                        "model": c.model_id,
+                        "reason": "measured only at efforts this task does not run",
+                    }
+                )
+        candidates = [best[c.model_id] for c in candidates if c.model_id in best]
+
     # Funded first, then score, then cheaper, then id — deterministic.
     candidates.sort(
         key=lambda c: (c.funding == "unfunded", -c.score, c.effective_cost_usd, c.model_id)
@@ -1396,7 +1436,8 @@ def _at_level(
     task: Task,
     bench: dict[str, Any],
     scales: tuple[EvidenceScale | None, EvidenceScale | None],
-    ranking: Ranking,
+    lam: float,
+    k: float,
 ) -> Candidate:
     """``c`` run at ``level`` (None: its headline row, at the posture's
     effort): quality from AA's row at that effort, and the requirement
@@ -1426,7 +1467,7 @@ def _at_level(
     mult = EFFORT_TOKEN_MULTIPLIER[level]
     eff_cost = c.blended_price_usd * c.scarcity * mult
     decades = math.log10(max(eff_cost, COST_FLOOR_USD) / COST_FLOOR_USD)
-    cost_pen = ranking.lam * ranking.k_points_per_decade * decades
+    cost_pen = lam * k * decades
     nudge = 0.5 if task.category in AGENT_CATEGORIES and c.platform_id in AGENT_SURFACES else 0.0
     return replace(
         c,
@@ -1449,8 +1490,9 @@ def effort_settings(
     pool: list[Candidate],
     task: Task,
     headroom: str,
-    ranking: Ranking,
     *,
+    lam: float,
+    k: float,
     catalog: dict[str, Any],
     benchmarks: dict[str, Any],
 ) -> list[Candidate]:
@@ -1485,7 +1527,7 @@ def effort_settings(
         if headroom == "uncapped" and c.scarcity == 0:
             levels = levels[-1:]  # a free path runs at its top effort
         out.extend(
-            _at_level(c, lv, model, task, bench, scales, ranking) for lv in (levels or [None])
+            _at_level(c, lv, model, task, bench, scales, lam, k) for lv in (levels or [None])
         )
     return out
 
@@ -1550,6 +1592,7 @@ def ladder(
         unavailable_models=unavailable_models,
         catalog=cat,
         benchmarks=bench,
+        effort_aware=False,
     )
     funded = [c for c in ranking.candidates if c.funding != "unfunded"]
     pool = funded or ranking.candidates
@@ -1559,7 +1602,15 @@ def ladder(
     headroom = consumption_headroom(user_context_text or "")
     # The picks are read off the same frontier drawn over each model at every
     # effort AA measured it at, so an effort is part of the pick it prices.
-    settings = effort_settings(pool, base, headroom, ranking, catalog=cat, benchmarks=bench)
+    settings = effort_settings(
+        pool,
+        base,
+        headroom,
+        lam=ranking.lam,
+        k=ranking.k_points_per_decade,
+        catalog=cat,
+        benchmarks=bench,
+    )
     # Every model AA measured only at efforts this task does not run leaves
     # none: the picks then fall back to the models' frontier.
     points = frontier(settings, bench) or front