roadmodel 0.2.76__tar.gz → 0.2.77__tar.gz

{roadmodel-0.2.76 → roadmodel-0.2.77}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: roadmodel
-Version: 0.2.76
+Version: 0.2.77
 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.76 → roadmodel-0.2.77}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "roadmodel"
-version = "0.2.76"
+version = "0.2.77"
 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.76 → roadmodel-0.2.77}/src/roadmodel/__init__.py

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

{roadmodel-0.2.76 → roadmodel-0.2.77}/src/roadmodel/cost.py

@@ -404,7 +404,7 @@ _HOST_METHODS: frozenset[str] = frozenset({"antigravity"})
 _LOCAL_PROVIDERS: frozenset[str] = frozenset({"ollama"})
 
 
-def model_provider(model_ref: str) -> str | None:
+def model_provider(model_ref: str, catalog: dict[str, Any] | None = None) -> str | None:
     """Resolve a model id-or-name to its MAKER (the company that produces it):
     ``anthropic`` / ``openai`` / ``google`` / ``xai`` / ``deepseek`` / ``mistral``
     / ``zai`` / ``groq`` / ``cursor`` …
@@ -419,7 +419,10 @@ def model_provider(model_ref: str) -> str | None:
     rather than dropping a valid backup.
     """
     try:
-        catalog = _load_catalog()
+        # A caller that already holds the catalog passes it: the scorer asks
+        # once per candidate, and re-parsing the JSON each time was most of a
+        # ladder table's cost (Phase 4.5, 2026-10-08).
+        catalog = catalog if catalog is not None else _load_catalog()
         model_id = str(_resolve_model(model_ref, catalog)["id"])
     except (ValueError, BundledDocNotFoundError, KeyError, TypeError):
         return None

{roadmodel-0.2.76 → roadmodel-0.2.77}/src/roadmodel/recommend.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 
 import contextvars
 import json
+import os
 import re
 from collections import Counter
 from concurrent.futures import ThreadPoolExecutor
@@ -1553,15 +1554,37 @@ def _enforce_table_effort(ladder: dict[str, dict[str, str]], row: scoring.Ladder
     return adjusted
 
 
+# Ladder tables already computed in this process, by user-context text, the
+# unavailable models and any catalog override. The catalog and benchmarks are
+# bundled, so one context always yields the same table; rebuilding it (28 rows,
+# each ranking the whole pool) cost the hosted service about a second a request
+# for a well-funded user (Phase 4.5 soak, 2026-10-08: B9 latency). Rows are
+# read, never mutated. Oldest entry out first past _TABLE_CACHE_MAX.
+_TABLE_CACHE: dict[tuple[str, tuple[str, ...], str], dict[str, scoring.Ladder]] = {}
+_TABLE_CACHE_MAX: Final = 64
+
+
 def _ladder_table_for(
     user_context_text: str, unavailable_models: list[str] | None
 ) -> dict[str, scoring.Ladder]:
     """The scorer's ladder table for this user-context, or an empty one if it
     cannot be computed: a scoring failure costs the table, never the call."""
+    key = (
+        user_context_text,
+        tuple(sorted(unavailable_models or [])),
+        os.environ.get("ROADMODEL_CATALOG_PATH", ""),
+    )
+    cached = _TABLE_CACHE.get(key)
+    if cached is not None:
+        return cached
     try:
-        return scoring.ladder_table(user_context_text, unavailable_models=unavailable_models)
+        table = scoring.ladder_table(user_context_text, unavailable_models=unavailable_models)
     except Exception:  # noqa: BLE001 - fail open to the free-choice ladder
         return {}
+    if len(_TABLE_CACHE) >= _TABLE_CACHE_MAX:
+        _TABLE_CACHE.pop(next(iter(_TABLE_CACHE)), None)
+    _TABLE_CACHE[key] = table
+    return table
 
 
 def _fit_row_to_input(

{roadmodel-0.2.76 → roadmodel-0.2.77}/src/roadmodel/scoring.py

@@ -1034,7 +1034,7 @@ def rank(
         if str(model.get("jurisdiction", "")).lower() not in juris:
             excluded.append({"model": model_id, "reason": "jurisdiction"})
             continue
-        provider = _cost.model_provider(model_id) or str(model.get("provider", "unknown"))
+        provider = _cost.model_provider(model_id, cat) or str(model.get("provider", "unknown"))
         quality, source, letter = _quality(model, task, bench, scale)
         points = _evidence_points(model_id, task, bench, scale)
         shortfall = max(0.0, requirement - quality)