minima-cli 0.4.9__py3-none-any.whl

minima/schemas/recommend.py

@@ -0,0 +1,104 @@
+"""Schemas for the per-call recommendation endpoint."""
+
+from __future__ import annotations
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from minima.schemas.common import Constraints, DecisionBasis, Difficulty, TaskInput, TaskType
+
+
+class RecommendRequest(BaseModel):
+    task: TaskInput
+    cost_quality_tradeoff: float = Field(
+        5.0, ge=0, le=10, description="0 = cheapest acceptable, 10 = highest quality"
+    )
+    constraints: Constraints = Field(default_factory=Constraints)
+    user_id: str | None = Field(
+        None, description="optional within-org actor label (NOT a tenant/auth boundary)"
+    )
+    namespace: str | None = Field(
+        None,
+        description=(
+            "optional within-org sub-scope (team/project/env), namespaced under your org. "
+            "The tenant boundary is your Minima API key -> your Mubit instance, not this field."
+        ),
+    )
+    max_candidates: int = Field(8, ge=1, le=64)
+    allow_llm_escalation: bool = True
+    explain: bool = True
+    baseline_model_id: str | None = Field(
+        None,
+        description=(
+            "the model you would have used without Minima; powers the vs_declared_default "
+            "savings baseline in GET /v1/savings"
+        ),
+    )
+
+
+class EvidenceRef(BaseModel):
+    """A recalled past outcome that informed a candidate's score."""
+
+    model_config = ConfigDict(protected_namespaces=())
+
+    entry_id: str = Field(..., description="QueryEvidence.id (used for outcome attribution)")
+    reference_id: str | None = None
+    model_id: str
+    score: float = Field(..., description="retrieval similarity")
+    knowledge_confidence: float = Field(..., ge=0, le=1)
+    observed_success: float = Field(..., ge=0, le=1)
+    is_stale: bool = False
+
+
+class RankedModel(BaseModel):
+    model_config = ConfigDict(protected_namespaces=())
+
+    model_id: str
+    provider: str
+    predicted_success: float = Field(..., ge=0, le=1)
+    est_cost_usd: float = Field(..., ge=0)
+    est_cost_breakdown: dict[str, float] = Field(default_factory=dict)
+    score: float = Field(..., description="final objective score; sorting key")
+    rationale: str = ""
+    decision_basis: DecisionBasis = DecisionBasis.prior
+    evidence: list[EvidenceRef] = Field(default_factory=list)
+    supports_prompt_caching: bool = False
+    context_window: int = 0
+    est_latency_ms: float | None = Field(
+        None, description="observed latency percentile from similar past outcomes (ms)"
+    )
+    latency_basis: str = Field("", description='e.g. "observed_p75"; empty without evidence')
+    est_cost_low: float | None = Field(
+        None, ge=0, description="low end of the data-grounded predictable cost band ($)"
+    )
+    est_cost_high: float | None = Field(
+        None, ge=0, description="high end of the data-grounded predictable cost band ($)"
+    )
+    cost_band_basis: str = Field(
+        "", description='e.g. "observed_p25_p75" | "rescaled_p25_p75"; empty without a band'
+    )
+    success_interval_width: float = Field(
+        0.0, ge=0, le=1, description="95% credible-interval width of predicted_success"
+    )
+
+
+class RecommendResponse(BaseModel):
+    recommendation_id: str
+    recommended_model: RankedModel
+    ranked: list[RankedModel] = Field(default_factory=list)
+    fallback_model: RankedModel | None = None
+    confidence: float = Field(..., ge=0, le=1)
+    decision_basis: DecisionBasis
+    threshold_used: float
+    classified_task_type: TaskType
+    classified_difficulty: Difficulty
+    catalog_version: str
+    catalog_stale: bool = False
+    latency_ms: int = 0
+    warnings: list[str] = Field(default_factory=list)
+    selection_policy: str = Field(
+        "argmin", description='"argmin" | "epsilon_softmax" (per-org opt-in exploration)'
+    )
+    recommended_actions: list[str] = Field(
+        default_factory=list,
+        description="near-free cost-saving actions to apply (e.g. enable_prompt_cache)",
+    )

minima/schemas/savings.py

@@ -0,0 +1,39 @@
+"""Schemas for the savings and calibration reporting endpoints.
+
+The payload bodies reuse the metrics dataclasses directly (pydantic v2 validates and
+serializes stdlib dataclasses), so the report shape has exactly one definition.
+"""
+
+from __future__ import annotations
+
+from pydantic import BaseModel, Field
+
+from minima.metrics.calibration import CalibrationReport, CusumFlag
+from minima.metrics.savings import SavingsSummary
+
+
+class SavingsGroup(BaseModel):
+    key: str
+    summary: SavingsSummary
+    health: dict[str, float | int] = Field(default_factory=dict)
+
+
+class SavingsResponse(BaseModel):
+    org_id: str
+    since: float
+    days: float
+    namespace: str | None = None
+    summary: SavingsSummary
+    health: dict[str, float | int] = Field(default_factory=dict)
+    group_by: str | None = None
+    groups: list[SavingsGroup] = Field(default_factory=list)
+
+
+class CalibrationResponse(BaseModel):
+    org_id: str
+    since: float
+    days: float
+    namespace: str | None = None
+    health: dict[str, float | int] = Field(default_factory=dict)
+    reports: list[CalibrationReport] = Field(default_factory=list)
+    drift_flags: list[CusumFlag] = Field(default_factory=list)

minima/schemas/strategies.py

@@ -0,0 +1,57 @@
+"""Schemas for the surfaced-strategies endpoint.
+
+``reflect()`` promotes accumulated outcomes/lessons into validated rules; Mubit's
+``surface_strategies`` clusters those lessons into ``EmergentStrategy`` summaries.
+This endpoint exposes them so callers can see *why* a namespace routes the way it does.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any
+
+from pydantic import BaseModel, Field
+
+
+def _g(d: Mapping[str, Any], *keys: str, default: Any = None) -> Any:
+    """First present key among snake_case/camelCase variants."""
+    for k in keys:
+        if k in d and d[k] is not None:
+            return d[k]
+    return default
+
+
+class Strategy(BaseModel):
+    strategy_id: str = ""
+    description: str = ""
+    supporting_lesson_count: int = 0
+    avg_confidence: float = 0.0
+    avg_reinforcement: float = 0.0
+    dominant_lesson_type: str = ""
+    dominant_scope: str = ""
+    lesson_ids: list[str] = Field(default_factory=list)
+
+    @classmethod
+    def from_emergent(cls, d: Mapping[str, Any]) -> Strategy:
+        """Parse a Mubit ``EmergentStrategy`` dict (snake_case or camelCase)."""
+        return cls(
+            strategy_id=str(_g(d, "strategy_id", "strategyId", default="")),
+            description=str(_g(d, "description", default="")),
+            supporting_lesson_count=int(
+                _g(d, "supporting_lesson_count", "supportingLessonCount", default=0)
+            ),
+            avg_confidence=float(_g(d, "avg_confidence", "avgConfidence", default=0.0)),
+            avg_reinforcement=float(_g(d, "avg_reinforcement", "avgReinforcement", default=0.0)),
+            dominant_lesson_type=str(
+                _g(d, "dominant_lesson_type", "dominantLessonType", default="")
+            ),
+            dominant_scope=str(_g(d, "dominant_scope", "dominantScope", default="")),
+            lesson_ids=[str(x) for x in (_g(d, "lesson_ids", "lessonIds", default=[]) or [])],
+        )
+
+
+class StrategiesResponse(BaseModel):
+    namespace: str | None = None
+    lane: str
+    strategies: list[Strategy] = Field(default_factory=list)
+    count: int = 0

minima/schemas/workflow.py

@@ -0,0 +1,43 @@
+"""Schemas for the multi-step workflow recommendation endpoint."""
+
+from __future__ import annotations
+
+from pydantic import BaseModel, Field
+
+from minima.schemas.common import Constraints, TaskInput
+from minima.schemas.recommend import RecommendResponse
+
+
+class WorkflowStep(BaseModel):
+    step_id: str = Field(..., min_length=1)
+    task: TaskInput
+    constraints: Constraints | None = Field(
+        None, description="per-step override; merged over global"
+    )
+    depends_on: list[str] = Field(default_factory=list)
+
+
+class WorkflowRequest(BaseModel):
+    steps: list[WorkflowStep] = Field(..., min_length=1)
+    cost_quality_tradeoff: float = Field(5.0, ge=0, le=10)
+    constraints: Constraints = Field(default_factory=Constraints)
+    user_id: str | None = Field(
+        None, description="optional within-org actor label (NOT a tenant/auth boundary)"
+    )
+    namespace: str | None = Field(
+        None, description="optional within-org sub-scope; tenant boundary is the Minima key"
+    )
+    allow_llm_escalation: bool = True
+
+
+class StepRecommendation(BaseModel):
+    step_id: str
+    recommendation: RecommendResponse
+
+
+class WorkflowResponse(BaseModel):
+    workflow_recommendation_id: str
+    steps: list[StepRecommendation]
+    total_est_cost_usd: float = Field(..., ge=0)
+    total_est_cost_if_all_premium: float = Field(..., ge=0)
+    confidence: float = Field(..., ge=0, le=1)

minima/seeding/__init__.py

@@ -0,0 +1 @@
+"""Cold-start seeding of Mubit memory (offline import)."""

minima/seeding/items.py

@@ -0,0 +1,42 @@
+"""Build Mubit batch_insert items from outcome records.
+
+``metadata_json`` must be a JSON *string* on the batch_insert wire (unlike remember(),
+which JSON-encodes a dict for you). ``embedding: []`` lets the server embed on ingest.
+"""
+
+from __future__ import annotations
+
+import json
+import time
+from collections.abc import Sequence
+from dataclasses import dataclass
+
+from minima.memory.records import OutcomeRecord
+
+
+@dataclass(slots=True)
+class SeedItem:
+    item_id: str
+    content: str
+    record: OutcomeRecord
+    env_tags: list[str]
+
+
+def build_item(seed: SeedItem, source: str = "system") -> dict:
+    # Stamp seed time, not dataset time: seeds are then governed by the explicit
+    # seed-vs-live weighting (source_dataset), not by pretending to be fresh or
+    # being decayed by an arbitrary benchmark-publication age.
+    if seed.record.recorded_at is None:
+        seed.record.recorded_at = time.time()
+    return {
+        "item_id": seed.item_id,
+        "text": seed.content,
+        "metadata_json": json.dumps(seed.record.to_metadata()),
+        "source": source,
+        "embedding": [],
+        "env_tags": list(seed.env_tags),
+    }
+
+
+def chunked(items: Sequence[dict], size: int) -> list[list[dict]]:
+    return [list(items[i : i + size]) for i in range(0, len(items), size)]

minima/seeding/llmrouterbench.py

@@ -0,0 +1,232 @@
+"""Fetch + raw-load LLMRouterBench / OpenRouterBench (offline benchmark).
+
+LLMRouterBench (HF dataset ``NPULH/LLMRouterBench``; code repo ``ynulihao/LLMRouterBench``,
+Findings@ACL 2026) ships as ONE gzipped tarball ``bench-release.tar.gz`` (~1.28 GB) whose
+members are::
+
+    bench-release/<dataset>/<model_name>/<dataset>-<model_name>-<YYYYMMDD_HHMMSS>.json
+
+Each JSON is one ``(dataset, split, model)`` run: top-level aggregate fields
+(``dataset_name``, ``split``, ``model_name``, ``demo``, ``data_fingerprint`` …) plus a
+``records`` list. Each record carries::
+
+    index, origin_query, prompt, prompt_tokens, completion_tokens,
+    cost, score, prediction, ground_truth, raw_output
+
+- ``score`` is 0.0/1.0 correctness (a few datasets use a graded [0,1] judge score).
+- ``cost`` is the *real* per-call USD cost — BUT open models run locally report ``0.0``
+  (handle this when building the cost axis; see Phase 2 of the plan and guard V2 — the
+  router must *decide* on independent market prices, not on this column it is *scored* on).
+
+We stream records straight out of the tarball (no multi-GB extraction) and drop the bulky
+``raw_output`` by default. This module is **Phase 1** of
+``docs/PLAN/LLMRouterBench-H1-setup.md`` — fetch + raw load only. The wide-DataFrame pivot
+the eval harness consumes (``<model>`` score + ``<model>|total_cost`` columns) is **Phase 3**
+and builds on :func:`iter_raw_records`.
+
+Requires the ``seed`` extra (``huggingface-hub``/``pandas``); raises a clear error otherwise.
+"""
+
+from __future__ import annotations
+
+import json
+import re
+import tarfile
+from collections import defaultdict
+from collections.abc import Iterator, Sequence
+from typing import Any
+
+_REPO_ID = "NPULH/LLMRouterBench"
+_TARBALL = "bench-release.tar.gz"
+_ROOT = "bench-release"
+_TS_RE = re.compile(r"(\d{8}_\d{6})\.json$")
+# Cost-column suffix the eval harness keys on. MUST match
+# ``minima.seeding.routerbench.detect_model_columns`` so the wide frame this module emits is
+# consumed by the same code path as RouterBench.
+_COST_SUFFIX = "|total_cost"
+
+# The per-record fields we keep. We drop the two bulky ones the eval never needs:
+# ``raw_output`` and ``prediction`` (the latter is a full role/content conversation in the
+# real data, despite schema.py declaring it ``str`` — confirmed by inspecting the bytes).
+_RECORD_FIELDS = (
+    "index", "origin_query", "prompt", "prompt_tokens",
+    "completion_tokens", "cost", "score", "ground_truth",
+)
+
+
+def _require_seed_extra():
+    try:
+        from huggingface_hub import hf_hub_download  # noqa: F401
+    except ImportError as exc:  # pragma: no cover
+        raise RuntimeError(
+            "LLMRouterBench needs the 'seed' extra: `uv sync --extra seed`."
+        ) from exc
+
+
+def download_tarball() -> str:
+    """Download (and HF-cache) ``bench-release.tar.gz``; return the local path.
+
+    Idempotent: ``hf_hub_download`` returns the cached file on subsequent calls without
+    re-downloading. The ~1.28 GB lives under the HF cache, not the repo.
+    """
+    _require_seed_extra()
+    from huggingface_hub import hf_hub_download
+
+    return hf_hub_download(repo_id=_REPO_ID, filename=_TARBALL, repo_type="dataset")
+
+
+def _split_member(name: str) -> tuple[str, str, str, str] | None:
+    """Map a member path to ``(dataset, subset, model, timestamp)``.
+
+    Two shapes occur in the release; the **model is always the directory immediately
+    above the file** and the **dataset is the first directory under the root** — the
+    optional middle segment is a subset/split (e.g. ``valid``, ``subset_500``)::
+
+        bench-release/<dataset>/<model>/<…ts>.json                (depth 4, subset="")
+        bench-release/<dataset>/<subset>/<model>/<…ts>.json       (depth 5)
+
+    (Parsing a fixed ``parts[2]`` as the model is the trap — it mis-reads the subset on
+    depth-5 paths; confirmed by inspecting the tarball.)
+    """
+    parts = name.split("/")
+    if len(parts) < 4 or parts[0] != _ROOT or not parts[-1].endswith(".json"):
+        return None
+    dataset = parts[1]
+    model = parts[-2]
+    subset = "/".join(parts[2:-2])  # "" for depth-4 paths
+    m = _TS_RE.search(parts[-1])
+    return dataset, subset, model, (m.group(1) if m else "")
+
+
+def list_release_contents(tarball_path: str | None = None) -> dict[str, Any]:
+    """Inventory the tarball WITHOUT parsing record bodies (one decompression pass).
+
+    Returns ``{"datasets": [...], "models": [...], "latest": {(dataset, model): name},
+    "file_count": int}``. ``latest`` keeps only the newest-timestamp file per
+    ``(dataset, model)`` so duplicate re-runs are de-duplicated, mirroring the authors'
+    ``BaselineDataLoader`` behaviour.
+    """
+    path = tarball_path or download_tarball()
+    latest: dict[tuple[str, str, str], tuple[str, str]] = {}  # (ds, subset, model) -> (ts, name)
+    file_count = 0
+    with tarfile.open(path, mode="r|gz") as tf:
+        for m in tf:
+            if not m.isfile():
+                continue
+            parsed = _split_member(m.name)
+            if parsed is None:
+                continue
+            ds, subset, model, ts = parsed
+            file_count += 1
+            key = (ds, subset, model)
+            if key not in latest or ts > latest[key][0]:
+                latest[key] = (ts, m.name)
+    datasets = sorted({k[0] for k in latest})
+    models = sorted({k[2] for k in latest})
+    by_dataset: dict[str, set[str]] = defaultdict(set)
+    for ds, _subset, model in latest:
+        by_dataset[ds].add(model)
+    return {
+        "datasets": datasets,
+        "models": models,
+        "latest": {k: v[1] for k, v in latest.items()},
+        "models_by_dataset": {k: sorted(v) for k, v in by_dataset.items()},
+        "file_count": file_count,
+    }
+
+
+def iter_raw_records(
+    tarball_path: str | None = None,
+    *,
+    datasets: set[str] | None = None,
+    models: set[str] | None = None,
+    limit: int | None = None,
+    skip_demo: bool = True,
+) -> Iterator[dict[str, Any]]:
+    """Stream flattened per-(prompt, model) records out of the tarball.
+
+    Each yielded dict has the keys ``dataset_id``, ``split``, ``model_name`` plus
+    :data:`_RECORD_FIELDS` (``raw_output`` dropped). Filter by ``datasets`` / ``models``
+    (matched on the member path, so unwanted files are skipped before JSON parsing).
+
+    NOTE: this reads every ``.json`` member; for a pristine release there is exactly one
+    file per ``(dataset, model)`` so no de-duplication is needed. If a release ever ships
+    duplicate timestamped re-runs, restrict to :func:`list_release_contents`'s ``latest``
+    set first.
+    """
+    _require_seed_extra()
+    path = tarball_path or download_tarball()
+    emitted = 0
+    with tarfile.open(path, mode="r|gz") as tf:
+        for m in tf:
+            if not m.isfile():
+                continue
+            parsed = _split_member(m.name)
+            if parsed is None:
+                continue
+            ds, _subset, model, _ts = parsed
+            if datasets is not None and ds not in datasets:
+                continue
+            if models is not None and model not in models:
+                continue
+            fh = tf.extractfile(m)
+            if fh is None:
+                continue
+            data = json.load(fh)
+            if skip_demo and data.get("demo", False):
+                continue
+            dataset_id = data.get("dataset_name", ds)
+            split = data.get("split", "")
+            model_name = data.get("model_name", model)
+            for rec in data.get("records", []):
+                row = {"dataset_id": dataset_id, "split": split, "model_name": model_name}
+                for f in _RECORD_FIELDS:
+                    row[f] = rec.get(f)
+                yield row
+                emitted += 1
+                if limit is not None and emitted >= limit:
+                    return
+
+
+def load_llmrouterbench_df(
+    candidates: Sequence[str],
+    datasets: Sequence[str],
+    tarball_path: str | None = None,
+):
+    """Pivot the long per-(prompt, model) records into the WIDE DataFrame the eval consumes.
+
+    This is Phase 3 of ``docs/PLAN/LLMRouterBench-H1-setup.md``. Output: one row per
+    ``(dataset, question index)``, with columns ``prompt``, ``eval_name`` (= dataset id), and
+    for each candidate model ``m`` a score column ``m`` and a cost column ``m|total_cost`` —
+    i.e. exactly the contract ``routerbench.detect_model_columns`` / ``harness.prepare_rows``
+    expect, so the eval reuses all its machinery unchanged.
+
+    Keyed by ``(dataset_id, index)`` — the question's identity — rather than prompt text, so it
+    is robust to repeated/boilerplate prompt strings within a dataset. Questions where any
+    candidate lacks a usable ``(score, cost)`` are dropped (the harness would drop them anyway).
+    """
+    _require_seed_extra()
+    import pandas as pd
+
+    cand = list(candidates)
+    want_ds = set(datasets)
+    bucket: dict[tuple[str, Any], dict[str, Any]] = {}
+    for r in iter_raw_records(tarball_path, datasets=want_ds, models=set(cand)):
+        key = (r["dataset_id"], r["index"])
+        slot = bucket.get(key)
+        if slot is None:
+            slot = {"prompt": r["prompt"], "scores": {}, "costs": {}}
+            bucket[key] = slot
+        slot["scores"][r["model_name"]] = r["score"]
+        slot["costs"][r["model_name"]] = r["cost"]
+
+    rows: list[dict[str, Any]] = []
+    for (dataset_id, _idx), slot in bucket.items():
+        if any(slot["scores"].get(m) is None or slot["costs"].get(m) is None for m in cand):
+            continue
+        row: dict[str, Any] = {"prompt": slot["prompt"], "eval_name": dataset_id}
+        for m in cand:
+            row[m] = slot["scores"][m]
+            row[f"{m}{_COST_SUFFIX}"] = slot["costs"][m]
+        rows.append(row)
+    return pd.DataFrame(rows)

minima/seeding/routerbench.py

@@ -0,0 +1,141 @@
+"""Load RouterBench (offline benchmark) into Minima outcome records.
+
+RouterBench (``withmartian/routerbench``) ships as pickled pandas frames
+(``routerbench_0shot.pkl``), not a ``datasets``-loadable layout — so it is fetched with
+``hf_hub_download`` + ``pandas.read_pickle``. Each row is a prompt; per model there is a
+``<model>`` correctness column (0/1) and a ``<model>|total_cost`` column (real USD for
+that call). We emit one outcome record per (prompt, model). Requires the ``seed`` extra
+(``datasets``/``huggingface-hub``/``pandas``); raises a clear error otherwise.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from minima.memory.keys import build_content, task_cluster, task_fingerprint
+from minima.memory.records import OutcomeRecord
+from minima.seeding.items import SeedItem
+
+_REPO_ID = "withmartian/routerbench"
+_SPLIT_FILES = {"0shot": "routerbench_0shot.pkl", "5shot": "routerbench_5shot.pkl"}
+_COST_SUFFIX = "|total_cost"
+
+_EVAL_TO_TASK_TYPE = {
+    "mbpp": "code",
+    "humaneval": "code",
+    "code-llama": "code",
+    "gsm8k": "reasoning",
+    "grade-school-math": "reasoning",
+    "math": "reasoning",
+    "mmlu": "qa",
+    "arc": "qa",
+    "hellaswag": "reasoning",
+    "winogrande": "reasoning",
+    "rag": "rag",
+    "mt-bench": "other",
+    "mtbench": "other",
+}
+
+
+def _reverse_aliases(aliases: dict[str, list[str]]) -> dict[str, str]:
+    reverse: dict[str, str] = {}
+    for canonical, names in aliases.items():
+        for name in names:
+            reverse[name] = canonical
+    return reverse
+
+
+def _task_type_for(eval_name: str) -> str:
+    name = (eval_name or "").lower()
+    for key, value in _EVAL_TO_TASK_TYPE.items():
+        if key in name:
+            return value
+    return "other"
+
+
+def detect_model_columns(columns: list[str]) -> dict[str, str]:
+    """Return {score_column: cost_column} for every model with a cost sibling."""
+    cost_cols = {c for c in columns if isinstance(c, str) and c.endswith(_COST_SUFFIX)}
+    pairs: dict[str, str] = {}
+    for cost_col in cost_cols:
+        score_col = cost_col[: -len(_COST_SUFFIX)]
+        if score_col in columns:
+            pairs[score_col] = cost_col
+    return pairs
+
+
+def load_routerbench_df(split: str = "0shot") -> Any:
+    """Download + read the RouterBench pickle into a pandas DataFrame."""
+    try:
+        import pandas as pd
+        from huggingface_hub import hf_hub_download
+    except ImportError as exc:  # pragma: no cover
+        raise RuntimeError(
+            "RouterBench needs the 'seed' extra: `uv sync --extra seed`. "
+            "For a network-free smoke test use `--dataset synthetic`."
+        ) from exc
+
+    filename = _SPLIT_FILES.get(split, _SPLIT_FILES["0shot"])
+    path = hf_hub_download(repo_id=_REPO_ID, filename=filename, repo_type="dataset")
+    return pd.read_pickle(path)
+
+
+def load_records(limit: int, aliases: dict[str, list[str]], split: str = "0shot") -> list[SeedItem]:
+    df = load_routerbench_df(split)
+    columns = list(df.columns)
+    model_columns = detect_model_columns(columns)
+    if not model_columns:
+        raise RuntimeError(
+            f"could not detect RouterBench model columns in {columns[:10]}...; "
+            "the dataset schema may have changed."
+        )
+
+    reverse = _reverse_aliases(aliases)
+    prompt_col = "prompt" if "prompt" in columns else columns[0]
+    out: list[SeedItem] = []
+
+    for row_index, row in enumerate(df.itertuples(index=False)):
+        if len(out) >= limit:
+            break
+        rowd = dict(zip(columns, row, strict=False))
+        prompt = str(rowd.get(prompt_col, "")).strip()
+        if not prompt:
+            continue
+        task_type = _task_type_for(str(rowd.get("eval_name", "")))
+        difficulty = "medium"
+        fingerprint = task_fingerprint(prompt)
+        cluster = task_cluster(task_type, difficulty)
+        content = build_content(task_type, difficulty, prompt)
+
+        for score_col, cost_col in model_columns.items():
+            quality = _to_float(rowd.get(score_col))
+            if quality is None:
+                continue
+            model_id = reverse.get(score_col, score_col)
+            record = OutcomeRecord(
+                model_id=model_id,
+                task_type=task_type,
+                difficulty=difficulty,
+                task_fingerprint=fingerprint,
+                task_cluster=cluster,
+                cost_usd=_to_float(rowd.get(cost_col)) or 0.0,
+                quality_score=max(0.0, min(1.0, quality)),
+                outcome="success" if quality >= 0.5 else "failure",
+                source_dataset="routerbench",
+            )
+            out.append(
+                SeedItem(
+                    item_id=f"rb-{row_index}-{score_col}",
+                    content=content,
+                    record=record,
+                    env_tags=["seed:routerbench"],
+                )
+            )
+    return out
+
+
+def _to_float(value: Any) -> float | None:
+    try:
+        return float(value)
+    except (TypeError, ValueError):
+        return None