roadmodel 0.2.2__tar.gz → 0.2.4__tar.gz

{roadmodel-0.2.2 → roadmodel-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: roadmodel
-Version: 0.2.2
+Version: 0.2.4
 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.2 → roadmodel-0.2.4}/pyproject.toml

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

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

{roadmodel-0.2.2 → roadmodel-0.2.4}/src/roadmodel/cost.py

@@ -258,6 +258,31 @@ def _resolve_method(platform_id: str, catalog: dict[str, Any]) -> dict[str, Any]
     )
 
 
+def canonical_model_name(model_ref: str) -> str:
+    """Resolve a model id-or-name to its catalog display ``name``; return the
+    input unchanged on any catalog miss (never raises).
+
+    The recommender LLM emits the model freely as either the catalog id/slug
+    or the display name, which made the response header (raw) disagree with the
+    cost/comparison table (catalog name) and risked silently dropping the cost
+    panel on an unrecognized label (#174). Callers canonicalize once so every
+    downstream consumer references one consistent name.
+    """
+    try:
+        return str(_resolve_model(model_ref, _load_catalog())["name"])
+    except (ValueError, BundledDocNotFoundError):
+        return model_ref
+
+
+def canonical_platform_name(platform_ref: str) -> str:
+    """Resolve an access-method id-or-name to its catalog display ``name``;
+    return the input unchanged on any catalog miss (never raises) (#174)."""
+    try:
+        return str(_resolve_method(platform_ref, _load_catalog())["name"])
+    except (ValueError, BundledDocNotFoundError):
+        return platform_ref
+
+
 def _as_dict(value: object) -> dict[str, Any]:
     if not isinstance(value, dict):
         raise BundledDocNotFoundError("catalog.json")

{roadmodel-0.2.2 → roadmodel-0.2.4}/src/roadmodel/providers/__init__.py

@@ -13,4 +13,6 @@ class ProviderAdapter(Protocol):
         model: str | None = None,
         api_key: str,
         max_output_tokens: int | None = None,
+        thinking_budget: int | None = None,
+        temperature: float | None = None,
     ) -> str: ...

{roadmodel-0.2.2 → roadmodel-0.2.4}/src/roadmodel/providers/anthropic.py

@@ -13,7 +13,17 @@ def recommend(
     model: str | None = None,
     api_key: str,
     max_output_tokens: int | None = None,
+    thinking_budget: int | None = None,
+    temperature: float | None = None,
 ) -> str:
+    # thinking_budget and temperature are accepted for ProviderAdapter Protocol
+    # parity but intentionally NOT forwarded: both are Gemini-specific knobs for
+    # the recommender latency/determinism work (issues #132, #176). Anthropic
+    # extended-thinking has different semantics (a `thinking` block with its own
+    # budget_tokens and minimums) and the recommender response shape does not
+    # tolerate small caps on Anthropic at all (PR #128). Anthropic reasoning
+    # control is Phase 5 paid-frontier scope.
+    _ = (thinking_budget, temperature)
     try:
         from anthropic import Anthropic, APIError
     except Exception as exc:  # pragma: no cover - dependency/runtime guard

{roadmodel-0.2.2 → roadmodel-0.2.4}/src/roadmodel/providers/google.py

@@ -15,6 +15,8 @@ def recommend(
     model: str | None = None,
     api_key: str,
     max_output_tokens: int | None = None,
+    thinking_budget: int | None = None,
+    temperature: float | None = None,
 ) -> str:
     try:
         from google import genai
@@ -32,6 +34,19 @@ def recommend(
         config: Any = {"system_instruction": system}
         if max_output_tokens is not None:
             config["max_output_tokens"] = max_output_tokens
+        if thinking_budget is not None:
+            # Gemini 2.5+ Flash reasons by default, and that reasoning is
+            # decoded before the visible answer (and counts against
+            # max_output_tokens). thinking_budget caps it: 0 disables
+            # thinking entirely, a small value bounds it. `is not None` —
+            # not truthiness — because 0 is a meaningful value (thinking off).
+            config["thinking_config"] = {"thinking_budget": thinking_budget}
+        if temperature is not None:
+            # Recommender determinism (#176): without this Gemini samples at
+            # its default temperature (~1.0), so identical input yields
+            # different model picks run-to-run. `is not None` — not truthiness
+            # — because 0.0 (greedy/deterministic) is the intended value.
+            config["temperature"] = temperature
         response = client.models.generate_content(
             model=model or DEFAULT_MODEL,
             contents=prompt,

{roadmodel-0.2.2 → roadmodel-0.2.4}/src/roadmodel/providers/openai.py

@@ -31,7 +31,16 @@ def recommend(
     model: str | None = None,
     api_key: str,
     max_output_tokens: int | None = None,
+    thinking_budget: int | None = None,
+    temperature: float | None = None,
 ) -> str:
+    # thinking_budget and temperature are accepted for ProviderAdapter Protocol
+    # parity but intentionally NOT forwarded: both are Gemini-specific knobs for
+    # the recommender latency/determinism work (issues #132, #176). OpenAI
+    # reasoning control uses a different mechanism (`reasoning.effort` on
+    # reasoning models), out of scope for the free-tier recommender, which runs
+    # on Gemini Flash.
+    _ = (thinking_budget, temperature)
     try:
         from openai import APIError, OpenAI
     except Exception as exc:  # pragma: no cover - dependency/runtime guard

{roadmodel-0.2.2 → roadmodel-0.2.4}/src/roadmodel/recommend.py

@@ -124,6 +124,8 @@ def recommend(
     config: Config,
     *,
     max_output_tokens: int | None = None,
+    thinking_budget: int | None = None,
+    temperature: float | None = None,
 ) -> dict[str, str]:
     user_context_text = user_context.read(config.user_context_path)
     system_prompt, user_prompt = build_prompt(prompt, user_context_text=user_context_text)
@@ -134,6 +136,8 @@ def recommend(
         model=config.model,
         api_key=config.api_key,
         max_output_tokens=max_output_tokens,
+        thinking_budget=thinking_budget,
+        temperature=temperature,
     )
     return parse_response(raw_response)
 
@@ -169,9 +173,29 @@ def recommend_structured(
     output_tokens: int | None = None,
     max_mode: bool = False,
     max_output_tokens: int | None = None,
+    thinking_budget: int | None = None,
+    temperature: float | None = None,
 ) -> dict[str, Any]:
     """Return roadmap-style structured output plus optional cost estimates."""
-    base = recommend(prompt, config, max_output_tokens=max_output_tokens)
+    base = recommend(
+        prompt,
+        config,
+        max_output_tokens=max_output_tokens,
+        thinking_budget=thinking_budget,
+        temperature=temperature,
+    )
+    # Canonicalize the model + platform to their catalog display names (#174):
+    # the LLM emits either the id/slug or the display name freely, which made
+    # the response header (raw) disagree with the cost/comparison table
+    # (catalog name) and risked a silent cost-panel drop on an unrecognized
+    # label. Resolve once here so the payload, per-surface settings, and the
+    # cost calls below all agree; falls back to the raw value on a catalog
+    # miss (canonical_* never raises).
+    base = {
+        **base,
+        "model": cost.canonical_model_name(base["model"]),
+        "platform": cost.canonical_platform_name(base["platform"]),
+    }
     payload: dict[str, Any] = {
         "model": base["model"],
         "platform": base["platform"],