minima-cli 0.4.9__py3-none-any.whl

minima/catalog/data/capability_priors.json

@@ -0,0 +1,210 @@
+{
+  "version": "fallback-snapshot-2026-06",
+  "note": "Cold-start fallback only. Live cost is overlaid from LiteLLM/OpenRouter at runtime; capability_by_task_type are normalized [0,1] heuristic priors, intended to be corrected by accumulated memory. Prices are approximate USD per million tokens.",
+  "models": [
+    {
+      "model_id": "claude-haiku-4-5",
+      "provider": "anthropic",
+      "display_name": "Claude Haiku 4.5",
+      "input_cost_per_mtok": 1.0,
+      "output_cost_per_mtok": 5.0,
+      "cache_read_cost_per_mtok": 0.1,
+      "supports_prompt_caching": true,
+      "context_window": 200000,
+      "max_output_tokens": 64000,
+      "capability_priors": {"intelligence_index": 0.5},
+      "capability_by_task_type": {
+        "code": 0.7, "summarization": 0.85, "extraction": 0.88, "qa": 0.8,
+        "reasoning": 0.6, "classification": 0.9, "translation": 0.85,
+        "creative": 0.75, "rag": 0.82, "tool_use": 0.75, "other": 0.72
+      }
+    },
+    {
+      "model_id": "claude-sonnet-4-6",
+      "provider": "anthropic",
+      "display_name": "Claude Sonnet 4.6",
+      "input_cost_per_mtok": 3.0,
+      "output_cost_per_mtok": 15.0,
+      "cache_read_cost_per_mtok": 0.3,
+      "supports_prompt_caching": true,
+      "context_window": 200000,
+      "max_output_tokens": 64000,
+      "capability_priors": {"intelligence_index": 0.72},
+      "capability_by_task_type": {
+        "code": 0.88, "summarization": 0.9, "extraction": 0.92, "qa": 0.9,
+        "reasoning": 0.85, "classification": 0.93, "translation": 0.9,
+        "creative": 0.88, "rag": 0.9, "tool_use": 0.9, "other": 0.86
+      }
+    },
+    {
+      "model_id": "claude-opus-4-8",
+      "provider": "anthropic",
+      "display_name": "Claude Opus 4.8",
+      "input_cost_per_mtok": 15.0,
+      "output_cost_per_mtok": 75.0,
+      "cache_read_cost_per_mtok": 1.5,
+      "supports_prompt_caching": true,
+      "context_window": 200000,
+      "max_output_tokens": 64000,
+      "capability_priors": {"intelligence_index": 0.95},
+      "capability_by_task_type": {
+        "code": 0.96, "summarization": 0.93, "extraction": 0.94, "qa": 0.95,
+        "reasoning": 0.97, "classification": 0.95, "translation": 0.93,
+        "creative": 0.94, "rag": 0.94, "tool_use": 0.95, "other": 0.93
+      }
+    },
+    {
+      "model_id": "gpt-4o-mini",
+      "provider": "openai",
+      "display_name": "GPT-4o mini",
+      "input_cost_per_mtok": 0.15,
+      "output_cost_per_mtok": 0.6,
+      "cache_read_cost_per_mtok": 0.075,
+      "supports_prompt_caching": true,
+      "context_window": 128000,
+      "max_output_tokens": 16384,
+      "capability_priors": {"intelligence_index": 0.45},
+      "capability_by_task_type": {
+        "code": 0.68, "summarization": 0.84, "extraction": 0.86, "qa": 0.78,
+        "reasoning": 0.55, "classification": 0.9, "translation": 0.83,
+        "creative": 0.72, "rag": 0.8, "tool_use": 0.72, "other": 0.7
+      }
+    },
+    {
+      "model_id": "gpt-4o",
+      "provider": "openai",
+      "display_name": "GPT-4o",
+      "input_cost_per_mtok": 2.5,
+      "output_cost_per_mtok": 10.0,
+      "cache_read_cost_per_mtok": 1.25,
+      "supports_prompt_caching": true,
+      "context_window": 128000,
+      "max_output_tokens": 16384,
+      "capability_priors": {"intelligence_index": 0.7},
+      "capability_by_task_type": {
+        "code": 0.85, "summarization": 0.9, "extraction": 0.9, "qa": 0.89,
+        "reasoning": 0.82, "classification": 0.92, "translation": 0.9,
+        "creative": 0.87, "rag": 0.89, "tool_use": 0.89, "other": 0.85
+      }
+    },
+    {
+      "model_id": "gemini-2.5-flash-lite",
+      "provider": "google",
+      "display_name": "Gemini 2.5 Flash-Lite",
+      "input_cost_per_mtok": 0.075,
+      "output_cost_per_mtok": 0.30,
+      "cache_read_cost_per_mtok": 0.018,
+      "supports_prompt_caching": true,
+      "context_window": 1048576,
+      "max_output_tokens": 65536,
+      "capability_priors": {"intelligence_index": 0.40},
+      "capability_by_task_type": {
+        "code": 0.62, "summarization": 0.80, "extraction": 0.84, "qa": 0.74,
+        "reasoning": 0.50, "classification": 0.86, "translation": 0.82,
+        "creative": 0.68, "rag": 0.78, "tool_use": 0.68, "other": 0.64
+      }
+    },
+    {
+      "model_id": "gemini-3.1-flash-lite",
+      "provider": "google",
+      "display_name": "Gemini 3.1 Flash-Lite",
+      "input_cost_per_mtok": 0.08,
+      "output_cost_per_mtok": 0.35,
+      "cache_read_cost_per_mtok": 0.02,
+      "supports_prompt_caching": true,
+      "context_window": 1048576,
+      "max_output_tokens": 65536,
+      "capability_priors": {"intelligence_index": 0.48},
+      "capability_by_task_type": {
+        "code": 0.68, "summarization": 0.83, "extraction": 0.86, "qa": 0.78,
+        "reasoning": 0.58, "classification": 0.88, "translation": 0.84,
+        "creative": 0.72, "rag": 0.80, "tool_use": 0.72, "other": 0.68
+      }
+    },
+    {
+      "model_id": "gemini-2.5-flash",
+      "provider": "google",
+      "display_name": "Gemini 2.5 Flash",
+      "input_cost_per_mtok": 0.3,
+      "output_cost_per_mtok": 2.5,
+      "cache_read_cost_per_mtok": 0.075,
+      "supports_prompt_caching": true,
+      "context_window": 1048576,
+      "max_output_tokens": 65536,
+      "capability_priors": {"intelligence_index": 0.55},
+      "capability_by_task_type": {
+        "code": 0.74, "summarization": 0.88, "extraction": 0.88, "qa": 0.82,
+        "reasoning": 0.66, "classification": 0.9, "translation": 0.88,
+        "creative": 0.78, "rag": 0.86, "tool_use": 0.8, "other": 0.76
+      }
+    },
+    {
+      "model_id": "gemini-3.5-flash",
+      "provider": "google",
+      "display_name": "Gemini 3.5 Flash",
+      "input_cost_per_mtok": 0.50,
+      "output_cost_per_mtok": 3.00,
+      "cache_read_cost_per_mtok": 0.125,
+      "supports_prompt_caching": true,
+      "context_window": 1048576,
+      "max_output_tokens": 65536,
+      "capability_priors": {"intelligence_index": 0.65},
+      "capability_by_task_type": {
+        "code": 0.85, "summarization": 0.88, "extraction": 0.90, "qa": 0.84,
+        "reasoning": 0.72, "classification": 0.91, "translation": 0.88,
+        "creative": 0.82, "rag": 0.87, "tool_use": 0.88, "other": 0.80
+      }
+    },
+    {
+      "model_id": "gemini-3-flash-preview",
+      "provider": "google",
+      "display_name": "Gemini 3 Flash (Preview)",
+      "input_cost_per_mtok": 0.35,
+      "output_cost_per_mtok": 2.50,
+      "cache_read_cost_per_mtok": 0.088,
+      "supports_prompt_caching": true,
+      "context_window": 1048576,
+      "max_output_tokens": 65536,
+      "capability_priors": {"intelligence_index": 0.62},
+      "capability_by_task_type": {
+        "code": 0.80, "summarization": 0.87, "extraction": 0.88, "qa": 0.83,
+        "reasoning": 0.70, "classification": 0.90, "translation": 0.87,
+        "creative": 0.80, "rag": 0.85, "tool_use": 0.84, "other": 0.78
+      }
+    },
+    {
+      "model_id": "gemini-2.5-pro",
+      "provider": "google",
+      "display_name": "Gemini 2.5 Pro",
+      "input_cost_per_mtok": 1.25,
+      "output_cost_per_mtok": 10.0,
+      "cache_read_cost_per_mtok": 0.31,
+      "supports_prompt_caching": true,
+      "context_window": 1048576,
+      "max_output_tokens": 65536,
+      "capability_priors": {"intelligence_index": 0.8},
+      "capability_by_task_type": {
+        "code": 0.9, "summarization": 0.92, "extraction": 0.92, "qa": 0.91,
+        "reasoning": 0.88, "classification": 0.93, "translation": 0.92,
+        "creative": 0.89, "rag": 0.91, "tool_use": 0.9, "other": 0.88
+      }
+    }
+    ,{
+      "model_id": "gemini-3.1-pro-preview",
+      "provider": "google",
+      "display_name": "Gemini 3.1 Pro (Preview)",
+      "input_cost_per_mtok": 2.00,
+      "output_cost_per_mtok": 12.00,
+      "cache_read_cost_per_mtok": 0.50,
+      "supports_prompt_caching": true,
+      "context_window": 1048576,
+      "max_output_tokens": 65536,
+      "capability_priors": {"intelligence_index": 0.90},
+      "capability_by_task_type": {
+        "code": 0.93, "summarization": 0.93, "extraction": 0.93, "qa": 0.93,
+        "reasoning": 0.95, "classification": 0.94, "translation": 0.93,
+        "creative": 0.91, "rag": 0.93, "tool_use": 0.92, "other": 0.91
+      }
+    }
+  ]
+}

minima/catalog/data/model_aliases.json

@@ -0,0 +1,12 @@
+{
+  "note": "Maps canonical Minima model_id -> alternate keys used by LiteLLM/OpenRouter price maps and by offline datasets (e.g. RouterBench). Used to overlay live cost and to normalize seeded model ids.",
+  "aliases": {
+    "claude-haiku-4-5": ["claude-haiku-4-5", "anthropic/claude-haiku-4.5", "claude-3-5-haiku-20241022", "claude-3-5-haiku-latest"],
+    "claude-sonnet-4-6": ["claude-sonnet-4-6", "anthropic/claude-sonnet-4.6", "claude-3-5-sonnet-20241022", "claude-3-5-sonnet-latest"],
+    "claude-opus-4-8": ["claude-opus-4-8", "anthropic/claude-opus-4.8", "claude-3-opus-20240229"],
+    "gpt-4o-mini": ["gpt-4o-mini", "openai/gpt-4o-mini", "gpt-4o-mini-2024-07-18"],
+    "gpt-4o": ["gpt-4o", "openai/gpt-4o", "gpt-4o-2024-08-06"],
+    "gemini-2.5-flash": ["gemini-2.5-flash", "gemini/gemini-2.5-flash", "google/gemini-2.5-flash"],
+    "gemini-2.5-pro": ["gemini-2.5-pro", "gemini/gemini-2.5-pro", "google/gemini-2.5-pro"]
+  }
+}

minima/catalog/merge.py

@@ -0,0 +1,69 @@
+"""Overlay live cost data onto the static capability snapshot."""
+
+from __future__ import annotations
+
+from datetime import UTC, datetime
+from typing import Any
+
+from minima.schemas.models_catalog import ModelCard
+
+
+def _per_mtok(per_token: Any) -> float | None:
+    try:
+        return float(per_token) * 1_000_000.0
+    except (TypeError, ValueError):
+        return None
+
+
+def overlay_litellm(
+    cards: list[ModelCard],
+    litellm_map: dict[str, Any],
+    aliases: dict[str, list[str]],
+) -> tuple[list[ModelCard], int]:
+    """Return (new cards with live cost where matched, number updated)."""
+    now = datetime.now(UTC)
+    out: list[ModelCard] = []
+    updated = 0
+
+    for card in cards:
+        keys = aliases.get(card.model_id, [card.model_id])
+        entry: dict[str, Any] | None = None
+        for key in keys:
+            candidate = litellm_map.get(key)
+            if isinstance(candidate, dict):
+                entry = candidate
+                break
+        if entry is None:
+            out.append(card)
+            continue
+
+        in_cost = _per_mtok(entry.get("input_cost_per_token"))
+        out_cost = _per_mtok(entry.get("output_cost_per_token"))
+        cache_cost = _per_mtok(entry.get("cache_read_input_token_cost"))
+        ctx = entry.get("max_input_tokens") or entry.get("max_tokens")
+
+        out.append(
+            card.model_copy(
+                update={
+                    "input_cost_per_mtok": in_cost
+                    if in_cost is not None
+                    else card.input_cost_per_mtok,
+                    "output_cost_per_mtok": out_cost
+                    if out_cost is not None
+                    else card.output_cost_per_mtok,
+                    "cache_read_cost_per_mtok": cache_cost
+                    if cache_cost is not None
+                    else card.cache_read_cost_per_mtok,
+                    "context_window": int(ctx) if ctx else card.context_window,
+                    "supports_prompt_caching": bool(
+                        entry.get("supports_prompt_caching", card.supports_prompt_caching)
+                    ),
+                    "cost_source": "litellm",
+                    "cost_fetched_at": now,
+                    "cost_stale": False,
+                }
+            )
+        )
+        updated += 1
+
+    return out, updated

minima/catalog/refresh.py

@@ -0,0 +1,54 @@
+"""Catalog refresh: fetch live cost, overlay onto snapshot, swap the store."""
+
+from __future__ import annotations
+
+import asyncio
+from datetime import UTC, datetime
+
+from minima.catalog.merge import overlay_litellm
+from minima.catalog.sources.litellm import fetch_litellm_prices
+from minima.catalog.store import Catalog, CatalogStore, load_aliases
+from minima.config import Settings
+from minima.logging import get_logger
+
+log = get_logger("minima.catalog")
+
+
+async def refresh_catalog(settings: Settings, store: CatalogStore) -> bool:
+    """Best-effort refresh. Returns True if live cost was applied."""
+    base = store.get()
+    aliases = load_aliases()
+    try:
+        litellm_map = await fetch_litellm_prices(settings.minima_litellm_prices_url)
+    except Exception as exc:  # noqa: BLE001 — keep last-good catalog on any failure
+        log.warning("catalog_fetch_failed", error=str(exc))
+        return False
+
+    new_cards, updated = overlay_litellm(base.cards, litellm_map, aliases)
+    if not updated:
+        log.warning("catalog_no_models_matched", total=len(new_cards))
+        return False
+
+    store.set(
+        Catalog(
+            cards=new_cards,
+            version=base.version,
+            refreshed_at=datetime.now(UTC),
+            cost_source="litellm",
+            stale_after_seconds=settings.minima_catalog_stale_after_seconds,
+        )
+    )
+    log.info("catalog_refreshed", updated=updated, total=len(new_cards))
+    return True
+
+
+async def refresh_loop(settings: Settings, store: CatalogStore) -> None:
+    """Background loop for the app lifespan; cancelled on shutdown."""
+    while True:
+        try:
+            await refresh_catalog(settings, store)
+        except asyncio.CancelledError:
+            raise
+        except Exception as exc:  # noqa: BLE001
+            log.warning("catalog_refresh_loop_error", error=str(exc))
+        await asyncio.sleep(settings.minima_catalog_refresh_seconds)

minima/catalog/sources/__init__.py

@@ -0,0 +1 @@
+"""External catalog data sources (best-effort, network)."""

minima/catalog/sources/litellm.py

@@ -0,0 +1,19 @@
+"""Fetch the LiteLLM community price map (per-token costs for thousands of models)."""
+
+from __future__ import annotations
+
+from typing import Any
+
+import httpx
+
+
+async def fetch_litellm_prices(url: str, timeout: float = 20.0) -> dict[str, Any]:
+    """Return the raw ``{model_key: {...cost fields...}}`` map.
+
+    Raises on network/HTTP error; callers treat failure as "keep last-good catalog".
+    """
+    async with httpx.AsyncClient(timeout=timeout) as client:
+        resp = await client.get(url)
+        resp.raise_for_status()
+        data = resp.json()
+    return data if isinstance(data, dict) else {}

minima/catalog/sources/openrouter.py

@@ -0,0 +1,25 @@
+"""Fetch the OpenRouter model list (pricing + context windows).
+
+Used as a secondary reconciliation source; wired into refresh in a later phase.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+import httpx
+
+
+async def fetch_openrouter_models(
+    url: str, api_key: str | None = None, timeout: float = 20.0
+) -> dict[str, dict[str, Any]]:
+    """Return ``{model_id: model_object}`` keyed by OpenRouter id, or {} on failure shape."""
+    headers = {"Authorization": f"Bearer {api_key}"} if api_key else {}
+    async with httpx.AsyncClient(timeout=timeout) as client:
+        resp = await client.get(url, headers=headers)
+        resp.raise_for_status()
+        data = resp.json()
+    rows = data.get("data") if isinstance(data, dict) else None
+    if not isinstance(rows, list):
+        return {}
+    return {str(row.get("id")): row for row in rows if isinstance(row, dict) and row.get("id")}

minima/catalog/store.py

@@ -0,0 +1,86 @@
+"""In-memory model catalog snapshot, atomically swappable on refresh."""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from datetime import UTC, datetime
+from importlib.resources import files
+
+from minima.config import Settings
+from minima.schemas.models_catalog import ModelCard
+
+
+def _data_text(name: str) -> str:
+    return files("minima.catalog").joinpath("data", name).read_text(encoding="utf-8")
+
+
+def load_aliases() -> dict[str, list[str]]:
+    raw = json.loads(_data_text("model_aliases.json"))
+    return raw.get("aliases", {})
+
+
+def load_snapshot_cards() -> tuple[list[ModelCard], str]:
+    raw = json.loads(_data_text("capability_priors.json"))
+    cards: list[ModelCard] = []
+    for m in raw.get("models", []):
+        cards.append(
+            ModelCard(
+                model_id=m["model_id"],
+                provider=m["provider"],
+                display_name=m.get("display_name", ""),
+                input_cost_per_mtok=m["input_cost_per_mtok"],
+                output_cost_per_mtok=m["output_cost_per_mtok"],
+                cache_read_cost_per_mtok=m.get("cache_read_cost_per_mtok"),
+                supports_prompt_caching=m.get("supports_prompt_caching", False),
+                context_window=m.get("context_window", 0),
+                max_output_tokens=m.get("max_output_tokens"),
+                capability_priors=m.get("capability_priors", {}),
+                capability_by_task_type=m.get("capability_by_task_type", {}),
+                cost_source="fallback-snapshot",
+                cost_fetched_at=None,
+                cost_stale=True,
+                capability_source="fallback-snapshot",
+            )
+        )
+    return cards, raw.get("version", "fallback-snapshot")
+
+
+@dataclass(slots=True)
+class Catalog:
+    cards: list[ModelCard]
+    version: str
+    refreshed_at: datetime | None
+    cost_source: str
+    stale_after_seconds: int = 86_400
+
+    def by_id(self) -> dict[str, ModelCard]:
+        return {c.model_id: c for c in self.cards}
+
+    @property
+    def stale(self) -> bool:
+        if self.cost_source == "fallback-snapshot" or self.refreshed_at is None:
+            return True
+        age = (datetime.now(UTC) - self.refreshed_at).total_seconds()
+        return age > self.stale_after_seconds
+
+
+class CatalogStore:
+    """Holds the current catalog; reads are lock-free (atomic pointer swap)."""
+
+    def __init__(self, settings: Settings):
+        self._settings = settings
+        cards, version = load_snapshot_cards()
+        self._catalog = Catalog(
+            cards=cards,
+            version=version,
+            refreshed_at=None,
+            cost_source="fallback-snapshot",
+            stale_after_seconds=settings.minima_catalog_stale_after_seconds,
+        )
+
+    def get(self) -> Catalog:
+        return self._catalog
+
+    def set(self, catalog: Catalog) -> None:
+        self._catalog = catalog